blob: ea8c68268bca446fc83ad80cab9fdb05c8e8e749 [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 +000020
Jiyong Parkc2a49cc2021-10-15 00:02:12 +090021use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
David Brazdil7d1e5ec2023-02-06 17:56:29 +000022 CpuTopology::CpuTopology, IVirtualizationService::IVirtualizationService,
23 PartitionType::PartitionType, VirtualMachineAppConfig::DebugLevel::DebugLevel,
Jiyong Parkc2a49cc2021-10-15 00:02:12 +090024};
David Brazdil20412d92021-03-18 10:53:06 +000025use anyhow::{Context, Error};
Alan Stokesc4d5def2023-02-14 17:01:59 +000026use binder::{ProcessState, Strong};
Jiyong Parkb1935ef2023-08-10 17:22:39 +090027use clap::{Args, Parser};
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;
Nikita Ioffeb0b67562022-11-22 15:48:06 +000030use run::{command_run, command_run_app, command_run_microdroid};
Nikita Ioffe5776f082023-02-10 21:38:26 +000031use std::num::NonZeroU16;
Andrew Walbranc4b1bde2022-02-03 15:26:02 +000032use std::path::{Path, PathBuf};
Andrew Walbranea9fa482021-03-04 16:11:12 +000033
Inseob Kima5a262f2021-11-17 19:41:03 +090034#[derive(Debug)]
35struct Idsigs(Vec<PathBuf>);
36
Alan Stokesfda70842023-12-20 17:50:14 +000037#[derive(Args, Default)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +090038/// Collection of flags that are at VM level and therefore applicable to all subcommands
39pub struct CommonConfig {
40 /// Name of VM
41 #[arg(long)]
42 name: Option<String>,
43
44 /// Run VM with vCPU topology matching that of the host. If unspecified, defaults to 1 vCPU.
45 #[arg(long, default_value = "one_cpu", value_parser = parse_cpu_topology)]
46 cpu_topology: CpuTopology,
47
48 /// Comma separated list of task profile names to apply to the VM
49 #[arg(long)]
50 task_profiles: Vec<String>,
51
52 /// Memory size (in MiB) of the VM. If unspecified, defaults to the value of `memory_mib`
53 /// in the VM config file.
54 #[arg(short, long)]
55 mem: Option<u32>,
56
57 /// Run VM in protected mode.
58 #[arg(short, long)]
59 protected: bool,
60}
61
Alan Stokesfda70842023-12-20 17:50:14 +000062#[derive(Args, Default)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +090063/// Collection of flags for debugging
64pub struct DebugConfig {
65 /// Debug level of the VM. Supported values: "full" (default), and "none".
66 #[arg(long, default_value = "full", value_parser = parse_debug_level)]
67 debug: DebugLevel,
68
69 /// Path to file for VM console output.
70 #[arg(long)]
71 console: Option<PathBuf>,
72
73 /// Path to file for VM console input.
74 #[arg(long)]
75 console_in: Option<PathBuf>,
76
77 /// Path to file for VM log output.
78 #[arg(long)]
79 log: Option<PathBuf>,
80
81 /// Port at which crosvm will start a gdb server to debug guest kernel.
82 /// Note: this is only supported on Android kernels android14-5.15 and higher.
83 #[arg(long)]
84 gdb: Option<NonZeroU16>,
85}
86
Alan Stokesfda70842023-12-20 17:50:14 +000087#[derive(Args, Default)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +090088/// Collection of flags that are Microdroid specific
89pub struct MicrodroidConfig {
90 /// Path to the file backing the storage.
91 /// Created if the option is used but the path does not exist in the device.
92 #[arg(long)]
93 storage: Option<PathBuf>,
94
95 /// Size of the storage. Used only if --storage is supplied but path does not exist
96 /// Default size is 10*1024*1024
97 #[arg(long)]
98 storage_size: Option<u64>,
99
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900100 /// Path to disk image containing vendor-specific modules.
Nikita Ioffe631717e2023-09-05 13:38:07 +0100101 #[cfg(vendor_modules)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900102 #[arg(long)]
103 vendor: Option<PathBuf>,
104
105 /// SysFS nodes of devices to assign to VM
Nikita Ioffe94a8a182023-11-16 16:37:48 +0000106 #[cfg(device_assignment)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900107 #[arg(long)]
108 devices: Vec<PathBuf>,
Inseob Kim172f9eb2023-11-06 17:02:08 +0900109
Inseob Kim7a1fc8f2023-11-22 18:45:28 +0900110 /// Version of GKI to use. If set, use instead of microdroid kernel
Inseob Kim172f9eb2023-11-06 17:02:08 +0900111 #[cfg(vendor_modules)]
112 #[arg(long)]
Inseob Kim7a1fc8f2023-11-22 18:45:28 +0900113 gki: Option<String>,
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900114}
115
Nikita Ioffe631717e2023-09-05 13:38:07 +0100116impl MicrodroidConfig {
117 #[cfg(vendor_modules)]
Nikita Ioffe631717e2023-09-05 13:38:07 +0100118 fn vendor(&self) -> &Option<PathBuf> {
119 &self.vendor
120 }
121
122 #[cfg(not(vendor_modules))]
Nikita Ioffe631717e2023-09-05 13:38:07 +0100123 fn vendor(&self) -> Option<PathBuf> {
124 None
125 }
Nikita Ioffe94a8a182023-11-16 16:37:48 +0000126
Inseob Kim172f9eb2023-11-06 17:02:08 +0900127 #[cfg(vendor_modules)]
Inseob Kim7a1fc8f2023-11-22 18:45:28 +0900128 fn gki(&self) -> Option<&str> {
129 self.gki.as_deref()
Inseob Kim172f9eb2023-11-06 17:02:08 +0900130 }
131
132 #[cfg(not(vendor_modules))]
Inseob Kim7a1fc8f2023-11-22 18:45:28 +0900133 fn gki(&self) -> Option<&str> {
134 None
Inseob Kim172f9eb2023-11-06 17:02:08 +0900135 }
136
Nikita Ioffe94a8a182023-11-16 16:37:48 +0000137 #[cfg(device_assignment)]
138 fn devices(&self) -> &Vec<PathBuf> {
139 &self.devices
140 }
141
142 #[cfg(not(device_assignment))]
143 fn devices(&self) -> Vec<PathBuf> {
144 Vec::new()
145 }
Nikita Ioffe631717e2023-09-05 13:38:07 +0100146}
147
Alan Stokesfda70842023-12-20 17:50:14 +0000148#[derive(Args, Default)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900149/// Flags for the run_app subcommand
150pub struct RunAppConfig {
151 #[command(flatten)]
152 common: CommonConfig,
153
154 #[command(flatten)]
155 debug: DebugConfig,
156
157 #[command(flatten)]
158 microdroid: MicrodroidConfig,
159
160 /// Path to VM Payload APK
161 apk: PathBuf,
162
163 /// Path to idsig of the APK
164 idsig: PathBuf,
165
166 /// Path to the instance image. Created if not exists.
167 instance: PathBuf,
168
169 /// Path to VM config JSON within APK (e.g. assets/vm_config.json)
170 #[arg(long)]
171 config_path: Option<String>,
172
173 /// Name of VM payload binary within APK (e.g. MicrodroidTestNativeLib.so)
174 #[arg(long)]
175 #[arg(alias = "payload_path")]
176 payload_binary_name: Option<String>,
177
Alan Stokesfda70842023-12-20 17:50:14 +0000178 /// Paths to extra apk files.
179 #[cfg(multi_tenant)]
180 #[arg(long = "extra-apk")]
181 #[clap(conflicts_with = "config_path")]
182 extra_apks: Vec<PathBuf>,
183
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900184 /// Paths to extra idsig files.
185 #[arg(long = "extra-idsig")]
186 extra_idsigs: Vec<PathBuf>,
187}
188
Alan Stokesfda70842023-12-20 17:50:14 +0000189impl RunAppConfig {
190 #[cfg(multi_tenant)]
191 fn extra_apks(&self) -> &[PathBuf] {
192 &self.extra_apks
193 }
194
195 #[cfg(not(multi_tenant))]
196 fn extra_apks(&self) -> &[PathBuf] {
197 &[]
198 }
199}
200
201#[derive(Args, Default)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900202/// Flags for the run_microdroid subcommand
203pub struct RunMicrodroidConfig {
204 #[command(flatten)]
205 common: CommonConfig,
206
207 #[command(flatten)]
208 debug: DebugConfig,
209
210 #[command(flatten)]
211 microdroid: MicrodroidConfig,
212
213 /// Path to the directory where VM-related files (e.g. instance.img, apk.idsig, etc.) will
214 /// be stored. If not specified a random directory under /data/local/tmp/microdroid will be
215 /// created and used.
216 #[arg(long)]
217 work_dir: Option<PathBuf>,
218}
219
Alan Stokesfda70842023-12-20 17:50:14 +0000220#[derive(Args, Default)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900221/// Flags for the run subcommand
222pub struct RunCustomVmConfig {
223 #[command(flatten)]
224 common: CommonConfig,
225
226 #[command(flatten)]
227 debug: DebugConfig,
228
229 /// Path to VM config JSON
230 config: PathBuf,
231}
232
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700233#[derive(Parser)]
David Brazdil20412d92021-03-18 10:53:06 +0000234enum Opt {
Shikha Panwar6d306412024-02-17 21:37:49 +0000235 /// Check if the feature is enabled on device.
236 CheckFeatureEnabled { feature: String },
Jooyung Han21e9b922021-06-26 04:14:16 +0900237 /// Run a virtual machine with a config in APK
238 RunApp {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900239 #[command(flatten)]
240 config: RunAppConfig,
Jooyung Han21e9b922021-06-26 04:14:16 +0900241 },
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000242 /// Run a virtual machine with Microdroid inside
243 RunMicrodroid {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900244 #[command(flatten)]
245 config: RunMicrodroidConfig,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000246 },
David Brazdil20412d92021-03-18 10:53:06 +0000247 /// Run a virtual machine
248 Run {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900249 #[command(flatten)]
250 config: RunCustomVmConfig,
David Brazdil3c2ddef2021-03-18 13:09:57 +0000251 },
David Brazdil20412d92021-03-18 10:53:06 +0000252 /// List running virtual machines
253 List,
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000254 /// Print information about virtual machine support
255 Info,
Andrew Walbrandff3b942021-06-09 15:20:36 +0000256 /// Create a new empty partition to be used as a writable partition for a VM
257 CreatePartition {
258 /// Path at which to create the image file
Andrew Walbrandff3b942021-06-09 15:20:36 +0000259 path: PathBuf,
260
261 /// The desired size of the partition, in bytes.
262 size: u64,
Jiyong Park9dd389e2021-08-23 20:42:59 +0900263
264 /// Type of the partition
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900265 #[arg(short = 't', long = "type", default_value = "raw",
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700266 value_parser = parse_partition_type)]
Jiyong Park9dd389e2021-08-23 20:42:59 +0900267 partition_type: PartitionType,
Andrew Walbrandff3b942021-06-09 15:20:36 +0000268 },
Jooyung Hanc221c052022-02-22 05:20:15 +0900269 /// Creates or update the idsig file by digesting the input APK file.
270 CreateIdsig {
271 /// Path to VM Payload APK
Jooyung Hanc221c052022-02-22 05:20:15 +0900272 apk: PathBuf,
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700273
Jooyung Hanc221c052022-02-22 05:20:15 +0900274 /// Path to idsig of the APK
Jooyung Hanc221c052022-02-22 05:20:15 +0900275 path: PathBuf,
276 },
David Brazdil20412d92021-03-18 10:53:06 +0000277}
278
Jiyong Parkc2a49cc2021-10-15 00:02:12 +0900279fn parse_debug_level(s: &str) -> Result<DebugLevel, String> {
280 match s {
281 "none" => Ok(DebugLevel::NONE),
Jiyong Parkc2a49cc2021-10-15 00:02:12 +0900282 "full" => Ok(DebugLevel::FULL),
283 _ => Err(format!("Invalid debug level {}", s)),
284 }
285}
286
Jiyong Park9dd389e2021-08-23 20:42:59 +0900287fn parse_partition_type(s: &str) -> Result<PartitionType, String> {
288 match s {
289 "raw" => Ok(PartitionType::RAW),
290 "instance" => Ok(PartitionType::ANDROID_VM_INSTANCE),
291 _ => Err(format!("Invalid partition type {}", s)),
292 }
293}
294
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000295fn parse_cpu_topology(s: &str) -> Result<CpuTopology, String> {
296 match s {
297 "one_cpu" => Ok(CpuTopology::ONE_CPU),
298 "match_host" => Ok(CpuTopology::MATCH_HOST),
299 _ => Err(format!("Invalid cpu topology {}", s)),
300 }
301}
302
Alan Stokesc4d5def2023-02-14 17:01:59 +0000303fn get_service() -> Result<Strong<dyn IVirtualizationService>, Error> {
304 let virtmgr =
305 vmclient::VirtualizationService::new().context("Failed to spawn VirtualizationService")?;
306 virtmgr.connect().context("Failed to connect to VirtualizationService")
307}
308
Shikha Panwar6d306412024-02-17 21:37:49 +0000309fn command_check_feature_enabled(feature: &str) {
310 println!(
311 "Feature {feature} is {}",
312 if avf_features::is_feature_enabled(feature) { "enabled" } else { "disabled" }
313 );
314}
315
Andrew Walbranea9fa482021-03-04 16:11:12 +0000316fn main() -> Result<(), Error> {
317 env_logger::init();
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700318 let opt = Opt::parse();
Andrew Walbranea9fa482021-03-04 16:11:12 +0000319
320 // We need to start the thread pool for Binder to work properly, especially link_to_death.
321 ProcessState::start_thread_pool();
322
David Brazdil20412d92021-03-18 10:53:06 +0000323 match opt {
Shikha Panwar6d306412024-02-17 21:37:49 +0000324 Opt::CheckFeatureEnabled { feature } => {
325 command_check_feature_enabled(&feature);
326 Ok(())
327 }
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900328 Opt::RunApp { config } => command_run_app(config),
329 Opt::RunMicrodroid { config } => command_run_microdroid(config),
330 Opt::Run { config } => command_run(config),
Alan Stokesc4d5def2023-02-14 17:01:59 +0000331 Opt::List => command_list(get_service()?.as_ref()),
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000332 Opt::Info => command_info(),
Jiyong Park9dd389e2021-08-23 20:42:59 +0900333 Opt::CreatePartition { path, size, partition_type } => {
Alan Stokesc4d5def2023-02-14 17:01:59 +0000334 command_create_partition(get_service()?.as_ref(), &path, size, partition_type)
Jiyong Park9dd389e2021-08-23 20:42:59 +0900335 }
Alan Stokesc4d5def2023-02-14 17:01:59 +0000336 Opt::CreateIdsig { apk, path } => {
337 command_create_idsig(get_service()?.as_ref(), &apk, &path)
338 }
Andrew Walbranea9fa482021-03-04 16:11:12 +0000339 }
340}
341
Andrew Walbran320b5602021-03-04 16:11:12 +0000342/// List the VMs currently running.
Andrew Walbran616d13f2022-05-12 18:35:55 +0000343fn command_list(service: &dyn IVirtualizationService) -> Result<(), Error> {
Andrew Walbran17de24f2021-05-27 13:27:30 +0000344 let vms = service.debugListVms().context("Failed to get list of VMs")?;
Andrew Walbran320b5602021-03-04 16:11:12 +0000345 println!("Running VMs: {:#?}", vms);
346 Ok(())
347}
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000348
349/// Print information about supported VM types.
350fn command_info() -> Result<(), Error> {
Alan Stokesc4d5def2023-02-14 17:01:59 +0000351 let non_protected_vm_supported = hypervisor_props::is_vm_supported()?;
352 let protected_vm_supported = hypervisor_props::is_protected_vm_supported()?;
Alan Stokes8d39a9b2023-01-10 15:01:00 +0000353 match (non_protected_vm_supported, protected_vm_supported) {
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000354 (false, false) => println!("VMs are not supported."),
355 (false, true) => println!("Only protected VMs are supported."),
Alan Stokes8d39a9b2023-01-10 15:01:00 +0000356 (true, false) => println!("Only non-protected VMs are supported."),
357 (true, true) => println!("Both protected and non-protected VMs are supported."),
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000358 }
359
Alan Stokesc4d5def2023-02-14 17:01:59 +0000360 if let Some(version) = hypervisor_props::version()? {
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000361 println!("Hypervisor version: {}", version);
362 } else {
363 println!("Hypervisor version not set.");
364 }
365
366 if Path::new("/dev/kvm").exists() {
367 println!("/dev/kvm exists.");
368 } else {
369 println!("/dev/kvm does not exist.");
370 }
371
Inseob Kim6ef80972023-07-20 17:23:36 +0900372 if Path::new("/dev/vfio/vfio").exists() {
373 println!("/dev/vfio/vfio exists.");
374 } else {
375 println!("/dev/vfio/vfio does not exist.");
376 }
377
378 if Path::new("/sys/bus/platform/drivers/vfio-platform").exists() {
379 println!("VFIO-platform is supported.");
380 } else {
381 println!("VFIO-platform is not supported.");
382 }
383
Inseob Kim75460b32023-08-09 13:41:31 +0900384 let devices = get_service()?.getAssignableDevices()?;
385 let devices = devices.into_iter().map(|x| x.node).collect::<Vec<_>>();
386 println!("Assignable devices: {}", serde_json::to_string(&devices)?);
387
Inseob Kim46257382024-01-03 15:41:22 +0900388 let os_list = get_service()?.getSupportedOSList()?;
389 println!("Available OS list: {}", serde_json::to_string(&os_list)?);
Inseob Kim7a1fc8f2023-11-22 18:45:28 +0900390
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000391 Ok(())
392}
Andrew Walbran1f810b62022-08-10 13:33:57 +0000393
394#[cfg(test)]
395mod tests {
396 use super::*;
Andrew Walbranaa1efc42022-08-10 13:33:57 +0000397 use clap::CommandFactory;
Andrew Walbran1f810b62022-08-10 13:33:57 +0000398
399 #[test]
400 fn verify_app() {
Andrew Walbranaa1efc42022-08-10 13:33:57 +0000401 // Check that the command parsing has been configured in a valid way.
402 Opt::command().debug_assert();
Andrew Walbran1f810b62022-08-10 13:33:57 +0000403 }
404}