Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +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 | //! Command to run a VM. |
| 16 | |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 17 | use crate::create_partition::command_create_partition; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 18 | use crate::sync::AtomicFlag; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 19 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame^] | 20 | DeathReason::DeathReason, IVirtualMachine::IVirtualMachine, |
| 21 | IVirtualMachineCallback::BnVirtualMachineCallback, |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 22 | IVirtualMachineCallback::IVirtualMachineCallback, |
| 23 | IVirtualizationService::IVirtualizationService, PartitionType::PartitionType, |
| 24 | VirtualMachineAppConfig::DebugLevel::DebugLevel, |
| 25 | VirtualMachineAppConfig::VirtualMachineAppConfig, VirtualMachineConfig::VirtualMachineConfig, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 26 | VirtualMachineState::VirtualMachineState, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 27 | }; |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 28 | use android_system_virtualizationservice::binder::{ |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 29 | BinderFeatures, DeathRecipient, IBinder, ParcelFileDescriptor, Strong, |
| 30 | }; |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 31 | use android_system_virtualizationservice::binder::{Interface, Result as BinderResult}; |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 32 | use anyhow::{bail, Context, Error}; |
| 33 | use microdroid_payload_config::VmPayloadConfig; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 34 | use std::fs::File; |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 35 | use std::io::{self, BufRead, BufReader}; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 36 | use std::os::unix::io::{AsRawFd, FromRawFd}; |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 37 | use std::path::{Path, PathBuf}; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 38 | use vmconfig::{open_parcel_file, VmConfig}; |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 39 | use zip::ZipArchive; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 40 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 41 | /// Run a VM from the given APK, idsig, and config. |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 42 | #[allow(clippy::too_many_arguments)] |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 43 | pub fn command_run_app( |
| 44 | service: Strong<dyn IVirtualizationService>, |
| 45 | apk: &Path, |
| 46 | idsig: &Path, |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 47 | instance: &Path, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 48 | config_path: &str, |
| 49 | daemonize: bool, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 50 | console_path: Option<&Path>, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 51 | log_path: Option<&Path>, |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 52 | debug_level: DebugLevel, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 53 | mem: Option<u32>, |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 54 | cpus: Option<u32>, |
| 55 | cpu_affinity: Option<String>, |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 56 | extra_idsigs: &[PathBuf], |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 57 | ) -> Result<(), Error> { |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 58 | let extra_apks = parse_extra_apk_list(apk, config_path)?; |
| 59 | if extra_apks.len() != extra_idsigs.len() { |
| 60 | bail!( |
| 61 | "Found {} extra apks, but there are {} extra idsigs", |
| 62 | extra_apks.len(), |
| 63 | extra_idsigs.len() |
| 64 | ) |
| 65 | } |
| 66 | |
| 67 | for i in 0..extra_apks.len() { |
| 68 | let extra_apk_fd = ParcelFileDescriptor::new(File::open(&extra_apks[i])?); |
| 69 | let extra_idsig_fd = ParcelFileDescriptor::new(File::create(&extra_idsigs[i])?); |
| 70 | service.createOrUpdateIdsigFile(&extra_apk_fd, &extra_idsig_fd)?; |
| 71 | } |
| 72 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 73 | let apk_file = File::open(apk).context("Failed to open APK file")?; |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 74 | let idsig_file = File::create(idsig).context("Failed to create idsig file")?; |
| 75 | |
| 76 | let apk_fd = ParcelFileDescriptor::new(apk_file); |
| 77 | let idsig_fd = ParcelFileDescriptor::new(idsig_file); |
| 78 | service.createOrUpdateIdsigFile(&apk_fd, &idsig_fd)?; |
| 79 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 80 | let idsig_file = File::open(idsig).context("Failed to open idsig file")?; |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 81 | let idsig_fd = ParcelFileDescriptor::new(idsig_file); |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 82 | |
| 83 | if !instance.exists() { |
| 84 | const INSTANCE_FILE_SIZE: u64 = 10 * 1024 * 1024; |
Jiyong Park | 9dd389e | 2021-08-23 20:42:59 +0900 | [diff] [blame] | 85 | command_create_partition( |
| 86 | service.clone(), |
| 87 | instance, |
| 88 | INSTANCE_FILE_SIZE, |
| 89 | PartitionType::ANDROID_VM_INSTANCE, |
| 90 | )?; |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 91 | } |
| 92 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 93 | let extra_idsig_files: Result<Vec<File>, _> = extra_idsigs.iter().map(File::open).collect(); |
| 94 | let extra_idsig_fds = extra_idsig_files?.into_iter().map(ParcelFileDescriptor::new).collect(); |
| 95 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 96 | let config = VirtualMachineConfig::AppConfig(VirtualMachineAppConfig { |
Jiyong Park | 0a24843 | 2021-08-20 23:32:39 +0900 | [diff] [blame] | 97 | apk: apk_fd.into(), |
| 98 | idsig: idsig_fd.into(), |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 99 | extraIdsigs: extra_idsig_fds, |
Jiyong Park | 48b354d | 2021-07-15 15:04:38 +0900 | [diff] [blame] | 100 | instanceImage: open_parcel_file(instance, true /* writable */)?.into(), |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 101 | configPath: config_path.to_owned(), |
Jiyong Park | c2a49cc | 2021-10-15 00:02:12 +0900 | [diff] [blame] | 102 | debugLevel: debug_level, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 103 | memoryMib: mem.unwrap_or(0) as i32, // 0 means use the VM default |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 104 | numCpus: cpus.unwrap_or(1) as i32, |
| 105 | cpuAffinity: cpu_affinity, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 106 | }); |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 107 | run( |
| 108 | service, |
| 109 | &config, |
| 110 | &format!("{:?}!{:?}", apk, config_path), |
| 111 | daemonize, |
| 112 | console_path, |
| 113 | log_path, |
| 114 | ) |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 115 | } |
| 116 | |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 117 | /// Run a VM from the given configuration file. |
| 118 | pub fn command_run( |
Andrew Walbran | 17de24f | 2021-05-27 13:27:30 +0000 | [diff] [blame] | 119 | service: Strong<dyn IVirtualizationService>, |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 120 | config_path: &Path, |
| 121 | daemonize: bool, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 122 | console_path: Option<&Path>, |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 123 | mem: Option<u32>, |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 124 | cpus: Option<u32>, |
| 125 | cpu_affinity: Option<String>, |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 126 | ) -> Result<(), Error> { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 127 | let config_file = File::open(config_path).context("Failed to open config file")?; |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 128 | let mut config = |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 129 | VmConfig::load(&config_file).context("Failed to parse config file")?.to_parcelable()?; |
Jiyong Park | d63cfff | 2021-09-27 20:10:17 +0900 | [diff] [blame] | 130 | if let Some(mem) = mem { |
| 131 | config.memoryMib = mem as i32; |
| 132 | } |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 133 | if let Some(cpus) = cpus { |
| 134 | config.numCpus = cpus as i32; |
| 135 | } |
| 136 | config.cpuAffinity = cpu_affinity; |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 137 | run( |
| 138 | service, |
| 139 | &VirtualMachineConfig::RawConfig(config), |
| 140 | &format!("{:?}", config_path), |
| 141 | daemonize, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 142 | console_path, |
| 143 | None, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 144 | ) |
| 145 | } |
| 146 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 147 | fn state_to_str(vm_state: VirtualMachineState) -> &'static str { |
| 148 | match vm_state { |
| 149 | VirtualMachineState::NOT_STARTED => "NOT_STARTED", |
| 150 | VirtualMachineState::STARTING => "STARTING", |
| 151 | VirtualMachineState::STARTED => "STARTED", |
| 152 | VirtualMachineState::READY => "READY", |
| 153 | VirtualMachineState::FINISHED => "FINISHED", |
| 154 | VirtualMachineState::DEAD => "DEAD", |
| 155 | _ => "(invalid state)", |
| 156 | } |
| 157 | } |
| 158 | |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 159 | fn run( |
| 160 | service: Strong<dyn IVirtualizationService>, |
| 161 | config: &VirtualMachineConfig, |
| 162 | config_path: &str, |
| 163 | daemonize: bool, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 164 | console_path: Option<&Path>, |
Jooyung Han | 21e9b92 | 2021-06-26 04:14:16 +0900 | [diff] [blame] | 165 | log_path: Option<&Path>, |
| 166 | ) -> Result<(), Error> { |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 167 | let console = if let Some(console_path) = console_path { |
| 168 | Some(ParcelFileDescriptor::new( |
| 169 | File::create(console_path) |
| 170 | .with_context(|| format!("Failed to open console file {:?}", console_path))?, |
| 171 | )) |
| 172 | } else if daemonize { |
| 173 | None |
| 174 | } else { |
| 175 | Some(ParcelFileDescriptor::new(duplicate_stdout()?)) |
| 176 | }; |
| 177 | let log = if let Some(log_path) = log_path { |
Andrew Walbran | be42924 | 2021-06-28 12:22:54 +0000 | [diff] [blame] | 178 | Some(ParcelFileDescriptor::new( |
| 179 | File::create(log_path) |
| 180 | .with_context(|| format!("Failed to open log file {:?}", log_path))?, |
| 181 | )) |
| 182 | } else if daemonize { |
| 183 | None |
| 184 | } else { |
| 185 | Some(ParcelFileDescriptor::new(duplicate_stdout()?)) |
| 186 | }; |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 187 | |
| 188 | let vm = |
| 189 | service.createVm(config, console.as_ref(), log.as_ref()).context("Failed to create VM")?; |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 190 | |
| 191 | let cid = vm.getCid().context("Failed to get CID")?; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 192 | println!( |
| 193 | "Created VM from {} with CID {}, state is {}.", |
| 194 | config_path, |
| 195 | cid, |
| 196 | state_to_str(vm.getState()?) |
| 197 | ); |
| 198 | vm.start()?; |
| 199 | println!("Started VM, state now {}.", state_to_str(vm.getState()?)); |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 200 | |
| 201 | if daemonize { |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 202 | // Pass the VM reference back to VirtualizationService and have it hold it in the |
| 203 | // background. |
Andrew Walbran | 17de24f | 2021-05-27 13:27:30 +0000 | [diff] [blame] | 204 | service.debugHoldVmRef(&vm).context("Failed to pass VM to VirtualizationService") |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 205 | } else { |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 206 | // Wait until the VM or VirtualizationService dies. If we just returned immediately then the |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 207 | // IVirtualMachine Binder object would be dropped and the VM would be killed. |
| 208 | wait_for_vm(vm) |
| 209 | } |
| 210 | } |
| 211 | |
Andrew Walbran | f6bf686 | 2021-05-21 12:41:13 +0000 | [diff] [blame] | 212 | /// Wait until the given VM or the VirtualizationService itself dies. |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 213 | fn wait_for_vm(vm: Strong<dyn IVirtualMachine>) -> Result<(), Error> { |
| 214 | let dead = AtomicFlag::default(); |
| 215 | let callback = BnVirtualMachineCallback::new_binder( |
| 216 | VirtualMachineCallback { dead: dead.clone() }, |
| 217 | BinderFeatures::default(), |
| 218 | ); |
| 219 | vm.registerCallback(&callback)?; |
| 220 | let death_recipient = wait_for_death(&mut vm.as_binder(), dead.clone())?; |
| 221 | dead.wait(); |
| 222 | // Ensure that death_recipient isn't dropped before we wait on the flag, as it is removed |
| 223 | // from the Binder when it's dropped. |
| 224 | drop(death_recipient); |
| 225 | Ok(()) |
| 226 | } |
| 227 | |
| 228 | /// Raise the given flag when the given Binder object dies. |
| 229 | /// |
| 230 | /// If the returned DeathRecipient is dropped then this will no longer do anything. |
| 231 | fn wait_for_death(binder: &mut impl IBinder, dead: AtomicFlag) -> Result<DeathRecipient, Error> { |
| 232 | let mut death_recipient = DeathRecipient::new(move || { |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 233 | eprintln!("VirtualizationService unexpectedly died"); |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 234 | dead.raise(); |
| 235 | }); |
| 236 | binder.link_to_death(&mut death_recipient)?; |
| 237 | Ok(death_recipient) |
| 238 | } |
| 239 | |
Inseob Kim | a5a262f | 2021-11-17 19:41:03 +0900 | [diff] [blame] | 240 | fn parse_extra_apk_list(apk: &Path, config_path: &str) -> Result<Vec<String>, Error> { |
| 241 | let mut archive = ZipArchive::new(File::open(apk)?)?; |
| 242 | let config_file = archive.by_name(config_path)?; |
| 243 | let config: VmPayloadConfig = serde_json::from_reader(config_file)?; |
| 244 | Ok(config.extra_apks.into_iter().map(|x| x.path).collect()) |
| 245 | } |
| 246 | |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 247 | #[derive(Debug)] |
| 248 | struct VirtualMachineCallback { |
| 249 | dead: AtomicFlag, |
| 250 | } |
| 251 | |
| 252 | impl Interface for VirtualMachineCallback {} |
| 253 | |
| 254 | impl IVirtualMachineCallback for VirtualMachineCallback { |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 255 | fn onPayloadStarted( |
| 256 | &self, |
| 257 | _cid: i32, |
| 258 | stream: Option<&ParcelFileDescriptor>, |
| 259 | ) -> BinderResult<()> { |
| 260 | // Show the output of the payload |
| 261 | if let Some(stream) = stream { |
| 262 | let mut reader = BufReader::new(stream.as_ref()); |
| 263 | loop { |
| 264 | let mut s = String::new(); |
| 265 | match reader.read_line(&mut s) { |
| 266 | Ok(0) => break, |
| 267 | Ok(_) => print!("{}", s), |
| 268 | Err(e) => eprintln!("error reading from virtual machine: {}", e), |
| 269 | }; |
| 270 | } |
Jiyong Park | 8611a6c | 2021-07-09 18:17:44 +0900 | [diff] [blame] | 271 | } |
| 272 | Ok(()) |
| 273 | } |
| 274 | |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 275 | fn onPayloadReady(&self, _cid: i32) -> BinderResult<()> { |
Inseob Kim | 8dbc322 | 2021-09-01 21:50:23 +0900 | [diff] [blame] | 276 | eprintln!("payload is ready"); |
Inseob Kim | 14cb869 | 2021-08-31 21:50:39 +0900 | [diff] [blame] | 277 | Ok(()) |
| 278 | } |
| 279 | |
Inseob Kim | 8dbc322 | 2021-09-01 21:50:23 +0900 | [diff] [blame] | 280 | fn onPayloadFinished(&self, _cid: i32, exit_code: i32) -> BinderResult<()> { |
| 281 | eprintln!("payload finished with exit code {}", exit_code); |
Inseob Kim | 2444af9 | 2021-08-31 01:22:50 +0900 | [diff] [blame] | 282 | Ok(()) |
| 283 | } |
| 284 | |
Jooyung Han | dd0a173 | 2021-11-23 15:26:20 +0900 | [diff] [blame] | 285 | fn onError(&self, _cid: i32, error_code: i32, message: &str) -> BinderResult<()> { |
| 286 | eprintln!("VM encountered an error: code={}, message={}", error_code, message); |
| 287 | Ok(()) |
| 288 | } |
| 289 | |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame^] | 290 | fn onDied(&self, _cid: i32, reason: DeathReason) -> BinderResult<()> { |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 291 | self.dead.raise(); |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame^] | 292 | |
| 293 | match reason { |
| 294 | DeathReason::SHUTDOWN => println!("VM shutdown cleanly."), |
| 295 | DeathReason::REBOOT => println!("VM tried to reboot, possibly due to a kernel panic."), |
| 296 | DeathReason::KILLED => println!("VM was killed."), |
| 297 | DeathReason::UNKNOWN => println!("VM died for an unknown reason."), |
| 298 | DeathReason::INFRASTRUCTURE_ERROR => println!("Error waiting for VM to finish."), |
| 299 | _ => println!("VM died for an unrecognised reason."), |
| 300 | } |
Andrew Walbran | f395b82 | 2021-05-05 10:38:59 +0000 | [diff] [blame] | 301 | Ok(()) |
| 302 | } |
| 303 | } |
| 304 | |
| 305 | /// Safely duplicate the standard output file descriptor. |
| 306 | fn duplicate_stdout() -> io::Result<File> { |
| 307 | let stdout_fd = io::stdout().as_raw_fd(); |
| 308 | // Safe because this just duplicates a file descriptor which we know to be valid, and we check |
| 309 | // for an error. |
| 310 | let dup_fd = unsafe { libc::dup(stdout_fd) }; |
| 311 | if dup_fd < 0 { |
| 312 | Err(io::Error::last_os_error()) |
| 313 | } else { |
| 314 | // Safe because we have just duplicated the file descriptor so we own it, and `from_raw_fd` |
| 315 | // takes ownership of it. |
| 316 | Ok(unsafe { File::from_raw_fd(dup_fd) }) |
| 317 | } |
| 318 | } |