Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +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 | //! Android VM control tool. |
| 16 | |
Jooyung Han | c221c05 | 2022-02-22 05:20:15 +0900 | [diff] [blame] | 17 | mod create_idsig; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 18 | mod create_partition; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 19 | mod run; |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 20 | mod sync; |
| 21 | |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 22 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
| 23 | IVirtualizationService::IVirtualizationService, PartitionType::PartitionType, |
| 24 | VirtualMachineAppConfig::DebugLevel::DebugLevel, |
| 25 | }; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 26 | use android_system_virtualizationservice::binder::{wait_for_interface, ProcessState, Strong}; |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 27 | use anyhow::{Context, Error}; |
Jooyung Han | c221c05 | 2022-02-22 05:20:15 +0900 | [diff] [blame] | 28 | use create_idsig::command_create_idsig; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 29 | use create_partition::command_create_partition; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 30 | use run::{command_run, command_run_app}; |
Andrew Walbran | c4b1bde | 2022-02-03 15:26:02 +0000 | [diff] [blame] | 31 | use rustutils::system_properties; |
| 32 | use std::path::{Path, PathBuf}; |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 33 | use structopt::clap::AppSettings; |
| 34 | use structopt::StructOpt; |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 35 | |
Andrew Walbran | 17de24f | 2021-05-27 13:27:30 +0000 | [diff] [blame] | 36 | const VIRTUALIZATION_SERVICE_BINDER_SERVICE_IDENTIFIER: &str = |
| 37 | "android.system.virtualizationservice"; |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 38 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 39 | #[derive(Debug)] |
| 40 | struct Idsigs(Vec<PathBuf>); |
| 41 | |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 42 | #[derive(StructOpt)] |
| 43 | #[structopt(no_version, global_settings = &[AppSettings::DisableVersion])] |
| 44 | enum Opt { |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 45 | /// Run a virtual machine with a config in APK |
| 46 | RunApp { |
| 47 | /// Path to VM Payload APK |
| 48 | #[structopt(parse(from_os_str))] |
| 49 | apk: PathBuf, |
| 50 | |
| 51 | /// Path to idsig of the APK |
| 52 | #[structopt(parse(from_os_str))] |
| 53 | idsig: PathBuf, |
| 54 | |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 55 | /// Path to the instance image. Created if not exists. |
| 56 | #[structopt(parse(from_os_str))] |
| 57 | instance: PathBuf, |
| 58 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 59 | /// Path to VM config JSON within APK (e.g. assets/vm_config.json) |
| 60 | config_path: String, |
| 61 | |
| 62 | /// Detach VM from the terminal and run in the background |
| 63 | #[structopt(short, long)] |
| 64 | daemonize: bool, |
| 65 | |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 66 | /// Path to file for VM console output. |
| 67 | #[structopt(long)] |
| 68 | console: Option<PathBuf>, |
| 69 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 70 | /// Path to file for VM log output. |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 71 | #[structopt(long)] |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 72 | log: Option<PathBuf>, |
Jiyong Park | 2360114 | 2021-07-05 13:15:32 +0900 | [diff] [blame] | 73 | |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 74 | /// Debug level of the VM. Supported values: "none" (default), "app_only", and "full". |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 75 | #[structopt(long, default_value = "none", parse(try_from_str=parse_debug_level))] |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 76 | debug: DebugLevel, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 77 | |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 78 | /// Run VM in protected mode. |
| 79 | #[structopt(short, long)] |
| 80 | protected: bool, |
| 81 | |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 82 | /// Memory size (in MiB) of the VM. If unspecified, defaults to the value of `memory_mib` |
| 83 | /// in the VM config file. |
| 84 | #[structopt(short, long)] |
| 85 | mem: Option<u32>, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 86 | |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 87 | /// Number of vCPUs in the VM. If unspecified, defaults to 1. |
| 88 | #[structopt(long)] |
| 89 | cpus: Option<u32>, |
| 90 | |
| 91 | /// Host CPUs where vCPUs are run on. If unspecified, vCPU runs on any host CPU. |
| 92 | #[structopt(long)] |
| 93 | cpu_affinity: Option<String>, |
| 94 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 95 | /// Paths to extra idsig files. |
Victor Hsieh | 9978257 | 2022-01-05 15:38:33 -0800 | [diff] [blame] | 96 | #[structopt(long = "extra-idsig")] |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 97 | extra_idsigs: Vec<PathBuf>, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 98 | }, |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 99 | /// Run a virtual machine |
| 100 | Run { |
| 101 | /// Path to VM config JSON |
| 102 | #[structopt(parse(from_os_str))] |
| 103 | config: PathBuf, |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 104 | |
| 105 | /// Detach VM from the terminal and run in the background |
| 106 | #[structopt(short, long)] |
| 107 | daemonize: bool, |
Andrew Walbran | be42924 | 2021-06-28 12:22:54 +0000 | [diff] [blame] | 108 | |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 109 | /// Number of vCPUs in the VM. If unspecified, defaults to 1. |
| 110 | #[structopt(long)] |
| 111 | cpus: Option<u32>, |
| 112 | |
| 113 | /// Host CPUs where vCPUs are run on. If unspecified, vCPU runs on any host CPU. The format |
| 114 | /// can be either a comma-separated list of CPUs or CPU ranges to run vCPUs on (e.g. |
| 115 | /// "0,1-3,5" to choose host CPUs 0, 1, 2, 3, and 5, or a colon-separated list of |
| 116 | /// assignments of vCPU-to-host-CPU assignments e.g. "0=0:1=1:2=2" to map vCPU 0 to host |
| 117 | /// CPU 0 and so on. |
| 118 | #[structopt(long)] |
| 119 | cpu_affinity: Option<String>, |
| 120 | |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 121 | /// Path to file for VM console output. |
| 122 | #[structopt(long)] |
| 123 | console: Option<PathBuf>, |
Jooyung Han | b7983a2 | 2022-02-22 05:21:27 +0900 | [diff] [blame] | 124 | |
| 125 | /// Path to file for VM log output. |
| 126 | #[structopt(long)] |
| 127 | log: Option<PathBuf>, |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 128 | }, |
| 129 | /// Stop a virtual machine running in the background |
| 130 | Stop { |
| 131 | /// CID of the virtual machine |
| 132 | cid: u32, |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 133 | }, |
| 134 | /// List running virtual machines |
| 135 | List, |
Andrew Walbran | c4b1bde | 2022-02-03 15:26:02 +0000 | [diff] [blame] | 136 | /// Print information about virtual machine support |
| 137 | Info, |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 138 | /// Create a new empty partition to be used as a writable partition for a VM |
| 139 | CreatePartition { |
| 140 | /// Path at which to create the image file |
| 141 | #[structopt(parse(from_os_str))] |
| 142 | path: PathBuf, |
| 143 | |
| 144 | /// The desired size of the partition, in bytes. |
| 145 | size: u64, |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 146 | |
| 147 | /// Type of the partition |
| 148 | #[structopt(short="t", long="type", default_value="raw", parse(try_from_str=parse_partition_type))] |
| 149 | partition_type: PartitionType, |
Andrew Walbran | dff3b94 | 2021-06-09 15:20:36 +0000 | [diff] [blame] | 150 | }, |
Jooyung Han | c221c05 | 2022-02-22 05:20:15 +0900 | [diff] [blame] | 151 | /// Creates or update the idsig file by digesting the input APK file. |
| 152 | CreateIdsig { |
| 153 | /// Path to VM Payload APK |
| 154 | #[structopt(parse(from_os_str))] |
| 155 | apk: PathBuf, |
| 156 | /// Path to idsig of the APK |
| 157 | #[structopt(parse(from_os_str))] |
| 158 | path: PathBuf, |
| 159 | }, |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 160 | } |
| 161 | |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 162 | fn parse_debug_level(s: &str) -> Result<DebugLevel, String> { |
| 163 | match s { |
| 164 | "none" => Ok(DebugLevel::NONE), |
| 165 | "app_only" => Ok(DebugLevel::APP_ONLY), |
| 166 | "full" => Ok(DebugLevel::FULL), |
| 167 | _ => Err(format!("Invalid debug level {}", s)), |
| 168 | } |
| 169 | } |
| 170 | |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 171 | fn parse_partition_type(s: &str) -> Result<PartitionType, String> { |
| 172 | match s { |
| 173 | "raw" => Ok(PartitionType::RAW), |
| 174 | "instance" => Ok(PartitionType::ANDROID_VM_INSTANCE), |
| 175 | _ => Err(format!("Invalid partition type {}", s)), |
| 176 | } |
| 177 | } |
| 178 | |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 179 | fn main() -> Result<(), Error> { |
| 180 | env_logger::init(); |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 181 | let opt = Opt::from_args(); |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 182 | |
| 183 | // We need to start the thread pool for Binder to work properly, especially link_to_death. |
| 184 | ProcessState::start_thread_pool(); |
| 185 | |
Andrew Walbran | f145380 | 2021-03-29 17:12:54 +0000 | [diff] [blame] | 186 | let service = wait_for_interface(VIRTUALIZATION_SERVICE_BINDER_SERVICE_IDENTIFIER) |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 187 | .context("Failed to find VirtualizationService")?; |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 188 | |
David Brazdil | 20412d9 | 2021-03-18 10:53:06 +0000 | [diff] [blame] | 189 | match opt { |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 190 | Opt::RunApp { |
| 191 | apk, |
| 192 | idsig, |
| 193 | instance, |
| 194 | config_path, |
| 195 | daemonize, |
| 196 | console, |
| 197 | log, |
| 198 | debug, |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 199 | protected, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 200 | mem, |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 201 | cpus, |
| 202 | cpu_affinity, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 203 | extra_idsigs, |
| 204 | } => command_run_app( |
| 205 | service, |
| 206 | &apk, |
| 207 | &idsig, |
| 208 | &instance, |
| 209 | &config_path, |
| 210 | daemonize, |
| 211 | console.as_deref(), |
| 212 | log.as_deref(), |
| 213 | debug, |
Andrew Walbran | 3994f00 | 2022-01-27 17:33:45 +0000 | [diff] [blame] | 214 | protected, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 215 | mem, |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 216 | cpus, |
| 217 | cpu_affinity, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 218 | &extra_idsigs, |
| 219 | ), |
Jooyung Han | b7983a2 | 2022-02-22 05:21:27 +0900 | [diff] [blame] | 220 | Opt::Run { config, daemonize, cpus, cpu_affinity, console, log } => { |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 221 | command_run( |
| 222 | service, |
| 223 | &config, |
| 224 | daemonize, |
| 225 | console.as_deref(), |
Jooyung Han | b7983a2 | 2022-02-22 05:21:27 +0900 | [diff] [blame] | 226 | log.as_deref(), |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 227 | /* mem */ None, |
| 228 | cpus, |
| 229 | cpu_affinity, |
| 230 | ) |
Andrew Walbran | be42924 | 2021-06-28 12:22:54 +0000 | [diff] [blame] | 231 | } |
Andrew Walbran | 17de24f | 2021-05-27 13:27:30 +0000 | [diff] [blame] | 232 | Opt::Stop { cid } => command_stop(service, cid), |
| 233 | Opt::List => command_list(service), |
Andrew Walbran | c4b1bde | 2022-02-03 15:26:02 +0000 | [diff] [blame] | 234 | Opt::Info => command_info(), |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 235 | Opt::CreatePartition { path, size, partition_type } => { |
| 236 | command_create_partition(service, &path, size, partition_type) |
| 237 | } |
Jooyung Han | c221c05 | 2022-02-22 05:20:15 +0900 | [diff] [blame] | 238 | Opt::CreateIdsig { apk, path } => command_create_idsig(service, &apk, &path), |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 239 | } |
| 240 | } |
| 241 | |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 242 | /// Retrieve reference to a previously daemonized VM and stop it. |
Andrew Walbran | 17de24f | 2021-05-27 13:27:30 +0000 | [diff] [blame] | 243 | fn command_stop(service: Strong<dyn IVirtualizationService>, cid: u32) -> Result<(), Error> { |
| 244 | service |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 245 | .debugDropVmRef(cid as i32) |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 246 | .context("Failed to get VM from VirtualizationService")? |
David Brazdil | 3c2ddef | 2021-03-18 13:09:57 +0000 | [diff] [blame] | 247 | .context("CID does not correspond to a running background VM")?; |
Andrew Walbran | ea9fa48 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 248 | Ok(()) |
| 249 | } |
| 250 | |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 251 | /// List the VMs currently running. |
Andrew Walbran | 17de24f | 2021-05-27 13:27:30 +0000 | [diff] [blame] | 252 | fn command_list(service: Strong<dyn IVirtualizationService>) -> Result<(), Error> { |
| 253 | let vms = service.debugListVms().context("Failed to get list of VMs")?; |
Andrew Walbran | 320b560 | 2021-03-04 16:11:12 +0000 | [diff] [blame] | 254 | println!("Running VMs: {:#?}", vms); |
| 255 | Ok(()) |
| 256 | } |
Andrew Walbran | c4b1bde | 2022-02-03 15:26:02 +0000 | [diff] [blame] | 257 | |
| 258 | /// Print information about supported VM types. |
| 259 | fn command_info() -> Result<(), Error> { |
| 260 | let unprotected_vm_supported = |
| 261 | system_properties::read_bool("ro.boot.hypervisor.vm.supported", false)?; |
| 262 | let protected_vm_supported = |
| 263 | system_properties::read_bool("ro.boot.hypervisor.protected_vm.supported", false)?; |
| 264 | match (unprotected_vm_supported, protected_vm_supported) { |
| 265 | (false, false) => println!("VMs are not supported."), |
| 266 | (false, true) => println!("Only protected VMs are supported."), |
| 267 | (true, false) => println!("Only unprotected VMs are supported."), |
| 268 | (true, true) => println!("Both protected and unprotected VMs are supported."), |
| 269 | } |
| 270 | |
Andrew Walbran | 014efb5 | 2022-02-03 17:43:11 +0000 | [diff] [blame] | 271 | if let Some(version) = system_properties::read("ro.boot.hypervisor.version")? { |
Andrew Walbran | c4b1bde | 2022-02-03 15:26:02 +0000 | [diff] [blame] | 272 | println!("Hypervisor version: {}", version); |
| 273 | } else { |
| 274 | println!("Hypervisor version not set."); |
| 275 | } |
| 276 | |
| 277 | if Path::new("/dev/kvm").exists() { |
| 278 | println!("/dev/kvm exists."); |
| 279 | } else { |
| 280 | println!("/dev/kvm does not exist."); |
| 281 | } |
| 282 | |
| 283 | Ok(()) |
| 284 | } |