Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +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 | |
| 15 | //! Command to run a VM. |
| 16 | |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 17 | use crate::create_partition::command_create_partition; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 18 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 19 | CpuTopology::CpuTopology, |
Alan Stokes | 0d1ef78 | 2022-09-27 13:46:35 +0100 | [diff] [blame] | 20 | IVirtualizationService::IVirtualizationService, |
| 21 | PartitionType::PartitionType, |
| 22 | VirtualMachineAppConfig::{DebugLevel::DebugLevel, Payload::Payload, VirtualMachineAppConfig}, |
| 23 | VirtualMachineConfig::VirtualMachineConfig, |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 24 | VirtualMachinePayloadConfig::VirtualMachinePayloadConfig, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 25 | VirtualMachineState::VirtualMachineState, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 26 | }; |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 27 | use anyhow::{anyhow, bail, Context, Error}; |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 28 | use binder::ParcelFileDescriptor; |
Nikita Ioffe | fc04196 | 2023-01-18 00:10:40 +0000 | [diff] [blame] | 29 | use glob::glob; |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 30 | use microdroid_payload_config::VmPayloadConfig; |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 31 | use rand::{distributions::Alphanumeric, Rng}; |
| 32 | use std::fs; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 33 | use std::fs::File; |
Alan Stokes | f30982b | 2022-11-18 11:50:32 +0000 | [diff] [blame] | 34 | use std::io; |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 35 | use std::num::NonZeroU16; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 36 | use std::os::unix::io::{AsRawFd, FromRawFd}; |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 37 | use std::path::{Path, PathBuf}; |
Alan Stokes | 2bead0d | 2022-09-05 16:58:34 +0100 | [diff] [blame] | 38 | use vmclient::{ErrorCode, VmInstance}; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 39 | use vmconfig::{open_parcel_file, VmConfig}; |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 40 | use zip::ZipArchive; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 41 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 42 | /// Run a VM from the given APK, idsig, and config. |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 43 | #[allow(clippy::too_many_arguments)] |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 44 | pub fn command_run_app( |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 45 | name: Option<String>, |
Andrew Walbran | 616d13f | 2022-05-12 18:35:55 +0000 | [diff] [blame] | 46 | service: &dyn IVirtualizationService, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 47 | apk: &Path, |
| 48 | idsig: &Path, |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 49 | instance: &Path, |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 50 | storage: Option<&Path>, |
| 51 | storage_size: Option<u64>, |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 52 | config_path: Option<String>, |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 53 | payload_binary_name: Option<String>, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 54 | console_path: Option<&Path>, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 55 | log_path: Option<&Path>, |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 56 | debug_level: DebugLevel, |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 57 | protected: bool, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 58 | mem: Option<u32>, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 59 | cpu_topology: CpuTopology, |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 60 | task_profiles: Vec<String>, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 61 | extra_idsigs: &[PathBuf], |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 62 | gdb: Option<NonZeroU16>, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 63 | ) -> Result<(), Error> { |
Steven Moreland | 6a55e2e | 2022-10-22 00:30:42 +0000 | [diff] [blame] | 64 | let apk_file = File::open(apk).context("Failed to open APK file")?; |
| 65 | |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 66 | let extra_apks = match config_path.as_deref() { |
| 67 | Some(path) => parse_extra_apk_list(apk, path)?, |
| 68 | None => vec![], |
| 69 | }; |
| 70 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 71 | if extra_apks.len() != extra_idsigs.len() { |
| 72 | bail!( |
| 73 | "Found {} extra apks, but there are {} extra idsigs", |
| 74 | extra_apks.len(), |
| 75 | extra_idsigs.len() |
| 76 | ) |
| 77 | } |
| 78 | |
| 79 | for i in 0..extra_apks.len() { |
| 80 | let extra_apk_fd = ParcelFileDescriptor::new(File::open(&extra_apks[i])?); |
| 81 | let extra_idsig_fd = ParcelFileDescriptor::new(File::create(&extra_idsigs[i])?); |
| 82 | service.createOrUpdateIdsigFile(&extra_apk_fd, &extra_idsig_fd)?; |
| 83 | } |
| 84 | |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 85 | let idsig_file = File::create(idsig).context("Failed to create idsig file")?; |
| 86 | |
| 87 | let apk_fd = ParcelFileDescriptor::new(apk_file); |
| 88 | let idsig_fd = ParcelFileDescriptor::new(idsig_file); |
| 89 | service.createOrUpdateIdsigFile(&apk_fd, &idsig_fd)?; |
| 90 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 91 | let idsig_file = File::open(idsig).context("Failed to open idsig file")?; |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 92 | let idsig_fd = ParcelFileDescriptor::new(idsig_file); |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 93 | |
| 94 | if !instance.exists() { |
| 95 | const INSTANCE_FILE_SIZE: u64 = 10 * 1024 * 1024; |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 96 | command_create_partition( |
Andrew Walbran | 616d13f | 2022-05-12 18:35:55 +0000 | [diff] [blame] | 97 | service, |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 98 | instance, |
| 99 | INSTANCE_FILE_SIZE, |
| 100 | PartitionType::ANDROID_VM_INSTANCE, |
| 101 | )?; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 102 | } |
| 103 | |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 104 | let storage = if let Some(path) = storage { |
| 105 | if !path.exists() { |
| 106 | command_create_partition( |
| 107 | service, |
| 108 | path, |
| 109 | storage_size.unwrap_or(10 * 1024 * 1024), |
Shikha Panwar | 9fd198f | 2022-11-18 17:43:43 +0000 | [diff] [blame] | 110 | PartitionType::ENCRYPTEDSTORE, |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 111 | )?; |
| 112 | } |
| 113 | Some(open_parcel_file(path, true)?) |
| 114 | } else { |
| 115 | None |
| 116 | }; |
| 117 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 118 | let extra_idsig_files: Result<Vec<File>, _> = extra_idsigs.iter().map(File::open).collect(); |
| 119 | let extra_idsig_fds = extra_idsig_files?.into_iter().map(ParcelFileDescriptor::new).collect(); |
| 120 | |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 121 | let payload = if let Some(config_path) = config_path { |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 122 | if payload_binary_name.is_some() { |
| 123 | bail!("Only one of --config-path or --payload-binary-name can be defined") |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 124 | } |
| 125 | Payload::ConfigPath(config_path) |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 126 | } else if let Some(payload_binary_name) = payload_binary_name { |
| 127 | Payload::PayloadConfig(VirtualMachinePayloadConfig { |
| 128 | payloadBinaryName: payload_binary_name, |
| 129 | }) |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 130 | } else { |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 131 | bail!("Either --config-path or --payload-binary-name must be defined") |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 132 | }; |
| 133 | |
| 134 | let payload_config_str = format!("{:?}!{:?}", apk, payload); |
| 135 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 136 | let config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig { |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 137 | name: name.unwrap_or_else(|| String::from("VmRunApp")), |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 138 | apk: apk_fd.into(), |
| 139 | idsig: idsig_fd.into(), |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 140 | extraIdsigs: extra_idsig_fds, |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 141 | instanceImage: open_parcel_file(instance, true /* writable */)?.into(), |
Shikha Panwar | 22e7045 | 2022-10-10 18:32:55 +0000 | [diff] [blame] | 142 | encryptedStorageImage: storage, |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 143 | payload, |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 144 | debugLevel: debug_level, |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 145 | protectedVm: protected, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 146 | memoryMib: mem.unwrap_or(0) as i32, // 0 means use the VM default |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 147 | cpuTopology: cpu_topology, |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 148 | taskProfiles: task_profiles, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 149 | gdbPort: gdb.map(u16::from).unwrap_or(0) as i32, // 0 means no gdb |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 150 | }); |
David Brazdil | 2b6352f | 2023-01-12 11:01:17 +0000 | [diff] [blame] | 151 | run(service, &config, &payload_config_str, console_path, log_path) |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 152 | } |
| 153 | |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 154 | fn find_empty_payload_apk_path() -> Result<PathBuf, Error> { |
Cole Faust | 237ee3e | 2023-03-01 11:58:01 -0800 | [diff] [blame] | 155 | const GLOB_PATTERN: &str = "/apex/com.android.virt/app/**/EmptyPayloadApp*.apk"; |
Nikita Ioffe | fc04196 | 2023-01-18 00:10:40 +0000 | [diff] [blame] | 156 | let mut entries: Vec<PathBuf> = |
| 157 | glob(GLOB_PATTERN).context("failed to glob")?.filter_map(|e| e.ok()).collect(); |
| 158 | if entries.len() > 1 { |
| 159 | return Err(anyhow!("Found more than one apk matching {}", GLOB_PATTERN)); |
| 160 | } |
| 161 | match entries.pop() { |
| 162 | Some(path) => Ok(path), |
| 163 | None => Err(anyhow!("No apks match {}", GLOB_PATTERN)), |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 164 | } |
| 165 | } |
| 166 | |
| 167 | fn create_work_dir() -> Result<PathBuf, Error> { |
| 168 | let s: String = |
| 169 | rand::thread_rng().sample_iter(&Alphanumeric).take(17).map(char::from).collect(); |
| 170 | let work_dir = PathBuf::from("/data/local/tmp/microdroid").join(s); |
| 171 | println!("creating work dir {}", work_dir.display()); |
| 172 | fs::create_dir_all(&work_dir).context("failed to mkdir")?; |
| 173 | Ok(work_dir) |
| 174 | } |
| 175 | |
| 176 | /// Run a VM with Microdroid |
| 177 | #[allow(clippy::too_many_arguments)] |
| 178 | pub fn command_run_microdroid( |
| 179 | name: Option<String>, |
| 180 | service: &dyn IVirtualizationService, |
| 181 | work_dir: Option<PathBuf>, |
| 182 | storage: Option<&Path>, |
| 183 | storage_size: Option<u64>, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 184 | console_path: Option<&Path>, |
| 185 | log_path: Option<&Path>, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 186 | debug_level: DebugLevel, |
| 187 | protected: bool, |
| 188 | mem: Option<u32>, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 189 | cpu_topology: CpuTopology, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 190 | task_profiles: Vec<String>, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 191 | gdb: Option<NonZeroU16>, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 192 | ) -> Result<(), Error> { |
Nikita Ioffe | fc04196 | 2023-01-18 00:10:40 +0000 | [diff] [blame] | 193 | let apk = find_empty_payload_apk_path()?; |
| 194 | println!("found path {}", apk.display()); |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 195 | |
| 196 | let work_dir = work_dir.unwrap_or(create_work_dir()?); |
| 197 | let idsig = work_dir.join("apk.idsig"); |
| 198 | println!("apk.idsig path: {}", idsig.display()); |
| 199 | let instance_img = work_dir.join("instance.img"); |
| 200 | println!("instance.img path: {}", instance_img.display()); |
| 201 | |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 202 | let payload_binary_name = "MicrodroidEmptyPayloadJniLib.so"; |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 203 | let extra_sig = []; |
| 204 | command_run_app( |
| 205 | name, |
| 206 | service, |
| 207 | &apk, |
| 208 | &idsig, |
| 209 | &instance_img, |
| 210 | storage, |
| 211 | storage_size, |
| 212 | /* config_path= */ None, |
Alan Stokes | 8f12f2b | 2023-01-09 09:19:20 +0000 | [diff] [blame] | 213 | Some(payload_binary_name.to_owned()), |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 214 | console_path, |
| 215 | log_path, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 216 | debug_level, |
| 217 | protected, |
| 218 | mem, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 219 | cpu_topology, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 220 | task_profiles, |
| 221 | &extra_sig, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 222 | gdb, |
Nikita Ioffe | b0b6756 | 2022-11-22 15:48:06 +0000 | [diff] [blame] | 223 | ) |
| 224 | } |
| 225 | |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 226 | /// Run a VM from the given configuration file. |
Jooyung Han | b7983a2 | 2022-02-22 05:21:27 +0900 | [diff] [blame] | 227 | #[allow(clippy::too_many_arguments)] |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 228 | pub fn command_run( |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 229 | name: Option<String>, |
Andrew Walbran | 616d13f | 2022-05-12 18:35:55 +0000 | [diff] [blame] | 230 | service: &dyn IVirtualizationService, |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 231 | config_path: &Path, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 232 | console_path: Option<&Path>, |
Jooyung Han | b7983a2 | 2022-02-22 05:21:27 +0900 | [diff] [blame] | 233 | log_path: Option<&Path>, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 234 | mem: Option<u32>, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 235 | cpu_topology: CpuTopology, |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 236 | task_profiles: Vec<String>, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 237 | gdb: Option<NonZeroU16>, |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 238 | ) -> Result<(), Error> { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 239 | let config_file = File::open(config_path).context("Failed to open config file")?; |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 240 | let mut config = |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 241 | VmConfig::load(&config_file).context("Failed to parse config file")?.to_parcelable()?; |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 242 | if let Some(mem) = mem { |
| 243 | config.memoryMib = mem as i32; |
| 244 | } |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 245 | if let Some(name) = name { |
| 246 | config.name = name; |
| 247 | } else { |
| 248 | config.name = String::from("VmRun"); |
| 249 | } |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 250 | if let Some(gdb) = gdb { |
| 251 | config.gdbPort = gdb.get() as i32; |
| 252 | } |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 253 | config.cpuTopology = cpu_topology; |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 254 | config.taskProfiles = task_profiles; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 255 | run( |
| 256 | service, |
| 257 | &VirtualMachineConfig::RawConfig(config), |
| 258 | &format!("{:?}", config_path), |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 259 | console_path, |
Jooyung Han | b7983a2 | 2022-02-22 05:21:27 +0900 | [diff] [blame] | 260 | log_path, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 261 | ) |
| 262 | } |
| 263 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 264 | fn state_to_str(vm_state: VirtualMachineState) -> &'static str { |
| 265 | match vm_state { |
| 266 | VirtualMachineState::NOT_STARTED => "NOT_STARTED", |
| 267 | VirtualMachineState::STARTING => "STARTING", |
| 268 | VirtualMachineState::STARTED => "STARTED", |
| 269 | VirtualMachineState::READY => "READY", |
| 270 | VirtualMachineState::FINISHED => "FINISHED", |
| 271 | VirtualMachineState::DEAD => "DEAD", |
| 272 | _ => "(invalid state)", |
| 273 | } |
| 274 | } |
| 275 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 276 | fn run( |
Andrew Walbran | 616d13f | 2022-05-12 18:35:55 +0000 | [diff] [blame] | 277 | service: &dyn IVirtualizationService, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 278 | config: &VirtualMachineConfig, |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 279 | payload_config: &str, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 280 | console_path: Option<&Path>, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 281 | log_path: Option<&Path>, |
| 282 | ) -> Result<(), Error> { |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 283 | let console = if let Some(console_path) = console_path { |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 284 | Some( |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 285 | File::create(console_path) |
| 286 | .with_context(|| format!("Failed to open console file {:?}", console_path))?, |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 287 | ) |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 288 | } else { |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 289 | Some(duplicate_stdout()?) |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 290 | }; |
| 291 | let log = if let Some(log_path) = log_path { |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 292 | Some( |
Andrew Walbran | be42924 | 2021-06-28 12:22:54 +0000 | [diff] [blame] | 293 | File::create(log_path) |
| 294 | .with_context(|| format!("Failed to open log file {:?}", log_path))?, |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 295 | ) |
Andrew Walbran | be42924 | 2021-06-28 12:22:54 +0000 | [diff] [blame] | 296 | } else { |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 297 | Some(duplicate_stdout()?) |
Andrew Walbran | be42924 | 2021-06-28 12:22:54 +0000 | [diff] [blame] | 298 | }; |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 299 | |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 300 | let callback = Box::new(Callback {}); |
| 301 | let vm = VmInstance::create(service, config, console, log, Some(callback)) |
| 302 | .context("Failed to create VM")?; |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 303 | vm.start().context("Failed to start VM")?; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 304 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 305 | println!( |
| 306 | "Created VM from {} with CID {}, state is {}.", |
Inseob Kim | 7b5f65c | 2022-11-15 14:27:04 +0900 | [diff] [blame] | 307 | payload_config, |
Andrew Walbran | d0ef400 | 2022-05-16 16:14:10 +0000 | [diff] [blame] | 308 | vm.cid(), |
| 309 | state_to_str(vm.state()?) |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 310 | ); |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 311 | |
David Brazdil | 2b6352f | 2023-01-12 11:01:17 +0000 | [diff] [blame] | 312 | // Wait until the VM or VirtualizationService dies. If we just returned immediately then the |
| 313 | // IVirtualMachine Binder object would be dropped and the VM would be killed. |
| 314 | let death_reason = vm.wait_for_death(); |
| 315 | println!("VM ended: {:?}", death_reason); |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 316 | Ok(()) |
| 317 | } |
| 318 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 319 | fn parse_extra_apk_list(apk: &Path, config_path: &str) -> Result<Vec<String>, Error> { |
| 320 | let mut archive = ZipArchive::new(File::open(apk)?)?; |
| 321 | let config_file = archive.by_name(config_path)?; |
| 322 | let config: VmPayloadConfig = serde_json::from_reader(config_file)?; |
| 323 | Ok(config.extra_apks.into_iter().map(|x| x.path).collect()) |
| 324 | } |
| 325 | |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 326 | struct Callback {} |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 327 | |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 328 | impl vmclient::VmCallback for Callback { |
David Brazdil | 451cc96 | 2022-10-14 14:08:12 +0100 | [diff] [blame] | 329 | fn on_payload_started(&self, _cid: i32) { |
| 330 | eprintln!("payload started"); |
| 331 | } |
| 332 | |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 333 | fn on_payload_ready(&self, _cid: i32) { |
Inseob Kim | 8dbc322 | 2021-09-01 21:50:23 +0900 | [diff] [blame] | 334 | eprintln!("payload is ready"); |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 335 | } |
| 336 | |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 337 | fn on_payload_finished(&self, _cid: i32, exit_code: i32) { |
Inseob Kim | 8dbc322 | 2021-09-01 21:50:23 +0900 | [diff] [blame] | 338 | eprintln!("payload finished with exit code {}", exit_code); |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 339 | } |
| 340 | |
Alan Stokes | 2bead0d | 2022-09-05 16:58:34 +0100 | [diff] [blame] | 341 | fn on_error(&self, _cid: i32, error_code: ErrorCode, message: &str) { |
| 342 | eprintln!("VM encountered an error: code={:?}, message={}", error_code, message); |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 343 | } |
| 344 | } |
| 345 | |
| 346 | /// Safely duplicate the standard output file descriptor. |
| 347 | fn duplicate_stdout() -> io::Result<File> { |
| 348 | let stdout_fd = io::stdout().as_raw_fd(); |
| 349 | // Safe because this just duplicates a file descriptor which we know to be valid, and we check |
| 350 | // for an error. |
| 351 | let dup_fd = unsafe { libc::dup(stdout_fd) }; |
| 352 | if dup_fd < 0 { |
| 353 | Err(io::Error::last_os_error()) |
| 354 | } else { |
| 355 | // Safe because we have just duplicated the file descriptor so we own it, and `from_raw_fd` |
| 356 | // takes ownership of it. |
| 357 | Ok(unsafe { File::from_raw_fd(dup_fd) }) |
| 358 | } |
| 359 | } |