blob: 97a27e04977299515f7d4b558cc08d657036f43b [file] [log] [blame]
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001// Copyright 2021, The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15//! Functions for running instances of `crosvm`.
16
David Brazdil4b4c5102022-12-19 22:56:20 +000017use crate::aidl::{remove_temporary_files, Cid, VirtualMachineCallbacks};
Seungjae Yoob2db3d22023-04-06 18:05:43 +090018use crate::atom::{get_num_cpus, write_vm_exited_stats_sync};
Jaewan Kim61f86142023-03-28 15:12:52 +090019use crate::debug_config::DebugConfig;
Seungjae Yoo6d265d92022-11-15 10:51:33 +090020use anyhow::{anyhow, bail, Context, Error, Result};
Andrew Walbran02b8ec02021-06-22 13:07:02 +000021use command_fds::CommandFdExt;
Jiyong Parke6ed0f92022-06-22 00:13:00 +090022use lazy_static::lazy_static;
Seungjae Yoo6d265d92022-11-15 10:51:33 +090023use libc::{sysconf, _SC_CLK_TCK};
Andrew Walbran3a5a9212021-05-04 17:09:08 +000024use log::{debug, error, info};
Jiyong Parkdcf17412022-02-08 15:07:23 +090025use semver::{Version, VersionReq};
Jiyong Park08eee7b2022-11-11 15:01:26 +090026use nix::{fcntl::OFlag, unistd::pipe2, unistd::Uid, unistd::User};
Jiyong Park2d736562022-10-24 22:40:12 +090027use regex::{Captures, Regex};
Keir Fraserf25cb922022-11-23 14:26:00 +000028use rustutils::system_properties;
Andrew Walbrandae07162021-03-12 17:05:20 +000029use shared_child::SharedChild;
Jiyong Parke6ed0f92022-06-22 00:13:00 +090030use std::borrow::Cow;
Seungjae Yoo6d265d92022-11-15 10:51:33 +090031use std::cmp::max;
Jiyong Park08eee7b2022-11-11 15:01:26 +090032use std::fmt;
David Brazdil4b4c5102022-12-19 22:56:20 +000033use std::fs::{read_to_string, File};
Andrew Walbranb27681f2022-02-23 15:11:52 +000034use std::io::{self, Read};
Andrew Walbranf8d94112021-09-07 11:45:36 +000035use std::mem;
Nikita Ioffe5776f082023-02-10 21:38:26 +000036use std::num::{NonZeroU16, NonZeroU32};
Andrew Walbranb27681f2022-02-23 15:11:52 +000037use std::os::unix::io::{AsRawFd, RawFd, FromRawFd};
Seungjae Yoo93430e82022-12-05 16:37:42 +090038use std::os::unix::process::ExitStatusExt;
Jiyong Park1612b902022-08-22 14:47:39 +090039use std::path::{Path, PathBuf};
Andrew Walbranc92d35f2022-01-12 12:45:19 +000040use std::process::{Command, ExitStatus};
Jiyong Parke6ed0f92022-06-22 00:13:00 +090041use std::sync::{Arc, Condvar, Mutex};
Seungjae Yoo2e7beea2022-08-24 16:09:12 +090042use std::time::{Duration, SystemTime};
David Brazdilf18e1162022-12-18 18:27:23 +000043use std::thread::{self, JoinHandle};
David Brazdil49f96f52022-12-16 21:29:13 +000044use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::DeathReason::DeathReason;
Jaewan Kim84b91212023-02-28 00:11:57 +090045use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
46 MemoryTrimLevel::MemoryTrimLevel,
47 VirtualMachineAppConfig::DebugLevel::DebugLevel
48};
David Brazdil528e0472022-10-10 15:06:02 +010049use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IGlobalVmContext::IGlobalVmContext;
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +000050use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IBoundDevice::IBoundDevice;
Alan Stokes0e82b502022-08-08 14:44:48 +010051use binder::Strong;
Inseob Kimc7d28c72021-10-25 14:28:10 +000052use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService;
Jiyong Park1612b902022-08-22 14:47:39 +090053use tombstoned_client::{TombstonedConnection, DebuggerdDumpType};
David Brazdil73988ea2022-11-11 15:10:32 +000054use rpcbinder::RpcServer;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000055
Keir Fraser13a956a2022-07-14 14:20:46 +000056/// external/crosvm
Elie Kheirallah2d12ff32023-03-20 18:12:07 +000057use base::AsRawDescriptor;
Keir Fraser13a956a2022-07-14 14:20:46 +000058use base::UnixSeqpacketListener;
Keir Frasercdd4b112022-11-24 14:02:25 +000059use vm_control::{BalloonControlCommand, VmRequest, VmResponse};
Keir Fraser13a956a2022-07-14 14:20:46 +000060
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000061const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm";
62
Jiyong Parkdcf17412022-02-08 15:07:23 +090063/// Version of the platform that crosvm currently implements. The format follows SemVer. This
64/// should be updated when there is a platform change in the crosvm side. Having this value here is
65/// fine because virtualizationservice and crosvm are supposed to be updated together in the virt
66/// APEX.
67const CROSVM_PLATFORM_VERSION: &str = "1.0.0";
68
Andrew Walbrand15c5632022-02-03 13:38:31 +000069/// The exit status which crosvm returns when it has an error starting a VM.
Alan Stokes7c459e82022-12-06 12:21:49 +000070const CROSVM_START_ERROR_STATUS: i32 = 1;
Andrew Walbranc92d35f2022-01-12 12:45:19 +000071/// The exit status which crosvm returns when a VM requests a reboot.
72const CROSVM_REBOOT_STATUS: i32 = 32;
Andrew Walbrand15c5632022-02-03 13:38:31 +000073/// The exit status which crosvm returns when it crashes due to an error.
74const CROSVM_CRASH_STATUS: i32 = 33;
Sebastian Ene23167d82022-10-07 14:09:53 +000075/// The exit status which crosvm returns when vcpu is stalled.
76const CROSVM_WATCHDOG_REBOOT_STATUS: i32 = 36;
Jiyong Park3115cdb2023-02-24 18:04:44 +090077/// The size of memory (in MiB) reserved for ramdump
78const RAMDUMP_RESERVED_MIB: u32 = 17;
Andrew Walbranc92d35f2022-01-12 12:45:19 +000079
Seungjae Yoo6d265d92022-11-15 10:51:33 +090080const MILLIS_PER_SEC: i64 = 1000;
81
Jaewan Kim46422812022-11-25 10:59:39 +090082const SYSPROP_CUSTOM_PVMFW_PATH: &str = "hypervisor.pvmfw.path";
83
Jiyong Parke6ed0f92022-06-22 00:13:00 +090084lazy_static! {
85 /// If the VM doesn't move to the Started state within this amount time, a hang-up error is
86 /// triggered.
Alan Stokesc3f2ac22022-06-23 12:19:46 +010087 static ref BOOT_HANGUP_TIMEOUT: Duration = if nested_virt::is_nested_virtualization().unwrap() {
Jiyong Parke6ed0f92022-06-22 00:13:00 +090088 // Nested virtualization is slow, so we need a longer timeout.
Inseob Kime557cec2023-01-26 22:49:58 +090089 Duration::from_secs(300)
Jiyong Parke6ed0f92022-06-22 00:13:00 +090090 } else {
Inseob Kime557cec2023-01-26 22:49:58 +090091 Duration::from_secs(30)
Jiyong Parke6ed0f92022-06-22 00:13:00 +090092 };
93}
94
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000095/// Configuration for a VM to run with crosvm.
96#[derive(Debug)]
Andrew Walbrand3a84182021-09-07 14:48:52 +000097pub struct CrosvmConfig {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000098 pub cid: Cid,
Seungjae Yoo62085c02022-08-12 04:44:52 +000099 pub name: String,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000100 pub bootloader: Option<File>,
101 pub kernel: Option<File>,
102 pub initrd: Option<File>,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000103 pub disks: Vec<DiskFile>,
104 pub params: Option<String>,
Andrew Walbranf8650422021-06-09 15:54:09 +0000105 pub protected: bool,
Jaewan Kim61f86142023-03-28 15:12:52 +0900106 pub debug_config: DebugConfig,
Andrew Walbranb15cd6e2021-07-05 16:38:07 +0000107 pub memory_mib: Option<NonZeroU32>,
Jiyong Park032615f2022-01-10 13:55:34 +0900108 pub cpus: Option<NonZeroU32>,
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000109 pub host_cpu_topology: bool,
Jiyong Parke6fb1672023-06-26 16:45:55 +0900110 pub console_out_fd: Option<File>,
111 pub console_in_fd: Option<File>,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000112 pub log_fd: Option<File>,
Jiyong Parke558ab12022-07-07 20:18:55 +0900113 pub ramdump: Option<File>,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000114 pub indirect_files: Vec<File>,
Jiyong Parkdcf17412022-02-08 15:07:23 +0900115 pub platform_version: VersionReq,
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900116 pub detect_hangup: bool,
Nikita Ioffe5776f082023-02-10 21:38:26 +0000117 pub gdb_port: Option<NonZeroU16>,
Inseob Kim7307a892023-09-14 13:37:58 +0900118 pub vfio_devices: Vec<VfioDevice>,
David Brazdil2dfefd12023-11-17 14:07:36 +0000119 pub dtbo: Option<File>,
Shikha Panwar55e10ec2024-02-13 12:53:49 +0000120 pub device_tree_overlay: Option<File>,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000121}
122
123/// A disk image to pass to crosvm for a VM.
124#[derive(Debug)]
125pub struct DiskFile {
126 pub image: File,
127 pub writable: bool,
128}
129
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000130type VfioDevice = Strong<dyn IBoundDevice>;
Inseob Kim7307a892023-09-14 13:37:58 +0900131
Andrew Walbran6b650662021-09-07 13:13:23 +0000132/// The lifecycle state which the payload in the VM has reported itself to be in.
133///
134/// Note that the order of enum variants is significant; only forward transitions are allowed by
135/// [`VmInstance::update_payload_state`].
136#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
137pub enum PayloadState {
138 Starting,
139 Started,
140 Ready,
141 Finished,
Jiyong Parka4eebde2022-07-12 18:01:12 +0900142 Hangup, // Hasn't reached to Ready before timeout expires
Andrew Walbran6b650662021-09-07 13:13:23 +0000143}
144
Andrew Walbranf8d94112021-09-07 11:45:36 +0000145/// The current state of the VM itself.
146#[derive(Debug)]
147pub enum VmState {
148 /// The VM has not yet tried to start.
149 NotStarted {
150 ///The configuration needed to start the VM, if it has not yet been started.
Inseob Kim7307a892023-09-14 13:37:58 +0900151 config: Box<CrosvmConfig>,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000152 },
153 /// The VM has been started.
154 Running {
155 /// The crosvm child process.
156 child: Arc<SharedChild>,
David Brazdilf18e1162022-12-18 18:27:23 +0000157 /// The thread waiting for crosvm to finish.
158 monitor_vm_exit_thread: Option<JoinHandle<()>>,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000159 },
160 /// The VM died or was killed.
161 Dead,
162 /// The VM failed to start.
163 Failed,
164}
165
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900166/// RSS values of VM and CrosVM process itself.
167#[derive(Copy, Clone, Debug, Default)]
168pub struct Rss {
169 pub vm: i64,
170 pub crosvm: i64,
171}
172
173/// Metrics regarding the VM.
174#[derive(Debug, Default)]
175pub struct VmMetric {
176 /// Recorded timestamp when the VM is started.
177 pub start_timestamp: Option<SystemTime>,
Pierre-Clément Tosi44aba642023-09-15 11:44:34 +0100178 /// Update most recent guest_time periodically from /proc/[crosvm pid]/stat while VM is
179 /// running.
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900180 pub cpu_guest_time: Option<i64>,
181 /// Update maximum RSS values periodically from /proc/[crosvm pid]/smaps while VM is running.
182 pub rss: Option<Rss>,
183}
184
Andrew Walbranf8d94112021-09-07 11:45:36 +0000185impl VmState {
186 /// Tries to start the VM, if it is in the `NotStarted` state.
187 ///
188 /// Returns an error if the VM is in the wrong state, or fails to start.
189 fn start(&mut self, instance: Arc<VmInstance>) -> Result<(), Error> {
190 let state = mem::replace(self, VmState::Failed);
191 if let VmState::NotStarted { config } = state {
Inseob Kim7307a892023-09-14 13:37:58 +0900192 let config = *config;
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900193 let detect_hangup = config.detect_hangup;
Andrew Walbranb27681f2022-02-23 15:11:52 +0000194 let (failure_pipe_read, failure_pipe_write) = create_pipe()?;
Inseob Kim6ef80972023-07-20 17:23:36 +0900195 let vfio_devices = config.vfio_devices.clone();
Andrew Walbranb27681f2022-02-23 15:11:52 +0000196
Andrew Walbranf8d94112021-09-07 11:45:36 +0000197 // If this fails and returns an error, `self` will be left in the `Failed` state.
Keir Fraser13a956a2022-07-14 14:20:46 +0000198 let child =
Keir Frasercdd4b112022-11-24 14:02:25 +0000199 Arc::new(run_vm(config, &instance.crosvm_control_socket_path, failure_pipe_write)?);
Andrew Walbranf8d94112021-09-07 11:45:36 +0000200
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900201 let instance_monitor_status = instance.clone();
202 let child_monitor_status = child.clone();
203 thread::spawn(move || {
204 instance_monitor_status.clone().monitor_vm_status(child_monitor_status);
205 });
206
Andrew Walbranf8d94112021-09-07 11:45:36 +0000207 let child_clone = child.clone();
Jiyong Parka4eebde2022-07-12 18:01:12 +0900208 let instance_clone = instance.clone();
David Brazdilf18e1162022-12-18 18:27:23 +0000209 let monitor_vm_exit_thread = Some(thread::spawn(move || {
Inseob Kim6ef80972023-07-20 17:23:36 +0900210 instance_clone.monitor_vm_exit(child_clone, failure_pipe_read, vfio_devices);
David Brazdilf18e1162022-12-18 18:27:23 +0000211 }));
Andrew Walbranf8d94112021-09-07 11:45:36 +0000212
Jiyong Parka4eebde2022-07-12 18:01:12 +0900213 if detect_hangup {
214 let child_clone = child.clone();
215 thread::spawn(move || {
216 instance.monitor_payload_hangup(child_clone);
217 });
218 }
219
Andrew Walbranf8d94112021-09-07 11:45:36 +0000220 // If it started correctly, update the state.
David Brazdilf18e1162022-12-18 18:27:23 +0000221 *self = VmState::Running { child, monitor_vm_exit_thread };
Andrew Walbranf8d94112021-09-07 11:45:36 +0000222 Ok(())
223 } else {
224 *self = state;
225 bail!("VM already started or failed")
226 }
227 }
228}
229
David Brazdil8cf8f482022-11-23 14:21:26 +0000230/// Internal struct that holds the handles to globally unique resources of a VM.
231#[derive(Debug)]
232pub struct VmContext {
233 #[allow(dead_code)] // Keeps the global context alive
234 global_context: Strong<dyn IGlobalVmContext>,
235 #[allow(dead_code)] // Keeps the server alive
236 vm_server: RpcServer,
237}
238
239impl VmContext {
240 /// Construct new VmContext.
241 pub fn new(global_context: Strong<dyn IGlobalVmContext>, vm_server: RpcServer) -> VmContext {
242 VmContext { global_context, vm_server }
243 }
244}
245
Andrew Walbranf8d94112021-09-07 11:45:36 +0000246/// Information about a particular instance of a VM which may be running.
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000247#[derive(Debug)]
248pub struct VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000249 /// The current state of the VM.
250 pub vm_state: Mutex<VmState>,
David Brazdil8cf8f482022-11-23 14:21:26 +0000251 /// Global resources allocated for this VM.
252 #[allow(dead_code)] // Keeps the context alive
253 vm_context: VmContext,
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000254 /// The CID assigned to the VM for vsock communication.
255 pub cid: Cid,
Keir Frasercdd4b112022-11-24 14:02:25 +0000256 /// Path to crosvm control socket
257 crosvm_control_socket_path: PathBuf,
Seungjae Yoo62085c02022-08-12 04:44:52 +0000258 /// The name of the VM.
259 pub name: String,
Andrew Walbranf8650422021-06-09 15:54:09 +0000260 /// Whether the VM is a protected VM.
261 pub protected: bool,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000262 /// Directory of temporary files used by the VM while it is running.
263 pub temporary_directory: PathBuf,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000264 /// The UID of the process which requested the VM.
265 pub requester_uid: u32,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000266 /// The PID of the process which requested the VM. Note that this process may no longer exist
267 /// and the PID may have been reused for a different process, so this should not be trusted.
Andrew Walbran02034492021-04-13 15:05:07 +0000268 pub requester_debug_pid: i32,
Andrew Walbrandae07162021-03-12 17:05:20 +0000269 /// Callbacks to clients of the VM.
270 pub callbacks: VirtualMachineCallbacks,
Inseob Kimc7d28c72021-10-25 14:28:10 +0000271 /// VirtualMachineService binder object for the VM.
272 pub vm_service: Mutex<Option<Strong<dyn IVirtualMachineService>>>,
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900273 /// Recorded metrics of VM such as timestamp or cpu / memory usage.
274 pub vm_metric: Mutex<VmMetric>,
Andrew Walbran6b650662021-09-07 13:13:23 +0000275 /// The latest lifecycle state which the payload reported itself to be in.
276 payload_state: Mutex<PayloadState>,
Jiyong Parka4eebde2022-07-12 18:01:12 +0900277 /// Represents the condition that payload_state was updated
278 payload_state_updated: Condvar,
Jiyong Park08eee7b2022-11-11 15:01:26 +0900279 /// The human readable name of requester_uid
280 requester_uid_name: String,
281}
282
283impl fmt::Display for VmInstance {
284 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
285 let adj = if self.protected { "Protected" } else { "Non-protected" };
286 write!(
287 f,
288 "{} virtual machine \"{}\" (owner: {}, cid: {})",
289 adj, self.name, self.requester_uid_name, self.cid
290 )
291 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000292}
293
294impl VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000295 /// Validates the given config and creates a new `VmInstance` but doesn't start running it.
296 pub fn new(
Andrew Walbrand3a84182021-09-07 14:48:52 +0000297 config: CrosvmConfig,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000298 temporary_directory: PathBuf,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000299 requester_uid: u32,
Andrew Walbran02034492021-04-13 15:05:07 +0000300 requester_debug_pid: i32,
David Brazdil8cf8f482022-11-23 14:21:26 +0000301 vm_context: VmContext,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000302 ) -> Result<VmInstance, Error> {
303 validate_config(&config)?;
Andrew Walbrand3a84182021-09-07 14:48:52 +0000304 let cid = config.cid;
Seungjae Yoo62085c02022-08-12 04:44:52 +0000305 let name = config.name.clone();
Andrew Walbrand3a84182021-09-07 14:48:52 +0000306 let protected = config.protected;
Jiyong Park08eee7b2022-11-11 15:01:26 +0900307 let requester_uid_name = User::from_uid(Uid::from_raw(requester_uid))
308 .ok()
309 .flatten()
310 .map_or_else(|| format!("{}", requester_uid), |u| u.name);
311 let instance = VmInstance {
Inseob Kim7307a892023-09-14 13:37:58 +0900312 vm_state: Mutex::new(VmState::NotStarted { config: Box::new(config) }),
David Brazdil528e0472022-10-10 15:06:02 +0100313 vm_context,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000314 cid,
Keir Frasercdd4b112022-11-24 14:02:25 +0000315 crosvm_control_socket_path: temporary_directory.join("crosvm.sock"),
Seungjae Yoo62085c02022-08-12 04:44:52 +0000316 name,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000317 protected,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000318 temporary_directory,
Andrew Walbran02034492021-04-13 15:05:07 +0000319 requester_uid,
Andrew Walbran02034492021-04-13 15:05:07 +0000320 requester_debug_pid,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000321 callbacks: Default::default(),
Inseob Kimc7d28c72021-10-25 14:28:10 +0000322 vm_service: Mutex::new(None),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900323 vm_metric: Mutex::new(Default::default()),
Andrew Walbranf8d94112021-09-07 11:45:36 +0000324 payload_state: Mutex::new(PayloadState::Starting),
Jiyong Parka4eebde2022-07-12 18:01:12 +0900325 payload_state_updated: Condvar::new(),
Jiyong Park08eee7b2022-11-11 15:01:26 +0900326 requester_uid_name,
327 };
328 info!("{} created", &instance);
329 Ok(instance)
Andrew Walbrandae07162021-03-12 17:05:20 +0000330 }
331
Andrew Walbranf8d94112021-09-07 11:45:36 +0000332 /// Starts an instance of `crosvm` to manage the VM. The `crosvm` instance will be killed when
333 /// the `VmInstance` is dropped.
334 pub fn start(self: &Arc<Self>) -> Result<(), Error> {
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900335 let mut vm_metric = self.vm_metric.lock().unwrap();
336 vm_metric.start_timestamp = Some(SystemTime::now());
Jiyong Park08eee7b2022-11-11 15:01:26 +0900337 let ret = self.vm_state.lock().unwrap().start(self.clone());
338 if ret.is_ok() {
339 info!("{} started", &self);
340 }
341 ret.with_context(|| format!("{} failed to start", &self))
Andrew Walbranf8d94112021-09-07 11:45:36 +0000342 }
343
Jiyong Parka4eebde2022-07-12 18:01:12 +0900344 /// Monitors the exit of the VM (i.e. termination of the `child` process). When that happens,
345 /// handles the event by updating the state, noityfing the event to clients by calling
346 /// callbacks, and removing temporary files for the VM.
Inseob Kim6ef80972023-07-20 17:23:36 +0900347 fn monitor_vm_exit(
348 &self,
349 child: Arc<SharedChild>,
350 mut failure_pipe_read: File,
Inseob Kim7307a892023-09-14 13:37:58 +0900351 vfio_devices: Vec<VfioDevice>,
Inseob Kim6ef80972023-07-20 17:23:36 +0900352 ) {
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000353 let result = child.wait();
354 match &result {
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900355 Err(e) => error!("Error waiting for crosvm({}) instance to die: {}", child.id(), e),
Sebastian Ene23167d82022-10-07 14:09:53 +0000356 Ok(status) => {
357 info!("crosvm({}) exited with status {}", child.id(), status);
358 if let Some(exit_status_code) = status.code() {
359 if exit_status_code == CROSVM_WATCHDOG_REBOOT_STATUS {
360 info!("detected vcpu stall on crosvm");
361 }
362 }
363 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000364 }
Andrew Walbranf8d94112021-09-07 11:45:36 +0000365
366 let mut vm_state = self.vm_state.lock().unwrap();
367 *vm_state = VmState::Dead;
368 // Ensure that the mutex is released before calling the callbacks.
369 drop(vm_state);
Jiyong Park08eee7b2022-11-11 15:01:26 +0900370 info!("{} exited", &self);
Andrew Walbranf8d94112021-09-07 11:45:36 +0000371
Jiyong Parka4eebde2022-07-12 18:01:12 +0900372 // Read the pipe to see if any failure reason is written
373 let mut failure_reason = String::new();
374 match failure_pipe_read.read_to_string(&mut failure_reason) {
375 Err(e) => error!("Error reading VM failure reason from pipe: {}", e),
376 Ok(len) if len > 0 => info!("VM returned failure reason '{}'", &failure_reason),
377 _ => (),
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900378 };
Andrew Walbranb27681f2022-02-23 15:11:52 +0000379
Jiyong Parka4eebde2022-07-12 18:01:12 +0900380 // In case of hangup, the pipe doesn't give us any information because the hangup can't be
381 // detected on the VM side (otherwise, it isn't a hangup), but in the
382 // monitor_payload_hangup function below which updates the payload state to Hangup.
383 let failure_reason =
384 if failure_reason.is_empty() && self.payload_state() == PayloadState::Hangup {
385 Cow::from("HANGUP")
386 } else {
387 Cow::from(failure_reason)
388 };
389
Jiyong Parke558ab12022-07-07 20:18:55 +0900390 self.handle_ramdump().unwrap_or_else(|e| error!("Error handling ramdump: {}", e));
Seungjae Yoob4c07ba2022-08-12 04:44:52 +0000391
392 let death_reason = death_reason(&result, &failure_reason);
Seungjae Yoo93430e82022-12-05 16:37:42 +0900393 let exit_signal = exit_signal(&result);
394
Seungjae Yoob4c07ba2022-08-12 04:44:52 +0000395 self.callbacks.callback_on_died(self.cid, death_reason);
Seungjae Yoo2e7beea2022-08-24 16:09:12 +0900396
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900397 let vm_metric = self.vm_metric.lock().unwrap();
Seungjae Yoob2db3d22023-04-06 18:05:43 +0900398 write_vm_exited_stats_sync(
Seungjae Yoo93430e82022-12-05 16:37:42 +0900399 self.requester_uid as i32,
400 &self.name,
401 death_reason,
402 exit_signal,
Chris Wailes75269622022-12-05 23:01:44 -0800403 &vm_metric,
Seungjae Yoo93430e82022-12-05 16:37:42 +0900404 );
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000405
David Brazdil4b4c5102022-12-19 22:56:20 +0000406 // Delete temporary files. The folder itself is removed by VirtualizationServiceInternal.
407 remove_temporary_files(&self.temporary_directory).unwrap_or_else(|e| {
408 error!("Error removing temporary files from {:?}: {}", self.temporary_directory, e);
409 });
Inseob Kim6ef80972023-07-20 17:23:36 +0900410
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000411 drop(vfio_devices); // Cleanup devices.
Andrew Walbrandae07162021-03-12 17:05:20 +0000412 }
413
Jiyong Parka4eebde2022-07-12 18:01:12 +0900414 /// Waits until payload is started, or timeout expires. When timeout occurs, kill
415 /// the VM to prevent indefinite hangup and update the payload_state accordingly.
416 fn monitor_payload_hangup(&self, child: Arc<SharedChild>) {
417 debug!("Starting to monitor hangup for Microdroid({})", child.id());
418 let (_, result) = self
419 .payload_state_updated
420 .wait_timeout_while(self.payload_state.lock().unwrap(), *BOOT_HANGUP_TIMEOUT, |s| {
421 *s < PayloadState::Started
422 })
423 .unwrap();
424 let child_still_running = child.try_wait().ok() == Some(None);
425 if result.timed_out() && child_still_running {
426 error!(
427 "Microdroid({}) failed to start payload within {} secs timeout. Shutting down.",
428 child.id(),
429 BOOT_HANGUP_TIMEOUT.as_secs()
430 );
431 self.update_payload_state(PayloadState::Hangup).unwrap();
432 if let Err(e) = self.kill() {
433 error!("Error stopping timed-out VM with CID {}: {:?}", child.id(), e);
434 }
435 }
436 }
437
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900438 fn monitor_vm_status(&self, child: Arc<SharedChild>) {
439 let pid = child.id();
440
441 loop {
442 {
443 // Check VM state
444 let vm_state = &*self.vm_state.lock().unwrap();
445 if let VmState::Dead = vm_state {
446 break;
447 }
448
449 let mut vm_metric = self.vm_metric.lock().unwrap();
450
451 // Get CPU Information
Jiyong Park85ea5382024-02-19 15:04:23 +0900452 match get_guest_time(pid) {
453 Ok(guest_time) => vm_metric.cpu_guest_time = Some(guest_time),
454 Err(e) => error!("Failed to get guest CPU time: {e:?}"),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900455 }
456
457 // Get Memory Information
Jiyong Park85ea5382024-02-19 15:04:23 +0900458 match get_rss(pid) {
459 Ok(rss) => {
460 vm_metric.rss = match &vm_metric.rss {
461 Some(x) => Some(Rss::extract_max(x, &rss)),
462 None => Some(rss),
463 }
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900464 }
Jiyong Park85ea5382024-02-19 15:04:23 +0900465 Err(e) => error!("Failed to get guest RSS: {}", e),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900466 }
467 }
468
469 thread::sleep(Duration::from_secs(1));
470 }
471 }
472
Andrew Walbran6b650662021-09-07 13:13:23 +0000473 /// Returns the last reported state of the VM payload.
474 pub fn payload_state(&self) -> PayloadState {
475 *self.payload_state.lock().unwrap()
476 }
477
478 /// Updates the payload state to the given value, if it is a valid state transition.
479 pub fn update_payload_state(&self, new_state: PayloadState) -> Result<(), Error> {
480 let mut state_locked = self.payload_state.lock().unwrap();
481 // Only allow forward transitions, e.g. from starting to started or finished, not back in
482 // the other direction.
483 if new_state > *state_locked {
484 *state_locked = new_state;
Jiyong Parka4eebde2022-07-12 18:01:12 +0900485 self.payload_state_updated.notify_all();
Andrew Walbran6b650662021-09-07 13:13:23 +0000486 Ok(())
487 } else {
488 bail!("Invalid payload state transition from {:?} to {:?}", *state_locked, new_state)
489 }
490 }
491
Andrew Walbranf8d94112021-09-07 11:45:36 +0000492 /// Kills the crosvm instance, if it is running.
Inseob Kima446f802022-07-11 19:46:37 +0900493 pub fn kill(&self) -> Result<(), Error> {
David Brazdilf18e1162022-12-18 18:27:23 +0000494 let monitor_vm_exit_thread = {
495 let vm_state = &mut *self.vm_state.lock().unwrap();
496 if let VmState::Running { child, monitor_vm_exit_thread } = vm_state {
497 let id = child.id();
498 debug!("Killing crosvm({})", id);
499 // TODO: Talk to crosvm to shutdown cleanly.
500 child.kill().with_context(|| format!("Error killing crosvm({id}) instance"))?;
501 monitor_vm_exit_thread.take()
Inseob Kima446f802022-07-11 19:46:37 +0900502 } else {
David Brazdilf18e1162022-12-18 18:27:23 +0000503 bail!("VM is not running")
Andrew Walbranf8d94112021-09-07 11:45:36 +0000504 }
David Brazdilf18e1162022-12-18 18:27:23 +0000505 };
506
507 // Wait for monitor_vm_exit() to finish. Must release vm_state lock
508 // first, as monitor_vm_exit() takes it as well.
509 monitor_vm_exit_thread.map(JoinHandle::join);
510
David Brazdil5af55832023-03-08 13:08:56 +0000511 // Now that the VM has been killed, shut down the VirtualMachineService
512 // server to eagerly free up the server threads.
513 self.vm_context.vm_server.shutdown()?;
514
David Brazdilf18e1162022-12-18 18:27:23 +0000515 Ok(())
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000516 }
Jiyong Parke558ab12022-07-07 20:18:55 +0900517
Keir Frasercdd4b112022-11-24 14:02:25 +0000518 /// Responds to memory-trimming notifications by inflating the virtio
519 /// balloon to reclaim guest memory.
520 pub fn trim_memory(&self, level: MemoryTrimLevel) -> Result<(), Error> {
521 let request = VmRequest::BalloonCommand(BalloonControlCommand::Stats {});
522 match vm_control::client::handle_request(&request, &self.crosvm_control_socket_path) {
523 Ok(VmResponse::BalloonStats { stats, balloon_actual: _ }) => {
524 if let Some(total_memory) = stats.total_memory {
525 // Reclaim up to 50% of total memory assuming worst case
526 // most memory is anonymous and must be swapped to zram
527 // with an approximate 2:1 compression ratio.
528 let pct = match level {
529 MemoryTrimLevel::TRIM_MEMORY_RUNNING_CRITICAL => 50,
530 MemoryTrimLevel::TRIM_MEMORY_RUNNING_LOW => 30,
531 MemoryTrimLevel::TRIM_MEMORY_RUNNING_MODERATE => 10,
532 _ => bail!("Invalid memory trim level {:?}", level),
533 };
Devin Moore30be4482023-08-21 22:44:26 +0000534 let command = BalloonControlCommand::Adjust {
535 num_bytes: total_memory * pct / 100,
536 wait_for_success: false,
537 };
Keir Frasercdd4b112022-11-24 14:02:25 +0000538 if let Err(e) = vm_control::client::handle_request(
539 &VmRequest::BalloonCommand(command),
540 &self.crosvm_control_socket_path,
541 ) {
542 bail!("Error sending balloon adjustment: {:?}", e);
543 }
544 }
545 }
546 Ok(VmResponse::Err(e)) => {
Alice Wangeff58392023-07-04 13:32:09 +0000547 // ENOTSUP is returned when the balloon protocol is not initialized. This
Keir Frasercdd4b112022-11-24 14:02:25 +0000548 // can occur for numerous reasons: Guest is still booting, guest doesn't
549 // support ballooning, host doesn't support ballooning. We don't log or
550 // raise an error in this case: trim is just a hint and we can ignore it.
551 if e.errno() != libc::ENOTSUP {
552 bail!("Errno return when requesting balloon stats: {}", e.errno())
553 }
554 }
555 e => bail!("Error requesting balloon stats: {:?}", e),
556 }
557 Ok(())
558 }
559
Alan Stokes3e98d292022-12-14 15:18:22 +0000560 /// Checks if ramdump has been created. If so, send it to tombstoned.
Jiyong Parke558ab12022-07-07 20:18:55 +0900561 fn handle_ramdump(&self) -> Result<(), Error> {
562 let ramdump_path = self.temporary_directory.join("ramdump");
Jiyong Park933d2b22023-02-28 11:41:19 +0900563 if !ramdump_path.as_path().try_exists()? {
564 return Ok(());
565 }
Jiyong Parke558ab12022-07-07 20:18:55 +0900566 if std::fs::metadata(&ramdump_path)?.len() > 0 {
Jiyong Park1612b902022-08-22 14:47:39 +0900567 Self::send_ramdump_to_tombstoned(&ramdump_path)?;
Jiyong Parke558ab12022-07-07 20:18:55 +0900568 }
569 Ok(())
570 }
Jiyong Park1612b902022-08-22 14:47:39 +0900571
572 fn send_ramdump_to_tombstoned(ramdump_path: &Path) -> Result<(), Error> {
573 let mut input = File::open(ramdump_path)
Alan Stokes3e98d292022-12-14 15:18:22 +0000574 .context(format!("Failed to open ramdump {:?} for reading", ramdump_path))?;
Jiyong Park1612b902022-08-22 14:47:39 +0900575
576 let pid = std::process::id() as i32;
577 let conn = TombstonedConnection::connect(pid, DebuggerdDumpType::Tombstone)
578 .context("Failed to connect to tombstoned")?;
579 let mut output = conn
580 .text_output
581 .as_ref()
582 .ok_or_else(|| anyhow!("Could not get file to write the tombstones on"))?;
583
584 std::io::copy(&mut input, &mut output).context("Failed to send ramdump to tombstoned")?;
585 info!("Ramdump {:?} sent to tombstoned", ramdump_path);
586
587 conn.notify_completion()?;
588 Ok(())
589 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000590}
591
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900592impl Rss {
593 fn extract_max(x: &Rss, y: &Rss) -> Rss {
594 Rss { vm: max(x.vm, y.vm), crosvm: max(x.crosvm, y.crosvm) }
595 }
596}
597
David Daiaaecf652024-02-22 14:41:39 -0800598// Get Cpus_allowed mask
599fn check_if_all_cpus_allowed() -> Result<bool> {
600 let file = read_to_string("/proc/self/status")?;
601 let lines: Vec<_> = file.split('\n').collect();
602
603 for line in lines {
604 if line.contains("Cpus_allowed_list") {
605 let prop: Vec<_> = line.split_whitespace().collect();
606 if prop.len() != 2 {
607 return Ok(false);
608 }
609 let cpu_list: Vec<_> = prop[1].split('-').collect();
610 //Only contiguous Cpu list allowed
611 if cpu_list.len() != 2 {
612 return Ok(false);
613 }
614 if let Some(cpus) = get_num_cpus() {
615 let max_cpu = cpu_list[1].parse::<usize>()?;
616 if max_cpu == cpus - 1 {
617 return Ok(true);
618 } else {
619 return Ok(false);
620 }
621 }
622 }
623 }
624 Ok(false)
625}
626
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900627// Get guest time from /proc/[crosvm pid]/stat
628fn get_guest_time(pid: u32) -> Result<i64> {
629 let file = read_to_string(format!("/proc/{}/stat", pid))?;
630 let data_list: Vec<_> = file.split_whitespace().collect();
631
632 // Information about guest_time is at 43th place of the file split with the whitespace.
633 // Example of /proc/[pid]/stat :
634 // 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
635 // 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
636 if data_list.len() < 43 {
637 bail!("Failed to parse command result for getting guest time : {}", file);
638 }
639
640 let guest_time_ticks = data_list[42].parse::<i64>()?;
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100641 // SAFETY: It just returns an integer about CPU tick information.
Charisee96113f32023-01-26 09:00:42 +0000642 let ticks_per_sec = unsafe { sysconf(_SC_CLK_TCK) };
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900643 Ok(guest_time_ticks * MILLIS_PER_SEC / ticks_per_sec)
644}
645
646// Get rss from /proc/[crosvm pid]/smaps
647fn get_rss(pid: u32) -> Result<Rss> {
648 let file = read_to_string(format!("/proc/{}/smaps", pid))?;
649 let lines: Vec<_> = file.split('\n').collect();
650
651 let mut rss_vm_total = 0i64;
652 let mut rss_crosvm_total = 0i64;
653 let mut is_vm = false;
654 for line in lines {
655 if line.contains("crosvm_guest") {
656 is_vm = true;
657 } else if line.contains("Rss:") {
658 let data_list: Vec<_> = line.split_whitespace().collect();
659 if data_list.len() < 2 {
660 bail!("Failed to parse command result for getting rss :\n{}", line);
661 }
662 let rss = data_list[1].parse::<i64>()?;
663
664 if is_vm {
665 rss_vm_total += rss;
666 is_vm = false;
667 }
668 rss_crosvm_total += rss;
669 }
670 }
671
672 Ok(Rss { vm: rss_vm_total, crosvm: rss_crosvm_total })
673}
674
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100675fn death_reason(result: &Result<ExitStatus, io::Error>, mut failure_reason: &str) -> DeathReason {
Pierre-Clément Tosic0611e72023-09-15 11:41:07 +0100676 if let Some((reason, info)) = failure_reason.split_once('|') {
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100677 // Separator indicates extra context information is present after the failure name.
Pierre-Clément Tosic0611e72023-09-15 11:41:07 +0100678 error!("Failure info: {info}");
679 failure_reason = reason;
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100680 }
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000681 if let Ok(status) = result {
Andrew Walbranb27681f2022-02-23 15:11:52 +0000682 match failure_reason {
683 "PVM_FIRMWARE_PUBLIC_KEY_MISMATCH" => {
684 return DeathReason::PVM_FIRMWARE_PUBLIC_KEY_MISMATCH
685 }
686 "PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED" => {
687 return DeathReason::PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED
688 }
Inseob Kim272f5722022-06-13 17:14:51 +0900689 "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE" => {
690 return DeathReason::MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE
691 }
692 "MICRODROID_PAYLOAD_HAS_CHANGED" => return DeathReason::MICRODROID_PAYLOAD_HAS_CHANGED,
693 "MICRODROID_PAYLOAD_VERIFICATION_FAILED" => {
694 return DeathReason::MICRODROID_PAYLOAD_VERIFICATION_FAILED
695 }
696 "MICRODROID_INVALID_PAYLOAD_CONFIG" => {
697 return DeathReason::MICRODROID_INVALID_PAYLOAD_CONFIG
698 }
699 "MICRODROID_UNKNOWN_RUNTIME_ERROR" => {
700 return DeathReason::MICRODROID_UNKNOWN_RUNTIME_ERROR
701 }
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900702 "HANGUP" => return DeathReason::HANGUP,
Andrew Walbranb27681f2022-02-23 15:11:52 +0000703 _ => {}
704 }
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000705 match status.code() {
706 None => DeathReason::KILLED,
707 Some(0) => DeathReason::SHUTDOWN,
Alan Stokes7c459e82022-12-06 12:21:49 +0000708 Some(CROSVM_START_ERROR_STATUS) => DeathReason::START_FAILED,
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000709 Some(CROSVM_REBOOT_STATUS) => DeathReason::REBOOT,
Andrew Walbrand15c5632022-02-03 13:38:31 +0000710 Some(CROSVM_CRASH_STATUS) => DeathReason::CRASH,
Sebastian Ene23167d82022-10-07 14:09:53 +0000711 Some(CROSVM_WATCHDOG_REBOOT_STATUS) => DeathReason::WATCHDOG_REBOOT,
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000712 Some(_) => DeathReason::UNKNOWN,
713 }
714 } else {
715 DeathReason::INFRASTRUCTURE_ERROR
716 }
717}
718
Seungjae Yoo93430e82022-12-05 16:37:42 +0900719fn exit_signal(result: &Result<ExitStatus, io::Error>) -> Option<i32> {
720 match result {
721 Ok(status) => status.signal(),
722 Err(_) => None,
723 }
724}
725
Inseob Kim6ef80972023-07-20 17:23:36 +0900726const SYSFS_PLATFORM_DEVICES_PATH: &str = "/sys/devices/platform/";
727const VFIO_PLATFORM_DRIVER_PATH: &str = "/sys/bus/platform/drivers/vfio-platform";
728
Inseob Kim7307a892023-09-14 13:37:58 +0900729fn vfio_argument_for_platform_device(device: &VfioDevice) -> Result<String, Error> {
Inseob Kim6ef80972023-07-20 17:23:36 +0900730 // Check platform device exists
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000731 let path = Path::new(&device.getSysfsPath()?).canonicalize()?;
Inseob Kim6ef80972023-07-20 17:23:36 +0900732 if !path.starts_with(SYSFS_PLATFORM_DEVICES_PATH) {
733 bail!("{path:?} is not a platform device");
734 }
735
736 // Check platform device is bound to VFIO driver
737 let dev_driver_path = path.join("driver").canonicalize()?;
738 if dev_driver_path != Path::new(VFIO_PLATFORM_DRIVER_PATH) {
739 bail!("{path:?} is not bound to VFIO-platform driver");
740 }
741
742 if let Some(p) = path.to_str() {
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000743 Ok(format!("--vfio={p},iommu=pkvm-iommu,dt-symbol={0}", device.getDtboLabel()?))
Inseob Kim6ef80972023-07-20 17:23:36 +0900744 } else {
745 bail!("invalid path {path:?}");
746 }
747}
748
David Brazdil2dfefd12023-11-17 14:07:36 +0000749fn append_platform_devices(
750 command: &mut Command,
751 preserved_fds: &mut Vec<RawFd>,
752 config: &CrosvmConfig,
753) -> Result<(), Error> {
754 if config.vfio_devices.is_empty() {
755 return Ok(());
756 }
757
758 let Some(dtbo) = &config.dtbo else {
759 bail!("VFIO devices assigned but no DTBO available");
760 };
761 command.arg(format!("--device-tree-overlay={},filter", add_preserved_fd(preserved_fds, dtbo)));
762
Inseob Kim6ef80972023-07-20 17:23:36 +0900763 for device in &config.vfio_devices {
764 command.arg(vfio_argument_for_platform_device(device)?);
765 }
Inseob Kim6ef80972023-07-20 17:23:36 +0900766 Ok(())
767}
768
Andrew Walbrand3a84182021-09-07 14:48:52 +0000769/// Starts an instance of `crosvm` to manage a new VM.
Keir Fraser13a956a2022-07-14 14:20:46 +0000770fn run_vm(
771 config: CrosvmConfig,
Keir Frasercdd4b112022-11-24 14:02:25 +0000772 crosvm_control_socket_path: &Path,
Keir Fraser13a956a2022-07-14 14:20:46 +0000773 failure_pipe_write: File,
774) -> Result<SharedChild, Error> {
Andrew Walbrand3a84182021-09-07 14:48:52 +0000775 validate_config(&config)?;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000776
777 let mut command = Command::new(CROSVM_PATH);
778 // TODO(qwandor): Remove --disable-sandbox.
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000779 command
780 .arg("--extended-status")
Jiyong Park6c60fea2022-10-24 16:10:01 +0900781 // Configure the logger for the crosvm process to silence logs from the disk crate which
782 // don't provide much information to us (but do spamming us).
783 .arg("--log-level")
Frederick Mayle138f53c2023-01-24 18:55:26 -0800784 .arg("info,disk=warn")
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000785 .arg("run")
786 .arg("--disable-sandbox")
787 .arg("--cid")
788 .arg(config.cid.to_string());
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000789
Keir Fraserf25cb922022-11-23 14:26:00 +0000790 if system_properties::read_bool("hypervisor.memory_reclaim.supported", false)? {
791 command.arg("--balloon-page-reporting");
792 } else {
793 command.arg("--no-balloon");
794 }
795
Andrew Walbranf8650422021-06-09 15:54:09 +0000796 if config.protected {
Jaewan Kim46422812022-11-25 10:59:39 +0900797 match system_properties::read(SYSPROP_CUSTOM_PVMFW_PATH)? {
798 Some(pvmfw_path) if !pvmfw_path.is_empty() => {
799 command.arg("--protected-vm-with-firmware").arg(pvmfw_path)
800 }
801 _ => command.arg("--protected-vm"),
802 };
Andrew Walbran0b5789f2022-02-04 13:57:57 +0000803
804 // 3 virtio-console devices + vsock = 4.
805 let virtio_pci_device_count = 4 + config.disks.len();
806 // crosvm virtio queue has 256 entries, so 2 MiB per device (2 pages per entry) should be
807 // enough.
Jiyong Park3115cdb2023-02-24 18:04:44 +0900808 let swiotlb_size_mib = 2 * virtio_pci_device_count as u32;
Andrew Walbran0b5789f2022-02-04 13:57:57 +0000809 command.arg("--swiotlb").arg(swiotlb_size_mib.to_string());
Frederick Mayle58baa302023-02-14 19:06:37 -0800810
811 // Workaround to keep crash_dump from trying to read protected guest memory.
812 // Context in b/238324526.
813 command.arg("--unmap-guest-memory-on-fork");
Jiyong Park3115cdb2023-02-24 18:04:44 +0900814
Jiyong Parked180932023-02-24 19:55:41 +0900815 if config.ramdump.is_some() {
Jaewan Kim3124ef02023-03-23 19:25:20 +0900816 // Protected VM needs to reserve memory for ramdump here. Note that we reserve more
Jiyong Parked180932023-02-24 19:55:41 +0900817 // memory for the restricted dma pool.
818 let ramdump_reserve = RAMDUMP_RESERVED_MIB + swiotlb_size_mib;
819 command.arg("--params").arg(format!("crashkernel={ramdump_reserve}M"));
820 }
Jaewan Kimd4dae652023-03-28 13:45:43 +0900821 } else if config.ramdump.is_some() {
822 command.arg("--params").arg(format!("crashkernel={RAMDUMP_RESERVED_MIB}M"));
823 }
Jaewan Kim61f86142023-03-28 15:12:52 +0900824 if config.debug_config.debug_level == DebugLevel::NONE
825 && config.debug_config.should_prepare_console_output()
826 {
Jaewan Kimd4dae652023-03-28 13:45:43 +0900827 // bootconfig.normal will be used, but we need log.
828 command.arg("--params").arg("printk.devkmsg=on");
829 command.arg("--params").arg("console=hvc0");
Andrew Walbranf8650422021-06-09 15:54:09 +0000830 }
831
Andrew Walbranb15cd6e2021-07-05 16:38:07 +0000832 if let Some(memory_mib) = config.memory_mib {
833 command.arg("--mem").arg(memory_mib.to_string());
834 }
835
Jiyong Park032615f2022-01-10 13:55:34 +0900836 if let Some(cpus) = config.cpus {
837 command.arg("--cpus").arg(cpus.to_string());
838 }
839
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000840 if config.host_cpu_topology {
David Daiaaecf652024-02-22 14:41:39 -0800841 if cfg!(virt_cpufreq) && check_if_all_cpus_allowed()? {
David Daie6f5bb02024-01-25 19:17:02 -0800842 command.arg("--host-cpu-topology");
David Daic97e82d2024-02-17 12:10:31 -0800843 cfg_if::cfg_if! {
844 if #[cfg(any(target_arch = "aarch64"))] {
845 command.arg("--virt-cpufreq");
846 }
847 }
David Daie6f5bb02024-01-25 19:17:02 -0800848 } else if let Some(cpus) = get_num_cpus() {
David Brazdil25e8c052023-02-17 12:53:01 +0000849 command.arg("--cpus").arg(cpus.to_string());
850 } else {
851 bail!("Could not determine the number of CPUs in the system");
852 }
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000853 }
854
Nikita Ioffe5776f082023-02-10 21:38:26 +0000855 if let Some(gdb_port) = config.gdb_port {
856 command.arg("--gdb").arg(gdb_port.to_string());
857 }
858
Jiyong Parkfa91d702021-10-18 23:51:39 +0900859 // Keep track of what file descriptors should be mapped to the crosvm process.
860 let mut preserved_fds = config.indirect_files.iter().map(|file| file.as_raw_fd()).collect();
861
Jiyong Park747d6362021-10-19 17:12:52 +0900862 // Setup the serial devices.
863 // 1. uart device: used as the output device by bootloaders and as early console by linux
Andrew Walbranb27681f2022-02-23 15:11:52 +0000864 // 2. uart device: used to report the reason for the VM failing.
865 // 3. virtio-console device: used as the console device where kmsg is redirected to
Jiyong Park4afe2012022-07-08 05:38:49 +0900866 // 4. virtio-console device: used as the ramdump output
Andrew Walbranb27681f2022-02-23 15:11:52 +0000867 // 5. virtio-console device: used as the logcat output
Jiyong Park747d6362021-10-19 17:12:52 +0900868 //
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900869 // When [console|log]_fd is not specified, the devices are attached to sink, which means what's
870 // written there is discarded.
Jiyong Parke6fb1672023-06-26 16:45:55 +0900871 let console_out_arg = format_serial_out_arg(&mut preserved_fds, &config.console_out_fd);
872 let console_in_arg = config
873 .console_in_fd
874 .as_ref()
875 .map(|fd| format!(",input={}", add_preserved_fd(&mut preserved_fds, fd)))
876 .unwrap_or_default();
877 let log_arg = format_serial_out_arg(&mut preserved_fds, &config.log_fd);
Andrew Walbranb27681f2022-02-23 15:11:52 +0000878 let failure_serial_path = add_preserved_fd(&mut preserved_fds, &failure_pipe_write);
Jiyong Parke6fb1672023-06-26 16:45:55 +0900879 let ramdump_arg = format_serial_out_arg(&mut preserved_fds, &config.ramdump);
Jiyong Parkfa91d702021-10-18 23:51:39 +0900880
Jiyong Park747d6362021-10-19 17:12:52 +0900881 // Warning: Adding more serial devices requires you to shift the PCI device ID of the boot
882 // disks in bootconfig.x86_64. This is because x86 crosvm puts serial devices and the block
883 // devices in the same PCI bus and serial devices comes before the block devices. Arm crosvm
884 // doesn't have the issue.
Jiyong Parkfa91d702021-10-18 23:51:39 +0900885 // /dev/ttyS0
Jiyong Park34cf4342023-07-03 15:03:15 +0900886 command.arg(format!("--serial={},hardware=serial,num=1", &console_out_arg));
Andrew Walbranb27681f2022-02-23 15:11:52 +0000887 // /dev/ttyS1
888 command.arg(format!("--serial=type=file,path={},hardware=serial,num=2", &failure_serial_path));
Jiyong Parkfa91d702021-10-18 23:51:39 +0900889 // /dev/hvc0
Jiyong Parke6fb1672023-06-26 16:45:55 +0900890 command.arg(format!(
891 "--serial={}{},hardware=virtio-console,num=1",
892 &console_out_arg, &console_in_arg
893 ));
Jiyong Park4afe2012022-07-08 05:38:49 +0900894 // /dev/hvc1
895 command.arg(format!("--serial={},hardware=virtio-console,num=2", &ramdump_arg));
Jiyong Parkae5a4ed2021-11-01 18:36:28 +0900896 // /dev/hvc2
897 command.arg(format!("--serial={},hardware=virtio-console,num=3", &log_arg));
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000898
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000899 if let Some(bootloader) = &config.bootloader {
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000900 command.arg("--bios").arg(add_preserved_fd(&mut preserved_fds, bootloader));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000901 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000902
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000903 if let Some(initrd) = &config.initrd {
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000904 command.arg("--initrd").arg(add_preserved_fd(&mut preserved_fds, initrd));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000905 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000906
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000907 if let Some(params) = &config.params {
908 command.arg("--params").arg(params);
909 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000910
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000911 for disk in &config.disks {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000912 command
913 .arg(if disk.writable { "--rwdisk" } else { "--disk" })
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000914 .arg(add_preserved_fd(&mut preserved_fds, &disk.image));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000915 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000916
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000917 if let Some(kernel) = &config.kernel {
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000918 command.arg(add_preserved_fd(&mut preserved_fds, kernel));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000919 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000920
Keir Frasercdd4b112022-11-24 14:02:25 +0000921 let control_server_socket = UnixSeqpacketListener::bind(crosvm_control_socket_path)
922 .context("failed to create control server")?;
Elie Kheirallah2d12ff32023-03-20 18:12:07 +0000923 command
924 .arg("--socket")
925 .arg(add_preserved_fd(&mut preserved_fds, &control_server_socket.as_raw_descriptor()));
Keir Fraser13a956a2022-07-14 14:20:46 +0000926
Shikha Panwar55e10ec2024-02-13 12:53:49 +0000927 if let Some(dt_overlay) = &config.device_tree_overlay {
928 command.arg("--device-tree-overlay").arg(add_preserved_fd(&mut preserved_fds, dt_overlay));
Seungjae Yoo4dd38182023-11-09 15:05:45 +0900929 }
Seungjae Yooec3bc522023-11-09 10:14:30 +0900930
David Brazdil2dfefd12023-11-17 14:07:36 +0000931 append_platform_devices(&mut command, &mut preserved_fds, &config)?;
Inseob Kim6ef80972023-07-20 17:23:36 +0900932
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000933 debug!("Preserving FDs {:?}", preserved_fds);
934 command.preserved_fds(preserved_fds);
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000935
Jiyong Park2d736562022-10-24 22:40:12 +0900936 print_crosvm_args(&command);
937
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000938 let result = SharedChild::spawn(&mut command)?;
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900939 debug!("Spawned crosvm({}).", result.id());
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000940 Ok(result)
941}
942
943/// Ensure that the configuration has a valid combination of fields set, or return an error if not.
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000944fn validate_config(config: &CrosvmConfig) -> Result<(), Error> {
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000945 if config.bootloader.is_none() && config.kernel.is_none() {
946 bail!("VM must have either a bootloader or a kernel image.");
947 }
948 if config.bootloader.is_some() && (config.kernel.is_some() || config.initrd.is_some()) {
949 bail!("Can't have both bootloader and kernel/initrd image.");
950 }
Jiyong Parkdcf17412022-02-08 15:07:23 +0900951 let version = Version::parse(CROSVM_PLATFORM_VERSION).unwrap();
952 if !config.platform_version.matches(&version) {
953 bail!(
954 "Incompatible platform version. The config is compatible with platform version(s) \
955 {}, but the actual platform version is {}",
956 config.platform_version,
957 version
958 );
959 }
960
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000961 Ok(())
962}
963
Jiyong Park2d736562022-10-24 22:40:12 +0900964/// Print arguments of the crosvm command. In doing so, /proc/self/fd/XX is annotated with the
965/// actual file path if the FD is backed by a regular file. If not, the /proc path is printed
966/// unmodified.
967fn print_crosvm_args(command: &Command) {
968 let re = Regex::new(r"/proc/self/fd/[\d]+").unwrap();
969 info!(
970 "Running crosvm with args: {:?}",
971 command
972 .get_args()
973 .map(|s| s.to_string_lossy())
974 .map(|s| {
975 re.replace_all(&s, |caps: &Captures| {
976 let path = &caps[0];
977 if let Ok(realpath) = std::fs::canonicalize(path) {
978 format!("{} ({})", path, realpath.to_string_lossy())
979 } else {
980 path.to_owned()
981 }
982 })
983 .into_owned()
984 })
985 .collect::<Vec<_>>()
986 );
987}
988
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000989/// Adds the file descriptor for `file` to `preserved_fds`, and returns a string of the form
990/// "/proc/self/fd/N" where N is the file descriptor.
Keir Fraser13a956a2022-07-14 14:20:46 +0000991fn add_preserved_fd(preserved_fds: &mut Vec<RawFd>, file: &dyn AsRawFd) -> String {
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000992 let fd = file.as_raw_fd();
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000993 preserved_fds.push(fd);
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000994 format!("/proc/self/fd/{}", fd)
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000995}
Andrew Walbranb27681f2022-02-23 15:11:52 +0000996
997/// Adds the file descriptor for `file` (if any) to `preserved_fds`, and returns the appropriate
998/// string for a crosvm `--serial` flag. If `file` is none, creates a dummy sink device.
Jiyong Parke6fb1672023-06-26 16:45:55 +0900999fn format_serial_out_arg(preserved_fds: &mut Vec<RawFd>, file: &Option<File>) -> String {
Andrew Walbranb27681f2022-02-23 15:11:52 +00001000 if let Some(file) = file {
1001 format!("type=file,path={}", add_preserved_fd(preserved_fds, file))
1002 } else {
1003 "type=sink".to_string()
1004 }
1005}
1006
1007/// Creates a new pipe with the `O_CLOEXEC` flag set, and returns the read side and write side.
1008fn create_pipe() -> Result<(File, File), Error> {
1009 let (raw_read, raw_write) = pipe2(OFlag::O_CLOEXEC)?;
Andrew Walbranb58d1b42023-07-07 13:54:49 +01001010 // SAFETY: We are the sole owner of this FD as we just created it, and it is valid and open.
Andrew Walbranb27681f2022-02-23 15:11:52 +00001011 let read_fd = unsafe { File::from_raw_fd(raw_read) };
Andrew Walbranb58d1b42023-07-07 13:54:49 +01001012 // SAFETY: We are the sole owner of this FD as we just created it, and it is valid and open.
Andrew Walbranb27681f2022-02-23 15:11:52 +00001013 let write_fd = unsafe { File::from_raw_fd(raw_write) };
1014 Ok((read_fd, write_fd))
1015}