Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1 | // Copyright 2021, The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 15 | //! Implementation of the AIDL interface of the VirtualizationService. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 16 | |
David Brazdil | 1f53070 | 2022-10-03 12:18:10 +0100 | [diff] [blame] | 17 | use crate::{get_calling_pid, get_calling_uid}; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 18 | use crate::atom::{ |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 19 | write_vm_booted_stats, write_vm_creation_stats}; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 20 | use crate::composite::make_composite_image; |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 21 | use crate::crosvm::{CrosvmConfig, DiskFile, PayloadState, VmContext, VmInstance, VmState}; |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 22 | use crate::payload::{add_microdroid_payload_images, add_microdroid_system_images}; |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 23 | use crate::selinux::{getfilecon, SeContext}; |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 24 | use android_os_permissions_aidl::aidl::android::os::IPermissionController; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 25 | use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::{ |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 26 | DeathReason::DeathReason, |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 27 | ErrorCode::ErrorCode, |
| 28 | }; |
| 29 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 30 | DiskImage::DiskImage, |
Alan Stokes | 0cc59ee | 2021-09-24 11:20:34 +0100 | [diff] [blame] | 31 | IVirtualMachine::{BnVirtualMachine, IVirtualMachine}, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 32 | IVirtualMachineCallback::IVirtualMachineCallback, |
| 33 | IVirtualizationService::IVirtualizationService, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 34 | MemoryTrimLevel::MemoryTrimLevel, |
Jiyong Park | 029977d | 2021-11-24 21:56:49 +0900 | [diff] [blame] | 35 | Partition::Partition, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 36 | PartitionType::PartitionType, |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 37 | VirtualMachineAppConfig::{DebugLevel::DebugLevel, Payload::Payload, VirtualMachineAppConfig}, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 38 | VirtualMachineConfig::VirtualMachineConfig, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 39 | VirtualMachineDebugInfo::VirtualMachineDebugInfo, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 40 | VirtualMachinePayloadConfig::VirtualMachinePayloadConfig, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 41 | VirtualMachineRawConfig::VirtualMachineRawConfig, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 42 | VirtualMachineState::VirtualMachineState, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 43 | }; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 44 | use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IVirtualizationServiceInternal::IVirtualizationServiceInternal; |
Seungjae Yoo | dd91f0f | 2022-11-09 15:25:21 +0900 | [diff] [blame] | 45 | use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::{ |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 46 | BnVirtualMachineService, IVirtualMachineService, |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 47 | }; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 48 | use anyhow::{bail, Context, Result}; |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 49 | use apkverify::{HashAlgorithm, V4Signature}; |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 50 | use binder::{ |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 51 | self, wait_for_interface, BinderFeatures, ExceptionCode, Interface, ParcelFileDescriptor, |
| 52 | Status, StatusCode, Strong, |
Andrew Walbran | a89fc13 | 2021-03-17 17:08:36 +0000 | [diff] [blame] | 53 | }; |
Andrew Walbran | dfc953d | 2021-06-10 13:59:56 +0000 | [diff] [blame] | 54 | use disk::QcowFile; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 55 | use lazy_static::lazy_static; |
Seungjae Yoo | 0a8c84c | 2022-07-11 08:19:15 +0000 | [diff] [blame] | 56 | use log::{debug, error, info, warn}; |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 57 | use microdroid_payload_config::{OsConfig, Task, TaskType, VmPayloadConfig}; |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 58 | use nix::unistd::pipe; |
David Brazdil | 73988ea | 2022-11-11 15:10:32 +0000 | [diff] [blame] | 59 | use rpcbinder::RpcServer; |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 60 | use semver::VersionReq; |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 61 | use std::convert::TryInto; |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 62 | use std::ffi::CStr; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 63 | use std::fs::{read_dir, remove_file, File, OpenOptions}; |
| 64 | use std::io::{BufRead, BufReader, Error, ErrorKind, Write}; |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 65 | use std::num::NonZeroU32; |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 66 | use std::os::unix::io::{FromRawFd, IntoRawFd}; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 67 | use std::os::unix::raw::pid_t; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 68 | use std::path::{Path, PathBuf}; |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 69 | use std::sync::{Arc, Mutex, Weak}; |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 70 | use vmconfig::VmConfig; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 71 | use vsock::VsockStream; |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 72 | use zip::ZipArchive; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 73 | |
David Brazdil | 41d1a87 | 2022-10-05 14:44:19 +0100 | [diff] [blame] | 74 | /// The unique ID of a VM used (together with a port number) for vsock communication. |
| 75 | pub type Cid = u32; |
| 76 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 77 | pub const BINDER_SERVICE_IDENTIFIER: &str = "android.system.virtualizationservice"; |
| 78 | |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 79 | /// The size of zero.img. |
| 80 | /// Gaps in composite disk images are filled with a shared zero.img. |
| 81 | const ZERO_FILLER_SIZE: u64 = 4096; |
| 82 | |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 83 | /// Magic string for the instance image |
| 84 | const ANDROID_VM_INSTANCE_MAGIC: &str = "Android-VM-instance"; |
| 85 | |
| 86 | /// Version of the instance image format |
| 87 | const ANDROID_VM_INSTANCE_VERSION: u16 = 1; |
| 88 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 89 | const MICRODROID_OS_NAME: &str = "microdroid"; |
| 90 | |
Shikha Panwar | 9fd198f | 2022-11-18 17:43:43 +0000 | [diff] [blame] | 91 | const UNFORMATTED_STORAGE_MAGIC: &str = "UNFORMATTED-STORAGE"; |
| 92 | |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 93 | /// crosvm requires all partitions to be a multiple of 4KiB. |
| 94 | const PARTITION_GRANULARITY_BYTES: u64 = 4096; |
| 95 | |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 96 | lazy_static! { |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 97 | pub static ref GLOBAL_SERVICE: Strong<dyn IVirtualizationServiceInternal> = |
| 98 | wait_for_interface(BINDER_SERVICE_IDENTIFIER) |
| 99 | .expect("Could not connect to VirtualizationServiceInternal"); |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 100 | } |
| 101 | |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 102 | fn create_or_update_idsig_file( |
| 103 | input_fd: &ParcelFileDescriptor, |
| 104 | idsig_fd: &ParcelFileDescriptor, |
| 105 | ) -> Result<()> { |
| 106 | let mut input = clone_file(input_fd)?; |
| 107 | let metadata = input.metadata().context("failed to get input metadata")?; |
| 108 | if !metadata.is_file() { |
| 109 | bail!("input is not a regular file"); |
| 110 | } |
| 111 | let mut sig = V4Signature::create(&mut input, 4096, &[], HashAlgorithm::SHA256) |
| 112 | .context("failed to create idsig")?; |
| 113 | |
| 114 | let mut output = clone_file(idsig_fd)?; |
Nikita Ioffe | c09b049 | 2022-12-14 20:18:33 +0000 | [diff] [blame] | 115 | output.set_len(0).context("failed to set_len on the idsig output")?; |
| 116 | sig.write_into(&mut output).context("failed to write idsig")?; |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 117 | Ok(()) |
| 118 | } |
| 119 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 120 | pub fn remove_temporary_files(path: &PathBuf) -> Result<()> { |
| 121 | for dir_entry in read_dir(path)? { |
| 122 | remove_file(dir_entry?.path())?; |
| 123 | } |
| 124 | Ok(()) |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 125 | } |
| 126 | |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 127 | /// Implementation of `IVirtualizationService`, the entry point of the AIDL service. |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 128 | #[derive(Debug, Default)] |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 129 | pub struct VirtualizationService { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 130 | state: Arc<Mutex<State>>, |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 131 | } |
| 132 | |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 133 | impl Interface for VirtualizationService { |
| 134 | fn dump(&self, mut file: &File, _args: &[&CStr]) -> Result<(), StatusCode> { |
| 135 | check_permission("android.permission.DUMP").or(Err(StatusCode::PERMISSION_DENIED))?; |
| 136 | let state = &mut *self.state.lock().unwrap(); |
| 137 | let vms = state.vms(); |
| 138 | writeln!(file, "Running {0} VMs:", vms.len()).or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 139 | for vm in vms { |
| 140 | writeln!(file, "VM CID: {}", vm.cid).or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 141 | writeln!(file, "\tState: {:?}", vm.vm_state.lock().unwrap()) |
| 142 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 143 | writeln!(file, "\tPayload state {:?}", vm.payload_state()) |
| 144 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 145 | writeln!(file, "\tProtected: {}", vm.protected).or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 146 | writeln!(file, "\ttemporary_directory: {}", vm.temporary_directory.to_string_lossy()) |
| 147 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 148 | writeln!(file, "\trequester_uid: {}", vm.requester_uid) |
| 149 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 150 | writeln!(file, "\trequester_debug_pid: {}", vm.requester_debug_pid) |
| 151 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 152 | } |
| 153 | Ok(()) |
| 154 | } |
| 155 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 156 | |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 157 | impl IVirtualizationService for VirtualizationService { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 158 | /// Creates (but does not start) a new VM with the given configuration, assigning it the next |
| 159 | /// available CID. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 160 | /// |
| 161 | /// Returns a binder `IVirtualMachine` object referring to it, as a handle for the client. |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 162 | fn createVm( |
Andrew Walbran | a89fc13 | 2021-03-17 17:08:36 +0000 | [diff] [blame] | 163 | &self, |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 164 | config: &VirtualMachineConfig, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 165 | console_fd: Option<&ParcelFileDescriptor>, |
Andrew Walbran | a89fc13 | 2021-03-17 17:08:36 +0000 | [diff] [blame] | 166 | log_fd: Option<&ParcelFileDescriptor>, |
| 167 | ) -> binder::Result<Strong<dyn IVirtualMachine>> { |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 168 | let mut is_protected = false; |
| 169 | let ret = self.create_vm_internal(config, console_fd, log_fd, &mut is_protected); |
Seungjae Yoo | 0a8c84c | 2022-07-11 08:19:15 +0000 | [diff] [blame] | 170 | write_vm_creation_stats(config, is_protected, &ret); |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 171 | ret |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 172 | } |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 173 | |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 174 | /// Initialise an empty partition image of the given size to be used as a writable partition. |
| 175 | fn initializeWritablePartition( |
| 176 | &self, |
| 177 | image_fd: &ParcelFileDescriptor, |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 178 | size_bytes: i64, |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 179 | partition_type: PartitionType, |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 180 | ) -> binder::Result<()> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 181 | check_manage_access()?; |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 182 | let size_bytes = size_bytes.try_into().map_err(|e| { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 183 | Status::new_exception_str( |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 184 | ExceptionCode::ILLEGAL_ARGUMENT, |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 185 | Some(format!("Invalid size {}: {:?}", size_bytes, e)), |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 186 | ) |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 187 | })?; |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 188 | let size_bytes = round_up(size_bytes, PARTITION_GRANULARITY_BYTES); |
Andrew Walbran | dfc953d | 2021-06-10 13:59:56 +0000 | [diff] [blame] | 189 | let image = clone_file(image_fd)?; |
Jooyung Han | 1edd5b9 | 2021-10-28 10:58:05 +0900 | [diff] [blame] | 190 | // initialize the file. Any data in the file will be erased. |
| 191 | image.set_len(0).map_err(|e| { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 192 | Status::new_service_specific_error_str( |
| 193 | -1, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 194 | Some(format!("Failed to reset a file: {:?}", e)), |
Jooyung Han | 1edd5b9 | 2021-10-28 10:58:05 +0900 | [diff] [blame] | 195 | ) |
| 196 | })?; |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 197 | let mut part = QcowFile::new(image, size_bytes).map_err(|e| { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 198 | Status::new_service_specific_error_str( |
| 199 | -1, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 200 | Some(format!("Failed to create QCOW2 image: {:?}", e)), |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 201 | ) |
Andrew Walbran | dfc953d | 2021-06-10 13:59:56 +0000 | [diff] [blame] | 202 | })?; |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 203 | |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 204 | match partition_type { |
| 205 | PartitionType::RAW => Ok(()), |
| 206 | PartitionType::ANDROID_VM_INSTANCE => format_as_android_vm_instance(&mut part), |
Shikha Panwar | 9fd198f | 2022-11-18 17:43:43 +0000 | [diff] [blame] | 207 | PartitionType::ENCRYPTEDSTORE => format_as_encryptedstore(&mut part), |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 208 | _ => Err(Error::new( |
| 209 | ErrorKind::Unsupported, |
| 210 | format!("Unsupported partition type {:?}", partition_type), |
| 211 | )), |
| 212 | } |
| 213 | .map_err(|e| { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 214 | Status::new_service_specific_error_str( |
| 215 | -1, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 216 | Some(format!("Failed to initialize partition as {:?}: {:?}", partition_type, e)), |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 217 | ) |
| 218 | })?; |
| 219 | |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 220 | Ok(()) |
| 221 | } |
| 222 | |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 223 | /// Creates or update the idsig file by digesting the input APK file. |
| 224 | fn createOrUpdateIdsigFile( |
| 225 | &self, |
| 226 | input_fd: &ParcelFileDescriptor, |
| 227 | idsig_fd: &ParcelFileDescriptor, |
| 228 | ) -> binder::Result<()> { |
| 229 | // TODO(b/193504400): do this only when (1) idsig_fd is empty or (2) the APK digest in |
| 230 | // idsig_fd is different from APK digest in input_fd |
| 231 | |
Jiyong Park | c3ca24f | 2022-06-28 10:45:15 +0900 | [diff] [blame] | 232 | check_manage_access()?; |
| 233 | |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 234 | create_or_update_idsig_file(input_fd, idsig_fd) |
| 235 | .map_err(|e| Status::new_service_specific_error_str(-1, Some(format!("{:?}", e))))?; |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 236 | Ok(()) |
| 237 | } |
| 238 | |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 239 | /// Get a list of all currently running VMs. This method is only intended for debug purposes, |
| 240 | /// and as such is only permitted from the shell user. |
| 241 | fn debugListVms(&self) -> binder::Result<Vec<VirtualMachineDebugInfo>> { |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 242 | // Delegate to the global service, including checking the debug permission. |
David Brazdil | d4f51a5 | 2023-01-11 14:09:27 +0000 | [diff] [blame] | 243 | GLOBAL_SERVICE.debugListVms() |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 244 | } |
| 245 | } |
| 246 | |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 247 | impl VirtualizationService { |
| 248 | pub fn init() -> VirtualizationService { |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 249 | VirtualizationService::default() |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 250 | } |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 251 | |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 252 | fn create_vm_context( |
| 253 | &self, |
| 254 | requester_debug_pid: pid_t, |
| 255 | ) -> binder::Result<(VmContext, Cid, PathBuf)> { |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 256 | const NUM_ATTEMPTS: usize = 5; |
| 257 | |
| 258 | for _ in 0..NUM_ATTEMPTS { |
Charisee | 96113f3 | 2023-01-26 09:00:42 +0000 | [diff] [blame] | 259 | let vm_context = GLOBAL_SERVICE.allocateGlobalVmContext(requester_debug_pid)?; |
David Brazdil | d4f51a5 | 2023-01-11 14:09:27 +0000 | [diff] [blame] | 260 | let cid = vm_context.getCid()? as Cid; |
| 261 | let temp_dir: PathBuf = vm_context.getTemporaryDirectory()?.into(); |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 262 | let service = VirtualMachineService::new_binder(self.state.clone(), cid).as_binder(); |
| 263 | |
| 264 | // Start VM service listening for connections from the new CID on port=CID. |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 265 | let port = cid; |
David Brazdil | 3238da4 | 2022-11-18 10:04:51 +0000 | [diff] [blame] | 266 | match RpcServer::new_vsock(service, cid, port) { |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 267 | Ok(vm_server) => { |
| 268 | vm_server.start(); |
David Brazdil | d4f51a5 | 2023-01-11 14:09:27 +0000 | [diff] [blame] | 269 | return Ok((VmContext::new(vm_context, vm_server), cid, temp_dir)); |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 270 | } |
| 271 | Err(err) => { |
| 272 | warn!("Could not start RpcServer on port {}: {}", port, err); |
| 273 | } |
| 274 | } |
| 275 | } |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 276 | Err(Status::new_service_specific_error_str( |
| 277 | -1, |
| 278 | Some("Too many attempts to create VM context failed."), |
| 279 | )) |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 280 | } |
| 281 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 282 | fn create_vm_internal( |
| 283 | &self, |
| 284 | config: &VirtualMachineConfig, |
| 285 | console_fd: Option<&ParcelFileDescriptor>, |
| 286 | log_fd: Option<&ParcelFileDescriptor>, |
| 287 | is_protected: &mut bool, |
| 288 | ) -> binder::Result<Strong<dyn IVirtualMachine>> { |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 289 | let requester_uid = get_calling_uid(); |
| 290 | let requester_debug_pid = get_calling_pid(); |
| 291 | |
| 292 | // Allocating VM context checks the MANAGE_VIRTUAL_MACHINE permission. |
| 293 | let (vm_context, cid, temporary_directory) = self.create_vm_context(requester_debug_pid)?; |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 294 | |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 295 | let is_custom = match config { |
| 296 | VirtualMachineConfig::RawConfig(_) => true, |
| 297 | VirtualMachineConfig::AppConfig(config) => { |
| 298 | // Some features are reserved for platform apps only, even when using |
| 299 | // VirtualMachineAppConfig: |
| 300 | // - controlling CPUs; |
| 301 | // - specifying a config file in the APK. |
| 302 | !config.taskProfiles.is_empty() || matches!(config.payload, Payload::ConfigPath(_)) |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 303 | } |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 304 | }; |
| 305 | if is_custom { |
| 306 | check_use_custom_virtual_machine()?; |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 307 | } |
| 308 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 309 | let state = &mut *self.state.lock().unwrap(); |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 310 | let console_fd = |
| 311 | clone_or_prepare_logger_fd(config, console_fd, format!("Console({})", cid))?; |
| 312 | let log_fd = clone_or_prepare_logger_fd(config, log_fd, format!("Log({})", cid))?; |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 313 | |
| 314 | // Counter to generate unique IDs for temporary image files. |
| 315 | let mut next_temporary_image_id = 0; |
| 316 | // Files which are referred to from composite images. These must be mapped to the crosvm |
| 317 | // child process, and not closed before it is started. |
| 318 | let mut indirect_files = vec![]; |
| 319 | |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 320 | let (is_app_config, config) = match config { |
| 321 | VirtualMachineConfig::RawConfig(config) => (false, BorrowedOrOwned::Borrowed(config)), |
| 322 | VirtualMachineConfig::AppConfig(config) => { |
| 323 | let config = load_app_config(config, &temporary_directory).map_err(|e| { |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 324 | *is_protected = config.protectedVm; |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 325 | let message = format!("Failed to load app config: {:?}", e); |
| 326 | error!("{}", message); |
| 327 | Status::new_service_specific_error_str(-1, Some(message)) |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 328 | })?; |
| 329 | (true, BorrowedOrOwned::Owned(config)) |
| 330 | } |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 331 | }; |
| 332 | let config = config.as_ref(); |
| 333 | *is_protected = config.protectedVm; |
| 334 | |
| 335 | // Check if partition images are labeled incorrectly. This is to prevent random images |
| 336 | // which are not protected by the Android Verified Boot (e.g. bits downloaded by apps) from |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 337 | // being loaded in a pVM. This applies to everything in the raw config, and everything but |
| 338 | // the non-executable, generated partitions in the app config. |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 339 | config |
| 340 | .disks |
| 341 | .iter() |
| 342 | .flat_map(|disk| disk.partitions.iter()) |
| 343 | .filter(|partition| { |
| 344 | if is_app_config { |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 345 | !is_safe_app_partition(&partition.label) |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 346 | } else { |
| 347 | true // all partitions are checked |
| 348 | } |
| 349 | }) |
| 350 | .try_for_each(check_label_for_partition) |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 351 | .map_err(|e| Status::new_service_specific_error_str(-1, Some(format!("{:?}", e))))?; |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 352 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 353 | let kernel = maybe_clone_file(&config.kernel)?; |
| 354 | let initrd = maybe_clone_file(&config.initrd)?; |
| 355 | |
| 356 | // In a protected VM, we require custom kernels to come from a trusted source (b/237054515). |
| 357 | if config.protectedVm { |
| 358 | check_label_for_kernel_files(&kernel, &initrd).map_err(|e| { |
| 359 | Status::new_service_specific_error_str(-1, Some(format!("{:?}", e))) |
| 360 | })?; |
| 361 | } |
| 362 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 363 | let zero_filler_path = temporary_directory.join("zero.img"); |
| 364 | write_zero_filler(&zero_filler_path).map_err(|e| { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 365 | error!("Failed to make composite image: {:?}", e); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 366 | Status::new_service_specific_error_str( |
| 367 | -1, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 368 | Some(format!("Failed to make composite image: {:?}", e)), |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 369 | ) |
| 370 | })?; |
| 371 | |
| 372 | // Assemble disk images if needed. |
| 373 | let disks = config |
| 374 | .disks |
| 375 | .iter() |
| 376 | .map(|disk| { |
| 377 | assemble_disk_image( |
| 378 | disk, |
| 379 | &zero_filler_path, |
| 380 | &temporary_directory, |
| 381 | &mut next_temporary_image_id, |
| 382 | &mut indirect_files, |
| 383 | ) |
| 384 | }) |
| 385 | .collect::<Result<Vec<DiskFile>, _>>()?; |
| 386 | |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 387 | // Creating this ramdump file unconditionally is not harmful as ramdump will be created |
| 388 | // only when the VM is configured as such. `ramdump_write` is sent to crosvm and will |
Jiyong Park | 4afe201 | 2022-07-08 05:38:49 +0900 | [diff] [blame] | 389 | // be the backing store for the /dev/hvc1 where VM will emit ramdump to. `ramdump_read` |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 390 | // will be sent back to the client (i.e. the VM owner) for readout. |
| 391 | let ramdump_path = temporary_directory.join("ramdump"); |
| 392 | let ramdump = prepare_ramdump_file(&ramdump_path).map_err(|e| { |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 393 | error!("Failed to prepare ramdump file: {:?}", e); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 394 | Status::new_service_specific_error_str( |
| 395 | -1, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 396 | Some(format!("Failed to prepare ramdump file: {:?}", e)), |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 397 | ) |
| 398 | })?; |
| 399 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 400 | // Actually start the VM. |
| 401 | let crosvm_config = CrosvmConfig { |
| 402 | cid, |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 403 | name: config.name.clone(), |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 404 | bootloader: maybe_clone_file(&config.bootloader)?, |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 405 | kernel, |
| 406 | initrd, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 407 | disks, |
| 408 | params: config.params.to_owned(), |
| 409 | protected: *is_protected, |
| 410 | memory_mib: config.memoryMib.try_into().ok().and_then(NonZeroU32::new), |
| 411 | cpus: config.numCpus.try_into().ok().and_then(NonZeroU32::new), |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 412 | task_profiles: config.taskProfiles.clone(), |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 413 | console_fd, |
| 414 | log_fd, |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 415 | ramdump: Some(ramdump), |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 416 | indirect_files, |
| 417 | platform_version: parse_platform_version_req(&config.platformVersion)?, |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 418 | detect_hangup: is_app_config, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 419 | }; |
| 420 | let instance = Arc::new( |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 421 | VmInstance::new( |
| 422 | crosvm_config, |
| 423 | temporary_directory, |
| 424 | requester_uid, |
| 425 | requester_debug_pid, |
| 426 | vm_context, |
| 427 | ) |
| 428 | .map_err(|e| { |
| 429 | error!("Failed to create VM with config {:?}: {:?}", config, e); |
| 430 | Status::new_service_specific_error_str( |
| 431 | -1, |
| 432 | Some(format!("Failed to create VM: {:?}", e)), |
| 433 | ) |
| 434 | })?, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 435 | ); |
| 436 | state.add_vm(Arc::downgrade(&instance)); |
| 437 | Ok(VirtualMachine::create(instance)) |
| 438 | } |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 439 | } |
| 440 | |
Andrew Walbran | fbb39d2 | 2021-07-28 17:01:25 +0000 | [diff] [blame] | 441 | fn write_zero_filler(zero_filler_path: &Path) -> Result<()> { |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 442 | let file = OpenOptions::new() |
| 443 | .create_new(true) |
| 444 | .read(true) |
| 445 | .write(true) |
| 446 | .open(zero_filler_path) |
| 447 | .with_context(|| "Failed to create zero.img")?; |
| 448 | file.set_len(ZERO_FILLER_SIZE)?; |
Andrew Walbran | fbb39d2 | 2021-07-28 17:01:25 +0000 | [diff] [blame] | 449 | Ok(()) |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 450 | } |
| 451 | |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 452 | fn format_as_android_vm_instance(part: &mut dyn Write) -> std::io::Result<()> { |
| 453 | part.write_all(ANDROID_VM_INSTANCE_MAGIC.as_bytes())?; |
| 454 | part.write_all(&ANDROID_VM_INSTANCE_VERSION.to_le_bytes())?; |
| 455 | part.flush() |
| 456 | } |
| 457 | |
Shikha Panwar | 9fd198f | 2022-11-18 17:43:43 +0000 | [diff] [blame] | 458 | fn format_as_encryptedstore(part: &mut dyn Write) -> std::io::Result<()> { |
| 459 | part.write_all(UNFORMATTED_STORAGE_MAGIC.as_bytes())?; |
| 460 | part.flush() |
| 461 | } |
| 462 | |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 463 | fn prepare_ramdump_file(ramdump_path: &Path) -> Result<File> { |
Chris Wailes | 9b866f0 | 2022-11-16 15:17:16 -0800 | [diff] [blame] | 464 | File::create(ramdump_path).context(format!("Failed to create ramdump file {:?}", &ramdump_path)) |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 465 | } |
| 466 | |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 467 | fn round_up(input: u64, granularity: u64) -> u64 { |
| 468 | if granularity == 0 { |
| 469 | return input; |
| 470 | } |
| 471 | // If the input is absurdly large we round down instead of up; it's going to fail anyway. |
| 472 | let result = input.checked_add(granularity - 1).unwrap_or(input); |
| 473 | (result / granularity) * granularity |
| 474 | } |
| 475 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 476 | /// Given the configuration for a disk image, assembles the `DiskFile` to pass to crosvm. |
| 477 | /// |
| 478 | /// This may involve assembling a composite disk from a set of partition images. |
| 479 | fn assemble_disk_image( |
| 480 | disk: &DiskImage, |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 481 | zero_filler_path: &Path, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 482 | temporary_directory: &Path, |
| 483 | next_temporary_image_id: &mut u64, |
| 484 | indirect_files: &mut Vec<File>, |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 485 | ) -> Result<DiskFile, Status> { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 486 | let image = if !disk.partitions.is_empty() { |
| 487 | if disk.image.is_some() { |
| 488 | warn!("DiskImage {:?} contains both image and partitions.", disk); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 489 | return Err(Status::new_exception_str( |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 490 | ExceptionCode::ILLEGAL_ARGUMENT, |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 491 | Some("DiskImage contains both image and partitions."), |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 492 | )); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 493 | } |
| 494 | |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 495 | let composite_image_filenames = |
| 496 | make_composite_image_filenames(temporary_directory, next_temporary_image_id); |
| 497 | let (image, partition_files) = make_composite_image( |
| 498 | &disk.partitions, |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 499 | zero_filler_path, |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 500 | &composite_image_filenames.composite, |
| 501 | &composite_image_filenames.header, |
| 502 | &composite_image_filenames.footer, |
| 503 | ) |
| 504 | .map_err(|e| { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 505 | error!("Failed to make composite image with config {:?}: {:?}", disk, e); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 506 | Status::new_service_specific_error_str( |
| 507 | -1, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 508 | Some(format!("Failed to make composite image: {:?}", e)), |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 509 | ) |
| 510 | })?; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 511 | |
| 512 | // Pass the file descriptors for the various partition files to crosvm when it |
| 513 | // is run. |
| 514 | indirect_files.extend(partition_files); |
| 515 | |
| 516 | image |
| 517 | } else if let Some(image) = &disk.image { |
| 518 | clone_file(image)? |
| 519 | } else { |
| 520 | warn!("DiskImage {:?} didn't contain image or partitions.", disk); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 521 | return Err(Status::new_exception_str( |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 522 | ExceptionCode::ILLEGAL_ARGUMENT, |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 523 | Some("DiskImage didn't contain image or partitions."), |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 524 | )); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 525 | }; |
| 526 | |
| 527 | Ok(DiskFile { image, writable: disk.writable }) |
| 528 | } |
| 529 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 530 | fn load_app_config( |
| 531 | config: &VirtualMachineAppConfig, |
| 532 | temporary_directory: &Path, |
Jooyung Han | adfb76c | 2021-06-28 17:29:30 +0900 | [diff] [blame] | 533 | ) -> Result<VirtualMachineRawConfig> { |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 534 | let apk_file = clone_file(config.apk.as_ref().unwrap())?; |
| 535 | let idsig_file = clone_file(config.idsig.as_ref().unwrap())?; |
Jiyong Park | 8d08181 | 2021-07-23 17:45:04 +0900 | [diff] [blame] | 536 | let instance_file = clone_file(config.instanceImage.as_ref().unwrap())?; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 537 | |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 538 | let storage_image = if let Some(file) = config.encryptedStorageImage.as_ref() { |
| 539 | Some(clone_file(file)?) |
| 540 | } else { |
| 541 | None |
| 542 | }; |
| 543 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 544 | let vm_payload_config = match &config.payload { |
| 545 | Payload::ConfigPath(config_path) => { |
| 546 | load_vm_payload_config_from_file(&apk_file, config_path.as_str()) |
| 547 | .with_context(|| format!("Couldn't read config from {}", config_path))? |
| 548 | } |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 549 | Payload::PayloadConfig(payload_config) => create_vm_payload_config(payload_config)?, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 550 | }; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 551 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 552 | // For now, the only supported OS is Microdroid |
| 553 | let os_name = vm_payload_config.os.name.as_str(); |
| 554 | if os_name != MICRODROID_OS_NAME { |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 555 | bail!("Unknown OS \"{}\"", os_name); |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 556 | } |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 557 | |
| 558 | // It is safe to construct a filename based on the os_name because we've already checked that it |
| 559 | // is one of the allowed values. |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 560 | let vm_config_path = PathBuf::from(format!("/apex/com.android.virt/etc/{}.json", os_name)); |
| 561 | let vm_config_file = File::open(vm_config_path)?; |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 562 | let mut vm_config = VmConfig::load(&vm_config_file)?.to_parcelable()?; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 563 | |
Andrew Walbran | cc04590 | 2021-07-27 16:06:17 +0000 | [diff] [blame] | 564 | if config.memoryMib > 0 { |
| 565 | vm_config.memoryMib = config.memoryMib; |
Andrew Walbran | 45bcb0c | 2021-07-14 15:02:06 +0000 | [diff] [blame] | 566 | } |
| 567 | |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 568 | vm_config.name = config.name.clone(); |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 569 | vm_config.protectedVm = config.protectedVm; |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 570 | vm_config.numCpus = config.numCpus; |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 571 | vm_config.taskProfiles = config.taskProfiles.clone(); |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 572 | |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 573 | // Microdroid takes additional init ramdisk & (optionally) storage image |
| 574 | add_microdroid_system_images(config, instance_file, storage_image, &mut vm_config)?; |
| 575 | |
| 576 | // Include Microdroid payload disk (contains apks, idsigs) in vm config |
| 577 | add_microdroid_payload_images( |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 578 | config, |
| 579 | temporary_directory, |
| 580 | apk_file, |
| 581 | idsig_file, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 582 | &vm_payload_config, |
| 583 | &mut vm_config, |
| 584 | )?; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 585 | |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 586 | Ok(vm_config) |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 587 | } |
| 588 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 589 | fn load_vm_payload_config_from_file(apk_file: &File, config_path: &str) -> Result<VmPayloadConfig> { |
| 590 | let mut apk_zip = ZipArchive::new(apk_file)?; |
| 591 | let config_file = apk_zip.by_name(config_path)?; |
| 592 | Ok(serde_json::from_reader(config_file)?) |
| 593 | } |
| 594 | |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 595 | fn create_vm_payload_config( |
| 596 | payload_config: &VirtualMachinePayloadConfig, |
| 597 | ) -> Result<VmPayloadConfig> { |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 598 | // There isn't an actual config file. Construct a synthetic VmPayloadConfig from the explicit |
| 599 | // parameters we've been given. Microdroid will do something equivalent inside the VM using the |
| 600 | // payload config that we send it via the metadata file. |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 601 | |
| 602 | let payload_binary_name = &payload_config.payloadBinaryName; |
| 603 | if payload_binary_name.contains('/') { |
| 604 | bail!("Payload binary name must not specify a path: {payload_binary_name}"); |
| 605 | } |
| 606 | |
| 607 | let task = Task { type_: TaskType::MicrodroidLauncher, command: payload_binary_name.clone() }; |
| 608 | Ok(VmPayloadConfig { |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 609 | os: OsConfig { name: MICRODROID_OS_NAME.to_owned() }, |
| 610 | task: Some(task), |
| 611 | apexes: vec![], |
| 612 | extra_apks: vec![], |
| 613 | prefer_staged: false, |
Alan Stokes | 1f417c9 | 2022-09-29 15:13:28 +0100 | [diff] [blame] | 614 | export_tombstones: false, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 615 | enable_authfs: false, |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 616 | }) |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 617 | } |
| 618 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 619 | /// Generates a unique filename to use for a composite disk image. |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 620 | fn make_composite_image_filenames( |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 621 | temporary_directory: &Path, |
| 622 | next_temporary_image_id: &mut u64, |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 623 | ) -> CompositeImageFilenames { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 624 | let id = *next_temporary_image_id; |
| 625 | *next_temporary_image_id += 1; |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 626 | CompositeImageFilenames { |
| 627 | composite: temporary_directory.join(format!("composite-{}.img", id)), |
| 628 | header: temporary_directory.join(format!("composite-{}-header.img", id)), |
| 629 | footer: temporary_directory.join(format!("composite-{}-footer.img", id)), |
| 630 | } |
| 631 | } |
| 632 | |
| 633 | /// Filenames for a composite disk image, including header and footer partitions. |
| 634 | #[derive(Clone, Debug, Eq, PartialEq)] |
| 635 | struct CompositeImageFilenames { |
| 636 | /// The composite disk image itself. |
| 637 | composite: PathBuf, |
| 638 | /// The header partition image. |
| 639 | header: PathBuf, |
| 640 | /// The footer partition image. |
| 641 | footer: PathBuf, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 642 | } |
| 643 | |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 644 | /// Checks whether the caller has a specific permission |
| 645 | fn check_permission(perm: &str) -> binder::Result<()> { |
David Brazdil | 1f53070 | 2022-10-03 12:18:10 +0100 | [diff] [blame] | 646 | let calling_pid = get_calling_pid(); |
| 647 | let calling_uid = get_calling_uid(); |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 648 | // Root can do anything |
| 649 | if calling_uid == 0 { |
| 650 | return Ok(()); |
| 651 | } |
| 652 | let perm_svc: Strong<dyn IPermissionController::IPermissionController> = |
| 653 | binder::get_interface("permission")?; |
| 654 | if perm_svc.checkPermission(perm, calling_pid, calling_uid as i32)? { |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 655 | Ok(()) |
| 656 | } else { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 657 | Err(Status::new_exception_str( |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 658 | ExceptionCode::SECURITY, |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 659 | Some(format!("does not have the {} permission", perm)), |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 660 | )) |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 661 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 662 | } |
| 663 | |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 664 | /// Check whether the caller of the current Binder method is allowed to manage VMs |
| 665 | fn check_manage_access() -> binder::Result<()> { |
| 666 | check_permission("android.permission.MANAGE_VIRTUAL_MACHINE") |
| 667 | } |
| 668 | |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 669 | /// Check whether the caller of the current Binder method is allowed to create custom VMs |
| 670 | fn check_use_custom_virtual_machine() -> binder::Result<()> { |
| 671 | check_permission("android.permission.USE_CUSTOM_VIRTUAL_MACHINE") |
| 672 | } |
| 673 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 674 | /// Return whether a partition is exempt from selinux label checks, because we know that it does |
| 675 | /// not contain code and is likely to be generated in an app-writable directory. |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 676 | fn is_safe_app_partition(label: &str) -> bool { |
Shikha Panwar | a2ff8c5 | 2022-11-30 19:25:46 +0000 | [diff] [blame] | 677 | // See add_microdroid_system_images & add_microdroid_payload_images in payload.rs. |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 678 | label == "vm-instance" |
Shikha Panwar | a2ff8c5 | 2022-11-30 19:25:46 +0000 | [diff] [blame] | 679 | || label == "encryptedstore" |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 680 | || label == "microdroid-apk-idsig" |
| 681 | || label == "payload-metadata" |
| 682 | || label.starts_with("extra-idsig-") |
| 683 | } |
| 684 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 685 | /// Check that a file SELinux label is acceptable. |
| 686 | /// |
| 687 | /// We only want to allow code in a VM to be sourced from places that apps, and the |
| 688 | /// system, do not have write access to. |
| 689 | /// |
| 690 | /// Note that sepolicy must also grant read access for these types to both virtualization |
| 691 | /// service and crosvm. |
| 692 | /// |
| 693 | /// App private data files are deliberately excluded, to avoid arbitrary payloads being run on |
| 694 | /// user devices (W^X). |
| 695 | fn check_label_is_allowed(context: &SeContext) -> Result<()> { |
| 696 | match context.selinux_type()? { |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 697 | | "system_file" // immutable dm-verity protected partition |
| 698 | | "apk_data_file" // APKs of an installed app |
Shikha Panwar | a2ff8c5 | 2022-11-30 19:25:46 +0000 | [diff] [blame] | 699 | | "staging_data_file" // updated/staged APEX images |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 700 | | "shell_data_file" // test files created via adb shell |
| 701 | => Ok(()), |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 702 | _ => bail!("Label {} is not allowed", context), |
Jiyong Park | 029977d | 2021-11-24 21:56:49 +0900 | [diff] [blame] | 703 | } |
| 704 | } |
| 705 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 706 | fn check_label_for_partition(partition: &Partition) -> Result<()> { |
| 707 | let file = partition.image.as_ref().unwrap().as_ref(); |
| 708 | check_label_is_allowed(&getfilecon(file)?) |
| 709 | .with_context(|| format!("Partition {} invalid", &partition.label)) |
| 710 | } |
| 711 | |
| 712 | fn check_label_for_kernel_files(kernel: &Option<File>, initrd: &Option<File>) -> Result<()> { |
| 713 | if let Some(f) = kernel { |
| 714 | check_label_for_file(f, "kernel")?; |
| 715 | } |
| 716 | if let Some(f) = initrd { |
| 717 | check_label_for_file(f, "initrd")?; |
| 718 | } |
| 719 | Ok(()) |
| 720 | } |
| 721 | fn check_label_for_file(file: &File, name: &str) -> Result<()> { |
| 722 | check_label_is_allowed(&getfilecon(file)?).with_context(|| format!("{} file invalid", name)) |
| 723 | } |
| 724 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 725 | /// Implementation of the AIDL `IVirtualMachine` interface. Used as a handle to a VM. |
| 726 | #[derive(Debug)] |
| 727 | struct VirtualMachine { |
| 728 | instance: Arc<VmInstance>, |
| 729 | } |
| 730 | |
| 731 | impl VirtualMachine { |
| 732 | fn create(instance: Arc<VmInstance>) -> Strong<dyn IVirtualMachine> { |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 733 | BnVirtualMachine::new_binder(VirtualMachine { instance }, BinderFeatures::default()) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 734 | } |
| 735 | } |
| 736 | |
| 737 | impl Interface for VirtualMachine {} |
| 738 | |
| 739 | impl IVirtualMachine for VirtualMachine { |
| 740 | fn getCid(&self) -> binder::Result<i32> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 741 | // Don't check permission. The owner of the VM might have passed this binder object to |
| 742 | // others. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 743 | Ok(self.instance.cid as i32) |
| 744 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 745 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 746 | fn getState(&self) -> binder::Result<VirtualMachineState> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 747 | // Don't check permission. The owner of the VM might have passed this binder object to |
| 748 | // others. |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 749 | Ok(get_state(&self.instance)) |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 750 | } |
| 751 | |
| 752 | fn registerCallback( |
| 753 | &self, |
| 754 | callback: &Strong<dyn IVirtualMachineCallback>, |
| 755 | ) -> binder::Result<()> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 756 | // Don't check permission. The owner of the VM might have passed this binder object to |
| 757 | // others. |
| 758 | // |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 759 | // TODO: Should this give an error if the VM is already dead? |
| 760 | self.instance.callbacks.add(callback.clone()); |
| 761 | Ok(()) |
| 762 | } |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 763 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 764 | fn start(&self) -> binder::Result<()> { |
| 765 | self.instance.start().map_err(|e| { |
| 766 | error!("Error starting VM with CID {}: {:?}", self.instance.cid, e); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 767 | Status::new_service_specific_error_str(-1, Some(e.to_string())) |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 768 | }) |
| 769 | } |
| 770 | |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 771 | fn stop(&self) -> binder::Result<()> { |
| 772 | self.instance.kill().map_err(|e| { |
| 773 | error!("Error stopping VM with CID {}: {:?}", self.instance.cid, e); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 774 | Status::new_service_specific_error_str(-1, Some(e.to_string())) |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 775 | }) |
| 776 | } |
| 777 | |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 778 | fn onTrimMemory(&self, level: MemoryTrimLevel) -> binder::Result<()> { |
| 779 | self.instance.trim_memory(level).map_err(|e| { |
| 780 | error!("Error trimming VM with CID {}: {:?}", self.instance.cid, e); |
| 781 | Status::new_service_specific_error_str(-1, Some(e.to_string())) |
| 782 | }) |
| 783 | } |
| 784 | |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 785 | fn connectVsock(&self, port: i32) -> binder::Result<ParcelFileDescriptor> { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 786 | if !matches!(&*self.instance.vm_state.lock().unwrap(), VmState::Running { .. }) { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 787 | return Err(Status::new_service_specific_error_str(-1, Some("VM is not running"))); |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 788 | } |
Alan Stokes | 10c4767 | 2022-12-13 17:17:08 +0000 | [diff] [blame] | 789 | let port = port as u32; |
| 790 | if port < 1024 { |
| 791 | return Err(Status::new_service_specific_error_str( |
| 792 | -1, |
| 793 | Some(format!("Can't connect to privileged port {port}")), |
| 794 | )); |
| 795 | } |
| 796 | let stream = VsockStream::connect_with_cid_port(self.instance.cid, port).map_err(|e| { |
| 797 | Status::new_service_specific_error_str(-1, Some(format!("Failed to connect: {:?}", e))) |
| 798 | })?; |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 799 | Ok(vsock_stream_to_pfd(stream)) |
| 800 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 801 | } |
| 802 | |
| 803 | impl Drop for VirtualMachine { |
| 804 | fn drop(&mut self) { |
| 805 | debug!("Dropping {:?}", self); |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 806 | if let Err(e) = self.instance.kill() { |
| 807 | debug!("Error stopping dropped VM with CID {}: {:?}", self.instance.cid, e); |
| 808 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 809 | } |
| 810 | } |
| 811 | |
| 812 | /// A set of Binders to be called back in response to various events on the VM, such as when it |
| 813 | /// dies. |
| 814 | #[derive(Debug, Default)] |
| 815 | pub struct VirtualMachineCallbacks(Mutex<Vec<Strong<dyn IVirtualMachineCallback>>>); |
| 816 | |
| 817 | impl VirtualMachineCallbacks { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 818 | /// Call all registered callbacks to notify that the payload has started. |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 819 | pub fn notify_payload_started(&self, cid: Cid) { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 820 | let callbacks = &*self.0.lock().unwrap(); |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 821 | for callback in callbacks { |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 822 | if let Err(e) = callback.onPayloadStarted(cid as i32) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 823 | error!("Error notifying payload start event from VM CID {}: {:?}", cid, e); |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 824 | } |
| 825 | } |
| 826 | } |
| 827 | |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 828 | /// Call all registered callbacks to notify that the payload is ready to serve. |
| 829 | pub fn notify_payload_ready(&self, cid: Cid) { |
| 830 | let callbacks = &*self.0.lock().unwrap(); |
| 831 | for callback in callbacks { |
| 832 | if let Err(e) = callback.onPayloadReady(cid as i32) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 833 | error!("Error notifying payload ready event from VM CID {}: {:?}", cid, e); |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 834 | } |
| 835 | } |
| 836 | } |
| 837 | |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 838 | /// Call all registered callbacks to notify that the payload has finished. |
| 839 | pub fn notify_payload_finished(&self, cid: Cid, exit_code: i32) { |
| 840 | let callbacks = &*self.0.lock().unwrap(); |
| 841 | for callback in callbacks { |
| 842 | if let Err(e) = callback.onPayloadFinished(cid as i32, exit_code) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 843 | error!("Error notifying payload finish event from VM CID {}: {:?}", cid, e); |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 844 | } |
| 845 | } |
| 846 | } |
| 847 | |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 848 | /// Call all registered callbacks to say that the VM encountered an error. |
Alan Stokes | 2bead0d | 2022-09-05 16:58:34 +0100 | [diff] [blame] | 849 | pub fn notify_error(&self, cid: Cid, error_code: ErrorCode, message: &str) { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 850 | let callbacks = &*self.0.lock().unwrap(); |
| 851 | for callback in callbacks { |
| 852 | if let Err(e) = callback.onError(cid as i32, error_code, message) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 853 | error!("Error notifying error event from VM CID {}: {:?}", cid, e); |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 854 | } |
| 855 | } |
| 856 | } |
| 857 | |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 858 | /// Call all registered callbacks to say that the VM has died. |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 859 | pub fn callback_on_died(&self, cid: Cid, reason: DeathReason) { |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 860 | let callbacks = &*self.0.lock().unwrap(); |
| 861 | for callback in callbacks { |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 862 | if let Err(e) = callback.onDied(cid as i32, reason) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 863 | error!("Error notifying exit of VM CID {}: {:?}", cid, e); |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 864 | } |
| 865 | } |
| 866 | } |
| 867 | |
| 868 | /// Add a new callback to the set. |
| 869 | fn add(&self, callback: Strong<dyn IVirtualMachineCallback>) { |
| 870 | self.0.lock().unwrap().push(callback); |
| 871 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 872 | } |
| 873 | |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 874 | /// The mutable state of the VirtualizationService. There should only be one instance of this |
| 875 | /// struct. |
Chris Wailes | 641fc4a | 2021-12-01 15:03:21 -0800 | [diff] [blame] | 876 | #[derive(Debug, Default)] |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 877 | struct State { |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 878 | /// The VMs which have been started. When VMs are started a weak reference is added to this list |
| 879 | /// while a strong reference is returned to the caller over Binder. Once all copies of the |
| 880 | /// Binder client are dropped the weak reference here will become invalid, and will be removed |
| 881 | /// from the list opportunistically the next time `add_vm` is called. |
| 882 | vms: Vec<Weak<VmInstance>>, |
| 883 | } |
| 884 | |
| 885 | impl State { |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 886 | /// Get a list of VMs which still have Binder references to them. |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 887 | fn vms(&self) -> Vec<Arc<VmInstance>> { |
| 888 | // Attempt to upgrade the weak pointers to strong pointers. |
| 889 | self.vms.iter().filter_map(Weak::upgrade).collect() |
| 890 | } |
| 891 | |
| 892 | /// Add a new VM to the list. |
| 893 | fn add_vm(&mut self, vm: Weak<VmInstance>) { |
| 894 | // Garbage collect any entries from the stored list which no longer exist. |
| 895 | self.vms.retain(|vm| vm.strong_count() > 0); |
| 896 | |
| 897 | // Actually add the new VM. |
| 898 | self.vms.push(vm); |
| 899 | } |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 900 | |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 901 | /// Get a VM that corresponds to the given cid |
| 902 | fn get_vm(&self, cid: Cid) -> Option<Arc<VmInstance>> { |
| 903 | self.vms().into_iter().find(|vm| vm.cid == cid) |
| 904 | } |
Jiyong Park | d50a024 | 2021-09-16 21:00:14 +0900 | [diff] [blame] | 905 | } |
| 906 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 907 | /// Gets the `VirtualMachineState` of the given `VmInstance`. |
| 908 | fn get_state(instance: &VmInstance) -> VirtualMachineState { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 909 | match &*instance.vm_state.lock().unwrap() { |
| 910 | VmState::NotStarted { .. } => VirtualMachineState::NOT_STARTED, |
| 911 | VmState::Running { .. } => match instance.payload_state() { |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 912 | PayloadState::Starting => VirtualMachineState::STARTING, |
| 913 | PayloadState::Started => VirtualMachineState::STARTED, |
| 914 | PayloadState::Ready => VirtualMachineState::READY, |
| 915 | PayloadState::Finished => VirtualMachineState::FINISHED, |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 916 | PayloadState::Hangup => VirtualMachineState::DEAD, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 917 | }, |
| 918 | VmState::Dead => VirtualMachineState::DEAD, |
| 919 | VmState::Failed => VirtualMachineState::DEAD, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 920 | } |
| 921 | } |
| 922 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 923 | /// Converts a `&ParcelFileDescriptor` to a `File` by cloning the file. |
Seungjae Yoo | 0a8c84c | 2022-07-11 08:19:15 +0000 | [diff] [blame] | 924 | pub fn clone_file(file: &ParcelFileDescriptor) -> Result<File, Status> { |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 925 | file.as_ref().try_clone().map_err(|e| { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 926 | Status::new_exception_str( |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 927 | ExceptionCode::BAD_PARCELABLE, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 928 | Some(format!("Failed to clone File from ParcelFileDescriptor: {:?}", e)), |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 929 | ) |
| 930 | }) |
| 931 | } |
| 932 | |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 933 | /// Converts an `&Option<ParcelFileDescriptor>` to an `Option<File>` by cloning the file. |
| 934 | fn maybe_clone_file(file: &Option<ParcelFileDescriptor>) -> Result<Option<File>, Status> { |
| 935 | file.as_ref().map(clone_file).transpose() |
| 936 | } |
| 937 | |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 938 | /// Converts a `VsockStream` to a `ParcelFileDescriptor`. |
| 939 | fn vsock_stream_to_pfd(stream: VsockStream) -> ParcelFileDescriptor { |
| 940 | // SAFETY: ownership is transferred from stream to f |
| 941 | let f = unsafe { File::from_raw_fd(stream.into_raw_fd()) }; |
| 942 | ParcelFileDescriptor::new(f) |
| 943 | } |
| 944 | |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 945 | /// Parses the platform version requirement string. |
| 946 | fn parse_platform_version_req(s: &str) -> Result<VersionReq, Status> { |
| 947 | VersionReq::parse(s).map_err(|e| { |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 948 | Status::new_exception_str( |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 949 | ExceptionCode::BAD_PARCELABLE, |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 950 | Some(format!("Invalid platform version requirement {}: {:?}", s, e)), |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 951 | ) |
| 952 | }) |
| 953 | } |
| 954 | |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 955 | fn is_debuggable(config: &VirtualMachineConfig) -> bool { |
| 956 | match config { |
| 957 | VirtualMachineConfig::AppConfig(config) => config.debugLevel != DebugLevel::NONE, |
| 958 | _ => false, |
| 959 | } |
| 960 | } |
| 961 | |
| 962 | fn clone_or_prepare_logger_fd( |
| 963 | config: &VirtualMachineConfig, |
| 964 | fd: Option<&ParcelFileDescriptor>, |
| 965 | tag: String, |
| 966 | ) -> Result<Option<File>, Status> { |
| 967 | if let Some(fd) = fd { |
| 968 | return Ok(Some(clone_file(fd)?)); |
| 969 | } |
| 970 | |
| 971 | if !is_debuggable(config) { |
| 972 | return Ok(None); |
| 973 | } |
| 974 | |
| 975 | let (raw_read_fd, raw_write_fd) = pipe().map_err(|e| { |
| 976 | Status::new_service_specific_error_str(-1, Some(format!("Failed to create pipe: {:?}", e))) |
| 977 | })?; |
| 978 | |
| 979 | // SAFETY: We are the sole owners of these fds as they were just created. |
| 980 | let mut reader = BufReader::new(unsafe { File::from_raw_fd(raw_read_fd) }); |
| 981 | let write_fd = unsafe { File::from_raw_fd(raw_write_fd) }; |
| 982 | |
| 983 | std::thread::spawn(move || loop { |
| 984 | let mut buf = vec![]; |
| 985 | match reader.read_until(b'\n', &mut buf) { |
| 986 | Ok(0) => { |
| 987 | // EOF |
| 988 | return; |
| 989 | } |
| 990 | Ok(size) => { |
| 991 | if buf[size - 1] == b'\n' { |
| 992 | buf.pop(); |
| 993 | } |
| 994 | info!("{}: {}", &tag, &String::from_utf8_lossy(&buf)); |
| 995 | } |
| 996 | Err(e) => { |
| 997 | error!("Could not read console pipe: {:?}", e); |
| 998 | return; |
| 999 | } |
| 1000 | }; |
| 1001 | }); |
| 1002 | |
| 1003 | Ok(Some(write_fd)) |
| 1004 | } |
| 1005 | |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 1006 | /// Simple utility for referencing Borrowed or Owned. Similar to std::borrow::Cow, but |
| 1007 | /// it doesn't require that T implements Clone. |
| 1008 | enum BorrowedOrOwned<'a, T> { |
| 1009 | Borrowed(&'a T), |
| 1010 | Owned(T), |
| 1011 | } |
| 1012 | |
| 1013 | impl<'a, T> AsRef<T> for BorrowedOrOwned<'a, T> { |
| 1014 | fn as_ref(&self) -> &T { |
| 1015 | match self { |
| 1016 | Self::Borrowed(b) => b, |
Chris Wailes | 68c39f8 | 2021-07-27 16:03:44 -0700 | [diff] [blame] | 1017 | Self::Owned(o) => o, |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 1018 | } |
| 1019 | } |
| 1020 | } |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1021 | |
| 1022 | /// Implementation of `IVirtualMachineService`, the entry point of the AIDL service. |
| 1023 | #[derive(Debug, Default)] |
| 1024 | struct VirtualMachineService { |
| 1025 | state: Arc<Mutex<State>>, |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1026 | cid: Cid, |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1027 | } |
| 1028 | |
| 1029 | impl Interface for VirtualMachineService {} |
| 1030 | |
| 1031 | impl IVirtualMachineService for VirtualMachineService { |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1032 | fn notifyPayloadStarted(&self) -> binder::Result<()> { |
| 1033 | let cid = self.cid; |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 1034 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1035 | info!("VM with CID {} started payload", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1036 | vm.update_payload_state(PayloadState::Started).map_err(|e| { |
| 1037 | Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string())) |
| 1038 | })?; |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 1039 | vm.callbacks.notify_payload_started(cid); |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 1040 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 1041 | let vm_start_timestamp = vm.vm_metric.lock().unwrap().start_timestamp; |
| 1042 | write_vm_booted_stats(vm.requester_uid as i32, &vm.name, vm_start_timestamp); |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 1043 | Ok(()) |
| 1044 | } else { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1045 | error!("notifyPayloadStarted is called from an unknown CID {}", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1046 | Err(Status::new_service_specific_error_str( |
| 1047 | -1, |
| 1048 | Some(format!("cannot find a VM with CID {}", cid)), |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 1049 | )) |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1050 | } |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1051 | } |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1052 | |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1053 | fn notifyPayloadReady(&self) -> binder::Result<()> { |
| 1054 | let cid = self.cid; |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1055 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1056 | info!("VM with CID {} reported payload is ready", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1057 | vm.update_payload_state(PayloadState::Ready).map_err(|e| { |
| 1058 | Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string())) |
| 1059 | })?; |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1060 | vm.callbacks.notify_payload_ready(cid); |
| 1061 | Ok(()) |
| 1062 | } else { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1063 | error!("notifyPayloadReady is called from an unknown CID {}", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1064 | Err(Status::new_service_specific_error_str( |
| 1065 | -1, |
| 1066 | Some(format!("cannot find a VM with CID {}", cid)), |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1067 | )) |
| 1068 | } |
| 1069 | } |
| 1070 | |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1071 | fn notifyPayloadFinished(&self, exit_code: i32) -> binder::Result<()> { |
| 1072 | let cid = self.cid; |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1073 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1074 | info!("VM with CID {} finished payload", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1075 | vm.update_payload_state(PayloadState::Finished).map_err(|e| { |
| 1076 | Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string())) |
| 1077 | })?; |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1078 | vm.callbacks.notify_payload_finished(cid, exit_code); |
| 1079 | Ok(()) |
| 1080 | } else { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1081 | error!("notifyPayloadFinished is called from an unknown CID {}", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1082 | Err(Status::new_service_specific_error_str( |
| 1083 | -1, |
| 1084 | Some(format!("cannot find a VM with CID {}", cid)), |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1085 | )) |
| 1086 | } |
| 1087 | } |
| 1088 | |
Alan Stokes | 2bead0d | 2022-09-05 16:58:34 +0100 | [diff] [blame] | 1089 | fn notifyError(&self, error_code: ErrorCode, message: &str) -> binder::Result<()> { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1090 | let cid = self.cid; |
| 1091 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1092 | info!("VM with CID {} encountered an error", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1093 | vm.update_payload_state(PayloadState::Finished).map_err(|e| { |
| 1094 | Status::new_exception_str(ExceptionCode::ILLEGAL_STATE, Some(e.to_string())) |
| 1095 | })?; |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1096 | vm.callbacks.notify_error(cid, error_code, message); |
| 1097 | Ok(()) |
| 1098 | } else { |
Seungjae Yoo | ec8c160 | 2022-06-20 05:28:00 +0000 | [diff] [blame] | 1099 | error!("notifyError is called from an unknown CID {}", cid); |
Andrew Walbran | dcf9d58 | 2022-08-03 11:25:24 +0000 | [diff] [blame] | 1100 | Err(Status::new_service_specific_error_str( |
| 1101 | -1, |
| 1102 | Some(format!("cannot find a VM with CID {}", cid)), |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1103 | )) |
| 1104 | } |
| 1105 | } |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1106 | } |
| 1107 | |
| 1108 | impl VirtualMachineService { |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1109 | fn new_binder(state: Arc<Mutex<State>>, cid: Cid) -> Strong<dyn IVirtualMachineService> { |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1110 | BnVirtualMachineService::new_binder( |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1111 | VirtualMachineService { state, cid }, |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1112 | BinderFeatures::default(), |
| 1113 | ) |
| 1114 | } |
| 1115 | } |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 1116 | |
| 1117 | #[cfg(test)] |
| 1118 | mod tests { |
| 1119 | use super::*; |
| 1120 | |
| 1121 | #[test] |
| 1122 | fn test_is_allowed_label_for_partition() -> Result<()> { |
| 1123 | let expected_results = vec![ |
| 1124 | ("u:object_r:system_file:s0", true), |
| 1125 | ("u:object_r:apk_data_file:s0", true), |
| 1126 | ("u:object_r:app_data_file:s0", false), |
| 1127 | ("u:object_r:app_data_file:s0:c512,c768", false), |
| 1128 | ("u:object_r:privapp_data_file:s0:c512,c768", false), |
| 1129 | ("invalid", false), |
| 1130 | ("user:role:apk_data_file:severity:categories", true), |
| 1131 | ("user:role:apk_data_file:severity:categories:extraneous", false), |
| 1132 | ]; |
| 1133 | |
| 1134 | for (label, expected_valid) in expected_results { |
| 1135 | let context = SeContext::new(label)?; |
| 1136 | let result = check_label_is_allowed(&context); |
| 1137 | if expected_valid { |
| 1138 | assert!(result.is_ok(), "Expected label {} to be allowed, got {:?}", label, result); |
| 1139 | } else if result.is_ok() { |
| 1140 | bail!("Expected label {} to be disallowed", label); |
| 1141 | } |
| 1142 | } |
| 1143 | Ok(()) |
| 1144 | } |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 1145 | |
| 1146 | #[test] |
| 1147 | fn test_create_or_update_idsig_file_empty_apk() -> Result<()> { |
| 1148 | let apk = tempfile::tempfile().unwrap(); |
| 1149 | let idsig = tempfile::tempfile().unwrap(); |
| 1150 | |
| 1151 | let ret = create_or_update_idsig_file( |
| 1152 | &ParcelFileDescriptor::new(apk), |
| 1153 | &ParcelFileDescriptor::new(idsig), |
| 1154 | ); |
| 1155 | assert!(ret.is_err(), "should fail"); |
| 1156 | Ok(()) |
| 1157 | } |
| 1158 | |
| 1159 | #[test] |
| 1160 | fn test_create_or_update_idsig_dir_instead_of_file_for_apk() -> Result<()> { |
| 1161 | let tmp_dir = tempfile::TempDir::new().unwrap(); |
| 1162 | let apk = File::open(tmp_dir.path()).unwrap(); |
| 1163 | let idsig = tempfile::tempfile().unwrap(); |
| 1164 | |
| 1165 | let ret = create_or_update_idsig_file( |
| 1166 | &ParcelFileDescriptor::new(apk), |
| 1167 | &ParcelFileDescriptor::new(idsig), |
| 1168 | ); |
| 1169 | assert!(ret.is_err(), "should fail"); |
| 1170 | Ok(()) |
| 1171 | } |
| 1172 | |
| 1173 | /// Verifies that create_or_update_idsig_file won't oom if a fd that corresponds to a directory |
| 1174 | /// on ext4 filesystem is passed. |
| 1175 | /// On ext4 lseek on a directory fd will return (off_t)-1 (see: |
| 1176 | /// https://bugzilla.kernel.org/show_bug.cgi?id=200043), which will result in |
| 1177 | /// create_or_update_idsig_file ooming while attempting to allocate petabytes of memory. |
| 1178 | #[test] |
| 1179 | fn test_create_or_update_idsig_does_not_crash_dir_on_ext4() -> Result<()> { |
| 1180 | // APEXes are backed by the ext4. |
| 1181 | let apk = File::open("/apex/com.android.virt/").unwrap(); |
| 1182 | let idsig = tempfile::tempfile().unwrap(); |
| 1183 | |
| 1184 | let ret = create_or_update_idsig_file( |
| 1185 | &ParcelFileDescriptor::new(apk), |
| 1186 | &ParcelFileDescriptor::new(idsig), |
| 1187 | ); |
| 1188 | assert!(ret.is_err(), "should fail"); |
| 1189 | Ok(()) |
| 1190 | } |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 1191 | } |