blob: 80ea9be2d938f88b7b834ba8f54751c85a196419 [file] [log] [blame]
Andrew Walbranea9fa482021-03-04 16:11:12 +00001// 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 Hanc221c052022-02-22 05:20:15 +090017mod create_idsig;
Jiyong Park48b354d2021-07-15 15:04:38 +090018mod create_partition;
Andrew Walbranf395b822021-05-05 10:38:59 +000019mod run;
Andrew Walbranea9fa482021-03-04 16:11:12 +000020mod sync;
21
Jiyong Parkc2a49cc2021-10-15 00:02:12 +090022use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
23 IVirtualizationService::IVirtualizationService, PartitionType::PartitionType,
24 VirtualMachineAppConfig::DebugLevel::DebugLevel,
25};
Jiyong Park48b354d2021-07-15 15:04:38 +090026use android_system_virtualizationservice::binder::{wait_for_interface, ProcessState, Strong};
David Brazdil20412d92021-03-18 10:53:06 +000027use anyhow::{Context, Error};
Jooyung Hanc221c052022-02-22 05:20:15 +090028use create_idsig::command_create_idsig;
Jiyong Park48b354d2021-07-15 15:04:38 +090029use create_partition::command_create_partition;
Jooyung Han21e9b922021-06-26 04:14:16 +090030use run::{command_run, command_run_app};
Andrew Walbranc4b1bde2022-02-03 15:26:02 +000031use rustutils::system_properties;
32use std::path::{Path, PathBuf};
David Brazdil20412d92021-03-18 10:53:06 +000033use structopt::clap::AppSettings;
34use structopt::StructOpt;
Andrew Walbranea9fa482021-03-04 16:11:12 +000035
Andrew Walbran17de24f2021-05-27 13:27:30 +000036const VIRTUALIZATION_SERVICE_BINDER_SERVICE_IDENTIFIER: &str =
37 "android.system.virtualizationservice";
Andrew Walbranea9fa482021-03-04 16:11:12 +000038
Inseob Kima5a262f2021-11-17 19:41:03 +090039#[derive(Debug)]
40struct Idsigs(Vec<PathBuf>);
41
David Brazdil20412d92021-03-18 10:53:06 +000042#[derive(StructOpt)]
43#[structopt(no_version, global_settings = &[AppSettings::DisableVersion])]
44enum Opt {
Jooyung Han21e9b922021-06-26 04:14:16 +090045 /// 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 Park48b354d2021-07-15 15:04:38 +090055 /// Path to the instance image. Created if not exists.
56 #[structopt(parse(from_os_str))]
57 instance: PathBuf,
58
Jooyung Han21e9b922021-06-26 04:14:16 +090059 /// 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 Parkb8182bb2021-10-26 22:53:08 +090066 /// Path to file for VM console output.
67 #[structopt(long)]
68 console: Option<PathBuf>,
69
Jooyung Han21e9b922021-06-26 04:14:16 +090070 /// Path to file for VM log output.
Jiyong Parkb8182bb2021-10-26 22:53:08 +090071 #[structopt(long)]
Jooyung Han21e9b922021-06-26 04:14:16 +090072 log: Option<PathBuf>,
Jiyong Park23601142021-07-05 13:15:32 +090073
Jiyong Parkc2a49cc2021-10-15 00:02:12 +090074 /// Debug level of the VM. Supported values: "none" (default), "app_only", and "full".
Jiyong Parkb8182bb2021-10-26 22:53:08 +090075 #[structopt(long, default_value = "none", parse(try_from_str=parse_debug_level))]
Jiyong Parkc2a49cc2021-10-15 00:02:12 +090076 debug: DebugLevel,
Jiyong Parkd63cfff2021-09-27 20:10:17 +090077
Andrew Walbran3994f002022-01-27 17:33:45 +000078 /// Run VM in protected mode.
79 #[structopt(short, long)]
80 protected: bool,
81
Jiyong Parkd63cfff2021-09-27 20:10:17 +090082 /// 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 Kima5a262f2021-11-17 19:41:03 +090086
Jiyong Park032615f2022-01-10 13:55:34 +090087 /// 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 Kima5a262f2021-11-17 19:41:03 +090095 /// Paths to extra idsig files.
Victor Hsieh99782572022-01-05 15:38:33 -080096 #[structopt(long = "extra-idsig")]
Inseob Kima5a262f2021-11-17 19:41:03 +090097 extra_idsigs: Vec<PathBuf>,
Jooyung Han21e9b922021-06-26 04:14:16 +090098 },
David Brazdil20412d92021-03-18 10:53:06 +000099 /// Run a virtual machine
100 Run {
101 /// Path to VM config JSON
102 #[structopt(parse(from_os_str))]
103 config: PathBuf,
David Brazdil3c2ddef2021-03-18 13:09:57 +0000104
105 /// Detach VM from the terminal and run in the background
106 #[structopt(short, long)]
107 daemonize: bool,
Andrew Walbranbe429242021-06-28 12:22:54 +0000108
Jiyong Park032615f2022-01-10 13:55:34 +0900109 /// 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 Parkb8182bb2021-10-26 22:53:08 +0900121 /// Path to file for VM console output.
122 #[structopt(long)]
123 console: Option<PathBuf>,
Jooyung Hanb7983a22022-02-22 05:21:27 +0900124
125 /// Path to file for VM log output.
126 #[structopt(long)]
127 log: Option<PathBuf>,
David Brazdil3c2ddef2021-03-18 13:09:57 +0000128 },
129 /// Stop a virtual machine running in the background
130 Stop {
131 /// CID of the virtual machine
132 cid: u32,
David Brazdil20412d92021-03-18 10:53:06 +0000133 },
134 /// List running virtual machines
135 List,
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000136 /// Print information about virtual machine support
137 Info,
Andrew Walbrandff3b942021-06-09 15:20:36 +0000138 /// 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 Park9dd389e2021-08-23 20:42:59 +0900146
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 Walbrandff3b942021-06-09 15:20:36 +0000150 },
Jooyung Hanc221c052022-02-22 05:20:15 +0900151 /// 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 Brazdil20412d92021-03-18 10:53:06 +0000160}
161
Jiyong Parkc2a49cc2021-10-15 00:02:12 +0900162fn 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 Park9dd389e2021-08-23 20:42:59 +0900171fn 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 Walbranea9fa482021-03-04 16:11:12 +0000179fn main() -> Result<(), Error> {
180 env_logger::init();
David Brazdil20412d92021-03-18 10:53:06 +0000181 let opt = Opt::from_args();
Andrew Walbranea9fa482021-03-04 16:11:12 +0000182
183 // We need to start the thread pool for Binder to work properly, especially link_to_death.
184 ProcessState::start_thread_pool();
185
Andrew Walbranf1453802021-03-29 17:12:54 +0000186 let service = wait_for_interface(VIRTUALIZATION_SERVICE_BINDER_SERVICE_IDENTIFIER)
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000187 .context("Failed to find VirtualizationService")?;
Andrew Walbran320b5602021-03-04 16:11:12 +0000188
David Brazdil20412d92021-03-18 10:53:06 +0000189 match opt {
Inseob Kima5a262f2021-11-17 19:41:03 +0900190 Opt::RunApp {
191 apk,
192 idsig,
193 instance,
194 config_path,
195 daemonize,
196 console,
197 log,
198 debug,
Andrew Walbran3994f002022-01-27 17:33:45 +0000199 protected,
Inseob Kima5a262f2021-11-17 19:41:03 +0900200 mem,
Jiyong Park032615f2022-01-10 13:55:34 +0900201 cpus,
202 cpu_affinity,
Inseob Kima5a262f2021-11-17 19:41:03 +0900203 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 Walbran3994f002022-01-27 17:33:45 +0000214 protected,
Inseob Kima5a262f2021-11-17 19:41:03 +0900215 mem,
Jiyong Park032615f2022-01-10 13:55:34 +0900216 cpus,
217 cpu_affinity,
Inseob Kima5a262f2021-11-17 19:41:03 +0900218 &extra_idsigs,
219 ),
Jooyung Hanb7983a22022-02-22 05:21:27 +0900220 Opt::Run { config, daemonize, cpus, cpu_affinity, console, log } => {
Jiyong Park032615f2022-01-10 13:55:34 +0900221 command_run(
222 service,
223 &config,
224 daemonize,
225 console.as_deref(),
Jooyung Hanb7983a22022-02-22 05:21:27 +0900226 log.as_deref(),
Jiyong Park032615f2022-01-10 13:55:34 +0900227 /* mem */ None,
228 cpus,
229 cpu_affinity,
230 )
Andrew Walbranbe429242021-06-28 12:22:54 +0000231 }
Andrew Walbran17de24f2021-05-27 13:27:30 +0000232 Opt::Stop { cid } => command_stop(service, cid),
233 Opt::List => command_list(service),
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000234 Opt::Info => command_info(),
Jiyong Park9dd389e2021-08-23 20:42:59 +0900235 Opt::CreatePartition { path, size, partition_type } => {
236 command_create_partition(service, &path, size, partition_type)
237 }
Jooyung Hanc221c052022-02-22 05:20:15 +0900238 Opt::CreateIdsig { apk, path } => command_create_idsig(service, &apk, &path),
Andrew Walbranea9fa482021-03-04 16:11:12 +0000239 }
240}
241
David Brazdil3c2ddef2021-03-18 13:09:57 +0000242/// Retrieve reference to a previously daemonized VM and stop it.
Andrew Walbran17de24f2021-05-27 13:27:30 +0000243fn command_stop(service: Strong<dyn IVirtualizationService>, cid: u32) -> Result<(), Error> {
244 service
David Brazdil3c2ddef2021-03-18 13:09:57 +0000245 .debugDropVmRef(cid as i32)
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000246 .context("Failed to get VM from VirtualizationService")?
David Brazdil3c2ddef2021-03-18 13:09:57 +0000247 .context("CID does not correspond to a running background VM")?;
Andrew Walbranea9fa482021-03-04 16:11:12 +0000248 Ok(())
249}
250
Andrew Walbran320b5602021-03-04 16:11:12 +0000251/// List the VMs currently running.
Andrew Walbran17de24f2021-05-27 13:27:30 +0000252fn command_list(service: Strong<dyn IVirtualizationService>) -> Result<(), Error> {
253 let vms = service.debugListVms().context("Failed to get list of VMs")?;
Andrew Walbran320b5602021-03-04 16:11:12 +0000254 println!("Running VMs: {:#?}", vms);
255 Ok(())
256}
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000257
258/// Print information about supported VM types.
259fn 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 Walbran014efb52022-02-03 17:43:11 +0000271 if let Some(version) = system_properties::read("ro.boot.hypervisor.version")? {
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000272 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}