blob: e133b8b5792e25b2ab61e52d249079480b8db5da [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
Jiyong Parkb1935ef2023-08-10 17:22:39 +090037#[derive(Args)]
38/// 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
62#[derive(Args)]
63/// 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
87#[derive(Args)]
88/// 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
100 /// Path to custom kernel image to use when booting Microdroid.
Nikita Ioffe631717e2023-09-05 13:38:07 +0100101 #[cfg(vendor_modules)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900102 #[arg(long)]
103 kernel: Option<PathBuf>,
104
105 /// Path to disk image containing vendor-specific modules.
Nikita Ioffe631717e2023-09-05 13:38:07 +0100106 #[cfg(vendor_modules)]
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900107 #[arg(long)]
108 vendor: Option<PathBuf>,
109
110 /// SysFS nodes of devices to assign to VM
111 #[arg(long)]
112 devices: Vec<PathBuf>,
113}
114
Nikita Ioffe631717e2023-09-05 13:38:07 +0100115impl MicrodroidConfig {
116 #[cfg(vendor_modules)]
117 fn kernel(&self) -> &Option<PathBuf> {
118 &self.kernel
119 }
120
121 #[cfg(not(vendor_modules))]
122 fn kernel(&self) -> Option<PathBuf> {
123 None
124 }
125
126 #[cfg(vendor_modules)]
127 fn vendor(&self) -> &Option<PathBuf> {
128 &self.vendor
129 }
130
131 #[cfg(not(vendor_modules))]
132 #[inline(always)]
133 fn vendor(&self) -> Option<PathBuf> {
134 None
135 }
136}
137
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900138#[derive(Args)]
139/// Flags for the run_app subcommand
140pub struct RunAppConfig {
141 #[command(flatten)]
142 common: CommonConfig,
143
144 #[command(flatten)]
145 debug: DebugConfig,
146
147 #[command(flatten)]
148 microdroid: MicrodroidConfig,
149
150 /// Path to VM Payload APK
151 apk: PathBuf,
152
153 /// Path to idsig of the APK
154 idsig: PathBuf,
155
156 /// Path to the instance image. Created if not exists.
157 instance: PathBuf,
158
159 /// Path to VM config JSON within APK (e.g. assets/vm_config.json)
160 #[arg(long)]
161 config_path: Option<String>,
162
163 /// Name of VM payload binary within APK (e.g. MicrodroidTestNativeLib.so)
164 #[arg(long)]
165 #[arg(alias = "payload_path")]
166 payload_binary_name: Option<String>,
167
168 /// Paths to extra idsig files.
169 #[arg(long = "extra-idsig")]
170 extra_idsigs: Vec<PathBuf>,
171}
172
173#[derive(Args)]
174/// Flags for the run_microdroid subcommand
175pub struct RunMicrodroidConfig {
176 #[command(flatten)]
177 common: CommonConfig,
178
179 #[command(flatten)]
180 debug: DebugConfig,
181
182 #[command(flatten)]
183 microdroid: MicrodroidConfig,
184
185 /// Path to the directory where VM-related files (e.g. instance.img, apk.idsig, etc.) will
186 /// be stored. If not specified a random directory under /data/local/tmp/microdroid will be
187 /// created and used.
188 #[arg(long)]
189 work_dir: Option<PathBuf>,
190}
191
192#[derive(Args)]
193/// Flags for the run subcommand
194pub struct RunCustomVmConfig {
195 #[command(flatten)]
196 common: CommonConfig,
197
198 #[command(flatten)]
199 debug: DebugConfig,
200
201 /// Path to VM config JSON
202 config: PathBuf,
203}
204
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700205#[derive(Parser)]
David Brazdil20412d92021-03-18 10:53:06 +0000206enum Opt {
Jooyung Han21e9b922021-06-26 04:14:16 +0900207 /// Run a virtual machine with a config in APK
208 RunApp {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900209 #[command(flatten)]
210 config: RunAppConfig,
Jooyung Han21e9b922021-06-26 04:14:16 +0900211 },
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000212 /// Run a virtual machine with Microdroid inside
213 RunMicrodroid {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900214 #[command(flatten)]
215 config: RunMicrodroidConfig,
Nikita Ioffeb0b67562022-11-22 15:48:06 +0000216 },
David Brazdil20412d92021-03-18 10:53:06 +0000217 /// Run a virtual machine
218 Run {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900219 #[command(flatten)]
220 config: RunCustomVmConfig,
David Brazdil3c2ddef2021-03-18 13:09:57 +0000221 },
David Brazdil20412d92021-03-18 10:53:06 +0000222 /// List running virtual machines
223 List,
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000224 /// Print information about virtual machine support
225 Info,
Andrew Walbrandff3b942021-06-09 15:20:36 +0000226 /// Create a new empty partition to be used as a writable partition for a VM
227 CreatePartition {
228 /// Path at which to create the image file
Andrew Walbrandff3b942021-06-09 15:20:36 +0000229 path: PathBuf,
230
231 /// The desired size of the partition, in bytes.
232 size: u64,
Jiyong Park9dd389e2021-08-23 20:42:59 +0900233
234 /// Type of the partition
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900235 #[arg(short = 't', long = "type", default_value = "raw",
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700236 value_parser = parse_partition_type)]
Jiyong Park9dd389e2021-08-23 20:42:59 +0900237 partition_type: PartitionType,
Andrew Walbrandff3b942021-06-09 15:20:36 +0000238 },
Jooyung Hanc221c052022-02-22 05:20:15 +0900239 /// Creates or update the idsig file by digesting the input APK file.
240 CreateIdsig {
241 /// Path to VM Payload APK
Jooyung Hanc221c052022-02-22 05:20:15 +0900242 apk: PathBuf,
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700243
Jooyung Hanc221c052022-02-22 05:20:15 +0900244 /// Path to idsig of the APK
Jooyung Hanc221c052022-02-22 05:20:15 +0900245 path: PathBuf,
246 },
David Brazdil20412d92021-03-18 10:53:06 +0000247}
248
Jiyong Parkc2a49cc2021-10-15 00:02:12 +0900249fn parse_debug_level(s: &str) -> Result<DebugLevel, String> {
250 match s {
251 "none" => Ok(DebugLevel::NONE),
Jiyong Parkc2a49cc2021-10-15 00:02:12 +0900252 "full" => Ok(DebugLevel::FULL),
253 _ => Err(format!("Invalid debug level {}", s)),
254 }
255}
256
Jiyong Park9dd389e2021-08-23 20:42:59 +0900257fn parse_partition_type(s: &str) -> Result<PartitionType, String> {
258 match s {
259 "raw" => Ok(PartitionType::RAW),
260 "instance" => Ok(PartitionType::ANDROID_VM_INSTANCE),
261 _ => Err(format!("Invalid partition type {}", s)),
262 }
263}
264
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000265fn parse_cpu_topology(s: &str) -> Result<CpuTopology, String> {
266 match s {
267 "one_cpu" => Ok(CpuTopology::ONE_CPU),
268 "match_host" => Ok(CpuTopology::MATCH_HOST),
269 _ => Err(format!("Invalid cpu topology {}", s)),
270 }
271}
272
Alan Stokesc4d5def2023-02-14 17:01:59 +0000273fn get_service() -> Result<Strong<dyn IVirtualizationService>, Error> {
274 let virtmgr =
275 vmclient::VirtualizationService::new().context("Failed to spawn VirtualizationService")?;
276 virtmgr.connect().context("Failed to connect to VirtualizationService")
277}
278
Andrew Walbranea9fa482021-03-04 16:11:12 +0000279fn main() -> Result<(), Error> {
280 env_logger::init();
Victor Hsiehb5bcfab2022-09-12 13:06:26 -0700281 let opt = Opt::parse();
Andrew Walbranea9fa482021-03-04 16:11:12 +0000282
283 // We need to start the thread pool for Binder to work properly, especially link_to_death.
284 ProcessState::start_thread_pool();
285
David Brazdil20412d92021-03-18 10:53:06 +0000286 match opt {
Jiyong Parkb1935ef2023-08-10 17:22:39 +0900287 Opt::RunApp { config } => command_run_app(config),
288 Opt::RunMicrodroid { config } => command_run_microdroid(config),
289 Opt::Run { config } => command_run(config),
Alan Stokesc4d5def2023-02-14 17:01:59 +0000290 Opt::List => command_list(get_service()?.as_ref()),
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000291 Opt::Info => command_info(),
Jiyong Park9dd389e2021-08-23 20:42:59 +0900292 Opt::CreatePartition { path, size, partition_type } => {
Alan Stokesc4d5def2023-02-14 17:01:59 +0000293 command_create_partition(get_service()?.as_ref(), &path, size, partition_type)
Jiyong Park9dd389e2021-08-23 20:42:59 +0900294 }
Alan Stokesc4d5def2023-02-14 17:01:59 +0000295 Opt::CreateIdsig { apk, path } => {
296 command_create_idsig(get_service()?.as_ref(), &apk, &path)
297 }
Andrew Walbranea9fa482021-03-04 16:11:12 +0000298 }
299}
300
Andrew Walbran320b5602021-03-04 16:11:12 +0000301/// List the VMs currently running.
Andrew Walbran616d13f2022-05-12 18:35:55 +0000302fn command_list(service: &dyn IVirtualizationService) -> Result<(), Error> {
Andrew Walbran17de24f2021-05-27 13:27:30 +0000303 let vms = service.debugListVms().context("Failed to get list of VMs")?;
Andrew Walbran320b5602021-03-04 16:11:12 +0000304 println!("Running VMs: {:#?}", vms);
305 Ok(())
306}
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000307
308/// Print information about supported VM types.
309fn command_info() -> Result<(), Error> {
Alan Stokesc4d5def2023-02-14 17:01:59 +0000310 let non_protected_vm_supported = hypervisor_props::is_vm_supported()?;
311 let protected_vm_supported = hypervisor_props::is_protected_vm_supported()?;
Alan Stokes8d39a9b2023-01-10 15:01:00 +0000312 match (non_protected_vm_supported, protected_vm_supported) {
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000313 (false, false) => println!("VMs are not supported."),
314 (false, true) => println!("Only protected VMs are supported."),
Alan Stokes8d39a9b2023-01-10 15:01:00 +0000315 (true, false) => println!("Only non-protected VMs are supported."),
316 (true, true) => println!("Both protected and non-protected VMs are supported."),
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000317 }
318
Alan Stokesc4d5def2023-02-14 17:01:59 +0000319 if let Some(version) = hypervisor_props::version()? {
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000320 println!("Hypervisor version: {}", version);
321 } else {
322 println!("Hypervisor version not set.");
323 }
324
325 if Path::new("/dev/kvm").exists() {
326 println!("/dev/kvm exists.");
327 } else {
328 println!("/dev/kvm does not exist.");
329 }
330
Inseob Kim6ef80972023-07-20 17:23:36 +0900331 if Path::new("/dev/vfio/vfio").exists() {
332 println!("/dev/vfio/vfio exists.");
333 } else {
334 println!("/dev/vfio/vfio does not exist.");
335 }
336
337 if Path::new("/sys/bus/platform/drivers/vfio-platform").exists() {
338 println!("VFIO-platform is supported.");
339 } else {
340 println!("VFIO-platform is not supported.");
341 }
342
Inseob Kim75460b32023-08-09 13:41:31 +0900343 let devices = get_service()?.getAssignableDevices()?;
344 let devices = devices.into_iter().map(|x| x.node).collect::<Vec<_>>();
345 println!("Assignable devices: {}", serde_json::to_string(&devices)?);
346
Andrew Walbranc4b1bde2022-02-03 15:26:02 +0000347 Ok(())
348}
Andrew Walbran1f810b62022-08-10 13:33:57 +0000349
350#[cfg(test)]
351mod tests {
352 use super::*;
Andrew Walbranaa1efc42022-08-10 13:33:57 +0000353 use clap::CommandFactory;
Andrew Walbran1f810b62022-08-10 13:33:57 +0000354
355 #[test]
356 fn verify_app() {
Andrew Walbranaa1efc42022-08-10 13:33:57 +0000357 // Check that the command parsing has been configured in a valid way.
358 Opt::command().debug_assert();
Andrew Walbran1f810b62022-08-10 13:33:57 +0000359 }
360}