blob: 184a396c9944b9ec0ef5b2c0e0825ef47910b42e [file] [log] [blame]
Andrew Walbranf395b822021-05-05 10:38:59 +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//! Command to run a VM.
16
17use crate::sync::AtomicFlag;
Andrew Walbranf6bf6862021-05-21 12:41:13 +000018use android_system_virtualizationservice::aidl::android::system::virtualizationservice::IVirtualizationService::IVirtualizationService;
19use android_system_virtualizationservice::aidl::android::system::virtualizationservice::IVirtualMachine::IVirtualMachine;
20use android_system_virtualizationservice::aidl::android::system::virtualizationservice::IVirtualMachineCallback::{
Andrew Walbranf395b822021-05-05 10:38:59 +000021 BnVirtualMachineCallback, IVirtualMachineCallback,
22};
Jooyung Han21e9b922021-06-26 04:14:16 +090023use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
24 VirtualMachineAppConfig::VirtualMachineAppConfig,
25 VirtualMachineConfig::VirtualMachineConfig,
26};
Andrew Walbranf6bf6862021-05-21 12:41:13 +000027use android_system_virtualizationservice::binder::{
Andrew Walbranf395b822021-05-05 10:38:59 +000028 BinderFeatures, DeathRecipient, IBinder, ParcelFileDescriptor, Strong,
29};
Andrew Walbranf6bf6862021-05-21 12:41:13 +000030use android_system_virtualizationservice::binder::{Interface, Result as BinderResult};
Andrew Walbranf395b822021-05-05 10:38:59 +000031use anyhow::{Context, Error};
32use std::fs::File;
Jiyong Park8611a6c2021-07-09 18:17:44 +090033use std::io::{self, BufRead, BufReader};
Andrew Walbranf395b822021-05-05 10:38:59 +000034use std::os::unix::io::{AsRawFd, FromRawFd};
35use std::path::Path;
Jooyung Hanfc732f52021-06-26 02:54:20 +090036use vmconfig::VmConfig;
Andrew Walbranf395b822021-05-05 10:38:59 +000037
Jooyung Han21e9b922021-06-26 04:14:16 +090038/// Run a VM from the given APK, idsig, and config.
39pub fn command_run_app(
40 service: Strong<dyn IVirtualizationService>,
41 apk: &Path,
42 idsig: &Path,
43 config_path: &str,
44 daemonize: bool,
45 log_path: Option<&Path>,
Jiyong Park23601142021-07-05 13:15:32 +090046 debug: bool,
Jooyung Han21e9b922021-06-26 04:14:16 +090047) -> Result<(), Error> {
48 let apk_file = File::open(apk).context("Failed to open APK file")?;
49 let idsig_file = File::open(idsig).context("Failed to open idsig file")?;
50 let config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig {
51 apk: ParcelFileDescriptor::new(apk_file).into(),
52 idsig: ParcelFileDescriptor::new(idsig_file).into(),
53 configPath: config_path.to_owned(),
Jiyong Park23601142021-07-05 13:15:32 +090054 debug,
Jooyung Han21e9b922021-06-26 04:14:16 +090055 });
56 run(service, &config, &format!("{:?}!{:?}", apk, config_path), daemonize, log_path)
57}
58
Andrew Walbranf395b822021-05-05 10:38:59 +000059/// Run a VM from the given configuration file.
60pub fn command_run(
Andrew Walbran17de24f2021-05-27 13:27:30 +000061 service: Strong<dyn IVirtualizationService>,
Andrew Walbranf395b822021-05-05 10:38:59 +000062 config_path: &Path,
63 daemonize: bool,
Andrew Walbranbe429242021-06-28 12:22:54 +000064 log_path: Option<&Path>,
Andrew Walbranf395b822021-05-05 10:38:59 +000065) -> Result<(), Error> {
Andrew Walbran3a5a9212021-05-04 17:09:08 +000066 let config_file = File::open(config_path).context("Failed to open config file")?;
67 let config =
68 VmConfig::load(&config_file).context("Failed to parse config file")?.to_parcelable()?;
Jooyung Han21e9b922021-06-26 04:14:16 +090069 run(
70 service,
71 &VirtualMachineConfig::RawConfig(config),
72 &format!("{:?}", config_path),
73 daemonize,
74 log_path,
75 )
76}
77
78fn run(
79 service: Strong<dyn IVirtualizationService>,
80 config: &VirtualMachineConfig,
81 config_path: &str,
82 daemonize: bool,
83 log_path: Option<&Path>,
84) -> Result<(), Error> {
Andrew Walbranbe429242021-06-28 12:22:54 +000085 let stdout = if let Some(log_path) = log_path {
86 Some(ParcelFileDescriptor::new(
87 File::create(log_path)
88 .with_context(|| format!("Failed to open log file {:?}", log_path))?,
89 ))
90 } else if daemonize {
91 None
92 } else {
93 Some(ParcelFileDescriptor::new(duplicate_stdout()?))
94 };
Jooyung Han21e9b922021-06-26 04:14:16 +090095 let vm = service.startVm(config, stdout.as_ref()).context("Failed to start VM")?;
Andrew Walbranf395b822021-05-05 10:38:59 +000096
97 let cid = vm.getCid().context("Failed to get CID")?;
Jooyung Han35edb8f2021-07-01 16:17:16 +090098 println!("Started VM from {} with CID {}.", config_path, cid);
Andrew Walbranf395b822021-05-05 10:38:59 +000099
100 if daemonize {
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000101 // Pass the VM reference back to VirtualizationService and have it hold it in the
102 // background.
Andrew Walbran17de24f2021-05-27 13:27:30 +0000103 service.debugHoldVmRef(&vm).context("Failed to pass VM to VirtualizationService")
Andrew Walbranf395b822021-05-05 10:38:59 +0000104 } else {
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000105 // Wait until the VM or VirtualizationService dies. If we just returned immediately then the
Andrew Walbranf395b822021-05-05 10:38:59 +0000106 // IVirtualMachine Binder object would be dropped and the VM would be killed.
107 wait_for_vm(vm)
108 }
109}
110
Andrew Walbranf6bf6862021-05-21 12:41:13 +0000111/// Wait until the given VM or the VirtualizationService itself dies.
Andrew Walbranf395b822021-05-05 10:38:59 +0000112fn wait_for_vm(vm: Strong<dyn IVirtualMachine>) -> Result<(), Error> {
113 let dead = AtomicFlag::default();
114 let callback = BnVirtualMachineCallback::new_binder(
115 VirtualMachineCallback { dead: dead.clone() },
116 BinderFeatures::default(),
117 );
118 vm.registerCallback(&callback)?;
119 let death_recipient = wait_for_death(&mut vm.as_binder(), dead.clone())?;
120 dead.wait();
121 // Ensure that death_recipient isn't dropped before we wait on the flag, as it is removed
122 // from the Binder when it's dropped.
123 drop(death_recipient);
124 Ok(())
125}
126
127/// Raise the given flag when the given Binder object dies.
128///
129/// If the returned DeathRecipient is dropped then this will no longer do anything.
130fn wait_for_death(binder: &mut impl IBinder, dead: AtomicFlag) -> Result<DeathRecipient, Error> {
131 let mut death_recipient = DeathRecipient::new(move || {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900132 eprintln!("VirtualizationService unexpectedly died");
Andrew Walbranf395b822021-05-05 10:38:59 +0000133 dead.raise();
134 });
135 binder.link_to_death(&mut death_recipient)?;
136 Ok(death_recipient)
137}
138
139#[derive(Debug)]
140struct VirtualMachineCallback {
141 dead: AtomicFlag,
142}
143
144impl Interface for VirtualMachineCallback {}
145
146impl IVirtualMachineCallback for VirtualMachineCallback {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900147 fn onPayloadStarted(&self, _cid: i32, stdout: &ParcelFileDescriptor) -> BinderResult<()> {
148 // Show the stdout of the payload
149 let mut reader = BufReader::new(stdout.as_ref());
150 loop {
151 let mut s = String::new();
152 match reader.read_line(&mut s) {
153 Ok(0) => break,
154 Ok(_) => print!("{}", s),
155 Err(e) => eprintln!("error reading from virtual machine: {}", e),
156 };
157 }
158 Ok(())
159 }
160
Andrew Walbranf395b822021-05-05 10:38:59 +0000161 fn onDied(&self, _cid: i32) -> BinderResult<()> {
Jiyong Park8611a6c2021-07-09 18:17:44 +0900162 // No need to explicitly report the event to the user (e.g. via println!) because this
163 // callback is registered only when the vm tool is invoked as interactive mode (e.g. not
164 // --daemonize) in which case the tool will exit to the shell prompt upon VM shutdown.
165 // Printing something will actually even confuse the user as the output from the app
166 // payload is printed.
Andrew Walbranf395b822021-05-05 10:38:59 +0000167 self.dead.raise();
168 Ok(())
169 }
170}
171
172/// Safely duplicate the standard output file descriptor.
173fn duplicate_stdout() -> io::Result<File> {
174 let stdout_fd = io::stdout().as_raw_fd();
175 // Safe because this just duplicates a file descriptor which we know to be valid, and we check
176 // for an error.
177 let dup_fd = unsafe { libc::dup(stdout_fd) };
178 if dup_fd < 0 {
179 Err(io::Error::last_os_error())
180 } else {
181 // Safe because we have just duplicated the file descriptor so we own it, and `from_raw_fd`
182 // takes ownership of it.
183 Ok(unsafe { File::from_raw_fd(dup_fd) })
184 }
185}