Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +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 | //! Functions for running instances of `crosvm`. |
| 16 | |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 17 | use crate::aidl::VirtualMachineCallbacks; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 18 | use crate::Cid; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 19 | use anyhow::{bail, Error}; |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 20 | use command_fds::CommandFdExt; |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 21 | use log::{debug, error, info}; |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 22 | use shared_child::SharedChild; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 23 | use std::fs::{remove_dir_all, File}; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 24 | use std::mem; |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 25 | use std::num::NonZeroU32; |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 26 | use std::os::unix::io::{AsRawFd, RawFd}; |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 27 | use std::path::PathBuf; |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 28 | use std::process::Command; |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 29 | use std::sync::{Arc, Mutex}; |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 30 | use std::thread; |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 31 | use vsock::VsockStream; |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 32 | use android_system_virtualmachineservice::binder::Strong; |
| 33 | use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 34 | |
| 35 | const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm"; |
| 36 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 37 | /// Configuration for a VM to run with crosvm. |
| 38 | #[derive(Debug)] |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 39 | pub struct CrosvmConfig { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 40 | pub cid: Cid, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 41 | pub bootloader: Option<File>, |
| 42 | pub kernel: Option<File>, |
| 43 | pub initrd: Option<File>, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 44 | pub disks: Vec<DiskFile>, |
| 45 | pub params: Option<String>, |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 46 | pub protected: bool, |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 47 | pub memory_mib: Option<NonZeroU32>, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 48 | pub log_fd: Option<File>, |
| 49 | pub indirect_files: Vec<File>, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 50 | } |
| 51 | |
| 52 | /// A disk image to pass to crosvm for a VM. |
| 53 | #[derive(Debug)] |
| 54 | pub struct DiskFile { |
| 55 | pub image: File, |
| 56 | pub writable: bool, |
| 57 | } |
| 58 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 59 | /// The lifecycle state which the payload in the VM has reported itself to be in. |
| 60 | /// |
| 61 | /// Note that the order of enum variants is significant; only forward transitions are allowed by |
| 62 | /// [`VmInstance::update_payload_state`]. |
| 63 | #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] |
| 64 | pub enum PayloadState { |
| 65 | Starting, |
| 66 | Started, |
| 67 | Ready, |
| 68 | Finished, |
| 69 | } |
| 70 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 71 | /// The current state of the VM itself. |
| 72 | #[derive(Debug)] |
| 73 | pub enum VmState { |
| 74 | /// The VM has not yet tried to start. |
| 75 | NotStarted { |
| 76 | ///The configuration needed to start the VM, if it has not yet been started. |
| 77 | config: CrosvmConfig, |
| 78 | }, |
| 79 | /// The VM has been started. |
| 80 | Running { |
| 81 | /// The crosvm child process. |
| 82 | child: Arc<SharedChild>, |
| 83 | }, |
| 84 | /// The VM died or was killed. |
| 85 | Dead, |
| 86 | /// The VM failed to start. |
| 87 | Failed, |
| 88 | } |
| 89 | |
| 90 | impl VmState { |
| 91 | /// Tries to start the VM, if it is in the `NotStarted` state. |
| 92 | /// |
| 93 | /// Returns an error if the VM is in the wrong state, or fails to start. |
| 94 | fn start(&mut self, instance: Arc<VmInstance>) -> Result<(), Error> { |
| 95 | let state = mem::replace(self, VmState::Failed); |
| 96 | if let VmState::NotStarted { config } = state { |
| 97 | // If this fails and returns an error, `self` will be left in the `Failed` state. |
| 98 | let child = Arc::new(run_vm(config)?); |
| 99 | |
| 100 | let child_clone = child.clone(); |
| 101 | thread::spawn(move || { |
| 102 | instance.monitor(child_clone); |
| 103 | }); |
| 104 | |
| 105 | // If it started correctly, update the state. |
| 106 | *self = VmState::Running { child }; |
| 107 | Ok(()) |
| 108 | } else { |
| 109 | *self = state; |
| 110 | bail!("VM already started or failed") |
| 111 | } |
| 112 | } |
| 113 | } |
| 114 | |
| 115 | /// Information about a particular instance of a VM which may be running. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 116 | #[derive(Debug)] |
| 117 | pub struct VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 118 | /// The current state of the VM. |
| 119 | pub vm_state: Mutex<VmState>, |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 120 | /// The CID assigned to the VM for vsock communication. |
| 121 | pub cid: Cid, |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 122 | /// Whether the VM is a protected VM. |
| 123 | pub protected: bool, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 124 | /// Directory of temporary files used by the VM while it is running. |
| 125 | pub temporary_directory: PathBuf, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 126 | /// The UID of the process which requested the VM. |
| 127 | pub requester_uid: u32, |
| 128 | /// The SID of the process which requested the VM. |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 129 | pub requester_sid: String, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 130 | /// The PID of the process which requested the VM. Note that this process may no longer exist |
| 131 | /// and the PID may have been reused for a different process, so this should not be trusted. |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 132 | pub requester_debug_pid: i32, |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 133 | /// Callbacks to clients of the VM. |
| 134 | pub callbacks: VirtualMachineCallbacks, |
Inseob Kim | 7f61fe7 | 2021-08-20 20:50:47 +0900 | [diff] [blame] | 135 | /// Input/output stream of the payload run in the VM. |
| 136 | pub stream: Mutex<Option<VsockStream>>, |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 137 | /// VirtualMachineService binder object for the VM. |
| 138 | pub vm_service: Mutex<Option<Strong<dyn IVirtualMachineService>>>, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 139 | /// The latest lifecycle state which the payload reported itself to be in. |
| 140 | payload_state: Mutex<PayloadState>, |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | impl VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 144 | /// Validates the given config and creates a new `VmInstance` but doesn't start running it. |
| 145 | pub fn new( |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 146 | config: CrosvmConfig, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 147 | temporary_directory: PathBuf, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 148 | requester_uid: u32, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 149 | requester_sid: String, |
| 150 | requester_debug_pid: i32, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 151 | ) -> Result<VmInstance, Error> { |
| 152 | validate_config(&config)?; |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 153 | let cid = config.cid; |
| 154 | let protected = config.protected; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 155 | Ok(VmInstance { |
| 156 | vm_state: Mutex::new(VmState::NotStarted { config }), |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 157 | cid, |
| 158 | protected, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 159 | temporary_directory, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 160 | requester_uid, |
| 161 | requester_sid, |
| 162 | requester_debug_pid, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 163 | callbacks: Default::default(), |
| 164 | stream: Mutex::new(None), |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 165 | vm_service: Mutex::new(None), |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 166 | payload_state: Mutex::new(PayloadState::Starting), |
| 167 | }) |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 168 | } |
| 169 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 170 | /// Starts an instance of `crosvm` to manage the VM. The `crosvm` instance will be killed when |
| 171 | /// the `VmInstance` is dropped. |
| 172 | pub fn start(self: &Arc<Self>) -> Result<(), Error> { |
| 173 | self.vm_state.lock().unwrap().start(self.clone()) |
| 174 | } |
| 175 | |
| 176 | /// Waits for the crosvm child process to finish, then marks the VM as no longer running and |
| 177 | /// calls any callbacks. |
| 178 | /// |
| 179 | /// This takes a separate reference to the `SharedChild` rather than using the one in |
| 180 | /// `self.vm_state` to avoid holding the lock on `vm_state` while it is running. |
| 181 | fn monitor(&self, child: Arc<SharedChild>) { |
| 182 | match child.wait() { |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 183 | Err(e) => error!("Error waiting for crosvm instance to die: {}", e), |
| 184 | Ok(status) => info!("crosvm exited with status {}", status), |
| 185 | } |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 186 | |
| 187 | let mut vm_state = self.vm_state.lock().unwrap(); |
| 188 | *vm_state = VmState::Dead; |
| 189 | // Ensure that the mutex is released before calling the callbacks. |
| 190 | drop(vm_state); |
| 191 | |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 192 | self.callbacks.callback_on_died(self.cid); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 193 | |
| 194 | // Delete temporary files. |
| 195 | if let Err(e) = remove_dir_all(&self.temporary_directory) { |
Andrew Walbran | 806f154 | 2021-06-10 14:07:12 +0000 | [diff] [blame] | 196 | error!("Error removing temporary directory {:?}: {}", self.temporary_directory, e); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 197 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 198 | } |
| 199 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 200 | /// Returns the last reported state of the VM payload. |
| 201 | pub fn payload_state(&self) -> PayloadState { |
| 202 | *self.payload_state.lock().unwrap() |
| 203 | } |
| 204 | |
| 205 | /// Updates the payload state to the given value, if it is a valid state transition. |
| 206 | pub fn update_payload_state(&self, new_state: PayloadState) -> Result<(), Error> { |
| 207 | let mut state_locked = self.payload_state.lock().unwrap(); |
| 208 | // Only allow forward transitions, e.g. from starting to started or finished, not back in |
| 209 | // the other direction. |
| 210 | if new_state > *state_locked { |
| 211 | *state_locked = new_state; |
| 212 | Ok(()) |
| 213 | } else { |
| 214 | bail!("Invalid payload state transition from {:?} to {:?}", *state_locked, new_state) |
| 215 | } |
| 216 | } |
| 217 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 218 | /// Kills the crosvm instance, if it is running. |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 219 | pub fn kill(&self) { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 220 | let vm_state = &*self.vm_state.lock().unwrap(); |
| 221 | if let VmState::Running { child } = vm_state { |
| 222 | // TODO: Talk to crosvm to shutdown cleanly. |
| 223 | if let Err(e) = child.kill() { |
| 224 | error!("Error killing crosvm instance: {}", e); |
| 225 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 226 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 227 | } |
| 228 | } |
| 229 | |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 230 | /// Starts an instance of `crosvm` to manage a new VM. |
| 231 | fn run_vm(config: CrosvmConfig) -> Result<SharedChild, Error> { |
| 232 | validate_config(&config)?; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 233 | |
| 234 | let mut command = Command::new(CROSVM_PATH); |
| 235 | // TODO(qwandor): Remove --disable-sandbox. |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 236 | command.arg("run").arg("--disable-sandbox").arg("--cid").arg(config.cid.to_string()); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 237 | |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 238 | if config.protected { |
| 239 | command.arg("--protected-vm"); |
| 240 | } |
| 241 | |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 242 | if let Some(memory_mib) = config.memory_mib { |
| 243 | command.arg("--mem").arg(memory_mib.to_string()); |
| 244 | } |
| 245 | |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame^] | 246 | // Keep track of what file descriptors should be mapped to the crosvm process. |
| 247 | let mut preserved_fds = config.indirect_files.iter().map(|file| file.as_raw_fd()).collect(); |
| 248 | |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 249 | // Setup the serial devices. |
| 250 | // 1. uart device: used as the output device by bootloaders and as early console by linux |
| 251 | // 2. virtio-console device: used as the console device |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame^] | 252 | // 3. virtio-console device: used as the logcat output |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 253 | // |
| 254 | // When log_fd is not specified, the devices are attached to sink, which means what's written |
| 255 | // there is discarded. |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame^] | 256 | let path = config.log_fd.as_ref().map(|fd| add_preserved_fd(&mut preserved_fds, fd)); |
| 257 | let backend = path.as_ref().map_or("sink", |_| "file"); |
| 258 | let path_arg = path.as_ref().map_or(String::new(), |path| format!(",path={}", path)); |
| 259 | |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 260 | // Warning: Adding more serial devices requires you to shift the PCI device ID of the boot |
| 261 | // disks in bootconfig.x86_64. This is because x86 crosvm puts serial devices and the block |
| 262 | // devices in the same PCI bus and serial devices comes before the block devices. Arm crosvm |
| 263 | // doesn't have the issue. |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame^] | 264 | // /dev/ttyS0 |
| 265 | command.arg(format!("--serial=type={}{},hardware=serial", backend, &path_arg)); |
| 266 | // /dev/hvc0 |
| 267 | command.arg(format!("--serial=type={}{},hardware=virtio-console,num=1", backend, &path_arg)); |
| 268 | // /dev/hvc1 |
| 269 | // TODO(b/200914564) use a different fd for logcat log |
| 270 | command.arg(format!("--serial=type={}{},hardware=virtio-console,num=2", backend, &path_arg)); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 271 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 272 | if let Some(bootloader) = &config.bootloader { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 273 | command.arg("--bios").arg(add_preserved_fd(&mut preserved_fds, bootloader)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 274 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 275 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 276 | if let Some(initrd) = &config.initrd { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 277 | command.arg("--initrd").arg(add_preserved_fd(&mut preserved_fds, initrd)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 278 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 279 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 280 | if let Some(params) = &config.params { |
| 281 | command.arg("--params").arg(params); |
| 282 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 283 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 284 | for disk in &config.disks { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 285 | command |
| 286 | .arg(if disk.writable { "--rwdisk" } else { "--disk" }) |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 287 | .arg(add_preserved_fd(&mut preserved_fds, &disk.image)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 288 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 289 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 290 | if let Some(kernel) = &config.kernel { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 291 | command.arg(add_preserved_fd(&mut preserved_fds, kernel)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 292 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 293 | |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 294 | debug!("Preserving FDs {:?}", preserved_fds); |
| 295 | command.preserved_fds(preserved_fds); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 296 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 297 | info!("Running {:?}", command); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 298 | let result = SharedChild::spawn(&mut command)?; |
| 299 | Ok(result) |
| 300 | } |
| 301 | |
| 302 | /// Ensure that the configuration has a valid combination of fields set, or return an error if not. |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 303 | fn validate_config(config: &CrosvmConfig) -> Result<(), Error> { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 304 | if config.bootloader.is_none() && config.kernel.is_none() { |
| 305 | bail!("VM must have either a bootloader or a kernel image."); |
| 306 | } |
| 307 | if config.bootloader.is_some() && (config.kernel.is_some() || config.initrd.is_some()) { |
| 308 | bail!("Can't have both bootloader and kernel/initrd image."); |
| 309 | } |
| 310 | Ok(()) |
| 311 | } |
| 312 | |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 313 | /// Adds the file descriptor for `file` to `preserved_fds`, and returns a string of the form |
| 314 | /// "/proc/self/fd/N" where N is the file descriptor. |
| 315 | fn add_preserved_fd(preserved_fds: &mut Vec<RawFd>, file: &File) -> String { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 316 | let fd = file.as_raw_fd(); |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 317 | preserved_fds.push(fd); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 318 | format!("/proc/self/fd/{}", fd) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 319 | } |