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 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 17 | use crate::aidl::{remove_temporary_files, Cid, VirtualMachineCallbacks}; |
David Brazdil | 25e8c05 | 2023-02-17 12:53:01 +0000 | [diff] [blame] | 18 | use crate::atom::{get_num_cpus, write_vm_exited_stats}; |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame^] | 19 | use crate::debug_config::DebugConfig; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 20 | use anyhow::{anyhow, bail, Context, Error, Result}; |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 21 | use command_fds::CommandFdExt; |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 22 | use lazy_static::lazy_static; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 23 | use libc::{sysconf, _SC_CLK_TCK}; |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 24 | use log::{debug, error, info}; |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 25 | use semver::{Version, VersionReq}; |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 26 | use nix::{fcntl::OFlag, unistd::pipe2, unistd::Uid, unistd::User}; |
Jiyong Park | 2d73656 | 2022-10-24 22:40:12 +0900 | [diff] [blame] | 27 | use regex::{Captures, Regex}; |
Keir Fraser | f25cb92 | 2022-11-23 14:26:00 +0000 | [diff] [blame] | 28 | use rustutils::system_properties; |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 29 | use shared_child::SharedChild; |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 30 | use std::borrow::Cow; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 31 | use std::cmp::max; |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 32 | use std::fmt; |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 33 | use std::fs::{read_to_string, File}; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 34 | use std::io::{self, Read}; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 35 | use std::mem; |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 36 | use std::num::{NonZeroU16, NonZeroU32}; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 37 | use std::os::unix::io::{AsRawFd, RawFd, FromRawFd}; |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 38 | use std::os::unix::process::ExitStatusExt; |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 39 | use std::path::{Path, PathBuf}; |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 40 | use std::process::{Command, ExitStatus}; |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 41 | use std::sync::{Arc, Condvar, Mutex}; |
Seungjae Yoo | 2e7beea | 2022-08-24 16:09:12 +0900 | [diff] [blame] | 42 | use std::time::{Duration, SystemTime}; |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 43 | use std::thread::{self, JoinHandle}; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 44 | use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::DeathReason::DeathReason; |
Jaewan Kim | 84b9121 | 2023-02-28 00:11:57 +0900 | [diff] [blame] | 45 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
| 46 | MemoryTrimLevel::MemoryTrimLevel, |
| 47 | VirtualMachineAppConfig::DebugLevel::DebugLevel |
| 48 | }; |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 49 | use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IGlobalVmContext::IGlobalVmContext; |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 50 | use binder::Strong; |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 51 | use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService; |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 52 | use tombstoned_client::{TombstonedConnection, DebuggerdDumpType}; |
David Brazdil | 73988ea | 2022-11-11 15:10:32 +0000 | [diff] [blame] | 53 | use rpcbinder::RpcServer; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 54 | |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 55 | /// external/crosvm |
Elie Kheirallah | 2d12ff3 | 2023-03-20 18:12:07 +0000 | [diff] [blame] | 56 | use base::AsRawDescriptor; |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 57 | use base::UnixSeqpacketListener; |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 58 | use vm_control::{BalloonControlCommand, VmRequest, VmResponse}; |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 59 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 60 | const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm"; |
| 61 | |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 62 | /// Version of the platform that crosvm currently implements. The format follows SemVer. This |
| 63 | /// should be updated when there is a platform change in the crosvm side. Having this value here is |
| 64 | /// fine because virtualizationservice and crosvm are supposed to be updated together in the virt |
| 65 | /// APEX. |
| 66 | const CROSVM_PLATFORM_VERSION: &str = "1.0.0"; |
| 67 | |
Andrew Walbran | d15c563 | 2022-02-03 13:38:31 +0000 | [diff] [blame] | 68 | /// The exit status which crosvm returns when it has an error starting a VM. |
Alan Stokes | 7c459e8 | 2022-12-06 12:21:49 +0000 | [diff] [blame] | 69 | const CROSVM_START_ERROR_STATUS: i32 = 1; |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 70 | /// The exit status which crosvm returns when a VM requests a reboot. |
| 71 | const CROSVM_REBOOT_STATUS: i32 = 32; |
Andrew Walbran | d15c563 | 2022-02-03 13:38:31 +0000 | [diff] [blame] | 72 | /// The exit status which crosvm returns when it crashes due to an error. |
| 73 | const CROSVM_CRASH_STATUS: i32 = 33; |
Sebastian Ene | 23167d8 | 2022-10-07 14:09:53 +0000 | [diff] [blame] | 74 | /// The exit status which crosvm returns when vcpu is stalled. |
| 75 | const CROSVM_WATCHDOG_REBOOT_STATUS: i32 = 36; |
Jiyong Park | 3115cdb | 2023-02-24 18:04:44 +0900 | [diff] [blame] | 76 | /// The size of memory (in MiB) reserved for ramdump |
| 77 | const RAMDUMP_RESERVED_MIB: u32 = 17; |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 78 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 79 | const MILLIS_PER_SEC: i64 = 1000; |
| 80 | |
Jaewan Kim | 4642281 | 2022-11-25 10:59:39 +0900 | [diff] [blame] | 81 | const SYSPROP_CUSTOM_PVMFW_PATH: &str = "hypervisor.pvmfw.path"; |
| 82 | |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 83 | lazy_static! { |
| 84 | /// If the VM doesn't move to the Started state within this amount time, a hang-up error is |
| 85 | /// triggered. |
Alan Stokes | c3f2ac2 | 2022-06-23 12:19:46 +0100 | [diff] [blame] | 86 | static ref BOOT_HANGUP_TIMEOUT: Duration = if nested_virt::is_nested_virtualization().unwrap() { |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 87 | // Nested virtualization is slow, so we need a longer timeout. |
Inseob Kim | e557cec | 2023-01-26 22:49:58 +0900 | [diff] [blame] | 88 | Duration::from_secs(300) |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 89 | } else { |
Inseob Kim | e557cec | 2023-01-26 22:49:58 +0900 | [diff] [blame] | 90 | Duration::from_secs(30) |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 91 | }; |
| 92 | } |
| 93 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 94 | /// Configuration for a VM to run with crosvm. |
| 95 | #[derive(Debug)] |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 96 | pub struct CrosvmConfig { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 97 | pub cid: Cid, |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 98 | pub name: String, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 99 | pub bootloader: Option<File>, |
| 100 | pub kernel: Option<File>, |
| 101 | pub initrd: Option<File>, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 102 | pub disks: Vec<DiskFile>, |
| 103 | pub params: Option<String>, |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 104 | pub protected: bool, |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame^] | 105 | pub debug_config: DebugConfig, |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 106 | pub memory_mib: Option<NonZeroU32>, |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 107 | pub cpus: Option<NonZeroU32>, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 108 | pub host_cpu_topology: bool, |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 109 | pub task_profiles: Vec<String>, |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 110 | pub console_fd: Option<File>, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 111 | pub log_fd: Option<File>, |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 112 | pub ramdump: Option<File>, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 113 | pub indirect_files: Vec<File>, |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 114 | pub platform_version: VersionReq, |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 115 | pub detect_hangup: bool, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 116 | pub gdb_port: Option<NonZeroU16>, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | /// A disk image to pass to crosvm for a VM. |
| 120 | #[derive(Debug)] |
| 121 | pub struct DiskFile { |
| 122 | pub image: File, |
| 123 | pub writable: bool, |
| 124 | } |
| 125 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 126 | /// The lifecycle state which the payload in the VM has reported itself to be in. |
| 127 | /// |
| 128 | /// Note that the order of enum variants is significant; only forward transitions are allowed by |
| 129 | /// [`VmInstance::update_payload_state`]. |
| 130 | #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] |
| 131 | pub enum PayloadState { |
| 132 | Starting, |
| 133 | Started, |
| 134 | Ready, |
| 135 | Finished, |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 136 | Hangup, // Hasn't reached to Ready before timeout expires |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 137 | } |
| 138 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 139 | /// The current state of the VM itself. |
| 140 | #[derive(Debug)] |
| 141 | pub enum VmState { |
| 142 | /// The VM has not yet tried to start. |
| 143 | NotStarted { |
| 144 | ///The configuration needed to start the VM, if it has not yet been started. |
| 145 | config: CrosvmConfig, |
| 146 | }, |
| 147 | /// The VM has been started. |
| 148 | Running { |
| 149 | /// The crosvm child process. |
| 150 | child: Arc<SharedChild>, |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 151 | /// The thread waiting for crosvm to finish. |
| 152 | monitor_vm_exit_thread: Option<JoinHandle<()>>, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 153 | }, |
| 154 | /// The VM died or was killed. |
| 155 | Dead, |
| 156 | /// The VM failed to start. |
| 157 | Failed, |
| 158 | } |
| 159 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 160 | /// RSS values of VM and CrosVM process itself. |
| 161 | #[derive(Copy, Clone, Debug, Default)] |
| 162 | pub struct Rss { |
| 163 | pub vm: i64, |
| 164 | pub crosvm: i64, |
| 165 | } |
| 166 | |
| 167 | /// Metrics regarding the VM. |
| 168 | #[derive(Debug, Default)] |
| 169 | pub struct VmMetric { |
| 170 | /// Recorded timestamp when the VM is started. |
| 171 | pub start_timestamp: Option<SystemTime>, |
| 172 | /// Update most recent guest_time periodically from /proc/[crosvm pid]/stat while VM is running. |
| 173 | pub cpu_guest_time: Option<i64>, |
| 174 | /// Update maximum RSS values periodically from /proc/[crosvm pid]/smaps while VM is running. |
| 175 | pub rss: Option<Rss>, |
| 176 | } |
| 177 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 178 | impl VmState { |
| 179 | /// Tries to start the VM, if it is in the `NotStarted` state. |
| 180 | /// |
| 181 | /// Returns an error if the VM is in the wrong state, or fails to start. |
| 182 | fn start(&mut self, instance: Arc<VmInstance>) -> Result<(), Error> { |
| 183 | let state = mem::replace(self, VmState::Failed); |
| 184 | if let VmState::NotStarted { config } = state { |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 185 | let detect_hangup = config.detect_hangup; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 186 | let (failure_pipe_read, failure_pipe_write) = create_pipe()?; |
| 187 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 188 | // If this fails and returns an error, `self` will be left in the `Failed` state. |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 189 | let child = |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 190 | Arc::new(run_vm(config, &instance.crosvm_control_socket_path, failure_pipe_write)?); |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 191 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 192 | let instance_monitor_status = instance.clone(); |
| 193 | let child_monitor_status = child.clone(); |
| 194 | thread::spawn(move || { |
| 195 | instance_monitor_status.clone().monitor_vm_status(child_monitor_status); |
| 196 | }); |
| 197 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 198 | let child_clone = child.clone(); |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 199 | let instance_clone = instance.clone(); |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 200 | let monitor_vm_exit_thread = Some(thread::spawn(move || { |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 201 | instance_clone.monitor_vm_exit(child_clone, failure_pipe_read); |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 202 | })); |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 203 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 204 | if detect_hangup { |
| 205 | let child_clone = child.clone(); |
| 206 | thread::spawn(move || { |
| 207 | instance.monitor_payload_hangup(child_clone); |
| 208 | }); |
| 209 | } |
| 210 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 211 | // If it started correctly, update the state. |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 212 | *self = VmState::Running { child, monitor_vm_exit_thread }; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 213 | Ok(()) |
| 214 | } else { |
| 215 | *self = state; |
| 216 | bail!("VM already started or failed") |
| 217 | } |
| 218 | } |
| 219 | } |
| 220 | |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 221 | /// Internal struct that holds the handles to globally unique resources of a VM. |
| 222 | #[derive(Debug)] |
| 223 | pub struct VmContext { |
| 224 | #[allow(dead_code)] // Keeps the global context alive |
| 225 | global_context: Strong<dyn IGlobalVmContext>, |
| 226 | #[allow(dead_code)] // Keeps the server alive |
| 227 | vm_server: RpcServer, |
| 228 | } |
| 229 | |
| 230 | impl VmContext { |
| 231 | /// Construct new VmContext. |
| 232 | pub fn new(global_context: Strong<dyn IGlobalVmContext>, vm_server: RpcServer) -> VmContext { |
| 233 | VmContext { global_context, vm_server } |
| 234 | } |
| 235 | } |
| 236 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 237 | /// Information about a particular instance of a VM which may be running. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 238 | #[derive(Debug)] |
| 239 | pub struct VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 240 | /// The current state of the VM. |
| 241 | pub vm_state: Mutex<VmState>, |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 242 | /// Global resources allocated for this VM. |
| 243 | #[allow(dead_code)] // Keeps the context alive |
| 244 | vm_context: VmContext, |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 245 | /// The CID assigned to the VM for vsock communication. |
| 246 | pub cid: Cid, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 247 | /// Path to crosvm control socket |
| 248 | crosvm_control_socket_path: PathBuf, |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 249 | /// The name of the VM. |
| 250 | pub name: String, |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 251 | /// Whether the VM is a protected VM. |
| 252 | pub protected: bool, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 253 | /// Directory of temporary files used by the VM while it is running. |
| 254 | pub temporary_directory: PathBuf, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 255 | /// The UID of the process which requested the VM. |
| 256 | pub requester_uid: u32, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 257 | /// The PID of the process which requested the VM. Note that this process may no longer exist |
| 258 | /// 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] | 259 | pub requester_debug_pid: i32, |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 260 | /// Callbacks to clients of the VM. |
| 261 | pub callbacks: VirtualMachineCallbacks, |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 262 | /// VirtualMachineService binder object for the VM. |
| 263 | pub vm_service: Mutex<Option<Strong<dyn IVirtualMachineService>>>, |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 264 | /// Recorded metrics of VM such as timestamp or cpu / memory usage. |
| 265 | pub vm_metric: Mutex<VmMetric>, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 266 | /// The latest lifecycle state which the payload reported itself to be in. |
| 267 | payload_state: Mutex<PayloadState>, |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 268 | /// Represents the condition that payload_state was updated |
| 269 | payload_state_updated: Condvar, |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 270 | /// The human readable name of requester_uid |
| 271 | requester_uid_name: String, |
| 272 | } |
| 273 | |
| 274 | impl fmt::Display for VmInstance { |
| 275 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 276 | let adj = if self.protected { "Protected" } else { "Non-protected" }; |
| 277 | write!( |
| 278 | f, |
| 279 | "{} virtual machine \"{}\" (owner: {}, cid: {})", |
| 280 | adj, self.name, self.requester_uid_name, self.cid |
| 281 | ) |
| 282 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 283 | } |
| 284 | |
| 285 | impl VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 286 | /// Validates the given config and creates a new `VmInstance` but doesn't start running it. |
| 287 | pub fn new( |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 288 | config: CrosvmConfig, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 289 | temporary_directory: PathBuf, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 290 | requester_uid: u32, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 291 | requester_debug_pid: i32, |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 292 | vm_context: VmContext, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 293 | ) -> Result<VmInstance, Error> { |
| 294 | validate_config(&config)?; |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 295 | let cid = config.cid; |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 296 | let name = config.name.clone(); |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 297 | let protected = config.protected; |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 298 | let requester_uid_name = User::from_uid(Uid::from_raw(requester_uid)) |
| 299 | .ok() |
| 300 | .flatten() |
| 301 | .map_or_else(|| format!("{}", requester_uid), |u| u.name); |
| 302 | let instance = VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 303 | vm_state: Mutex::new(VmState::NotStarted { config }), |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 304 | vm_context, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 305 | cid, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 306 | crosvm_control_socket_path: temporary_directory.join("crosvm.sock"), |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 307 | name, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 308 | protected, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 309 | temporary_directory, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 310 | requester_uid, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 311 | requester_debug_pid, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 312 | callbacks: Default::default(), |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 313 | vm_service: Mutex::new(None), |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 314 | vm_metric: Mutex::new(Default::default()), |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 315 | payload_state: Mutex::new(PayloadState::Starting), |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 316 | payload_state_updated: Condvar::new(), |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 317 | requester_uid_name, |
| 318 | }; |
| 319 | info!("{} created", &instance); |
| 320 | Ok(instance) |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 321 | } |
| 322 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 323 | /// Starts an instance of `crosvm` to manage the VM. The `crosvm` instance will be killed when |
| 324 | /// the `VmInstance` is dropped. |
| 325 | pub fn start(self: &Arc<Self>) -> Result<(), Error> { |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 326 | let mut vm_metric = self.vm_metric.lock().unwrap(); |
| 327 | vm_metric.start_timestamp = Some(SystemTime::now()); |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 328 | let ret = self.vm_state.lock().unwrap().start(self.clone()); |
| 329 | if ret.is_ok() { |
| 330 | info!("{} started", &self); |
| 331 | } |
| 332 | ret.with_context(|| format!("{} failed to start", &self)) |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 333 | } |
| 334 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 335 | /// Monitors the exit of the VM (i.e. termination of the `child` process). When that happens, |
| 336 | /// handles the event by updating the state, noityfing the event to clients by calling |
| 337 | /// callbacks, and removing temporary files for the VM. |
| 338 | fn monitor_vm_exit(&self, child: Arc<SharedChild>, mut failure_pipe_read: File) { |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 339 | let result = child.wait(); |
| 340 | match &result { |
Jooyung Han | bfe086f | 2021-10-28 10:15:45 +0900 | [diff] [blame] | 341 | Err(e) => error!("Error waiting for crosvm({}) instance to die: {}", child.id(), e), |
Sebastian Ene | 23167d8 | 2022-10-07 14:09:53 +0000 | [diff] [blame] | 342 | Ok(status) => { |
| 343 | info!("crosvm({}) exited with status {}", child.id(), status); |
| 344 | if let Some(exit_status_code) = status.code() { |
| 345 | if exit_status_code == CROSVM_WATCHDOG_REBOOT_STATUS { |
| 346 | info!("detected vcpu stall on crosvm"); |
| 347 | } |
| 348 | } |
| 349 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 350 | } |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 351 | |
| 352 | let mut vm_state = self.vm_state.lock().unwrap(); |
| 353 | *vm_state = VmState::Dead; |
| 354 | // Ensure that the mutex is released before calling the callbacks. |
| 355 | drop(vm_state); |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 356 | info!("{} exited", &self); |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 357 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 358 | // Read the pipe to see if any failure reason is written |
| 359 | let mut failure_reason = String::new(); |
| 360 | match failure_pipe_read.read_to_string(&mut failure_reason) { |
| 361 | Err(e) => error!("Error reading VM failure reason from pipe: {}", e), |
| 362 | Ok(len) if len > 0 => info!("VM returned failure reason '{}'", &failure_reason), |
| 363 | _ => (), |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 364 | }; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 365 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 366 | // In case of hangup, the pipe doesn't give us any information because the hangup can't be |
| 367 | // detected on the VM side (otherwise, it isn't a hangup), but in the |
| 368 | // monitor_payload_hangup function below which updates the payload state to Hangup. |
| 369 | let failure_reason = |
| 370 | if failure_reason.is_empty() && self.payload_state() == PayloadState::Hangup { |
| 371 | Cow::from("HANGUP") |
| 372 | } else { |
| 373 | Cow::from(failure_reason) |
| 374 | }; |
| 375 | |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 376 | self.handle_ramdump().unwrap_or_else(|e| error!("Error handling ramdump: {}", e)); |
Seungjae Yoo | b4c07ba | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 377 | |
| 378 | let death_reason = death_reason(&result, &failure_reason); |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 379 | let exit_signal = exit_signal(&result); |
| 380 | |
Seungjae Yoo | b4c07ba | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 381 | self.callbacks.callback_on_died(self.cid, death_reason); |
Seungjae Yoo | 2e7beea | 2022-08-24 16:09:12 +0900 | [diff] [blame] | 382 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 383 | let vm_metric = self.vm_metric.lock().unwrap(); |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 384 | write_vm_exited_stats( |
| 385 | self.requester_uid as i32, |
| 386 | &self.name, |
| 387 | death_reason, |
| 388 | exit_signal, |
Chris Wailes | 7526962 | 2022-12-05 23:01:44 -0800 | [diff] [blame] | 389 | &vm_metric, |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 390 | ); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 391 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 392 | // Delete temporary files. The folder itself is removed by VirtualizationServiceInternal. |
| 393 | remove_temporary_files(&self.temporary_directory).unwrap_or_else(|e| { |
| 394 | error!("Error removing temporary files from {:?}: {}", self.temporary_directory, e); |
| 395 | }); |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 396 | } |
| 397 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 398 | /// Waits until payload is started, or timeout expires. When timeout occurs, kill |
| 399 | /// the VM to prevent indefinite hangup and update the payload_state accordingly. |
| 400 | fn monitor_payload_hangup(&self, child: Arc<SharedChild>) { |
| 401 | debug!("Starting to monitor hangup for Microdroid({})", child.id()); |
| 402 | let (_, result) = self |
| 403 | .payload_state_updated |
| 404 | .wait_timeout_while(self.payload_state.lock().unwrap(), *BOOT_HANGUP_TIMEOUT, |s| { |
| 405 | *s < PayloadState::Started |
| 406 | }) |
| 407 | .unwrap(); |
| 408 | let child_still_running = child.try_wait().ok() == Some(None); |
| 409 | if result.timed_out() && child_still_running { |
| 410 | error!( |
| 411 | "Microdroid({}) failed to start payload within {} secs timeout. Shutting down.", |
| 412 | child.id(), |
| 413 | BOOT_HANGUP_TIMEOUT.as_secs() |
| 414 | ); |
| 415 | self.update_payload_state(PayloadState::Hangup).unwrap(); |
| 416 | if let Err(e) = self.kill() { |
| 417 | error!("Error stopping timed-out VM with CID {}: {:?}", child.id(), e); |
| 418 | } |
| 419 | } |
| 420 | } |
| 421 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 422 | fn monitor_vm_status(&self, child: Arc<SharedChild>) { |
| 423 | let pid = child.id(); |
| 424 | |
| 425 | loop { |
| 426 | { |
| 427 | // Check VM state |
| 428 | let vm_state = &*self.vm_state.lock().unwrap(); |
| 429 | if let VmState::Dead = vm_state { |
| 430 | break; |
| 431 | } |
| 432 | |
| 433 | let mut vm_metric = self.vm_metric.lock().unwrap(); |
| 434 | |
| 435 | // Get CPU Information |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 436 | if let Ok(guest_time) = get_guest_time(pid) { |
| 437 | vm_metric.cpu_guest_time = Some(guest_time); |
| 438 | } else { |
| 439 | error!("Failed to parse /proc/[pid]/stat"); |
| 440 | } |
| 441 | |
| 442 | // Get Memory Information |
| 443 | if let Ok(rss) = get_rss(pid) { |
| 444 | vm_metric.rss = match &vm_metric.rss { |
| 445 | Some(x) => Some(Rss::extract_max(x, &rss)), |
| 446 | None => Some(rss), |
| 447 | } |
| 448 | } else { |
| 449 | error!("Failed to parse /proc/[pid]/smaps"); |
| 450 | } |
| 451 | } |
| 452 | |
| 453 | thread::sleep(Duration::from_secs(1)); |
| 454 | } |
| 455 | } |
| 456 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 457 | /// Returns the last reported state of the VM payload. |
| 458 | pub fn payload_state(&self) -> PayloadState { |
| 459 | *self.payload_state.lock().unwrap() |
| 460 | } |
| 461 | |
| 462 | /// Updates the payload state to the given value, if it is a valid state transition. |
| 463 | pub fn update_payload_state(&self, new_state: PayloadState) -> Result<(), Error> { |
| 464 | let mut state_locked = self.payload_state.lock().unwrap(); |
| 465 | // Only allow forward transitions, e.g. from starting to started or finished, not back in |
| 466 | // the other direction. |
| 467 | if new_state > *state_locked { |
| 468 | *state_locked = new_state; |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 469 | self.payload_state_updated.notify_all(); |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 470 | Ok(()) |
| 471 | } else { |
| 472 | bail!("Invalid payload state transition from {:?} to {:?}", *state_locked, new_state) |
| 473 | } |
| 474 | } |
| 475 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 476 | /// Kills the crosvm instance, if it is running. |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 477 | pub fn kill(&self) -> Result<(), Error> { |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 478 | let monitor_vm_exit_thread = { |
| 479 | let vm_state = &mut *self.vm_state.lock().unwrap(); |
| 480 | if let VmState::Running { child, monitor_vm_exit_thread } = vm_state { |
| 481 | let id = child.id(); |
| 482 | debug!("Killing crosvm({})", id); |
| 483 | // TODO: Talk to crosvm to shutdown cleanly. |
| 484 | child.kill().with_context(|| format!("Error killing crosvm({id}) instance"))?; |
| 485 | monitor_vm_exit_thread.take() |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 486 | } else { |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 487 | bail!("VM is not running") |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 488 | } |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 489 | }; |
| 490 | |
| 491 | // Wait for monitor_vm_exit() to finish. Must release vm_state lock |
| 492 | // first, as monitor_vm_exit() takes it as well. |
| 493 | monitor_vm_exit_thread.map(JoinHandle::join); |
| 494 | |
David Brazdil | 5af5583 | 2023-03-08 13:08:56 +0000 | [diff] [blame] | 495 | // Now that the VM has been killed, shut down the VirtualMachineService |
| 496 | // server to eagerly free up the server threads. |
| 497 | self.vm_context.vm_server.shutdown()?; |
| 498 | |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 499 | Ok(()) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 500 | } |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 501 | |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 502 | /// Responds to memory-trimming notifications by inflating the virtio |
| 503 | /// balloon to reclaim guest memory. |
| 504 | pub fn trim_memory(&self, level: MemoryTrimLevel) -> Result<(), Error> { |
| 505 | let request = VmRequest::BalloonCommand(BalloonControlCommand::Stats {}); |
| 506 | match vm_control::client::handle_request(&request, &self.crosvm_control_socket_path) { |
| 507 | Ok(VmResponse::BalloonStats { stats, balloon_actual: _ }) => { |
| 508 | if let Some(total_memory) = stats.total_memory { |
| 509 | // Reclaim up to 50% of total memory assuming worst case |
| 510 | // most memory is anonymous and must be swapped to zram |
| 511 | // with an approximate 2:1 compression ratio. |
| 512 | let pct = match level { |
| 513 | MemoryTrimLevel::TRIM_MEMORY_RUNNING_CRITICAL => 50, |
| 514 | MemoryTrimLevel::TRIM_MEMORY_RUNNING_LOW => 30, |
| 515 | MemoryTrimLevel::TRIM_MEMORY_RUNNING_MODERATE => 10, |
| 516 | _ => bail!("Invalid memory trim level {:?}", level), |
| 517 | }; |
| 518 | let command = |
| 519 | BalloonControlCommand::Adjust { num_bytes: total_memory * pct / 100 }; |
| 520 | if let Err(e) = vm_control::client::handle_request( |
| 521 | &VmRequest::BalloonCommand(command), |
| 522 | &self.crosvm_control_socket_path, |
| 523 | ) { |
| 524 | bail!("Error sending balloon adjustment: {:?}", e); |
| 525 | } |
| 526 | } |
| 527 | } |
| 528 | Ok(VmResponse::Err(e)) => { |
| 529 | // ENOTSUP is returned when the balloon protocol is not initialised. This |
| 530 | // can occur for numerous reasons: Guest is still booting, guest doesn't |
| 531 | // support ballooning, host doesn't support ballooning. We don't log or |
| 532 | // raise an error in this case: trim is just a hint and we can ignore it. |
| 533 | if e.errno() != libc::ENOTSUP { |
| 534 | bail!("Errno return when requesting balloon stats: {}", e.errno()) |
| 535 | } |
| 536 | } |
| 537 | e => bail!("Error requesting balloon stats: {:?}", e), |
| 538 | } |
| 539 | Ok(()) |
| 540 | } |
| 541 | |
Alan Stokes | 3e98d29 | 2022-12-14 15:18:22 +0000 | [diff] [blame] | 542 | /// Checks if ramdump has been created. If so, send it to tombstoned. |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 543 | fn handle_ramdump(&self) -> Result<(), Error> { |
| 544 | let ramdump_path = self.temporary_directory.join("ramdump"); |
Jiyong Park | 933d2b2 | 2023-02-28 11:41:19 +0900 | [diff] [blame] | 545 | if !ramdump_path.as_path().try_exists()? { |
| 546 | return Ok(()); |
| 547 | } |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 548 | if std::fs::metadata(&ramdump_path)?.len() > 0 { |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 549 | Self::send_ramdump_to_tombstoned(&ramdump_path)?; |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 550 | } |
| 551 | Ok(()) |
| 552 | } |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 553 | |
| 554 | fn send_ramdump_to_tombstoned(ramdump_path: &Path) -> Result<(), Error> { |
| 555 | let mut input = File::open(ramdump_path) |
Alan Stokes | 3e98d29 | 2022-12-14 15:18:22 +0000 | [diff] [blame] | 556 | .context(format!("Failed to open ramdump {:?} for reading", ramdump_path))?; |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 557 | |
| 558 | let pid = std::process::id() as i32; |
| 559 | let conn = TombstonedConnection::connect(pid, DebuggerdDumpType::Tombstone) |
| 560 | .context("Failed to connect to tombstoned")?; |
| 561 | let mut output = conn |
| 562 | .text_output |
| 563 | .as_ref() |
| 564 | .ok_or_else(|| anyhow!("Could not get file to write the tombstones on"))?; |
| 565 | |
| 566 | std::io::copy(&mut input, &mut output).context("Failed to send ramdump to tombstoned")?; |
| 567 | info!("Ramdump {:?} sent to tombstoned", ramdump_path); |
| 568 | |
| 569 | conn.notify_completion()?; |
| 570 | Ok(()) |
| 571 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 572 | } |
| 573 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 574 | impl Rss { |
| 575 | fn extract_max(x: &Rss, y: &Rss) -> Rss { |
| 576 | Rss { vm: max(x.vm, y.vm), crosvm: max(x.crosvm, y.crosvm) } |
| 577 | } |
| 578 | } |
| 579 | |
| 580 | // Get guest time from /proc/[crosvm pid]/stat |
| 581 | fn get_guest_time(pid: u32) -> Result<i64> { |
| 582 | let file = read_to_string(format!("/proc/{}/stat", pid))?; |
| 583 | let data_list: Vec<_> = file.split_whitespace().collect(); |
| 584 | |
| 585 | // Information about guest_time is at 43th place of the file split with the whitespace. |
| 586 | // Example of /proc/[pid]/stat : |
| 587 | // 6603 (kworker/104:1H-kblockd) I 2 0 0 0 -1 69238880 0 0 0 0 0 88 0 0 0 -20 1 0 1845 0 0 |
| 588 | // 18446744073709551615 0 0 0 0 0 0 0 2147483647 0 0 0 0 17 104 0 0 0 0 0 0 0 0 0 0 0 0 0 |
| 589 | if data_list.len() < 43 { |
| 590 | bail!("Failed to parse command result for getting guest time : {}", file); |
| 591 | } |
| 592 | |
| 593 | let guest_time_ticks = data_list[42].parse::<i64>()?; |
| 594 | // SAFETY : It just returns an integer about CPU tick information. |
Charisee | 96113f3 | 2023-01-26 09:00:42 +0000 | [diff] [blame] | 595 | let ticks_per_sec = unsafe { sysconf(_SC_CLK_TCK) }; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 596 | Ok(guest_time_ticks * MILLIS_PER_SEC / ticks_per_sec) |
| 597 | } |
| 598 | |
| 599 | // Get rss from /proc/[crosvm pid]/smaps |
| 600 | fn get_rss(pid: u32) -> Result<Rss> { |
| 601 | let file = read_to_string(format!("/proc/{}/smaps", pid))?; |
| 602 | let lines: Vec<_> = file.split('\n').collect(); |
| 603 | |
| 604 | let mut rss_vm_total = 0i64; |
| 605 | let mut rss_crosvm_total = 0i64; |
| 606 | let mut is_vm = false; |
| 607 | for line in lines { |
| 608 | if line.contains("crosvm_guest") { |
| 609 | is_vm = true; |
| 610 | } else if line.contains("Rss:") { |
| 611 | let data_list: Vec<_> = line.split_whitespace().collect(); |
| 612 | if data_list.len() < 2 { |
| 613 | bail!("Failed to parse command result for getting rss :\n{}", line); |
| 614 | } |
| 615 | let rss = data_list[1].parse::<i64>()?; |
| 616 | |
| 617 | if is_vm { |
| 618 | rss_vm_total += rss; |
| 619 | is_vm = false; |
| 620 | } |
| 621 | rss_crosvm_total += rss; |
| 622 | } |
| 623 | } |
| 624 | |
| 625 | Ok(Rss { vm: rss_vm_total, crosvm: rss_crosvm_total }) |
| 626 | } |
| 627 | |
Alan Stokes | 3ba10fd | 2022-10-06 15:46:51 +0100 | [diff] [blame] | 628 | fn death_reason(result: &Result<ExitStatus, io::Error>, mut failure_reason: &str) -> DeathReason { |
| 629 | if let Some(position) = failure_reason.find('|') { |
| 630 | // Separator indicates extra context information is present after the failure name. |
| 631 | error!("Failure info: {}", &failure_reason[(position + 1)..]); |
| 632 | failure_reason = &failure_reason[..position]; |
| 633 | } |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 634 | if let Ok(status) = result { |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 635 | match failure_reason { |
| 636 | "PVM_FIRMWARE_PUBLIC_KEY_MISMATCH" => { |
| 637 | return DeathReason::PVM_FIRMWARE_PUBLIC_KEY_MISMATCH |
| 638 | } |
| 639 | "PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED" => { |
| 640 | return DeathReason::PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED |
| 641 | } |
| 642 | "BOOTLOADER_PUBLIC_KEY_MISMATCH" => return DeathReason::BOOTLOADER_PUBLIC_KEY_MISMATCH, |
| 643 | "BOOTLOADER_INSTANCE_IMAGE_CHANGED" => { |
| 644 | return DeathReason::BOOTLOADER_INSTANCE_IMAGE_CHANGED |
| 645 | } |
Inseob Kim | 272f572 | 2022-06-13 17:14:51 +0900 | [diff] [blame] | 646 | "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE" => { |
| 647 | return DeathReason::MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE |
| 648 | } |
| 649 | "MICRODROID_PAYLOAD_HAS_CHANGED" => return DeathReason::MICRODROID_PAYLOAD_HAS_CHANGED, |
| 650 | "MICRODROID_PAYLOAD_VERIFICATION_FAILED" => { |
| 651 | return DeathReason::MICRODROID_PAYLOAD_VERIFICATION_FAILED |
| 652 | } |
| 653 | "MICRODROID_INVALID_PAYLOAD_CONFIG" => { |
| 654 | return DeathReason::MICRODROID_INVALID_PAYLOAD_CONFIG |
| 655 | } |
| 656 | "MICRODROID_UNKNOWN_RUNTIME_ERROR" => { |
| 657 | return DeathReason::MICRODROID_UNKNOWN_RUNTIME_ERROR |
| 658 | } |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 659 | "HANGUP" => return DeathReason::HANGUP, |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 660 | _ => {} |
| 661 | } |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 662 | match status.code() { |
| 663 | None => DeathReason::KILLED, |
| 664 | Some(0) => DeathReason::SHUTDOWN, |
Alan Stokes | 7c459e8 | 2022-12-06 12:21:49 +0000 | [diff] [blame] | 665 | Some(CROSVM_START_ERROR_STATUS) => DeathReason::START_FAILED, |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 666 | Some(CROSVM_REBOOT_STATUS) => DeathReason::REBOOT, |
Andrew Walbran | d15c563 | 2022-02-03 13:38:31 +0000 | [diff] [blame] | 667 | Some(CROSVM_CRASH_STATUS) => DeathReason::CRASH, |
Sebastian Ene | 23167d8 | 2022-10-07 14:09:53 +0000 | [diff] [blame] | 668 | Some(CROSVM_WATCHDOG_REBOOT_STATUS) => DeathReason::WATCHDOG_REBOOT, |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 669 | Some(_) => DeathReason::UNKNOWN, |
| 670 | } |
| 671 | } else { |
| 672 | DeathReason::INFRASTRUCTURE_ERROR |
| 673 | } |
| 674 | } |
| 675 | |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 676 | fn exit_signal(result: &Result<ExitStatus, io::Error>) -> Option<i32> { |
| 677 | match result { |
| 678 | Ok(status) => status.signal(), |
| 679 | Err(_) => None, |
| 680 | } |
| 681 | } |
| 682 | |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 683 | /// Starts an instance of `crosvm` to manage a new VM. |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 684 | fn run_vm( |
| 685 | config: CrosvmConfig, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 686 | crosvm_control_socket_path: &Path, |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 687 | failure_pipe_write: File, |
| 688 | ) -> Result<SharedChild, Error> { |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 689 | validate_config(&config)?; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 690 | |
| 691 | let mut command = Command::new(CROSVM_PATH); |
| 692 | // TODO(qwandor): Remove --disable-sandbox. |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 693 | command |
| 694 | .arg("--extended-status") |
Jiyong Park | 6c60fea | 2022-10-24 16:10:01 +0900 | [diff] [blame] | 695 | // Configure the logger for the crosvm process to silence logs from the disk crate which |
| 696 | // don't provide much information to us (but do spamming us). |
| 697 | .arg("--log-level") |
Frederick Mayle | 138f53c | 2023-01-24 18:55:26 -0800 | [diff] [blame] | 698 | .arg("info,disk=warn") |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 699 | .arg("run") |
| 700 | .arg("--disable-sandbox") |
| 701 | .arg("--cid") |
| 702 | .arg(config.cid.to_string()); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 703 | |
Keir Fraser | f25cb92 | 2022-11-23 14:26:00 +0000 | [diff] [blame] | 704 | if system_properties::read_bool("hypervisor.memory_reclaim.supported", false)? { |
| 705 | command.arg("--balloon-page-reporting"); |
| 706 | } else { |
| 707 | command.arg("--no-balloon"); |
| 708 | } |
| 709 | |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 710 | if config.protected { |
Jaewan Kim | 4642281 | 2022-11-25 10:59:39 +0900 | [diff] [blame] | 711 | match system_properties::read(SYSPROP_CUSTOM_PVMFW_PATH)? { |
| 712 | Some(pvmfw_path) if !pvmfw_path.is_empty() => { |
| 713 | command.arg("--protected-vm-with-firmware").arg(pvmfw_path) |
| 714 | } |
| 715 | _ => command.arg("--protected-vm"), |
| 716 | }; |
Andrew Walbran | 0b5789f | 2022-02-04 13:57:57 +0000 | [diff] [blame] | 717 | |
| 718 | // 3 virtio-console devices + vsock = 4. |
| 719 | let virtio_pci_device_count = 4 + config.disks.len(); |
| 720 | // crosvm virtio queue has 256 entries, so 2 MiB per device (2 pages per entry) should be |
| 721 | // enough. |
Jiyong Park | 3115cdb | 2023-02-24 18:04:44 +0900 | [diff] [blame] | 722 | let swiotlb_size_mib = 2 * virtio_pci_device_count as u32; |
Andrew Walbran | 0b5789f | 2022-02-04 13:57:57 +0000 | [diff] [blame] | 723 | command.arg("--swiotlb").arg(swiotlb_size_mib.to_string()); |
Frederick Mayle | 58baa30 | 2023-02-14 19:06:37 -0800 | [diff] [blame] | 724 | |
| 725 | // Workaround to keep crash_dump from trying to read protected guest memory. |
| 726 | // Context in b/238324526. |
| 727 | command.arg("--unmap-guest-memory-on-fork"); |
Jiyong Park | 3115cdb | 2023-02-24 18:04:44 +0900 | [diff] [blame] | 728 | |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 729 | if config.ramdump.is_some() { |
Jaewan Kim | 3124ef0 | 2023-03-23 19:25:20 +0900 | [diff] [blame] | 730 | // Protected VM needs to reserve memory for ramdump here. Note that we reserve more |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 731 | // memory for the restricted dma pool. |
| 732 | let ramdump_reserve = RAMDUMP_RESERVED_MIB + swiotlb_size_mib; |
| 733 | command.arg("--params").arg(format!("crashkernel={ramdump_reserve}M")); |
| 734 | } |
Jaewan Kim | d4dae65 | 2023-03-28 13:45:43 +0900 | [diff] [blame] | 735 | } else if config.ramdump.is_some() { |
| 736 | command.arg("--params").arg(format!("crashkernel={RAMDUMP_RESERVED_MIB}M")); |
| 737 | } |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame^] | 738 | if config.debug_config.debug_level == DebugLevel::NONE |
| 739 | && config.debug_config.should_prepare_console_output() |
| 740 | { |
Jaewan Kim | d4dae65 | 2023-03-28 13:45:43 +0900 | [diff] [blame] | 741 | // bootconfig.normal will be used, but we need log. |
| 742 | command.arg("--params").arg("printk.devkmsg=on"); |
| 743 | command.arg("--params").arg("console=hvc0"); |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 744 | } |
| 745 | |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 746 | if let Some(memory_mib) = config.memory_mib { |
| 747 | command.arg("--mem").arg(memory_mib.to_string()); |
| 748 | } |
| 749 | |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 750 | if let Some(cpus) = config.cpus { |
| 751 | command.arg("--cpus").arg(cpus.to_string()); |
| 752 | } |
| 753 | |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 754 | if config.host_cpu_topology { |
David Brazdil | 25e8c05 | 2023-02-17 12:53:01 +0000 | [diff] [blame] | 755 | // TODO(b/266664564): replace with --host-cpu-topology once available |
| 756 | if let Some(cpus) = get_num_cpus() { |
| 757 | command.arg("--cpus").arg(cpus.to_string()); |
| 758 | } else { |
| 759 | bail!("Could not determine the number of CPUs in the system"); |
| 760 | } |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 761 | } |
| 762 | |
Jiyong Park | dfe16d6 | 2022-04-20 17:32:12 +0900 | [diff] [blame] | 763 | if !config.task_profiles.is_empty() { |
| 764 | command.arg("--task-profiles").arg(config.task_profiles.join(",")); |
| 765 | } |
| 766 | |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 767 | if let Some(gdb_port) = config.gdb_port { |
| 768 | command.arg("--gdb").arg(gdb_port.to_string()); |
| 769 | } |
| 770 | |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 771 | // Keep track of what file descriptors should be mapped to the crosvm process. |
| 772 | let mut preserved_fds = config.indirect_files.iter().map(|file| file.as_raw_fd()).collect(); |
| 773 | |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 774 | // Setup the serial devices. |
| 775 | // 1. uart device: used as the output device by bootloaders and as early console by linux |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 776 | // 2. uart device: used to report the reason for the VM failing. |
| 777 | // 3. virtio-console device: used as the console device where kmsg is redirected to |
Jiyong Park | 4afe201 | 2022-07-08 05:38:49 +0900 | [diff] [blame] | 778 | // 4. virtio-console device: used as the ramdump output |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 779 | // 5. virtio-console device: used as the logcat output |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 780 | // |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 781 | // When [console|log]_fd is not specified, the devices are attached to sink, which means what's |
| 782 | // written there is discarded. |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 783 | let console_arg = format_serial_arg(&mut preserved_fds, &config.console_fd); |
| 784 | let log_arg = format_serial_arg(&mut preserved_fds, &config.log_fd); |
| 785 | let failure_serial_path = add_preserved_fd(&mut preserved_fds, &failure_pipe_write); |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 786 | let ramdump_arg = format_serial_arg(&mut preserved_fds, &config.ramdump); |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 787 | |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 788 | // Warning: Adding more serial devices requires you to shift the PCI device ID of the boot |
| 789 | // disks in bootconfig.x86_64. This is because x86 crosvm puts serial devices and the block |
| 790 | // devices in the same PCI bus and serial devices comes before the block devices. Arm crosvm |
| 791 | // doesn't have the issue. |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 792 | // /dev/ttyS0 |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 793 | command.arg(format!("--serial={},hardware=serial,num=1", &console_arg)); |
| 794 | // /dev/ttyS1 |
| 795 | command.arg(format!("--serial=type=file,path={},hardware=serial,num=2", &failure_serial_path)); |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 796 | // /dev/hvc0 |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 797 | command.arg(format!("--serial={},hardware=virtio-console,num=1", &console_arg)); |
Jiyong Park | 4afe201 | 2022-07-08 05:38:49 +0900 | [diff] [blame] | 798 | // /dev/hvc1 |
| 799 | command.arg(format!("--serial={},hardware=virtio-console,num=2", &ramdump_arg)); |
Jiyong Park | ae5a4ed | 2021-11-01 18:36:28 +0900 | [diff] [blame] | 800 | // /dev/hvc2 |
| 801 | command.arg(format!("--serial={},hardware=virtio-console,num=3", &log_arg)); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 802 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 803 | if let Some(bootloader) = &config.bootloader { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 804 | command.arg("--bios").arg(add_preserved_fd(&mut preserved_fds, bootloader)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 805 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 806 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 807 | if let Some(initrd) = &config.initrd { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 808 | command.arg("--initrd").arg(add_preserved_fd(&mut preserved_fds, initrd)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 809 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 810 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 811 | if let Some(params) = &config.params { |
| 812 | command.arg("--params").arg(params); |
| 813 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 814 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 815 | for disk in &config.disks { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 816 | command |
| 817 | .arg(if disk.writable { "--rwdisk" } else { "--disk" }) |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 818 | .arg(add_preserved_fd(&mut preserved_fds, &disk.image)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 819 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 820 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 821 | if let Some(kernel) = &config.kernel { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 822 | command.arg(add_preserved_fd(&mut preserved_fds, kernel)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 823 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 824 | |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 825 | let control_server_socket = UnixSeqpacketListener::bind(crosvm_control_socket_path) |
| 826 | .context("failed to create control server")?; |
Elie Kheirallah | 2d12ff3 | 2023-03-20 18:12:07 +0000 | [diff] [blame] | 827 | command |
| 828 | .arg("--socket") |
| 829 | .arg(add_preserved_fd(&mut preserved_fds, &control_server_socket.as_raw_descriptor())); |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 830 | |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 831 | debug!("Preserving FDs {:?}", preserved_fds); |
| 832 | command.preserved_fds(preserved_fds); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 833 | |
Jiyong Park | 2d73656 | 2022-10-24 22:40:12 +0900 | [diff] [blame] | 834 | print_crosvm_args(&command); |
| 835 | |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 836 | let result = SharedChild::spawn(&mut command)?; |
Jooyung Han | bfe086f | 2021-10-28 10:15:45 +0900 | [diff] [blame] | 837 | debug!("Spawned crosvm({}).", result.id()); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 838 | Ok(result) |
| 839 | } |
| 840 | |
| 841 | /// 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] | 842 | fn validate_config(config: &CrosvmConfig) -> Result<(), Error> { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 843 | if config.bootloader.is_none() && config.kernel.is_none() { |
| 844 | bail!("VM must have either a bootloader or a kernel image."); |
| 845 | } |
| 846 | if config.bootloader.is_some() && (config.kernel.is_some() || config.initrd.is_some()) { |
| 847 | bail!("Can't have both bootloader and kernel/initrd image."); |
| 848 | } |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 849 | let version = Version::parse(CROSVM_PLATFORM_VERSION).unwrap(); |
| 850 | if !config.platform_version.matches(&version) { |
| 851 | bail!( |
| 852 | "Incompatible platform version. The config is compatible with platform version(s) \ |
| 853 | {}, but the actual platform version is {}", |
| 854 | config.platform_version, |
| 855 | version |
| 856 | ); |
| 857 | } |
| 858 | |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 859 | Ok(()) |
| 860 | } |
| 861 | |
Jiyong Park | 2d73656 | 2022-10-24 22:40:12 +0900 | [diff] [blame] | 862 | /// Print arguments of the crosvm command. In doing so, /proc/self/fd/XX is annotated with the |
| 863 | /// actual file path if the FD is backed by a regular file. If not, the /proc path is printed |
| 864 | /// unmodified. |
| 865 | fn print_crosvm_args(command: &Command) { |
| 866 | let re = Regex::new(r"/proc/self/fd/[\d]+").unwrap(); |
| 867 | info!( |
| 868 | "Running crosvm with args: {:?}", |
| 869 | command |
| 870 | .get_args() |
| 871 | .map(|s| s.to_string_lossy()) |
| 872 | .map(|s| { |
| 873 | re.replace_all(&s, |caps: &Captures| { |
| 874 | let path = &caps[0]; |
| 875 | if let Ok(realpath) = std::fs::canonicalize(path) { |
| 876 | format!("{} ({})", path, realpath.to_string_lossy()) |
| 877 | } else { |
| 878 | path.to_owned() |
| 879 | } |
| 880 | }) |
| 881 | .into_owned() |
| 882 | }) |
| 883 | .collect::<Vec<_>>() |
| 884 | ); |
| 885 | } |
| 886 | |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 887 | /// Adds the file descriptor for `file` to `preserved_fds`, and returns a string of the form |
| 888 | /// "/proc/self/fd/N" where N is the file descriptor. |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 889 | fn add_preserved_fd(preserved_fds: &mut Vec<RawFd>, file: &dyn AsRawFd) -> String { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 890 | let fd = file.as_raw_fd(); |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 891 | preserved_fds.push(fd); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 892 | format!("/proc/self/fd/{}", fd) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 893 | } |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 894 | |
| 895 | /// Adds the file descriptor for `file` (if any) to `preserved_fds`, and returns the appropriate |
| 896 | /// string for a crosvm `--serial` flag. If `file` is none, creates a dummy sink device. |
| 897 | fn format_serial_arg(preserved_fds: &mut Vec<RawFd>, file: &Option<File>) -> String { |
| 898 | if let Some(file) = file { |
| 899 | format!("type=file,path={}", add_preserved_fd(preserved_fds, file)) |
| 900 | } else { |
| 901 | "type=sink".to_string() |
| 902 | } |
| 903 | } |
| 904 | |
| 905 | /// Creates a new pipe with the `O_CLOEXEC` flag set, and returns the read side and write side. |
| 906 | fn create_pipe() -> Result<(File, File), Error> { |
| 907 | let (raw_read, raw_write) = pipe2(OFlag::O_CLOEXEC)?; |
| 908 | // SAFETY: We are the sole owners of these fds as they were just created. |
| 909 | let read_fd = unsafe { File::from_raw_fd(raw_read) }; |
| 910 | let write_fd = unsafe { File::from_raw_fd(raw_write) }; |
| 911 | Ok((read_fd, write_fd)) |
| 912 | } |