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; |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 21 | use crate::crosvm::{CrosvmConfig, DiskFile, PayloadState, VfioDevice, VmContext, VmInstance, VmState}; |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 22 | use crate::debug_config::DebugConfig; |
Nikita Ioffe | 5dfddf2 | 2023-06-29 16:11:26 +0100 | [diff] [blame] | 23 | use crate::payload::{add_microdroid_payload_images, add_microdroid_system_images, add_microdroid_vendor_image}; |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 24 | use crate::selinux::{getfilecon, SeContext}; |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 25 | use android_os_permissions_aidl::aidl::android::os::IPermissionController; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 26 | use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::{ |
Alice Wang | 4e3015d | 2023-10-10 09:35:37 +0000 | [diff] [blame] | 27 | Certificate::Certificate, |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 28 | DeathReason::DeathReason, |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 29 | ErrorCode::ErrorCode, |
| 30 | }; |
| 31 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
Inseob Kim | 53d0b21 | 2023-07-20 16:58:37 +0900 | [diff] [blame] | 32 | AssignableDevice::AssignableDevice, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 33 | CpuTopology::CpuTopology, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 34 | DiskImage::DiskImage, |
Alan Stokes | 0cc59ee | 2021-09-24 11:20:34 +0100 | [diff] [blame] | 35 | IVirtualMachine::{BnVirtualMachine, IVirtualMachine}, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 36 | IVirtualMachineCallback::IVirtualMachineCallback, |
| 37 | IVirtualizationService::IVirtualizationService, |
Alan Stokes | 27f3ef0 | 2023-09-29 15:09:35 +0100 | [diff] [blame] | 38 | IVirtualizationService::FEATURE_MULTI_TENANT, |
Nikita Ioffe | 631717e | 2023-09-05 13:38:07 +0100 | [diff] [blame] | 39 | IVirtualizationService::FEATURE_VENDOR_MODULES, |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 40 | IVirtualizationService::FEATURE_DICE_CHANGES, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 41 | MemoryTrimLevel::MemoryTrimLevel, |
Jiyong Park | 029977d | 2021-11-24 21:56:49 +0900 | [diff] [blame] | 42 | Partition::Partition, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 43 | PartitionType::PartitionType, |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 44 | VirtualMachineAppConfig::{DebugLevel::DebugLevel, Payload::Payload, VirtualMachineAppConfig}, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 45 | VirtualMachineConfig::VirtualMachineConfig, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 46 | VirtualMachineDebugInfo::VirtualMachineDebugInfo, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 47 | VirtualMachinePayloadConfig::VirtualMachinePayloadConfig, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 48 | VirtualMachineRawConfig::VirtualMachineRawConfig, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 49 | VirtualMachineState::VirtualMachineState, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 50 | }; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 51 | use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IVirtualizationServiceInternal::IVirtualizationServiceInternal; |
Seungjae Yoo | dd91f0f | 2022-11-09 15:25:21 +0900 | [diff] [blame] | 52 | use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::{ |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 53 | BnVirtualMachineService, IVirtualMachineService, |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 54 | }; |
Alan Stokes | 25f6936 | 2023-03-06 16:51:54 +0000 | [diff] [blame] | 55 | use anyhow::{anyhow, bail, Context, Result}; |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 56 | use apkverify::{HashAlgorithm, V4Signature}; |
Jiyong Park | d7bd2f2 | 2023-08-10 20:41:19 +0900 | [diff] [blame] | 57 | use avflog::LogResult; |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 58 | use binder::{ |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 59 | self, wait_for_interface, BinderFeatures, ExceptionCode, Interface, ParcelFileDescriptor, |
| 60 | Status, StatusCode, Strong, |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 61 | IntoBinderResult, |
Andrew Walbran | a89fc13 | 2021-03-17 17:08:36 +0000 | [diff] [blame] | 62 | }; |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 63 | use disk::QcowFile; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 64 | use lazy_static::lazy_static; |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 65 | use libfdt::Fdt; |
Seungjae Yoo | 0a8c84c | 2022-07-11 08:19:15 +0000 | [diff] [blame] | 66 | use log::{debug, error, info, warn}; |
Seungjae Yoo | fd9a062 | 2022-10-14 10:01:29 +0900 | [diff] [blame] | 67 | use microdroid_payload_config::{OsConfig, Task, TaskType, VmPayloadConfig}; |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 68 | use nix::unistd::pipe; |
David Brazdil | 73988ea | 2022-11-11 15:10:32 +0000 | [diff] [blame] | 69 | use rpcbinder::RpcServer; |
Alan Stokes | 25f6936 | 2023-03-06 16:51:54 +0000 | [diff] [blame] | 70 | use rustutils::system_properties; |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 71 | use semver::VersionReq; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 72 | use std::collections::HashSet; |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 73 | use std::convert::TryInto; |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 74 | use std::ffi::{CStr, CString}; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 75 | use std::fs::{canonicalize, read_dir, remove_file, File, OpenOptions}; |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 76 | use std::io::{BufRead, BufReader, Error, ErrorKind, Write}; |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 77 | use std::num::{NonZeroU16, NonZeroU32}; |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 78 | use std::os::unix::io::{FromRawFd, IntoRawFd}; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 79 | use std::os::unix::raw::pid_t; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 80 | use std::path::{Path, PathBuf}; |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 81 | use std::sync::{Arc, Mutex, Weak}; |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 82 | use vbmeta::VbMetaImage; |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 83 | use vmconfig::VmConfig; |
David Brazdil | afc9a9e | 2023-01-12 16:08:10 +0000 | [diff] [blame] | 84 | use vsock::VsockStream; |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 85 | use zip::ZipArchive; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 86 | |
David Brazdil | 41d1a87 | 2022-10-05 14:44:19 +0100 | [diff] [blame] | 87 | /// The unique ID of a VM used (together with a port number) for vsock communication. |
| 88 | pub type Cid = u32; |
| 89 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 90 | pub const BINDER_SERVICE_IDENTIFIER: &str = "android.system.virtualizationservice"; |
| 91 | |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 92 | /// The size of zero.img. |
| 93 | /// Gaps in composite disk images are filled with a shared zero.img. |
| 94 | const ZERO_FILLER_SIZE: u64 = 4096; |
| 95 | |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 96 | /// Magic string for the instance image |
| 97 | const ANDROID_VM_INSTANCE_MAGIC: &str = "Android-VM-instance"; |
| 98 | |
| 99 | /// Version of the instance image format |
| 100 | const ANDROID_VM_INSTANCE_VERSION: u16 = 1; |
| 101 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 102 | const MICRODROID_OS_NAME: &str = "microdroid"; |
| 103 | |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 104 | const MICRODROID_GKI_OS_NAME: &str = "microdroid_gki"; |
| 105 | |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 106 | const UNFORMATTED_STORAGE_MAGIC: &str = "UNFORMATTED-STORAGE"; |
| 107 | |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 108 | /// Roughly estimated sufficient size for storing vendor public key into DTBO. |
| 109 | const EMPTY_VENDOR_DT_OVERLAY_BUF_SIZE: usize = 10000; |
| 110 | |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 111 | /// crosvm requires all partitions to be a multiple of 4KiB. |
| 112 | const PARTITION_GRANULARITY_BYTES: u64 = 4096; |
| 113 | |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 114 | lazy_static! { |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 115 | pub static ref GLOBAL_SERVICE: Strong<dyn IVirtualizationServiceInternal> = |
| 116 | wait_for_interface(BINDER_SERVICE_IDENTIFIER) |
| 117 | .expect("Could not connect to VirtualizationServiceInternal"); |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 118 | } |
| 119 | |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 120 | fn create_or_update_idsig_file( |
| 121 | input_fd: &ParcelFileDescriptor, |
| 122 | idsig_fd: &ParcelFileDescriptor, |
| 123 | ) -> Result<()> { |
| 124 | let mut input = clone_file(input_fd)?; |
| 125 | let metadata = input.metadata().context("failed to get input metadata")?; |
| 126 | if !metadata.is_file() { |
| 127 | bail!("input is not a regular file"); |
| 128 | } |
Alan Stokes | 25f6936 | 2023-03-06 16:51:54 +0000 | [diff] [blame] | 129 | let mut sig = |
| 130 | V4Signature::create(&mut input, get_current_sdk()?, 4096, &[], HashAlgorithm::SHA256) |
| 131 | .context("failed to create idsig")?; |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 132 | |
| 133 | let mut output = clone_file(idsig_fd)?; |
Jiyong Park | 8d19295 | 2023-06-26 14:29:51 +0900 | [diff] [blame] | 134 | |
| 135 | // Optimization. We don't have to update idsig file whenever a VM is started. Don't update it, |
| 136 | // if the idsig file already has the same APK digest. |
| 137 | if output.metadata()?.len() > 0 { |
| 138 | if let Ok(out_sig) = V4Signature::from_idsig(&mut output) { |
| 139 | if out_sig.signing_info.apk_digest == sig.signing_info.apk_digest { |
| 140 | debug!("idsig {:?} is up-to-date with apk {:?}.", output, input); |
| 141 | return Ok(()); |
| 142 | } |
| 143 | } |
| 144 | // if we fail to read v4signature from output, that's fine. User can pass a random file. |
| 145 | // We will anyway overwrite the file to the v4signature generated from input_fd. |
| 146 | } |
| 147 | |
Nikita Ioffe | c09b049 | 2022-12-14 20:18:33 +0000 | [diff] [blame] | 148 | output.set_len(0).context("failed to set_len on the idsig output")?; |
| 149 | sig.write_into(&mut output).context("failed to write idsig")?; |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 150 | Ok(()) |
| 151 | } |
| 152 | |
Alan Stokes | 25f6936 | 2023-03-06 16:51:54 +0000 | [diff] [blame] | 153 | fn get_current_sdk() -> Result<u32> { |
| 154 | let current_sdk = system_properties::read("ro.build.version.sdk")?; |
| 155 | let current_sdk = current_sdk.ok_or_else(|| anyhow!("SDK version missing"))?; |
| 156 | current_sdk.parse().context("Malformed SDK version") |
| 157 | } |
| 158 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 159 | pub fn remove_temporary_files(path: &PathBuf) -> Result<()> { |
| 160 | for dir_entry in read_dir(path)? { |
| 161 | remove_file(dir_entry?.path())?; |
| 162 | } |
| 163 | Ok(()) |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 164 | } |
| 165 | |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 166 | /// Implementation of `IVirtualizationService`, the entry point of the AIDL service. |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 167 | #[derive(Debug, Default)] |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 168 | pub struct VirtualizationService { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 169 | state: Arc<Mutex<State>>, |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 170 | } |
| 171 | |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 172 | impl Interface for VirtualizationService { |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 173 | fn dump(&self, writer: &mut dyn Write, _args: &[&CStr]) -> Result<(), StatusCode> { |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 174 | check_permission("android.permission.DUMP").or(Err(StatusCode::PERMISSION_DENIED))?; |
| 175 | let state = &mut *self.state.lock().unwrap(); |
| 176 | let vms = state.vms(); |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 177 | writeln!(writer, "Running {0} VMs:", vms.len()).or(Err(StatusCode::UNKNOWN_ERROR))?; |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 178 | for vm in vms { |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 179 | writeln!(writer, "VM CID: {}", vm.cid).or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 180 | writeln!(writer, "\tState: {:?}", vm.vm_state.lock().unwrap()) |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 181 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 182 | writeln!(writer, "\tPayload state {:?}", vm.payload_state()) |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 183 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 184 | writeln!(writer, "\tProtected: {}", vm.protected).or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 185 | writeln!(writer, "\ttemporary_directory: {}", vm.temporary_directory.to_string_lossy()) |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 186 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 187 | writeln!(writer, "\trequester_uid: {}", vm.requester_uid) |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 188 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
Andrei Homescu | 0cf8e22 | 2023-11-09 04:27:55 +0000 | [diff] [blame] | 189 | writeln!(writer, "\trequester_debug_pid: {}", vm.requester_debug_pid) |
Shikha Panwar | d8e3542 | 2021-10-11 13:51:27 +0000 | [diff] [blame] | 190 | .or(Err(StatusCode::UNKNOWN_ERROR))?; |
| 191 | } |
| 192 | Ok(()) |
| 193 | } |
| 194 | } |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 195 | impl IVirtualizationService for VirtualizationService { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 196 | /// Creates (but does not start) a new VM with the given configuration, assigning it the next |
| 197 | /// available CID. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 198 | /// |
| 199 | /// 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] | 200 | fn createVm( |
Andrew Walbran | a89fc13 | 2021-03-17 17:08:36 +0000 | [diff] [blame] | 201 | &self, |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 202 | config: &VirtualMachineConfig, |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 203 | console_out_fd: Option<&ParcelFileDescriptor>, |
| 204 | console_in_fd: Option<&ParcelFileDescriptor>, |
Andrew Walbran | a89fc13 | 2021-03-17 17:08:36 +0000 | [diff] [blame] | 205 | log_fd: Option<&ParcelFileDescriptor>, |
| 206 | ) -> binder::Result<Strong<dyn IVirtualMachine>> { |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 207 | let mut is_protected = false; |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 208 | let ret = self.create_vm_internal( |
| 209 | config, |
| 210 | console_out_fd, |
| 211 | console_in_fd, |
| 212 | log_fd, |
| 213 | &mut is_protected, |
| 214 | ); |
Seungjae Yoo | 0a8c84c | 2022-07-11 08:19:15 +0000 | [diff] [blame] | 215 | write_vm_creation_stats(config, is_protected, &ret); |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 216 | ret |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 217 | } |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 218 | |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 219 | /// Initialise an empty partition image of the given size to be used as a writable partition. |
| 220 | fn initializeWritablePartition( |
| 221 | &self, |
| 222 | image_fd: &ParcelFileDescriptor, |
Alan Stokes | ff0005f | 2023-01-30 09:53:00 +0000 | [diff] [blame] | 223 | size_bytes: i64, |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 224 | partition_type: PartitionType, |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 225 | ) -> binder::Result<()> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 226 | check_manage_access()?; |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 227 | let size_bytes = size_bytes |
| 228 | .try_into() |
| 229 | .with_context(|| format!("Invalid size: {}", size_bytes)) |
| 230 | .or_binder_exception(ExceptionCode::ILLEGAL_ARGUMENT)?; |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 231 | let size_bytes = round_up(size_bytes, PARTITION_GRANULARITY_BYTES); |
| 232 | let image = clone_file(image_fd)?; |
| 233 | // initialize the file. Any data in the file will be erased. |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 234 | image.set_len(0).context("Failed to reset a file").or_service_specific_exception(-1)?; |
| 235 | let mut part = QcowFile::new(image, size_bytes) |
| 236 | .context("Failed to create QCOW2 image") |
| 237 | .or_service_specific_exception(-1)?; |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 238 | |
| 239 | match partition_type { |
| 240 | PartitionType::RAW => Ok(()), |
| 241 | PartitionType::ANDROID_VM_INSTANCE => format_as_android_vm_instance(&mut part), |
| 242 | PartitionType::ENCRYPTEDSTORE => format_as_encryptedstore(&mut part), |
| 243 | _ => Err(Error::new( |
| 244 | ErrorKind::Unsupported, |
| 245 | format!("Unsupported partition type {:?}", partition_type), |
| 246 | )), |
| 247 | } |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 248 | .with_context(|| format!("Failed to initialize partition as {:?}", partition_type)) |
| 249 | .or_service_specific_exception(-1)?; |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 250 | |
| 251 | Ok(()) |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 252 | } |
| 253 | |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 254 | /// Creates or update the idsig file by digesting the input APK file. |
| 255 | fn createOrUpdateIdsigFile( |
| 256 | &self, |
| 257 | input_fd: &ParcelFileDescriptor, |
| 258 | idsig_fd: &ParcelFileDescriptor, |
| 259 | ) -> binder::Result<()> { |
Jiyong Park | c3ca24f | 2022-06-28 10:45:15 +0900 | [diff] [blame] | 260 | check_manage_access()?; |
| 261 | |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 262 | create_or_update_idsig_file(input_fd, idsig_fd).or_service_specific_exception(-1)?; |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 263 | Ok(()) |
| 264 | } |
| 265 | |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 266 | /// Get a list of all currently running VMs. This method is only intended for debug purposes, |
| 267 | /// and as such is only permitted from the shell user. |
| 268 | fn debugListVms(&self) -> binder::Result<Vec<VirtualMachineDebugInfo>> { |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 269 | // Delegate to the global service, including checking the debug permission. |
David Brazdil | d4f51a5 | 2023-01-11 14:09:27 +0000 | [diff] [blame] | 270 | GLOBAL_SERVICE.debugListVms() |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 271 | } |
Inseob Kim | 53d0b21 | 2023-07-20 16:58:37 +0900 | [diff] [blame] | 272 | |
| 273 | /// Get a list of assignable device types. |
| 274 | fn getAssignableDevices(&self) -> binder::Result<Vec<AssignableDevice>> { |
| 275 | // Delegate to the global service, including checking the permission. |
| 276 | GLOBAL_SERVICE.getAssignableDevices() |
| 277 | } |
Nikita Ioffe | f7c742a | 2023-09-04 16:57:59 +0100 | [diff] [blame] | 278 | |
| 279 | /// Returns whether given feature is enabled |
| 280 | fn isFeatureEnabled(&self, feature: &str) -> binder::Result<bool> { |
| 281 | check_manage_access()?; |
| 282 | |
| 283 | // This approach is quite cumbersome, but will do the work for the short term. |
| 284 | // TODO(b/298012279): make this scalable. |
| 285 | match feature { |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 286 | FEATURE_DICE_CHANGES => Ok(cfg!(dice_changes)), |
Alan Stokes | 27f3ef0 | 2023-09-29 15:09:35 +0100 | [diff] [blame] | 287 | FEATURE_MULTI_TENANT => Ok(cfg!(multi_tenant)), |
Nikita Ioffe | 631717e | 2023-09-05 13:38:07 +0100 | [diff] [blame] | 288 | FEATURE_VENDOR_MODULES => Ok(cfg!(vendor_modules)), |
Nikita Ioffe | f7c742a | 2023-09-04 16:57:59 +0100 | [diff] [blame] | 289 | _ => { |
Alan Stokes | 7f27c0d | 2023-09-07 16:22:58 +0100 | [diff] [blame] | 290 | warn!("unknown feature {feature}"); |
Nikita Ioffe | f7c742a | 2023-09-04 16:57:59 +0100 | [diff] [blame] | 291 | Ok(false) |
| 292 | } |
| 293 | } |
| 294 | } |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 295 | } |
| 296 | |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 297 | impl VirtualizationService { |
| 298 | pub fn init() -> VirtualizationService { |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 299 | VirtualizationService::default() |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 300 | } |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 301 | |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 302 | fn create_vm_context( |
| 303 | &self, |
| 304 | requester_debug_pid: pid_t, |
| 305 | ) -> binder::Result<(VmContext, Cid, PathBuf)> { |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 306 | const NUM_ATTEMPTS: usize = 5; |
| 307 | |
| 308 | for _ in 0..NUM_ATTEMPTS { |
Charisee | 96113f3 | 2023-01-26 09:00:42 +0000 | [diff] [blame] | 309 | let vm_context = GLOBAL_SERVICE.allocateGlobalVmContext(requester_debug_pid)?; |
David Brazdil | d4f51a5 | 2023-01-11 14:09:27 +0000 | [diff] [blame] | 310 | let cid = vm_context.getCid()? as Cid; |
| 311 | let temp_dir: PathBuf = vm_context.getTemporaryDirectory()?.into(); |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 312 | let service = VirtualMachineService::new_binder(self.state.clone(), cid).as_binder(); |
| 313 | |
| 314 | // 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] | 315 | let port = cid; |
David Brazdil | 3238da4 | 2022-11-18 10:04:51 +0000 | [diff] [blame] | 316 | match RpcServer::new_vsock(service, cid, port) { |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 317 | Ok(vm_server) => { |
| 318 | vm_server.start(); |
David Brazdil | d4f51a5 | 2023-01-11 14:09:27 +0000 | [diff] [blame] | 319 | return Ok((VmContext::new(vm_context, vm_server), cid, temp_dir)); |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 320 | } |
| 321 | Err(err) => { |
| 322 | warn!("Could not start RpcServer on port {}: {}", port, err); |
| 323 | } |
| 324 | } |
| 325 | } |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 326 | Err(anyhow!("Too many attempts to create VM context failed")) |
| 327 | .or_service_specific_exception(-1) |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 328 | } |
| 329 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 330 | fn create_vm_internal( |
| 331 | &self, |
| 332 | config: &VirtualMachineConfig, |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 333 | console_out_fd: Option<&ParcelFileDescriptor>, |
| 334 | console_in_fd: Option<&ParcelFileDescriptor>, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 335 | log_fd: Option<&ParcelFileDescriptor>, |
| 336 | is_protected: &mut bool, |
| 337 | ) -> binder::Result<Strong<dyn IVirtualMachine>> { |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 338 | let requester_uid = get_calling_uid(); |
| 339 | let requester_debug_pid = get_calling_pid(); |
| 340 | |
Nikita Ioffe | 631717e | 2023-09-05 13:38:07 +0100 | [diff] [blame] | 341 | check_config_features(config)?; |
| 342 | |
David Brazdil | 209074a | 2023-01-12 16:44:51 +0000 | [diff] [blame] | 343 | // Allocating VM context checks the MANAGE_VIRTUAL_MACHINE permission. |
| 344 | 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] | 345 | |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 346 | let is_custom = match config { |
| 347 | VirtualMachineConfig::RawConfig(_) => true, |
| 348 | VirtualMachineConfig::AppConfig(config) => { |
| 349 | // Some features are reserved for platform apps only, even when using |
Nikita Ioffe | a0eb5ee | 2023-06-26 18:18:21 +0100 | [diff] [blame] | 350 | // VirtualMachineAppConfig. Almost all of these features are grouped in the |
| 351 | // CustomConfig struct: |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 352 | // - controlling CPUs; |
Nikita Ioffe | a0eb5ee | 2023-06-26 18:18:21 +0100 | [diff] [blame] | 353 | // - specifying a config file in the APK; (this one is not part of CustomConfig) |
Nikita Ioffe | 26c35ed | 2023-06-05 17:49:08 +0100 | [diff] [blame] | 354 | // - gdbPort is set, meaning that crosvm will start a gdb server; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 355 | // - using anything other than the default kernel; |
| 356 | // - specifying devices to be assigned. |
Nikita Ioffe | a0eb5ee | 2023-06-26 18:18:21 +0100 | [diff] [blame] | 357 | config.customConfig.is_some() || matches!(config.payload, Payload::ConfigPath(_)) |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 358 | } |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 359 | }; |
| 360 | if is_custom { |
| 361 | check_use_custom_virtual_machine()?; |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 362 | } |
| 363 | |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 364 | let gdb_port = extract_gdb_port(config); |
| 365 | |
| 366 | // Additional permission checks if caller request gdb. |
| 367 | if gdb_port.is_some() { |
| 368 | check_gdb_allowed(config)?; |
| 369 | } |
| 370 | |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 371 | let vendor_public_key = extract_vendor_public_key(config) |
| 372 | .context("Failed to extract vendor public key") |
| 373 | .or_service_specific_exception(-1)?; |
| 374 | let dtbo_vendor = if let Some(vendor_public_key) = vendor_public_key { |
| 375 | let dtbo_for_vendor_image = temporary_directory.join("dtbo_vendor"); |
| 376 | create_dtbo_for_vendor_image(&vendor_public_key, &dtbo_for_vendor_image) |
| 377 | .context("Failed to write vendor_public_key") |
| 378 | .or_service_specific_exception(-1)?; |
| 379 | let file = File::open(dtbo_for_vendor_image) |
| 380 | .context("Failed to open dtbo_vendor") |
| 381 | .or_service_specific_exception(-1)?; |
| 382 | Some(file) |
| 383 | } else { |
| 384 | None |
| 385 | }; |
| 386 | |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 387 | let debug_level = match config { |
| 388 | VirtualMachineConfig::AppConfig(config) => config.debugLevel, |
| 389 | _ => DebugLevel::NONE, |
| 390 | }; |
| 391 | let debug_config = DebugConfig::new(debug_level); |
| 392 | |
| 393 | let ramdump = if debug_config.is_ramdump_needed() { |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 394 | Some(prepare_ramdump_file(&temporary_directory)?) |
| 395 | } else { |
| 396 | None |
| 397 | }; |
| 398 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 399 | let state = &mut *self.state.lock().unwrap(); |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 400 | let console_out_fd = |
| 401 | clone_or_prepare_logger_fd(&debug_config, console_out_fd, format!("Console({})", cid))?; |
| 402 | let console_in_fd = console_in_fd.map(clone_file).transpose()?; |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 403 | let log_fd = clone_or_prepare_logger_fd(&debug_config, log_fd, format!("Log({})", cid))?; |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 404 | |
| 405 | // Counter to generate unique IDs for temporary image files. |
| 406 | let mut next_temporary_image_id = 0; |
| 407 | // Files which are referred to from composite images. These must be mapped to the crosvm |
| 408 | // child process, and not closed before it is started. |
| 409 | let mut indirect_files = vec![]; |
| 410 | |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 411 | let (is_app_config, config) = match config { |
| 412 | VirtualMachineConfig::RawConfig(config) => (false, BorrowedOrOwned::Borrowed(config)), |
| 413 | VirtualMachineConfig::AppConfig(config) => { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 414 | let config = load_app_config(config, &debug_config, &temporary_directory) |
| 415 | .or_service_specific_exception_with(-1, |e| { |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 416 | *is_protected = config.protectedVm; |
| 417 | let message = format!("Failed to load app config: {:?}", e); |
| 418 | error!("{}", message); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 419 | message |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 420 | })?; |
Alan Stokes | 7bc146c | 2022-10-20 17:10:32 +0100 | [diff] [blame] | 421 | (true, BorrowedOrOwned::Owned(config)) |
| 422 | } |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 423 | }; |
| 424 | let config = config.as_ref(); |
| 425 | *is_protected = config.protectedVm; |
| 426 | |
| 427 | // Check if partition images are labeled incorrectly. This is to prevent random images |
| 428 | // which are not protected by the Android Verified Boot (e.g. bits downloaded by apps) from |
Alan Stokes | 3e5eec1 | 2023-09-07 12:10:00 +0100 | [diff] [blame] | 429 | // being loaded in a pVM. This applies to everything but the instance image in the raw |
| 430 | // config, and everything but the non-executable, generated partitions in the app |
| 431 | // config. |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 432 | config |
| 433 | .disks |
| 434 | .iter() |
| 435 | .flat_map(|disk| disk.partitions.iter()) |
| 436 | .filter(|partition| { |
| 437 | if is_app_config { |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 438 | !is_safe_app_partition(&partition.label) |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 439 | } else { |
Alice Wang | c206b9b | 2023-08-28 14:13:51 +0000 | [diff] [blame] | 440 | !is_safe_raw_partition(&partition.label) |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 441 | } |
| 442 | }) |
| 443 | .try_for_each(check_label_for_partition) |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 444 | .or_service_specific_exception(-1)?; |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 445 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 446 | let kernel = maybe_clone_file(&config.kernel)?; |
| 447 | let initrd = maybe_clone_file(&config.initrd)?; |
| 448 | |
| 449 | // In a protected VM, we require custom kernels to come from a trusted source (b/237054515). |
| 450 | if config.protectedVm { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 451 | check_label_for_kernel_files(&kernel, &initrd).or_service_specific_exception(-1)?; |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 452 | } |
| 453 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 454 | let zero_filler_path = temporary_directory.join("zero.img"); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 455 | write_zero_filler(&zero_filler_path) |
| 456 | .context("Failed to make composite image") |
| 457 | .with_log() |
| 458 | .or_service_specific_exception(-1)?; |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 459 | |
| 460 | // Assemble disk images if needed. |
| 461 | let disks = config |
| 462 | .disks |
| 463 | .iter() |
| 464 | .map(|disk| { |
| 465 | assemble_disk_image( |
| 466 | disk, |
| 467 | &zero_filler_path, |
| 468 | &temporary_directory, |
| 469 | &mut next_temporary_image_id, |
| 470 | &mut indirect_files, |
| 471 | ) |
| 472 | }) |
| 473 | .collect::<Result<Vec<DiskFile>, _>>()?; |
| 474 | |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 475 | let (cpus, host_cpu_topology) = match config.cpuTopology { |
| 476 | CpuTopology::MATCH_HOST => (None, true), |
| 477 | CpuTopology::ONE_CPU => (NonZeroU32::new(1), false), |
| 478 | val => { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 479 | return Err(anyhow!("Failed to parse CPU topology value {:?}", val)) |
| 480 | .with_log() |
| 481 | .or_service_specific_exception(-1); |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 482 | } |
| 483 | }; |
| 484 | |
David Brazdil | 2dfefd1 | 2023-11-17 14:07:36 +0000 | [diff] [blame^] | 485 | let (vfio_devices, dtbo) = if !config.devices.is_empty() { |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 486 | let mut set = HashSet::new(); |
| 487 | for device in config.devices.iter() { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 488 | let path = canonicalize(device) |
| 489 | .with_context(|| format!("can't canonicalize {device}")) |
| 490 | .or_service_specific_exception(-1)?; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 491 | if !set.insert(path) { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 492 | return Err(anyhow!("duplicated device {device}")) |
| 493 | .or_binder_exception(ExceptionCode::ILLEGAL_ARGUMENT); |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 494 | } |
| 495 | } |
David Brazdil | 2dfefd1 | 2023-11-17 14:07:36 +0000 | [diff] [blame^] | 496 | let devices = GLOBAL_SERVICE |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 497 | .bindDevicesToVfioDriver(&config.devices)? |
| 498 | .into_iter() |
| 499 | .map(|x| VfioDevice { |
| 500 | sysfs_path: PathBuf::from(&x.sysfsPath), |
Jaewan Kim | 35e818d | 2023-10-18 05:36:38 +0000 | [diff] [blame] | 501 | dtbo_label: x.dtboLabel, |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 502 | }) |
David Brazdil | 2dfefd1 | 2023-11-17 14:07:36 +0000 | [diff] [blame^] | 503 | .collect::<Vec<_>>(); |
| 504 | let dtbo_file = File::from( |
| 505 | GLOBAL_SERVICE |
| 506 | .getDtboFile()? |
| 507 | .as_ref() |
| 508 | .try_clone() |
| 509 | .context("Failed to create File from ParcelFileDescriptor") |
| 510 | .or_binder_exception(ExceptionCode::BAD_PARCELABLE)?, |
| 511 | ); |
| 512 | (devices, Some(dtbo_file)) |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 513 | } else { |
David Brazdil | 2dfefd1 | 2023-11-17 14:07:36 +0000 | [diff] [blame^] | 514 | (vec![], None) |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 515 | }; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 516 | |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 517 | // Actually start the VM. |
| 518 | let crosvm_config = CrosvmConfig { |
| 519 | cid, |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 520 | name: config.name.clone(), |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 521 | bootloader: maybe_clone_file(&config.bootloader)?, |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 522 | kernel, |
| 523 | initrd, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 524 | disks, |
| 525 | params: config.params.to_owned(), |
| 526 | protected: *is_protected, |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 527 | debug_config, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 528 | memory_mib: config.memoryMib.try_into().ok().and_then(NonZeroU32::new), |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 529 | cpus, |
| 530 | host_cpu_topology, |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 531 | task_profiles: config.taskProfiles.clone(), |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 532 | console_out_fd, |
| 533 | console_in_fd, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 534 | log_fd, |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 535 | ramdump, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 536 | indirect_files, |
| 537 | platform_version: parse_platform_version_req(&config.platformVersion)?, |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 538 | detect_hangup: is_app_config, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 539 | gdb_port, |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 540 | vfio_devices, |
David Brazdil | 2dfefd1 | 2023-11-17 14:07:36 +0000 | [diff] [blame^] | 541 | dtbo, |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 542 | dtbo_vendor, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 543 | }; |
| 544 | let instance = Arc::new( |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 545 | VmInstance::new( |
| 546 | crosvm_config, |
| 547 | temporary_directory, |
| 548 | requester_uid, |
| 549 | requester_debug_pid, |
| 550 | vm_context, |
| 551 | ) |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 552 | .with_context(|| format!("Failed to create VM with config {:?}", config)) |
| 553 | .with_log() |
| 554 | .or_service_specific_exception(-1)?, |
Shikha Panwar | 061aa2c | 2022-04-05 12:52:56 +0000 | [diff] [blame] | 555 | ); |
| 556 | state.add_vm(Arc::downgrade(&instance)); |
| 557 | Ok(VirtualMachine::create(instance)) |
| 558 | } |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 559 | } |
| 560 | |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 561 | fn extract_vendor_public_key(config: &VirtualMachineConfig) -> Result<Option<Vec<u8>>> { |
| 562 | let VirtualMachineConfig::AppConfig(config) = config else { |
| 563 | return Ok(None); |
| 564 | }; |
| 565 | let Some(custom_config) = &config.customConfig else { |
| 566 | return Ok(None); |
| 567 | }; |
| 568 | let Some(file) = custom_config.vendorImage.as_ref() else { |
| 569 | return Ok(None); |
| 570 | }; |
| 571 | |
| 572 | let file = clone_file(file)?; |
| 573 | let size = file.metadata().context("Failed to get metadata from microdroid-vendor.img")?.len(); |
| 574 | let vbmeta = VbMetaImage::verify_reader_region(&file, 0, size) |
| 575 | .context("Failed to get vbmeta from microdroid-vendor.img")?; |
| 576 | let vendor_public_key = vbmeta |
| 577 | .public_key() |
| 578 | .ok_or(anyhow!("No public key is extracted from microdroid-vendor.img"))? |
| 579 | .to_vec(); |
| 580 | |
| 581 | Ok(Some(vendor_public_key)) |
| 582 | } |
| 583 | |
| 584 | fn create_dtbo_for_vendor_image(vendor_public_key: &[u8], dtbo: &PathBuf) -> Result<()> { |
| 585 | if dtbo.exists() { |
| 586 | return Err(anyhow!("DTBO file already exists")); |
| 587 | } |
| 588 | |
| 589 | let mut buf = vec![0; EMPTY_VENDOR_DT_OVERLAY_BUF_SIZE]; |
| 590 | let fdt = Fdt::create_empty_tree(buf.as_mut_slice()) |
| 591 | .map_err(|e| anyhow!("Failed to create FDT: {:?}", e))?; |
| 592 | let mut root = fdt.root_mut().map_err(|e| anyhow!("Failed to get root node: {:?}", e))?; |
| 593 | |
| 594 | let fragment_node_name = CString::new("fragment@0")?; |
| 595 | let mut fragment_node = root |
| 596 | .add_subnode(fragment_node_name.as_c_str()) |
| 597 | .map_err(|e| anyhow!("Failed to create fragment node: {:?}", e))?; |
| 598 | let target_path_prop_name = CString::new("target-path")?; |
| 599 | let target_path = CString::new("/")?; |
| 600 | fragment_node |
| 601 | .setprop(target_path_prop_name.as_c_str(), target_path.to_bytes_with_nul()) |
| 602 | .map_err(|e| anyhow!("Failed to set target-path: {:?}", e))?; |
| 603 | let overlay_node_name = CString::new("__overlay__")?; |
| 604 | let mut overlay_node = fragment_node |
| 605 | .add_subnode(overlay_node_name.as_c_str()) |
| 606 | .map_err(|e| anyhow!("Failed to create overlay node: {:?}", e))?; |
| 607 | |
| 608 | let avf_node_name = CString::new("avf")?; |
| 609 | let mut avf_node = overlay_node |
| 610 | .add_subnode(avf_node_name.as_c_str()) |
| 611 | .map_err(|e| anyhow!("Failed to create avf node: {:?}", e))?; |
| 612 | let vendor_public_key_name = CString::new("vendor_public_key")?; |
| 613 | avf_node |
| 614 | .setprop(vendor_public_key_name.as_c_str(), vendor_public_key) |
| 615 | .map_err(|e| anyhow!("Failed to set avf/vendor_public_key: {:?}", e))?; |
| 616 | |
| 617 | fdt.pack().map_err(|e| anyhow!("Failed to pack fdt: {:?}", e))?; |
| 618 | let mut file = File::create(dtbo)?; |
| 619 | file.write_all(fdt.as_slice())?; |
| 620 | Ok(file.flush()?) |
| 621 | } |
| 622 | |
Andrew Walbran | fbb39d2 | 2021-07-28 17:01:25 +0000 | [diff] [blame] | 623 | fn write_zero_filler(zero_filler_path: &Path) -> Result<()> { |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 624 | let file = OpenOptions::new() |
| 625 | .create_new(true) |
| 626 | .read(true) |
| 627 | .write(true) |
| 628 | .open(zero_filler_path) |
| 629 | .with_context(|| "Failed to create zero.img")?; |
| 630 | file.set_len(ZERO_FILLER_SIZE)?; |
Andrew Walbran | fbb39d2 | 2021-07-28 17:01:25 +0000 | [diff] [blame] | 631 | Ok(()) |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 632 | } |
| 633 | |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 634 | fn format_as_android_vm_instance(part: &mut dyn Write) -> std::io::Result<()> { |
| 635 | part.write_all(ANDROID_VM_INSTANCE_MAGIC.as_bytes())?; |
| 636 | part.write_all(&ANDROID_VM_INSTANCE_VERSION.to_le_bytes())?; |
| 637 | part.flush() |
| 638 | } |
| 639 | |
| 640 | fn format_as_encryptedstore(part: &mut dyn Write) -> std::io::Result<()> { |
| 641 | part.write_all(UNFORMATTED_STORAGE_MAGIC.as_bytes())?; |
| 642 | part.flush() |
| 643 | } |
| 644 | |
| 645 | fn round_up(input: u64, granularity: u64) -> u64 { |
| 646 | if granularity == 0 { |
| 647 | return input; |
| 648 | } |
| 649 | // If the input is absurdly large we round down instead of up; it's going to fail anyway. |
| 650 | let result = input.checked_add(granularity - 1).unwrap_or(input); |
| 651 | (result / granularity) * granularity |
| 652 | } |
| 653 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 654 | /// Given the configuration for a disk image, assembles the `DiskFile` to pass to crosvm. |
| 655 | /// |
| 656 | /// This may involve assembling a composite disk from a set of partition images. |
| 657 | fn assemble_disk_image( |
| 658 | disk: &DiskImage, |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 659 | zero_filler_path: &Path, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 660 | temporary_directory: &Path, |
| 661 | next_temporary_image_id: &mut u64, |
| 662 | indirect_files: &mut Vec<File>, |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 663 | ) -> Result<DiskFile, Status> { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 664 | let image = if !disk.partitions.is_empty() { |
| 665 | if disk.image.is_some() { |
| 666 | warn!("DiskImage {:?} contains both image and partitions.", disk); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 667 | return Err(anyhow!("DiskImage contains both image and partitions")) |
| 668 | .or_binder_exception(ExceptionCode::ILLEGAL_ARGUMENT); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 669 | } |
| 670 | |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 671 | let composite_image_filenames = |
| 672 | make_composite_image_filenames(temporary_directory, next_temporary_image_id); |
| 673 | let (image, partition_files) = make_composite_image( |
| 674 | &disk.partitions, |
Jooyung Han | 9588463 | 2021-07-06 22:27:54 +0900 | [diff] [blame] | 675 | zero_filler_path, |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 676 | &composite_image_filenames.composite, |
| 677 | &composite_image_filenames.header, |
| 678 | &composite_image_filenames.footer, |
| 679 | ) |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 680 | .with_context(|| format!("Failed to make composite disk image with config {:?}", disk)) |
| 681 | .with_log() |
| 682 | .or_service_specific_exception(-1)?; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 683 | |
| 684 | // Pass the file descriptors for the various partition files to crosvm when it |
| 685 | // is run. |
| 686 | indirect_files.extend(partition_files); |
| 687 | |
| 688 | image |
| 689 | } else if let Some(image) = &disk.image { |
| 690 | clone_file(image)? |
| 691 | } else { |
| 692 | warn!("DiskImage {:?} didn't contain image or partitions.", disk); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 693 | return Err(anyhow!("DiskImage didn't contain image or partitions.")) |
| 694 | .or_binder_exception(ExceptionCode::ILLEGAL_ARGUMENT); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 695 | }; |
| 696 | |
| 697 | Ok(DiskFile { image, writable: disk.writable }) |
| 698 | } |
| 699 | |
Nikita Ioffe | aa6858c | 2023-07-04 01:37:41 +0100 | [diff] [blame] | 700 | fn append_kernel_param(param: &str, vm_config: &mut VirtualMachineRawConfig) { |
| 701 | if let Some(ref mut params) = vm_config.params { |
| 702 | params.push(' '); |
| 703 | params.push_str(param) |
| 704 | } else { |
| 705 | vm_config.params = Some(param.to_owned()) |
| 706 | } |
| 707 | } |
| 708 | |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 709 | fn is_valid_os(os_name: &str) -> bool { |
| 710 | if os_name == MICRODROID_OS_NAME { |
| 711 | return true; |
| 712 | } |
| 713 | if cfg!(vendor_modules) && os_name == MICRODROID_GKI_OS_NAME { |
| 714 | return true; |
| 715 | } |
| 716 | false |
| 717 | } |
| 718 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 719 | fn load_app_config( |
| 720 | config: &VirtualMachineAppConfig, |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 721 | debug_config: &DebugConfig, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 722 | temporary_directory: &Path, |
Jooyung Han | adfb76c | 2021-06-28 17:29:30 +0900 | [diff] [blame] | 723 | ) -> Result<VirtualMachineRawConfig> { |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 724 | let apk_file = clone_file(config.apk.as_ref().unwrap())?; |
| 725 | let idsig_file = clone_file(config.idsig.as_ref().unwrap())?; |
Jiyong Park | 8d08181 | 2021-07-23 17:45:04 +0900 | [diff] [blame] | 726 | let instance_file = clone_file(config.instanceImage.as_ref().unwrap())?; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 727 | |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 728 | let storage_image = if let Some(file) = config.encryptedStorageImage.as_ref() { |
| 729 | Some(clone_file(file)?) |
| 730 | } else { |
| 731 | None |
| 732 | }; |
| 733 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 734 | let vm_payload_config = match &config.payload { |
| 735 | Payload::ConfigPath(config_path) => { |
| 736 | load_vm_payload_config_from_file(&apk_file, config_path.as_str()) |
| 737 | .with_context(|| format!("Couldn't read config from {}", config_path))? |
| 738 | } |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 739 | Payload::PayloadConfig(payload_config) => create_vm_payload_config(payload_config)?, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 740 | }; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 741 | |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 742 | // For now, the only supported OS is Microdroid and Microdroid GKI |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 743 | let os_name = vm_payload_config.os.name.as_str(); |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 744 | if !is_valid_os(os_name) { |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 745 | bail!("Unknown OS \"{}\"", os_name); |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 746 | } |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 747 | |
| 748 | // It is safe to construct a filename based on the os_name because we've already checked that it |
| 749 | // is one of the allowed values. |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 750 | let vm_config_path = PathBuf::from(format!("/apex/com.android.virt/etc/{}.json", os_name)); |
| 751 | let vm_config_file = File::open(vm_config_path)?; |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 752 | let mut vm_config = VmConfig::load(&vm_config_file)?.to_parcelable()?; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 753 | |
Nikita Ioffe | a0eb5ee | 2023-06-26 18:18:21 +0100 | [diff] [blame] | 754 | if let Some(custom_config) = &config.customConfig { |
| 755 | if let Some(file) = custom_config.customKernelImage.as_ref() { |
| 756 | vm_config.kernel = Some(ParcelFileDescriptor::new(clone_file(file)?)) |
| 757 | } |
| 758 | vm_config.taskProfiles = custom_config.taskProfiles.clone(); |
| 759 | vm_config.gdbPort = custom_config.gdbPort; |
Nikita Ioffe | 5dfddf2 | 2023-06-29 16:11:26 +0100 | [diff] [blame] | 760 | |
| 761 | if let Some(file) = custom_config.vendorImage.as_ref() { |
Nikita Ioffe | aa6858c | 2023-07-04 01:37:41 +0100 | [diff] [blame] | 762 | add_microdroid_vendor_image(clone_file(file)?, &mut vm_config); |
| 763 | append_kernel_param("androidboot.microdroid.mount_vendor=1", &mut vm_config) |
Nikita Ioffe | 5dfddf2 | 2023-06-29 16:11:26 +0100 | [diff] [blame] | 764 | } |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 765 | |
| 766 | vm_config.devices = custom_config.devices.clone(); |
Nikita Ioffe | 26c35ed | 2023-06-05 17:49:08 +0100 | [diff] [blame] | 767 | } |
| 768 | |
Andrew Walbran | cc04590 | 2021-07-27 16:06:17 +0000 | [diff] [blame] | 769 | if config.memoryMib > 0 { |
| 770 | vm_config.memoryMib = config.memoryMib; |
Andrew Walbran | 45bcb0c | 2021-07-14 15:02:06 +0000 | [diff] [blame] | 771 | } |
| 772 | |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 773 | vm_config.name = config.name.clone(); |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 774 | vm_config.protectedVm = config.protectedVm; |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 775 | vm_config.cpuTopology = config.cpuTopology; |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 776 | |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 777 | // Microdroid takes additional init ramdisk & (optionally) storage image |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 778 | add_microdroid_system_images(config, instance_file, storage_image, os_name, &mut vm_config)?; |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 779 | |
| 780 | // Include Microdroid payload disk (contains apks, idsigs) in vm config |
| 781 | add_microdroid_payload_images( |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 782 | config, |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 783 | debug_config, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 784 | temporary_directory, |
| 785 | apk_file, |
| 786 | idsig_file, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 787 | &vm_payload_config, |
| 788 | &mut vm_config, |
| 789 | )?; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 790 | |
Andrew Walbran | cc0db52 | 2021-07-12 17:03:42 +0000 | [diff] [blame] | 791 | Ok(vm_config) |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 792 | } |
| 793 | |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 794 | fn load_vm_payload_config_from_file(apk_file: &File, config_path: &str) -> Result<VmPayloadConfig> { |
| 795 | let mut apk_zip = ZipArchive::new(apk_file)?; |
| 796 | let config_file = apk_zip.by_name(config_path)?; |
| 797 | Ok(serde_json::from_reader(config_file)?) |
| 798 | } |
| 799 | |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 800 | fn create_vm_payload_config( |
| 801 | payload_config: &VirtualMachinePayloadConfig, |
| 802 | ) -> Result<VmPayloadConfig> { |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 803 | // There isn't an actual config file. Construct a synthetic VmPayloadConfig from the explicit |
| 804 | // parameters we've been given. Microdroid will do something equivalent inside the VM using the |
| 805 | // payload config that we send it via the metadata file. |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 806 | |
| 807 | let payload_binary_name = &payload_config.payloadBinaryName; |
| 808 | if payload_binary_name.contains('/') { |
| 809 | bail!("Payload binary name must not specify a path: {payload_binary_name}"); |
| 810 | } |
| 811 | |
| 812 | let task = Task { type_: TaskType::MicrodroidLauncher, command: payload_binary_name.clone() }; |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 813 | let name = payload_config.osName.clone(); |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 814 | Ok(VmPayloadConfig { |
Inseob Kim | 172f9eb | 2023-11-06 17:02:08 +0900 | [diff] [blame] | 815 | os: OsConfig { name }, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 816 | task: Some(task), |
| 817 | apexes: vec![], |
| 818 | extra_apks: vec![], |
| 819 | prefer_staged: false, |
Inseob Kim | ab1037d | 2023-02-08 17:03:31 +0900 | [diff] [blame] | 820 | export_tombstones: None, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 821 | enable_authfs: false, |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 822 | }) |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 823 | } |
| 824 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 825 | /// Generates a unique filename to use for a composite disk image. |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 826 | fn make_composite_image_filenames( |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 827 | temporary_directory: &Path, |
| 828 | next_temporary_image_id: &mut u64, |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 829 | ) -> CompositeImageFilenames { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 830 | let id = *next_temporary_image_id; |
| 831 | *next_temporary_image_id += 1; |
Andrew Walbran | 3eca16c | 2021-06-14 11:15:14 +0000 | [diff] [blame] | 832 | CompositeImageFilenames { |
| 833 | composite: temporary_directory.join(format!("composite-{}.img", id)), |
| 834 | header: temporary_directory.join(format!("composite-{}-header.img", id)), |
| 835 | footer: temporary_directory.join(format!("composite-{}-footer.img", id)), |
| 836 | } |
| 837 | } |
| 838 | |
| 839 | /// Filenames for a composite disk image, including header and footer partitions. |
| 840 | #[derive(Clone, Debug, Eq, PartialEq)] |
| 841 | struct CompositeImageFilenames { |
| 842 | /// The composite disk image itself. |
| 843 | composite: PathBuf, |
| 844 | /// The header partition image. |
| 845 | header: PathBuf, |
| 846 | /// The footer partition image. |
| 847 | footer: PathBuf, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 848 | } |
| 849 | |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 850 | /// Checks whether the caller has a specific permission |
| 851 | fn check_permission(perm: &str) -> binder::Result<()> { |
David Brazdil | 1f53070 | 2022-10-03 12:18:10 +0100 | [diff] [blame] | 852 | let calling_pid = get_calling_pid(); |
| 853 | let calling_uid = get_calling_uid(); |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 854 | // Root can do anything |
| 855 | if calling_uid == 0 { |
| 856 | return Ok(()); |
| 857 | } |
| 858 | let perm_svc: Strong<dyn IPermissionController::IPermissionController> = |
| 859 | binder::get_interface("permission")?; |
| 860 | if perm_svc.checkPermission(perm, calling_pid, calling_uid as i32)? { |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 861 | Ok(()) |
| 862 | } else { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 863 | Err(anyhow!("does not have the {} permission", perm)) |
| 864 | .or_binder_exception(ExceptionCode::SECURITY) |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 865 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 866 | } |
| 867 | |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 868 | /// Check whether the caller of the current Binder method is allowed to manage VMs |
| 869 | fn check_manage_access() -> binder::Result<()> { |
| 870 | check_permission("android.permission.MANAGE_VIRTUAL_MACHINE") |
| 871 | } |
| 872 | |
Inseob Kim | 1119d70 | 2022-05-02 18:01:58 +0900 | [diff] [blame] | 873 | /// Check whether the caller of the current Binder method is allowed to create custom VMs |
| 874 | fn check_use_custom_virtual_machine() -> binder::Result<()> { |
| 875 | check_permission("android.permission.USE_CUSTOM_VIRTUAL_MACHINE") |
| 876 | } |
| 877 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 878 | /// Return whether a partition is exempt from selinux label checks, because we know that it does |
| 879 | /// 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] | 880 | fn is_safe_app_partition(label: &str) -> bool { |
Shikha Panwar | a2ff8c5 | 2022-11-30 19:25:46 +0000 | [diff] [blame] | 881 | // See add_microdroid_system_images & add_microdroid_payload_images in payload.rs. |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 882 | label == "vm-instance" |
Shikha Panwar | a2ff8c5 | 2022-11-30 19:25:46 +0000 | [diff] [blame] | 883 | || label == "encryptedstore" |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 884 | || label == "microdroid-apk-idsig" |
| 885 | || label == "payload-metadata" |
| 886 | || label.starts_with("extra-idsig-") |
| 887 | } |
| 888 | |
Alice Wang | c206b9b | 2023-08-28 14:13:51 +0000 | [diff] [blame] | 889 | /// Returns whether a partition with the given label is safe for a raw config VM. |
| 890 | fn is_safe_raw_partition(label: &str) -> bool { |
| 891 | label == "vm-instance" |
| 892 | } |
| 893 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 894 | /// Check that a file SELinux label is acceptable. |
| 895 | /// |
| 896 | /// We only want to allow code in a VM to be sourced from places that apps, and the |
Seungjae Yoo | 2b74c44 | 2023-11-15 18:05:07 +0900 | [diff] [blame] | 897 | /// system or vendor, do not have write access to. |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 898 | /// |
| 899 | /// Note that sepolicy must also grant read access for these types to both virtualization |
| 900 | /// service and crosvm. |
| 901 | /// |
| 902 | /// App private data files are deliberately excluded, to avoid arbitrary payloads being run on |
| 903 | /// user devices (W^X). |
| 904 | fn check_label_is_allowed(context: &SeContext) -> Result<()> { |
| 905 | match context.selinux_type()? { |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 906 | | "apk_data_file" // APKs of an installed app |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 907 | | "shell_data_file" // test files created via adb shell |
Alan Stokes | fe4bb0c | 2023-03-20 14:15:36 +0000 | [diff] [blame] | 908 | | "staging_data_file" // updated/staged APEX images |
| 909 | | "system_file" // immutable dm-verity protected partition |
| 910 | | "virtualizationservice_data_file" // files created by VS / VirtMgr |
Seungjae Yoo | 2b74c44 | 2023-11-15 18:05:07 +0900 | [diff] [blame] | 911 | | "vendor_microdroid_file" // immutable dm-verity protected partition (/vendor/etc/avf/microdroid/.*) |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 912 | => Ok(()), |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 913 | _ => bail!("Label {} is not allowed", context), |
Jiyong Park | 029977d | 2021-11-24 21:56:49 +0900 | [diff] [blame] | 914 | } |
| 915 | } |
| 916 | |
Alan Stokes | 185fe11 | 2023-01-10 16:20:55 +0000 | [diff] [blame] | 917 | fn check_label_for_partition(partition: &Partition) -> Result<()> { |
| 918 | let file = partition.image.as_ref().unwrap().as_ref(); |
| 919 | check_label_is_allowed(&getfilecon(file)?) |
| 920 | .with_context(|| format!("Partition {} invalid", &partition.label)) |
| 921 | } |
| 922 | |
| 923 | fn check_label_for_kernel_files(kernel: &Option<File>, initrd: &Option<File>) -> Result<()> { |
| 924 | if let Some(f) = kernel { |
| 925 | check_label_for_file(f, "kernel")?; |
| 926 | } |
| 927 | if let Some(f) = initrd { |
| 928 | check_label_for_file(f, "initrd")?; |
| 929 | } |
| 930 | Ok(()) |
| 931 | } |
| 932 | fn check_label_for_file(file: &File, name: &str) -> Result<()> { |
| 933 | check_label_is_allowed(&getfilecon(file)?).with_context(|| format!("{} file invalid", name)) |
| 934 | } |
| 935 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 936 | /// Implementation of the AIDL `IVirtualMachine` interface. Used as a handle to a VM. |
| 937 | #[derive(Debug)] |
| 938 | struct VirtualMachine { |
| 939 | instance: Arc<VmInstance>, |
| 940 | } |
| 941 | |
| 942 | impl VirtualMachine { |
| 943 | fn create(instance: Arc<VmInstance>) -> Strong<dyn IVirtualMachine> { |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 944 | BnVirtualMachine::new_binder(VirtualMachine { instance }, BinderFeatures::default()) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 945 | } |
| 946 | } |
| 947 | |
| 948 | impl Interface for VirtualMachine {} |
| 949 | |
| 950 | impl IVirtualMachine for VirtualMachine { |
| 951 | fn getCid(&self) -> binder::Result<i32> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 952 | // Don't check permission. The owner of the VM might have passed this binder object to |
| 953 | // others. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 954 | Ok(self.instance.cid as i32) |
| 955 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 956 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 957 | fn getState(&self) -> binder::Result<VirtualMachineState> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 958 | // Don't check permission. The owner of the VM might have passed this binder object to |
| 959 | // others. |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 960 | Ok(get_state(&self.instance)) |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 961 | } |
| 962 | |
| 963 | fn registerCallback( |
| 964 | &self, |
| 965 | callback: &Strong<dyn IVirtualMachineCallback>, |
| 966 | ) -> binder::Result<()> { |
Jiyong Park | 753553b | 2021-07-12 21:21:09 +0900 | [diff] [blame] | 967 | // Don't check permission. The owner of the VM might have passed this binder object to |
| 968 | // others. |
| 969 | // |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 970 | // TODO: Should this give an error if the VM is already dead? |
| 971 | self.instance.callbacks.add(callback.clone()); |
| 972 | Ok(()) |
| 973 | } |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 974 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 975 | fn start(&self) -> binder::Result<()> { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 976 | self.instance |
| 977 | .start() |
| 978 | .with_context(|| format!("Error starting VM with CID {}", self.instance.cid)) |
| 979 | .with_log() |
| 980 | .or_service_specific_exception(-1) |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 981 | } |
| 982 | |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 983 | fn stop(&self) -> binder::Result<()> { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 984 | self.instance |
| 985 | .kill() |
| 986 | .with_context(|| format!("Error stopping VM with CID {}", self.instance.cid)) |
| 987 | .with_log() |
| 988 | .or_service_specific_exception(-1) |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 989 | } |
| 990 | |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 991 | fn onTrimMemory(&self, level: MemoryTrimLevel) -> binder::Result<()> { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 992 | self.instance |
| 993 | .trim_memory(level) |
| 994 | .with_context(|| format!("Error trimming VM with CID {}", self.instance.cid)) |
| 995 | .with_log() |
| 996 | .or_service_specific_exception(-1) |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 997 | } |
| 998 | |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 999 | fn connectVsock(&self, port: i32) -> binder::Result<ParcelFileDescriptor> { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 1000 | if !matches!(&*self.instance.vm_state.lock().unwrap(), VmState::Running { .. }) { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1001 | return Err(anyhow!("VM is not running")).or_service_specific_exception(-1); |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 1002 | } |
Alan Stokes | 10c4767 | 2022-12-13 17:17:08 +0000 | [diff] [blame] | 1003 | let port = port as u32; |
| 1004 | if port < 1024 { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1005 | return Err(anyhow!("Can't connect to privileged port {port}")) |
| 1006 | .or_service_specific_exception(-1); |
Alan Stokes | 10c4767 | 2022-12-13 17:17:08 +0000 | [diff] [blame] | 1007 | } |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1008 | let stream = VsockStream::connect_with_cid_port(self.instance.cid, port) |
| 1009 | .context("Failed to connect") |
| 1010 | .or_service_specific_exception(-1)?; |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 1011 | Ok(vsock_stream_to_pfd(stream)) |
| 1012 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 1013 | } |
| 1014 | |
| 1015 | impl Drop for VirtualMachine { |
| 1016 | fn drop(&mut self) { |
| 1017 | debug!("Dropping {:?}", self); |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 1018 | if let Err(e) = self.instance.kill() { |
| 1019 | debug!("Error stopping dropped VM with CID {}: {:?}", self.instance.cid, e); |
| 1020 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 1021 | } |
| 1022 | } |
| 1023 | |
| 1024 | /// A set of Binders to be called back in response to various events on the VM, such as when it |
| 1025 | /// dies. |
| 1026 | #[derive(Debug, Default)] |
| 1027 | pub struct VirtualMachineCallbacks(Mutex<Vec<Strong<dyn IVirtualMachineCallback>>>); |
| 1028 | |
| 1029 | impl VirtualMachineCallbacks { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 1030 | /// Call all registered callbacks to notify that the payload has started. |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 1031 | pub fn notify_payload_started(&self, cid: Cid) { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 1032 | let callbacks = &*self.0.lock().unwrap(); |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 1033 | for callback in callbacks { |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 1034 | if let Err(e) = callback.onPayloadStarted(cid as i32) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 1035 | error!("Error notifying payload start event from VM CID {}: {:?}", cid, e); |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 1036 | } |
| 1037 | } |
| 1038 | } |
| 1039 | |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1040 | /// Call all registered callbacks to notify that the payload is ready to serve. |
| 1041 | pub fn notify_payload_ready(&self, cid: Cid) { |
| 1042 | let callbacks = &*self.0.lock().unwrap(); |
| 1043 | for callback in callbacks { |
| 1044 | if let Err(e) = callback.onPayloadReady(cid as i32) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 1045 | error!("Error notifying payload ready event from VM CID {}: {:?}", cid, e); |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1046 | } |
| 1047 | } |
| 1048 | } |
| 1049 | |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1050 | /// Call all registered callbacks to notify that the payload has finished. |
| 1051 | pub fn notify_payload_finished(&self, cid: Cid, exit_code: i32) { |
| 1052 | let callbacks = &*self.0.lock().unwrap(); |
| 1053 | for callback in callbacks { |
| 1054 | if let Err(e) = callback.onPayloadFinished(cid as i32, exit_code) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 1055 | error!("Error notifying payload finish event from VM CID {}: {:?}", cid, e); |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1056 | } |
| 1057 | } |
| 1058 | } |
| 1059 | |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1060 | /// Call all registered callbacks to say that the VM encountered an error. |
Alan Stokes | 2bead0d | 2022-09-05 16:58:34 +0100 | [diff] [blame] | 1061 | pub fn notify_error(&self, cid: Cid, error_code: ErrorCode, message: &str) { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1062 | let callbacks = &*self.0.lock().unwrap(); |
| 1063 | for callback in callbacks { |
| 1064 | if let Err(e) = callback.onError(cid as i32, error_code, message) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 1065 | error!("Error notifying error event from VM CID {}: {:?}", cid, e); |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1066 | } |
| 1067 | } |
| 1068 | } |
| 1069 | |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 1070 | /// Call all registered callbacks to say that the VM has died. |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 1071 | pub fn callback_on_died(&self, cid: Cid, reason: DeathReason) { |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 1072 | let callbacks = &*self.0.lock().unwrap(); |
| 1073 | for callback in callbacks { |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 1074 | if let Err(e) = callback.onDied(cid as i32, reason) { |
Alan Stokes | 70ccf16 | 2022-07-08 11:05:03 +0100 | [diff] [blame] | 1075 | error!("Error notifying exit of VM CID {}: {:?}", cid, e); |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 1076 | } |
| 1077 | } |
| 1078 | } |
| 1079 | |
| 1080 | /// Add a new callback to the set. |
| 1081 | fn add(&self, callback: Strong<dyn IVirtualMachineCallback>) { |
| 1082 | self.0.lock().unwrap().push(callback); |
| 1083 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1084 | } |
| 1085 | |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 1086 | /// The mutable state of the VirtualizationService. There should only be one instance of this |
| 1087 | /// struct. |
Chris Wailes | 641fc4a | 2021-12-01 15:03:21 -0800 | [diff] [blame] | 1088 | #[derive(Debug, Default)] |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1089 | struct State { |
Alan Stokes | 3e5eec1 | 2023-09-07 12:10:00 +0100 | [diff] [blame] | 1090 | /// The VMs which have been started. When VMs are started a weak reference is added to this |
| 1091 | /// list while a strong reference is returned to the caller over Binder. Once all copies of |
| 1092 | /// the Binder client are dropped the weak reference here will become invalid, and will be |
| 1093 | /// removed from the list opportunistically the next time `add_vm` is called. |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 1094 | vms: Vec<Weak<VmInstance>>, |
| 1095 | } |
| 1096 | |
| 1097 | impl State { |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 1098 | /// Get a list of VMs which still have Binder references to them. |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 1099 | fn vms(&self) -> Vec<Arc<VmInstance>> { |
| 1100 | // Attempt to upgrade the weak pointers to strong pointers. |
| 1101 | self.vms.iter().filter_map(Weak::upgrade).collect() |
| 1102 | } |
| 1103 | |
| 1104 | /// Add a new VM to the list. |
| 1105 | fn add_vm(&mut self, vm: Weak<VmInstance>) { |
| 1106 | // Garbage collect any entries from the stored list which no longer exist. |
| 1107 | self.vms.retain(|vm| vm.strong_count() > 0); |
| 1108 | |
| 1109 | // Actually add the new VM. |
| 1110 | self.vms.push(vm); |
| 1111 | } |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 1112 | |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 1113 | /// Get a VM that corresponds to the given cid |
| 1114 | fn get_vm(&self, cid: Cid) -> Option<Arc<VmInstance>> { |
| 1115 | self.vms().into_iter().find(|vm| vm.cid == cid) |
| 1116 | } |
Jiyong Park | d50a024 | 2021-09-16 21:00:14 +0900 | [diff] [blame] | 1117 | } |
| 1118 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 1119 | /// Gets the `VirtualMachineState` of the given `VmInstance`. |
| 1120 | fn get_state(instance: &VmInstance) -> VirtualMachineState { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 1121 | match &*instance.vm_state.lock().unwrap() { |
| 1122 | VmState::NotStarted { .. } => VirtualMachineState::NOT_STARTED, |
| 1123 | VmState::Running { .. } => match instance.payload_state() { |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 1124 | PayloadState::Starting => VirtualMachineState::STARTING, |
| 1125 | PayloadState::Started => VirtualMachineState::STARTED, |
| 1126 | PayloadState::Ready => VirtualMachineState::READY, |
| 1127 | PayloadState::Finished => VirtualMachineState::FINISHED, |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 1128 | PayloadState::Hangup => VirtualMachineState::DEAD, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 1129 | }, |
| 1130 | VmState::Dead => VirtualMachineState::DEAD, |
| 1131 | VmState::Failed => VirtualMachineState::DEAD, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 1132 | } |
| 1133 | } |
| 1134 | |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 1135 | /// Converts a `&ParcelFileDescriptor` to a `File` by cloning the file. |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1136 | pub fn clone_file(file: &ParcelFileDescriptor) -> binder::Result<File> { |
| 1137 | file.as_ref() |
| 1138 | .try_clone() |
| 1139 | .context("Failed to clone File from ParcelFileDescriptor") |
| 1140 | .or_binder_exception(ExceptionCode::BAD_PARCELABLE) |
Andrei Homescu | 11333c6 | 2023-11-09 04:26:39 +0000 | [diff] [blame] | 1141 | .map(File::from) |
David Brazdil | f50c7a6 | 2023-04-19 14:22:42 +0000 | [diff] [blame] | 1142 | } |
| 1143 | |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 1144 | /// Converts an `&Option<ParcelFileDescriptor>` to an `Option<File>` by cloning the file. |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1145 | fn maybe_clone_file(file: &Option<ParcelFileDescriptor>) -> binder::Result<Option<File>> { |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 1146 | file.as_ref().map(clone_file).transpose() |
| 1147 | } |
| 1148 | |
Andrew Walbran | cbe8b08 | 2021-08-06 15:42:11 +0000 | [diff] [blame] | 1149 | /// Converts a `VsockStream` to a `ParcelFileDescriptor`. |
| 1150 | fn vsock_stream_to_pfd(stream: VsockStream) -> ParcelFileDescriptor { |
| 1151 | // SAFETY: ownership is transferred from stream to f |
| 1152 | let f = unsafe { File::from_raw_fd(stream.into_raw_fd()) }; |
| 1153 | ParcelFileDescriptor::new(f) |
| 1154 | } |
| 1155 | |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 1156 | /// Parses the platform version requirement string. |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1157 | fn parse_platform_version_req(s: &str) -> binder::Result<VersionReq> { |
| 1158 | VersionReq::parse(s) |
| 1159 | .with_context(|| format!("Invalid platform version requirement {}", s)) |
| 1160 | .or_binder_exception(ExceptionCode::BAD_PARCELABLE) |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 1161 | } |
| 1162 | |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 1163 | /// Create the empty ramdump file |
| 1164 | fn prepare_ramdump_file(temporary_directory: &Path) -> binder::Result<File> { |
| 1165 | // `ramdump_write` is sent to crosvm and will be the backing store for the /dev/hvc1 where |
| 1166 | // VM will emit ramdump to. `ramdump_read` will be sent back to the client (i.e. the VM |
| 1167 | // owner) for readout. |
| 1168 | let ramdump_path = temporary_directory.join("ramdump"); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1169 | let ramdump = File::create(ramdump_path) |
| 1170 | .context("Failed to prepare ramdump file") |
| 1171 | .with_log() |
| 1172 | .or_service_specific_exception(-1)?; |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 1173 | Ok(ramdump) |
| 1174 | } |
| 1175 | |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 1176 | fn is_protected(config: &VirtualMachineConfig) -> bool { |
| 1177 | match config { |
| 1178 | VirtualMachineConfig::RawConfig(config) => config.protectedVm, |
| 1179 | VirtualMachineConfig::AppConfig(config) => config.protectedVm, |
| 1180 | } |
| 1181 | } |
| 1182 | |
| 1183 | fn check_gdb_allowed(config: &VirtualMachineConfig) -> binder::Result<()> { |
| 1184 | if is_protected(config) { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1185 | return Err(anyhow!("Can't use gdb with protected VMs")) |
| 1186 | .or_binder_exception(ExceptionCode::SECURITY); |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 1187 | } |
| 1188 | |
| 1189 | match config { |
| 1190 | VirtualMachineConfig::RawConfig(_) => Ok(()), |
| 1191 | VirtualMachineConfig::AppConfig(config) => { |
| 1192 | if config.debugLevel != DebugLevel::FULL { |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1193 | Err(anyhow!("Can't use gdb with non-debuggable VMs")) |
| 1194 | .or_binder_exception(ExceptionCode::SECURITY) |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 1195 | } else { |
| 1196 | Ok(()) |
| 1197 | } |
| 1198 | } |
| 1199 | } |
| 1200 | } |
| 1201 | |
| 1202 | fn extract_gdb_port(config: &VirtualMachineConfig) -> Option<NonZeroU16> { |
| 1203 | match config { |
| 1204 | VirtualMachineConfig::RawConfig(config) => NonZeroU16::new(config.gdbPort as u16), |
Nikita Ioffe | a0eb5ee | 2023-06-26 18:18:21 +0100 | [diff] [blame] | 1205 | VirtualMachineConfig::AppConfig(config) => { |
| 1206 | NonZeroU16::new(config.customConfig.as_ref().map(|c| c.gdbPort).unwrap_or(0) as u16) |
| 1207 | } |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 1208 | } |
| 1209 | } |
| 1210 | |
Nikita Ioffe | 631717e | 2023-09-05 13:38:07 +0100 | [diff] [blame] | 1211 | fn check_no_vendor_modules(config: &VirtualMachineConfig) -> binder::Result<()> { |
| 1212 | let VirtualMachineConfig::AppConfig(config) = config else { return Ok(()) }; |
| 1213 | if let Some(custom_config) = &config.customConfig { |
| 1214 | if custom_config.vendorImage.is_some() || custom_config.customKernelImage.is_some() { |
| 1215 | return Err(anyhow!("vendor modules feature is disabled")) |
| 1216 | .or_binder_exception(ExceptionCode::UNSUPPORTED_OPERATION); |
| 1217 | } |
| 1218 | } |
| 1219 | Ok(()) |
| 1220 | } |
| 1221 | |
Nikita Ioffe | 94a8a18 | 2023-11-16 16:37:48 +0000 | [diff] [blame] | 1222 | fn check_no_devices(config: &VirtualMachineConfig) -> binder::Result<()> { |
| 1223 | let VirtualMachineConfig::AppConfig(config) = config else { return Ok(()) }; |
| 1224 | if let Some(custom_config) = &config.customConfig { |
| 1225 | if !custom_config.devices.is_empty() { |
| 1226 | return Err(anyhow!("device assignment feature is disabled")) |
| 1227 | .or_binder_exception(ExceptionCode::UNSUPPORTED_OPERATION); |
| 1228 | } |
| 1229 | } |
| 1230 | Ok(()) |
| 1231 | } |
| 1232 | |
Nikita Ioffe | 631717e | 2023-09-05 13:38:07 +0100 | [diff] [blame] | 1233 | fn check_config_features(config: &VirtualMachineConfig) -> binder::Result<()> { |
| 1234 | if !cfg!(vendor_modules) { |
| 1235 | check_no_vendor_modules(config)?; |
| 1236 | } |
Nikita Ioffe | 94a8a18 | 2023-11-16 16:37:48 +0000 | [diff] [blame] | 1237 | if !cfg!(device_assignment) { |
| 1238 | check_no_devices(config)?; |
| 1239 | } |
Nikita Ioffe | 631717e | 2023-09-05 13:38:07 +0100 | [diff] [blame] | 1240 | Ok(()) |
| 1241 | } |
| 1242 | |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 1243 | fn clone_or_prepare_logger_fd( |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 1244 | debug_config: &DebugConfig, |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 1245 | fd: Option<&ParcelFileDescriptor>, |
| 1246 | tag: String, |
| 1247 | ) -> Result<Option<File>, Status> { |
| 1248 | if let Some(fd) = fd { |
| 1249 | return Ok(Some(clone_file(fd)?)); |
| 1250 | } |
| 1251 | |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 1252 | if !debug_config.should_prepare_console_output() { |
Jaewan Kim | 66f062e | 2023-02-25 01:07:43 +0900 | [diff] [blame] | 1253 | return Ok(None); |
| 1254 | }; |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 1255 | |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1256 | let (raw_read_fd, raw_write_fd) = |
| 1257 | pipe().context("Failed to create pipe").or_service_specific_exception(-1)?; |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 1258 | |
Andrew Walbran | b58d1b4 | 2023-07-07 13:54:49 +0100 | [diff] [blame] | 1259 | // SAFETY: We are the sole owner of this FD as we just created it, and it is valid and open. |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 1260 | let mut reader = BufReader::new(unsafe { File::from_raw_fd(raw_read_fd) }); |
Andrew Walbran | b58d1b4 | 2023-07-07 13:54:49 +0100 | [diff] [blame] | 1261 | // SAFETY: We are the sole owner of this FD as we just created it, and it is valid and open. |
Inseob Kim | 0168b46 | 2022-12-27 14:54:35 +0900 | [diff] [blame] | 1262 | let write_fd = unsafe { File::from_raw_fd(raw_write_fd) }; |
| 1263 | |
| 1264 | std::thread::spawn(move || loop { |
| 1265 | let mut buf = vec![]; |
| 1266 | match reader.read_until(b'\n', &mut buf) { |
| 1267 | Ok(0) => { |
| 1268 | // EOF |
| 1269 | return; |
| 1270 | } |
| 1271 | Ok(size) => { |
| 1272 | if buf[size - 1] == b'\n' { |
| 1273 | buf.pop(); |
| 1274 | } |
| 1275 | info!("{}: {}", &tag, &String::from_utf8_lossy(&buf)); |
| 1276 | } |
| 1277 | Err(e) => { |
| 1278 | error!("Could not read console pipe: {:?}", e); |
| 1279 | return; |
| 1280 | } |
| 1281 | }; |
| 1282 | }); |
| 1283 | |
| 1284 | Ok(Some(write_fd)) |
| 1285 | } |
| 1286 | |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 1287 | /// Simple utility for referencing Borrowed or Owned. Similar to std::borrow::Cow, but |
| 1288 | /// it doesn't require that T implements Clone. |
| 1289 | enum BorrowedOrOwned<'a, T> { |
| 1290 | Borrowed(&'a T), |
| 1291 | Owned(T), |
| 1292 | } |
| 1293 | |
| 1294 | impl<'a, T> AsRef<T> for BorrowedOrOwned<'a, T> { |
| 1295 | fn as_ref(&self) -> &T { |
| 1296 | match self { |
| 1297 | Self::Borrowed(b) => b, |
Chris Wailes | 68c39f8 | 2021-07-27 16:03:44 -0700 | [diff] [blame] | 1298 | Self::Owned(o) => o, |
Jooyung Han | 35edb8f | 2021-07-01 16:17:16 +0900 | [diff] [blame] | 1299 | } |
| 1300 | } |
| 1301 | } |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1302 | |
| 1303 | /// Implementation of `IVirtualMachineService`, the entry point of the AIDL service. |
| 1304 | #[derive(Debug, Default)] |
| 1305 | struct VirtualMachineService { |
| 1306 | state: Arc<Mutex<State>>, |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1307 | cid: Cid, |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1308 | } |
| 1309 | |
| 1310 | impl Interface for VirtualMachineService {} |
| 1311 | |
| 1312 | impl IVirtualMachineService for VirtualMachineService { |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1313 | fn notifyPayloadStarted(&self) -> binder::Result<()> { |
| 1314 | let cid = self.cid; |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 1315 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1316 | info!("VM with CID {} started payload", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1317 | vm.update_payload_state(PayloadState::Started) |
| 1318 | .or_binder_exception(ExceptionCode::ILLEGAL_STATE)?; |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 1319 | vm.callbacks.notify_payload_started(cid); |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 1320 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 1321 | let vm_start_timestamp = vm.vm_metric.lock().unwrap().start_timestamp; |
| 1322 | 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] | 1323 | Ok(()) |
| 1324 | } else { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1325 | error!("notifyPayloadStarted is called from an unknown CID {}", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1326 | Err(anyhow!("cannot find a VM with CID {}", cid)).or_service_specific_exception(-1) |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1327 | } |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1328 | } |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1329 | |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1330 | fn notifyPayloadReady(&self) -> binder::Result<()> { |
| 1331 | let cid = self.cid; |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1332 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1333 | info!("VM with CID {} reported payload is ready", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1334 | vm.update_payload_state(PayloadState::Ready) |
| 1335 | .or_binder_exception(ExceptionCode::ILLEGAL_STATE)?; |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1336 | vm.callbacks.notify_payload_ready(cid); |
| 1337 | Ok(()) |
| 1338 | } else { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1339 | error!("notifyPayloadReady is called from an unknown CID {}", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1340 | Err(anyhow!("cannot find a VM with CID {}", cid)).or_service_specific_exception(-1) |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 1341 | } |
| 1342 | } |
| 1343 | |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1344 | fn notifyPayloadFinished(&self, exit_code: i32) -> binder::Result<()> { |
| 1345 | let cid = self.cid; |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1346 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1347 | info!("VM with CID {} finished payload", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1348 | vm.update_payload_state(PayloadState::Finished) |
| 1349 | .or_binder_exception(ExceptionCode::ILLEGAL_STATE)?; |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1350 | vm.callbacks.notify_payload_finished(cid, exit_code); |
| 1351 | Ok(()) |
| 1352 | } else { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1353 | error!("notifyPayloadFinished is called from an unknown CID {}", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1354 | Err(anyhow!("cannot find a VM with CID {}", cid)).or_service_specific_exception(-1) |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1355 | } |
| 1356 | } |
| 1357 | |
Alan Stokes | 2bead0d | 2022-09-05 16:58:34 +0100 | [diff] [blame] | 1358 | fn notifyError(&self, error_code: ErrorCode, message: &str) -> binder::Result<()> { |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1359 | let cid = self.cid; |
| 1360 | if let Some(vm) = self.state.lock().unwrap().get_vm(cid) { |
David Brazdil | 415097c | 2022-10-21 14:17:05 +0100 | [diff] [blame] | 1361 | info!("VM with CID {} encountered an error", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1362 | vm.update_payload_state(PayloadState::Finished) |
| 1363 | .or_binder_exception(ExceptionCode::ILLEGAL_STATE)?; |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 1364 | vm.callbacks.notify_error(cid, error_code, message); |
| 1365 | Ok(()) |
| 1366 | } else { |
Seungjae Yoo | ec8c160 | 2022-06-20 05:28:00 +0000 | [diff] [blame] | 1367 | error!("notifyError is called from an unknown CID {}", cid); |
Jiyong Park | 2227eaa | 2023-08-04 11:59:18 +0900 | [diff] [blame] | 1368 | Err(anyhow!("cannot find a VM with CID {}", cid)).or_service_specific_exception(-1) |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 1369 | } |
| 1370 | } |
Alice Wang | c2fec93 | 2023-02-23 16:24:02 +0000 | [diff] [blame] | 1371 | |
Alice Wang | 4e3015d | 2023-10-10 09:35:37 +0000 | [diff] [blame] | 1372 | fn requestAttestation(&self, csr: &[u8]) -> binder::Result<Vec<Certificate>> { |
Alice Wang | bff017f | 2023-11-09 14:43:28 +0000 | [diff] [blame] | 1373 | GLOBAL_SERVICE.requestAttestation(csr, get_calling_uid() as i32) |
Alice Wang | c2fec93 | 2023-02-23 16:24:02 +0000 | [diff] [blame] | 1374 | } |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1375 | } |
| 1376 | |
| 1377 | impl VirtualMachineService { |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1378 | fn new_binder(state: Arc<Mutex<State>>, cid: Cid) -> Strong<dyn IVirtualMachineService> { |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1379 | BnVirtualMachineService::new_binder( |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 1380 | VirtualMachineService { state, cid }, |
Inseob Kim | 1b95f2e | 2021-08-19 13:17:40 +0900 | [diff] [blame] | 1381 | BinderFeatures::default(), |
| 1382 | ) |
| 1383 | } |
| 1384 | } |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 1385 | |
| 1386 | #[cfg(test)] |
| 1387 | mod tests { |
| 1388 | use super::*; |
| 1389 | |
| 1390 | #[test] |
| 1391 | fn test_is_allowed_label_for_partition() -> Result<()> { |
| 1392 | let expected_results = vec![ |
| 1393 | ("u:object_r:system_file:s0", true), |
| 1394 | ("u:object_r:apk_data_file:s0", true), |
| 1395 | ("u:object_r:app_data_file:s0", false), |
| 1396 | ("u:object_r:app_data_file:s0:c512,c768", false), |
| 1397 | ("u:object_r:privapp_data_file:s0:c512,c768", false), |
| 1398 | ("invalid", false), |
| 1399 | ("user:role:apk_data_file:severity:categories", true), |
| 1400 | ("user:role:apk_data_file:severity:categories:extraneous", false), |
| 1401 | ]; |
| 1402 | |
| 1403 | for (label, expected_valid) in expected_results { |
| 1404 | let context = SeContext::new(label)?; |
| 1405 | let result = check_label_is_allowed(&context); |
| 1406 | if expected_valid { |
| 1407 | assert!(result.is_ok(), "Expected label {} to be allowed, got {:?}", label, result); |
| 1408 | } else if result.is_ok() { |
| 1409 | bail!("Expected label {} to be disallowed", label); |
| 1410 | } |
| 1411 | } |
| 1412 | Ok(()) |
| 1413 | } |
Nikita Ioffe | f1ce987 | 2022-12-09 13:31:59 +0000 | [diff] [blame] | 1414 | |
| 1415 | #[test] |
| 1416 | fn test_create_or_update_idsig_file_empty_apk() -> Result<()> { |
| 1417 | let apk = tempfile::tempfile().unwrap(); |
| 1418 | let idsig = tempfile::tempfile().unwrap(); |
| 1419 | |
| 1420 | let ret = create_or_update_idsig_file( |
| 1421 | &ParcelFileDescriptor::new(apk), |
| 1422 | &ParcelFileDescriptor::new(idsig), |
| 1423 | ); |
| 1424 | assert!(ret.is_err(), "should fail"); |
| 1425 | Ok(()) |
| 1426 | } |
| 1427 | |
| 1428 | #[test] |
| 1429 | fn test_create_or_update_idsig_dir_instead_of_file_for_apk() -> Result<()> { |
| 1430 | let tmp_dir = tempfile::TempDir::new().unwrap(); |
| 1431 | let apk = File::open(tmp_dir.path()).unwrap(); |
| 1432 | let idsig = tempfile::tempfile().unwrap(); |
| 1433 | |
| 1434 | let ret = create_or_update_idsig_file( |
| 1435 | &ParcelFileDescriptor::new(apk), |
| 1436 | &ParcelFileDescriptor::new(idsig), |
| 1437 | ); |
| 1438 | assert!(ret.is_err(), "should fail"); |
| 1439 | Ok(()) |
| 1440 | } |
| 1441 | |
| 1442 | /// Verifies that create_or_update_idsig_file won't oom if a fd that corresponds to a directory |
| 1443 | /// on ext4 filesystem is passed. |
| 1444 | /// On ext4 lseek on a directory fd will return (off_t)-1 (see: |
| 1445 | /// https://bugzilla.kernel.org/show_bug.cgi?id=200043), which will result in |
| 1446 | /// create_or_update_idsig_file ooming while attempting to allocate petabytes of memory. |
| 1447 | #[test] |
| 1448 | fn test_create_or_update_idsig_does_not_crash_dir_on_ext4() -> Result<()> { |
| 1449 | // APEXes are backed by the ext4. |
| 1450 | let apk = File::open("/apex/com.android.virt/").unwrap(); |
| 1451 | let idsig = tempfile::tempfile().unwrap(); |
| 1452 | |
| 1453 | let ret = create_or_update_idsig_file( |
| 1454 | &ParcelFileDescriptor::new(apk), |
| 1455 | &ParcelFileDescriptor::new(idsig), |
| 1456 | ); |
| 1457 | assert!(ret.is_err(), "should fail"); |
| 1458 | Ok(()) |
| 1459 | } |
Jiyong Park | 8d19295 | 2023-06-26 14:29:51 +0900 | [diff] [blame] | 1460 | |
| 1461 | #[test] |
| 1462 | fn test_create_or_update_idsig_does_not_update_if_already_valid() -> Result<()> { |
| 1463 | use std::io::Seek; |
| 1464 | |
| 1465 | // Pick any APK |
| 1466 | let mut apk = File::open("/system/priv-app/Shell/Shell.apk").unwrap(); |
| 1467 | let mut idsig = tempfile::tempfile().unwrap(); |
| 1468 | |
| 1469 | create_or_update_idsig_file( |
| 1470 | &ParcelFileDescriptor::new(apk.try_clone()?), |
| 1471 | &ParcelFileDescriptor::new(idsig.try_clone()?), |
| 1472 | )?; |
| 1473 | let modified_orig = idsig.metadata()?.modified()?; |
| 1474 | apk.rewind()?; |
| 1475 | idsig.rewind()?; |
| 1476 | |
| 1477 | // Call the function again |
| 1478 | create_or_update_idsig_file( |
| 1479 | &ParcelFileDescriptor::new(apk.try_clone()?), |
| 1480 | &ParcelFileDescriptor::new(idsig.try_clone()?), |
| 1481 | )?; |
| 1482 | let modified_new = idsig.metadata()?.modified()?; |
| 1483 | assert!(modified_orig == modified_new, "idsig file was updated unnecessarily"); |
| 1484 | Ok(()) |
| 1485 | } |
Nikita Ioffe | aa6858c | 2023-07-04 01:37:41 +0100 | [diff] [blame] | 1486 | |
| 1487 | #[test] |
| 1488 | fn test_append_kernel_param_first_param() { |
| 1489 | let mut vm_config = VirtualMachineRawConfig { ..Default::default() }; |
| 1490 | append_kernel_param("foo=1", &mut vm_config); |
| 1491 | assert_eq!(vm_config.params, Some("foo=1".to_owned())) |
| 1492 | } |
| 1493 | |
| 1494 | #[test] |
| 1495 | fn test_append_kernel_param() { |
| 1496 | let mut vm_config = |
| 1497 | VirtualMachineRawConfig { params: Some("foo=5".to_owned()), ..Default::default() }; |
| 1498 | append_kernel_param("bar=42", &mut vm_config); |
| 1499 | assert_eq!(vm_config.params, Some("foo=5 bar=42".to_owned())) |
| 1500 | } |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 1501 | |
| 1502 | #[test] |
| 1503 | fn test_create_dtbo_for_vendor_image() -> Result<()> { |
| 1504 | let vendor_public_key = String::from("foo"); |
| 1505 | let vendor_public_key = vendor_public_key.as_bytes(); |
| 1506 | |
| 1507 | let tmp_dir = tempfile::TempDir::new()?; |
| 1508 | let dtbo_path = tmp_dir.path().to_path_buf().join("bar"); |
| 1509 | |
| 1510 | create_dtbo_for_vendor_image(vendor_public_key, &dtbo_path)?; |
| 1511 | |
| 1512 | let data = std::fs::read(dtbo_path)?; |
| 1513 | let fdt = Fdt::from_slice(&data).unwrap(); |
| 1514 | |
| 1515 | let fragment_node_path = CString::new("/fragment@0")?; |
| 1516 | let fragment_node = fdt.node(fragment_node_path.as_c_str()).unwrap(); |
| 1517 | let Some(fragment_node) = fragment_node else { |
| 1518 | bail!("fragment_node shouldn't be None."); |
| 1519 | }; |
| 1520 | let target_path_prop_name = CString::new("target-path")?; |
| 1521 | let target_path_from_dtbo = |
| 1522 | fragment_node.getprop(target_path_prop_name.as_c_str()).unwrap(); |
| 1523 | let target_path_expected = CString::new("/")?; |
| 1524 | assert_eq!(target_path_from_dtbo, Some(target_path_expected.to_bytes_with_nul())); |
| 1525 | |
| 1526 | let avf_node_path = CString::new("/fragment@0/__overlay__/avf")?; |
| 1527 | let avf_node = fdt.node(avf_node_path.as_c_str()).unwrap(); |
| 1528 | let Some(avf_node) = avf_node else { |
| 1529 | bail!("avf_node shouldn't be None."); |
| 1530 | }; |
| 1531 | let vendor_public_key_name = CString::new("vendor_public_key")?; |
| 1532 | let key_from_dtbo = avf_node.getprop(vendor_public_key_name.as_c_str()).unwrap(); |
| 1533 | assert_eq!(key_from_dtbo, Some(vendor_public_key)); |
| 1534 | |
| 1535 | tmp_dir.close()?; |
| 1536 | Ok(()) |
| 1537 | } |
| 1538 | |
| 1539 | #[test] |
| 1540 | fn test_create_dtbo_for_vendor_image_throws_error_if_already_exists() -> Result<()> { |
| 1541 | let vendor_public_key = String::from("foo"); |
| 1542 | let vendor_public_key = vendor_public_key.as_bytes(); |
| 1543 | |
| 1544 | let tmp_dir = tempfile::TempDir::new()?; |
| 1545 | let dtbo_path = tmp_dir.path().to_path_buf().join("bar"); |
| 1546 | |
| 1547 | create_dtbo_for_vendor_image(vendor_public_key, &dtbo_path)?; |
| 1548 | |
| 1549 | let ret_second_trial = create_dtbo_for_vendor_image(vendor_public_key, &dtbo_path); |
| 1550 | assert!(ret_second_trial.is_err(), "should fail"); |
| 1551 | |
| 1552 | tmp_dir.close()?; |
| 1553 | Ok(()) |
| 1554 | } |
Alan Stokes | 53cc5ca | 2022-08-30 14:28:19 +0100 | [diff] [blame] | 1555 | } |