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