blob: 77dd76f31f7574f784ebb006f76a4779b4020367 [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;
Alan Stokes0e82b502022-08-08 14:44:48 +010050use binder::Strong;
Inseob Kimc7d28c72021-10-25 14:28:10 +000051use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService;
Jiyong Park1612b902022-08-22 14:47:39 +090052use tombstoned_client::{TombstonedConnection, DebuggerdDumpType};
David Brazdil73988ea2022-11-11 15:10:32 +000053use rpcbinder::RpcServer;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000054
Keir Fraser13a956a2022-07-14 14:20:46 +000055/// external/crosvm
Elie Kheirallah2d12ff32023-03-20 18:12:07 +000056use base::AsRawDescriptor;
Keir Fraser13a956a2022-07-14 14:20:46 +000057use base::UnixSeqpacketListener;
Keir Frasercdd4b112022-11-24 14:02:25 +000058use vm_control::{BalloonControlCommand, VmRequest, VmResponse};
Keir Fraser13a956a2022-07-14 14:20:46 +000059
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000060const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm";
61
Jiyong Parkdcf17412022-02-08 15:07:23 +090062/// 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.
66const CROSVM_PLATFORM_VERSION: &str = "1.0.0";
67
Andrew Walbrand15c5632022-02-03 13:38:31 +000068/// The exit status which crosvm returns when it has an error starting a VM.
Alan Stokes7c459e82022-12-06 12:21:49 +000069const CROSVM_START_ERROR_STATUS: i32 = 1;
Andrew Walbranc92d35f2022-01-12 12:45:19 +000070/// The exit status which crosvm returns when a VM requests a reboot.
71const CROSVM_REBOOT_STATUS: i32 = 32;
Andrew Walbrand15c5632022-02-03 13:38:31 +000072/// The exit status which crosvm returns when it crashes due to an error.
73const CROSVM_CRASH_STATUS: i32 = 33;
Sebastian Ene23167d82022-10-07 14:09:53 +000074/// The exit status which crosvm returns when vcpu is stalled.
75const CROSVM_WATCHDOG_REBOOT_STATUS: i32 = 36;
Jiyong Park3115cdb2023-02-24 18:04:44 +090076/// The size of memory (in MiB) reserved for ramdump
77const RAMDUMP_RESERVED_MIB: u32 = 17;
Andrew Walbranc92d35f2022-01-12 12:45:19 +000078
Seungjae Yoo6d265d92022-11-15 10:51:33 +090079const MILLIS_PER_SEC: i64 = 1000;
80
Jaewan Kim46422812022-11-25 10:59:39 +090081const SYSPROP_CUSTOM_PVMFW_PATH: &str = "hypervisor.pvmfw.path";
82
Jiyong Parke6ed0f92022-06-22 00:13:00 +090083lazy_static! {
84 /// If the VM doesn't move to the Started state within this amount time, a hang-up error is
85 /// triggered.
Alan Stokesc3f2ac22022-06-23 12:19:46 +010086 static ref BOOT_HANGUP_TIMEOUT: Duration = if nested_virt::is_nested_virtualization().unwrap() {
Jiyong Parke6ed0f92022-06-22 00:13:00 +090087 // Nested virtualization is slow, so we need a longer timeout.
Inseob Kime557cec2023-01-26 22:49:58 +090088 Duration::from_secs(300)
Jiyong Parke6ed0f92022-06-22 00:13:00 +090089 } else {
Inseob Kime557cec2023-01-26 22:49:58 +090090 Duration::from_secs(30)
Jiyong Parke6ed0f92022-06-22 00:13:00 +090091 };
92}
93
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000094/// Configuration for a VM to run with crosvm.
95#[derive(Debug)]
Andrew Walbrand3a84182021-09-07 14:48:52 +000096pub struct CrosvmConfig {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +000097 pub cid: Cid,
Seungjae Yoo62085c02022-08-12 04:44:52 +000098 pub name: String,
Andrew Walbrand3a84182021-09-07 14:48:52 +000099 pub bootloader: Option<File>,
100 pub kernel: Option<File>,
101 pub initrd: Option<File>,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000102 pub disks: Vec<DiskFile>,
103 pub params: Option<String>,
Andrew Walbranf8650422021-06-09 15:54:09 +0000104 pub protected: bool,
Jaewan Kim61f86142023-03-28 15:12:52 +0900105 pub debug_config: DebugConfig,
Andrew Walbranb15cd6e2021-07-05 16:38:07 +0000106 pub memory_mib: Option<NonZeroU32>,
Jiyong Park032615f2022-01-10 13:55:34 +0900107 pub cpus: Option<NonZeroU32>,
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000108 pub host_cpu_topology: bool,
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900109 pub task_profiles: Vec<String>,
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 Kim6ef80972023-07-20 17:23:36 +0900118 pub vfio_devices: Vec<PathBuf>,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000119}
120
121/// A disk image to pass to crosvm for a VM.
122#[derive(Debug)]
123pub struct DiskFile {
124 pub image: File,
125 pub writable: bool,
126}
127
Andrew Walbran6b650662021-09-07 13:13:23 +0000128/// The lifecycle state which the payload in the VM has reported itself to be in.
129///
130/// Note that the order of enum variants is significant; only forward transitions are allowed by
131/// [`VmInstance::update_payload_state`].
132#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
133pub enum PayloadState {
134 Starting,
135 Started,
136 Ready,
137 Finished,
Jiyong Parka4eebde2022-07-12 18:01:12 +0900138 Hangup, // Hasn't reached to Ready before timeout expires
Andrew Walbran6b650662021-09-07 13:13:23 +0000139}
140
Andrew Walbranf8d94112021-09-07 11:45:36 +0000141/// The current state of the VM itself.
142#[derive(Debug)]
143pub enum VmState {
144 /// The VM has not yet tried to start.
145 NotStarted {
146 ///The configuration needed to start the VM, if it has not yet been started.
147 config: CrosvmConfig,
148 },
149 /// The VM has been started.
150 Running {
151 /// The crosvm child process.
152 child: Arc<SharedChild>,
David Brazdilf18e1162022-12-18 18:27:23 +0000153 /// The thread waiting for crosvm to finish.
154 monitor_vm_exit_thread: Option<JoinHandle<()>>,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000155 },
156 /// The VM died or was killed.
157 Dead,
158 /// The VM failed to start.
159 Failed,
160}
161
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900162/// RSS values of VM and CrosVM process itself.
163#[derive(Copy, Clone, Debug, Default)]
164pub struct Rss {
165 pub vm: i64,
166 pub crosvm: i64,
167}
168
169/// Metrics regarding the VM.
170#[derive(Debug, Default)]
171pub struct VmMetric {
172 /// Recorded timestamp when the VM is started.
173 pub start_timestamp: Option<SystemTime>,
174 /// Update most recent guest_time periodically from /proc/[crosvm pid]/stat while VM is running.
175 pub cpu_guest_time: Option<i64>,
176 /// Update maximum RSS values periodically from /proc/[crosvm pid]/smaps while VM is running.
177 pub rss: Option<Rss>,
178}
179
Andrew Walbranf8d94112021-09-07 11:45:36 +0000180impl VmState {
181 /// Tries to start the VM, if it is in the `NotStarted` state.
182 ///
183 /// Returns an error if the VM is in the wrong state, or fails to start.
184 fn start(&mut self, instance: Arc<VmInstance>) -> Result<(), Error> {
185 let state = mem::replace(self, VmState::Failed);
186 if let VmState::NotStarted { config } = state {
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900187 let detect_hangup = config.detect_hangup;
Andrew Walbranb27681f2022-02-23 15:11:52 +0000188 let (failure_pipe_read, failure_pipe_write) = create_pipe()?;
Inseob Kim6ef80972023-07-20 17:23:36 +0900189 let vfio_devices = config.vfio_devices.clone();
Andrew Walbranb27681f2022-02-23 15:11:52 +0000190
Andrew Walbranf8d94112021-09-07 11:45:36 +0000191 // If this fails and returns an error, `self` will be left in the `Failed` state.
Keir Fraser13a956a2022-07-14 14:20:46 +0000192 let child =
Keir Frasercdd4b112022-11-24 14:02:25 +0000193 Arc::new(run_vm(config, &instance.crosvm_control_socket_path, failure_pipe_write)?);
Andrew Walbranf8d94112021-09-07 11:45:36 +0000194
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900195 let instance_monitor_status = instance.clone();
196 let child_monitor_status = child.clone();
197 thread::spawn(move || {
198 instance_monitor_status.clone().monitor_vm_status(child_monitor_status);
199 });
200
Andrew Walbranf8d94112021-09-07 11:45:36 +0000201 let child_clone = child.clone();
Jiyong Parka4eebde2022-07-12 18:01:12 +0900202 let instance_clone = instance.clone();
David Brazdilf18e1162022-12-18 18:27:23 +0000203 let monitor_vm_exit_thread = Some(thread::spawn(move || {
Inseob Kim6ef80972023-07-20 17:23:36 +0900204 instance_clone.monitor_vm_exit(child_clone, failure_pipe_read, vfio_devices);
David Brazdilf18e1162022-12-18 18:27:23 +0000205 }));
Andrew Walbranf8d94112021-09-07 11:45:36 +0000206
Jiyong Parka4eebde2022-07-12 18:01:12 +0900207 if detect_hangup {
208 let child_clone = child.clone();
209 thread::spawn(move || {
210 instance.monitor_payload_hangup(child_clone);
211 });
212 }
213
Andrew Walbranf8d94112021-09-07 11:45:36 +0000214 // If it started correctly, update the state.
David Brazdilf18e1162022-12-18 18:27:23 +0000215 *self = VmState::Running { child, monitor_vm_exit_thread };
Andrew Walbranf8d94112021-09-07 11:45:36 +0000216 Ok(())
217 } else {
218 *self = state;
219 bail!("VM already started or failed")
220 }
221 }
222}
223
David Brazdil8cf8f482022-11-23 14:21:26 +0000224/// Internal struct that holds the handles to globally unique resources of a VM.
225#[derive(Debug)]
226pub struct VmContext {
227 #[allow(dead_code)] // Keeps the global context alive
228 global_context: Strong<dyn IGlobalVmContext>,
229 #[allow(dead_code)] // Keeps the server alive
230 vm_server: RpcServer,
231}
232
233impl VmContext {
234 /// Construct new VmContext.
235 pub fn new(global_context: Strong<dyn IGlobalVmContext>, vm_server: RpcServer) -> VmContext {
236 VmContext { global_context, vm_server }
237 }
238}
239
Andrew Walbranf8d94112021-09-07 11:45:36 +0000240/// Information about a particular instance of a VM which may be running.
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000241#[derive(Debug)]
242pub struct VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000243 /// The current state of the VM.
244 pub vm_state: Mutex<VmState>,
David Brazdil8cf8f482022-11-23 14:21:26 +0000245 /// Global resources allocated for this VM.
246 #[allow(dead_code)] // Keeps the context alive
247 vm_context: VmContext,
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000248 /// The CID assigned to the VM for vsock communication.
249 pub cid: Cid,
Keir Frasercdd4b112022-11-24 14:02:25 +0000250 /// Path to crosvm control socket
251 crosvm_control_socket_path: PathBuf,
Seungjae Yoo62085c02022-08-12 04:44:52 +0000252 /// The name of the VM.
253 pub name: String,
Andrew Walbranf8650422021-06-09 15:54:09 +0000254 /// Whether the VM is a protected VM.
255 pub protected: bool,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000256 /// Directory of temporary files used by the VM while it is running.
257 pub temporary_directory: PathBuf,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000258 /// The UID of the process which requested the VM.
259 pub requester_uid: u32,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000260 /// The PID of the process which requested the VM. Note that this process may no longer exist
261 /// and the PID may have been reused for a different process, so this should not be trusted.
Andrew Walbran02034492021-04-13 15:05:07 +0000262 pub requester_debug_pid: i32,
Andrew Walbrandae07162021-03-12 17:05:20 +0000263 /// Callbacks to clients of the VM.
264 pub callbacks: VirtualMachineCallbacks,
Inseob Kimc7d28c72021-10-25 14:28:10 +0000265 /// VirtualMachineService binder object for the VM.
266 pub vm_service: Mutex<Option<Strong<dyn IVirtualMachineService>>>,
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900267 /// Recorded metrics of VM such as timestamp or cpu / memory usage.
268 pub vm_metric: Mutex<VmMetric>,
Andrew Walbran6b650662021-09-07 13:13:23 +0000269 /// The latest lifecycle state which the payload reported itself to be in.
270 payload_state: Mutex<PayloadState>,
Jiyong Parka4eebde2022-07-12 18:01:12 +0900271 /// Represents the condition that payload_state was updated
272 payload_state_updated: Condvar,
Jiyong Park08eee7b2022-11-11 15:01:26 +0900273 /// The human readable name of requester_uid
274 requester_uid_name: String,
275}
276
277impl fmt::Display for VmInstance {
278 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
279 let adj = if self.protected { "Protected" } else { "Non-protected" };
280 write!(
281 f,
282 "{} virtual machine \"{}\" (owner: {}, cid: {})",
283 adj, self.name, self.requester_uid_name, self.cid
284 )
285 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000286}
287
288impl VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000289 /// Validates the given config and creates a new `VmInstance` but doesn't start running it.
290 pub fn new(
Andrew Walbrand3a84182021-09-07 14:48:52 +0000291 config: CrosvmConfig,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000292 temporary_directory: PathBuf,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000293 requester_uid: u32,
Andrew Walbran02034492021-04-13 15:05:07 +0000294 requester_debug_pid: i32,
David Brazdil8cf8f482022-11-23 14:21:26 +0000295 vm_context: VmContext,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000296 ) -> Result<VmInstance, Error> {
297 validate_config(&config)?;
Andrew Walbrand3a84182021-09-07 14:48:52 +0000298 let cid = config.cid;
Seungjae Yoo62085c02022-08-12 04:44:52 +0000299 let name = config.name.clone();
Andrew Walbrand3a84182021-09-07 14:48:52 +0000300 let protected = config.protected;
Jiyong Park08eee7b2022-11-11 15:01:26 +0900301 let requester_uid_name = User::from_uid(Uid::from_raw(requester_uid))
302 .ok()
303 .flatten()
304 .map_or_else(|| format!("{}", requester_uid), |u| u.name);
305 let instance = VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000306 vm_state: Mutex::new(VmState::NotStarted { config }),
David Brazdil528e0472022-10-10 15:06:02 +0100307 vm_context,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000308 cid,
Keir Frasercdd4b112022-11-24 14:02:25 +0000309 crosvm_control_socket_path: temporary_directory.join("crosvm.sock"),
Seungjae Yoo62085c02022-08-12 04:44:52 +0000310 name,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000311 protected,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000312 temporary_directory,
Andrew Walbran02034492021-04-13 15:05:07 +0000313 requester_uid,
Andrew Walbran02034492021-04-13 15:05:07 +0000314 requester_debug_pid,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000315 callbacks: Default::default(),
Inseob Kimc7d28c72021-10-25 14:28:10 +0000316 vm_service: Mutex::new(None),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900317 vm_metric: Mutex::new(Default::default()),
Andrew Walbranf8d94112021-09-07 11:45:36 +0000318 payload_state: Mutex::new(PayloadState::Starting),
Jiyong Parka4eebde2022-07-12 18:01:12 +0900319 payload_state_updated: Condvar::new(),
Jiyong Park08eee7b2022-11-11 15:01:26 +0900320 requester_uid_name,
321 };
322 info!("{} created", &instance);
323 Ok(instance)
Andrew Walbrandae07162021-03-12 17:05:20 +0000324 }
325
Andrew Walbranf8d94112021-09-07 11:45:36 +0000326 /// Starts an instance of `crosvm` to manage the VM. The `crosvm` instance will be killed when
327 /// the `VmInstance` is dropped.
328 pub fn start(self: &Arc<Self>) -> Result<(), Error> {
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900329 let mut vm_metric = self.vm_metric.lock().unwrap();
330 vm_metric.start_timestamp = Some(SystemTime::now());
Jiyong Park08eee7b2022-11-11 15:01:26 +0900331 let ret = self.vm_state.lock().unwrap().start(self.clone());
332 if ret.is_ok() {
333 info!("{} started", &self);
334 }
335 ret.with_context(|| format!("{} failed to start", &self))
Andrew Walbranf8d94112021-09-07 11:45:36 +0000336 }
337
Jiyong Parka4eebde2022-07-12 18:01:12 +0900338 /// Monitors the exit of the VM (i.e. termination of the `child` process). When that happens,
339 /// handles the event by updating the state, noityfing the event to clients by calling
340 /// callbacks, and removing temporary files for the VM.
Inseob Kim6ef80972023-07-20 17:23:36 +0900341 fn monitor_vm_exit(
342 &self,
343 child: Arc<SharedChild>,
344 mut failure_pipe_read: File,
345 vfio_devices: Vec<PathBuf>,
346 ) {
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000347 let result = child.wait();
348 match &result {
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900349 Err(e) => error!("Error waiting for crosvm({}) instance to die: {}", child.id(), e),
Sebastian Ene23167d82022-10-07 14:09:53 +0000350 Ok(status) => {
351 info!("crosvm({}) exited with status {}", child.id(), status);
352 if let Some(exit_status_code) = status.code() {
353 if exit_status_code == CROSVM_WATCHDOG_REBOOT_STATUS {
354 info!("detected vcpu stall on crosvm");
355 }
356 }
357 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000358 }
Andrew Walbranf8d94112021-09-07 11:45:36 +0000359
360 let mut vm_state = self.vm_state.lock().unwrap();
361 *vm_state = VmState::Dead;
362 // Ensure that the mutex is released before calling the callbacks.
363 drop(vm_state);
Jiyong Park08eee7b2022-11-11 15:01:26 +0900364 info!("{} exited", &self);
Andrew Walbranf8d94112021-09-07 11:45:36 +0000365
Jiyong Parka4eebde2022-07-12 18:01:12 +0900366 // Read the pipe to see if any failure reason is written
367 let mut failure_reason = String::new();
368 match failure_pipe_read.read_to_string(&mut failure_reason) {
369 Err(e) => error!("Error reading VM failure reason from pipe: {}", e),
370 Ok(len) if len > 0 => info!("VM returned failure reason '{}'", &failure_reason),
371 _ => (),
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900372 };
Andrew Walbranb27681f2022-02-23 15:11:52 +0000373
Jiyong Parka4eebde2022-07-12 18:01:12 +0900374 // In case of hangup, the pipe doesn't give us any information because the hangup can't be
375 // detected on the VM side (otherwise, it isn't a hangup), but in the
376 // monitor_payload_hangup function below which updates the payload state to Hangup.
377 let failure_reason =
378 if failure_reason.is_empty() && self.payload_state() == PayloadState::Hangup {
379 Cow::from("HANGUP")
380 } else {
381 Cow::from(failure_reason)
382 };
383
Jiyong Parke558ab12022-07-07 20:18:55 +0900384 self.handle_ramdump().unwrap_or_else(|e| error!("Error handling ramdump: {}", e));
Seungjae Yoob4c07ba2022-08-12 04:44:52 +0000385
386 let death_reason = death_reason(&result, &failure_reason);
Seungjae Yoo93430e82022-12-05 16:37:42 +0900387 let exit_signal = exit_signal(&result);
388
Seungjae Yoob4c07ba2022-08-12 04:44:52 +0000389 self.callbacks.callback_on_died(self.cid, death_reason);
Seungjae Yoo2e7beea2022-08-24 16:09:12 +0900390
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900391 let vm_metric = self.vm_metric.lock().unwrap();
Seungjae Yoob2db3d22023-04-06 18:05:43 +0900392 write_vm_exited_stats_sync(
Seungjae Yoo93430e82022-12-05 16:37:42 +0900393 self.requester_uid as i32,
394 &self.name,
395 death_reason,
396 exit_signal,
Chris Wailes75269622022-12-05 23:01:44 -0800397 &vm_metric,
Seungjae Yoo93430e82022-12-05 16:37:42 +0900398 );
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000399
David Brazdil4b4c5102022-12-19 22:56:20 +0000400 // Delete temporary files. The folder itself is removed by VirtualizationServiceInternal.
401 remove_temporary_files(&self.temporary_directory).unwrap_or_else(|e| {
402 error!("Error removing temporary files from {:?}: {}", self.temporary_directory, e);
403 });
Inseob Kim6ef80972023-07-20 17:23:36 +0900404
405 // TODO(b/278008182): clean up assigned devices.
406 for device in vfio_devices.iter() {
407 info!("NOT RELEASING {device:?}");
408 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000409 }
410
Jiyong Parka4eebde2022-07-12 18:01:12 +0900411 /// Waits until payload is started, or timeout expires. When timeout occurs, kill
412 /// the VM to prevent indefinite hangup and update the payload_state accordingly.
413 fn monitor_payload_hangup(&self, child: Arc<SharedChild>) {
414 debug!("Starting to monitor hangup for Microdroid({})", child.id());
415 let (_, result) = self
416 .payload_state_updated
417 .wait_timeout_while(self.payload_state.lock().unwrap(), *BOOT_HANGUP_TIMEOUT, |s| {
418 *s < PayloadState::Started
419 })
420 .unwrap();
421 let child_still_running = child.try_wait().ok() == Some(None);
422 if result.timed_out() && child_still_running {
423 error!(
424 "Microdroid({}) failed to start payload within {} secs timeout. Shutting down.",
425 child.id(),
426 BOOT_HANGUP_TIMEOUT.as_secs()
427 );
428 self.update_payload_state(PayloadState::Hangup).unwrap();
429 if let Err(e) = self.kill() {
430 error!("Error stopping timed-out VM with CID {}: {:?}", child.id(), e);
431 }
432 }
433 }
434
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900435 fn monitor_vm_status(&self, child: Arc<SharedChild>) {
436 let pid = child.id();
437
438 loop {
439 {
440 // Check VM state
441 let vm_state = &*self.vm_state.lock().unwrap();
442 if let VmState::Dead = vm_state {
443 break;
444 }
445
446 let mut vm_metric = self.vm_metric.lock().unwrap();
447
448 // Get CPU Information
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900449 if let Ok(guest_time) = get_guest_time(pid) {
450 vm_metric.cpu_guest_time = Some(guest_time);
451 } else {
452 error!("Failed to parse /proc/[pid]/stat");
453 }
454
455 // Get Memory Information
456 if let Ok(rss) = get_rss(pid) {
457 vm_metric.rss = match &vm_metric.rss {
458 Some(x) => Some(Rss::extract_max(x, &rss)),
459 None => Some(rss),
460 }
461 } else {
462 error!("Failed to parse /proc/[pid]/smaps");
463 }
464 }
465
466 thread::sleep(Duration::from_secs(1));
467 }
468 }
469
Andrew Walbran6b650662021-09-07 13:13:23 +0000470 /// Returns the last reported state of the VM payload.
471 pub fn payload_state(&self) -> PayloadState {
472 *self.payload_state.lock().unwrap()
473 }
474
475 /// Updates the payload state to the given value, if it is a valid state transition.
476 pub fn update_payload_state(&self, new_state: PayloadState) -> Result<(), Error> {
477 let mut state_locked = self.payload_state.lock().unwrap();
478 // Only allow forward transitions, e.g. from starting to started or finished, not back in
479 // the other direction.
480 if new_state > *state_locked {
481 *state_locked = new_state;
Jiyong Parka4eebde2022-07-12 18:01:12 +0900482 self.payload_state_updated.notify_all();
Andrew Walbran6b650662021-09-07 13:13:23 +0000483 Ok(())
484 } else {
485 bail!("Invalid payload state transition from {:?} to {:?}", *state_locked, new_state)
486 }
487 }
488
Andrew Walbranf8d94112021-09-07 11:45:36 +0000489 /// Kills the crosvm instance, if it is running.
Inseob Kima446f802022-07-11 19:46:37 +0900490 pub fn kill(&self) -> Result<(), Error> {
David Brazdilf18e1162022-12-18 18:27:23 +0000491 let monitor_vm_exit_thread = {
492 let vm_state = &mut *self.vm_state.lock().unwrap();
493 if let VmState::Running { child, monitor_vm_exit_thread } = vm_state {
494 let id = child.id();
495 debug!("Killing crosvm({})", id);
496 // TODO: Talk to crosvm to shutdown cleanly.
497 child.kill().with_context(|| format!("Error killing crosvm({id}) instance"))?;
498 monitor_vm_exit_thread.take()
Inseob Kima446f802022-07-11 19:46:37 +0900499 } else {
David Brazdilf18e1162022-12-18 18:27:23 +0000500 bail!("VM is not running")
Andrew Walbranf8d94112021-09-07 11:45:36 +0000501 }
David Brazdilf18e1162022-12-18 18:27:23 +0000502 };
503
504 // Wait for monitor_vm_exit() to finish. Must release vm_state lock
505 // first, as monitor_vm_exit() takes it as well.
506 monitor_vm_exit_thread.map(JoinHandle::join);
507
David Brazdil5af55832023-03-08 13:08:56 +0000508 // Now that the VM has been killed, shut down the VirtualMachineService
509 // server to eagerly free up the server threads.
510 self.vm_context.vm_server.shutdown()?;
511
David Brazdilf18e1162022-12-18 18:27:23 +0000512 Ok(())
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000513 }
Jiyong Parke558ab12022-07-07 20:18:55 +0900514
Keir Frasercdd4b112022-11-24 14:02:25 +0000515 /// Responds to memory-trimming notifications by inflating the virtio
516 /// balloon to reclaim guest memory.
517 pub fn trim_memory(&self, level: MemoryTrimLevel) -> Result<(), Error> {
518 let request = VmRequest::BalloonCommand(BalloonControlCommand::Stats {});
519 match vm_control::client::handle_request(&request, &self.crosvm_control_socket_path) {
520 Ok(VmResponse::BalloonStats { stats, balloon_actual: _ }) => {
521 if let Some(total_memory) = stats.total_memory {
522 // Reclaim up to 50% of total memory assuming worst case
523 // most memory is anonymous and must be swapped to zram
524 // with an approximate 2:1 compression ratio.
525 let pct = match level {
526 MemoryTrimLevel::TRIM_MEMORY_RUNNING_CRITICAL => 50,
527 MemoryTrimLevel::TRIM_MEMORY_RUNNING_LOW => 30,
528 MemoryTrimLevel::TRIM_MEMORY_RUNNING_MODERATE => 10,
529 _ => bail!("Invalid memory trim level {:?}", level),
530 };
Devin Moore30be4482023-08-21 22:44:26 +0000531 let command = BalloonControlCommand::Adjust {
532 num_bytes: total_memory * pct / 100,
533 wait_for_success: false,
534 };
Keir Frasercdd4b112022-11-24 14:02:25 +0000535 if let Err(e) = vm_control::client::handle_request(
536 &VmRequest::BalloonCommand(command),
537 &self.crosvm_control_socket_path,
538 ) {
539 bail!("Error sending balloon adjustment: {:?}", e);
540 }
541 }
542 }
543 Ok(VmResponse::Err(e)) => {
Alice Wangeff58392023-07-04 13:32:09 +0000544 // ENOTSUP is returned when the balloon protocol is not initialized. This
Keir Frasercdd4b112022-11-24 14:02:25 +0000545 // can occur for numerous reasons: Guest is still booting, guest doesn't
546 // support ballooning, host doesn't support ballooning. We don't log or
547 // raise an error in this case: trim is just a hint and we can ignore it.
548 if e.errno() != libc::ENOTSUP {
549 bail!("Errno return when requesting balloon stats: {}", e.errno())
550 }
551 }
552 e => bail!("Error requesting balloon stats: {:?}", e),
553 }
554 Ok(())
555 }
556
Alan Stokes3e98d292022-12-14 15:18:22 +0000557 /// Checks if ramdump has been created. If so, send it to tombstoned.
Jiyong Parke558ab12022-07-07 20:18:55 +0900558 fn handle_ramdump(&self) -> Result<(), Error> {
559 let ramdump_path = self.temporary_directory.join("ramdump");
Jiyong Park933d2b22023-02-28 11:41:19 +0900560 if !ramdump_path.as_path().try_exists()? {
561 return Ok(());
562 }
Jiyong Parke558ab12022-07-07 20:18:55 +0900563 if std::fs::metadata(&ramdump_path)?.len() > 0 {
Jiyong Park1612b902022-08-22 14:47:39 +0900564 Self::send_ramdump_to_tombstoned(&ramdump_path)?;
Jiyong Parke558ab12022-07-07 20:18:55 +0900565 }
566 Ok(())
567 }
Jiyong Park1612b902022-08-22 14:47:39 +0900568
569 fn send_ramdump_to_tombstoned(ramdump_path: &Path) -> Result<(), Error> {
570 let mut input = File::open(ramdump_path)
Alan Stokes3e98d292022-12-14 15:18:22 +0000571 .context(format!("Failed to open ramdump {:?} for reading", ramdump_path))?;
Jiyong Park1612b902022-08-22 14:47:39 +0900572
573 let pid = std::process::id() as i32;
574 let conn = TombstonedConnection::connect(pid, DebuggerdDumpType::Tombstone)
575 .context("Failed to connect to tombstoned")?;
576 let mut output = conn
577 .text_output
578 .as_ref()
579 .ok_or_else(|| anyhow!("Could not get file to write the tombstones on"))?;
580
581 std::io::copy(&mut input, &mut output).context("Failed to send ramdump to tombstoned")?;
582 info!("Ramdump {:?} sent to tombstoned", ramdump_path);
583
584 conn.notify_completion()?;
585 Ok(())
586 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000587}
588
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900589impl Rss {
590 fn extract_max(x: &Rss, y: &Rss) -> Rss {
591 Rss { vm: max(x.vm, y.vm), crosvm: max(x.crosvm, y.crosvm) }
592 }
593}
594
595// Get guest time from /proc/[crosvm pid]/stat
596fn get_guest_time(pid: u32) -> Result<i64> {
597 let file = read_to_string(format!("/proc/{}/stat", pid))?;
598 let data_list: Vec<_> = file.split_whitespace().collect();
599
600 // Information about guest_time is at 43th place of the file split with the whitespace.
601 // Example of /proc/[pid]/stat :
602 // 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
603 // 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
604 if data_list.len() < 43 {
605 bail!("Failed to parse command result for getting guest time : {}", file);
606 }
607
608 let guest_time_ticks = data_list[42].parse::<i64>()?;
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100609 // SAFETY: It just returns an integer about CPU tick information.
Charisee96113f32023-01-26 09:00:42 +0000610 let ticks_per_sec = unsafe { sysconf(_SC_CLK_TCK) };
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900611 Ok(guest_time_ticks * MILLIS_PER_SEC / ticks_per_sec)
612}
613
614// Get rss from /proc/[crosvm pid]/smaps
615fn get_rss(pid: u32) -> Result<Rss> {
616 let file = read_to_string(format!("/proc/{}/smaps", pid))?;
617 let lines: Vec<_> = file.split('\n').collect();
618
619 let mut rss_vm_total = 0i64;
620 let mut rss_crosvm_total = 0i64;
621 let mut is_vm = false;
622 for line in lines {
623 if line.contains("crosvm_guest") {
624 is_vm = true;
625 } else if line.contains("Rss:") {
626 let data_list: Vec<_> = line.split_whitespace().collect();
627 if data_list.len() < 2 {
628 bail!("Failed to parse command result for getting rss :\n{}", line);
629 }
630 let rss = data_list[1].parse::<i64>()?;
631
632 if is_vm {
633 rss_vm_total += rss;
634 is_vm = false;
635 }
636 rss_crosvm_total += rss;
637 }
638 }
639
640 Ok(Rss { vm: rss_vm_total, crosvm: rss_crosvm_total })
641}
642
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100643fn death_reason(result: &Result<ExitStatus, io::Error>, mut failure_reason: &str) -> DeathReason {
644 if let Some(position) = failure_reason.find('|') {
645 // Separator indicates extra context information is present after the failure name.
646 error!("Failure info: {}", &failure_reason[(position + 1)..]);
647 failure_reason = &failure_reason[..position];
648 }
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000649 if let Ok(status) = result {
Andrew Walbranb27681f2022-02-23 15:11:52 +0000650 match failure_reason {
651 "PVM_FIRMWARE_PUBLIC_KEY_MISMATCH" => {
652 return DeathReason::PVM_FIRMWARE_PUBLIC_KEY_MISMATCH
653 }
654 "PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED" => {
655 return DeathReason::PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED
656 }
Inseob Kim272f5722022-06-13 17:14:51 +0900657 "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE" => {
658 return DeathReason::MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE
659 }
660 "MICRODROID_PAYLOAD_HAS_CHANGED" => return DeathReason::MICRODROID_PAYLOAD_HAS_CHANGED,
661 "MICRODROID_PAYLOAD_VERIFICATION_FAILED" => {
662 return DeathReason::MICRODROID_PAYLOAD_VERIFICATION_FAILED
663 }
664 "MICRODROID_INVALID_PAYLOAD_CONFIG" => {
665 return DeathReason::MICRODROID_INVALID_PAYLOAD_CONFIG
666 }
667 "MICRODROID_UNKNOWN_RUNTIME_ERROR" => {
668 return DeathReason::MICRODROID_UNKNOWN_RUNTIME_ERROR
669 }
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900670 "HANGUP" => return DeathReason::HANGUP,
Andrew Walbranb27681f2022-02-23 15:11:52 +0000671 _ => {}
672 }
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000673 match status.code() {
674 None => DeathReason::KILLED,
675 Some(0) => DeathReason::SHUTDOWN,
Alan Stokes7c459e82022-12-06 12:21:49 +0000676 Some(CROSVM_START_ERROR_STATUS) => DeathReason::START_FAILED,
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000677 Some(CROSVM_REBOOT_STATUS) => DeathReason::REBOOT,
Andrew Walbrand15c5632022-02-03 13:38:31 +0000678 Some(CROSVM_CRASH_STATUS) => DeathReason::CRASH,
Sebastian Ene23167d82022-10-07 14:09:53 +0000679 Some(CROSVM_WATCHDOG_REBOOT_STATUS) => DeathReason::WATCHDOG_REBOOT,
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000680 Some(_) => DeathReason::UNKNOWN,
681 }
682 } else {
683 DeathReason::INFRASTRUCTURE_ERROR
684 }
685}
686
Seungjae Yoo93430e82022-12-05 16:37:42 +0900687fn exit_signal(result: &Result<ExitStatus, io::Error>) -> Option<i32> {
688 match result {
689 Ok(status) => status.signal(),
690 Err(_) => None,
691 }
692}
693
Inseob Kim6ef80972023-07-20 17:23:36 +0900694const SYSFS_PLATFORM_DEVICES_PATH: &str = "/sys/devices/platform/";
695const VFIO_PLATFORM_DRIVER_PATH: &str = "/sys/bus/platform/drivers/vfio-platform";
696
697fn vfio_argument_for_platform_device(path: &Path) -> Result<String, Error> {
698 // Check platform device exists
699 let path = path.canonicalize()?;
700 if !path.starts_with(SYSFS_PLATFORM_DEVICES_PATH) {
701 bail!("{path:?} is not a platform device");
702 }
703
704 // Check platform device is bound to VFIO driver
705 let dev_driver_path = path.join("driver").canonicalize()?;
706 if dev_driver_path != Path::new(VFIO_PLATFORM_DRIVER_PATH) {
707 bail!("{path:?} is not bound to VFIO-platform driver");
708 }
709
710 if let Some(p) = path.to_str() {
711 Ok(format!("--vfio={p},iommu=viommu"))
712 } else {
713 bail!("invalid path {path:?}");
714 }
715}
716
717fn append_platform_devices(command: &mut Command, config: &CrosvmConfig) -> Result<(), Error> {
718 for device in &config.vfio_devices {
719 command.arg(vfio_argument_for_platform_device(device)?);
720 }
Seungjae Yoo9d3c20a2023-09-07 15:36:44 +0900721 // TODO(b/291192693): add dtbo to command line when assigned device is not empty.
Inseob Kim6ef80972023-07-20 17:23:36 +0900722 Ok(())
723}
724
Andrew Walbrand3a84182021-09-07 14:48:52 +0000725/// Starts an instance of `crosvm` to manage a new VM.
Keir Fraser13a956a2022-07-14 14:20:46 +0000726fn run_vm(
727 config: CrosvmConfig,
Keir Frasercdd4b112022-11-24 14:02:25 +0000728 crosvm_control_socket_path: &Path,
Keir Fraser13a956a2022-07-14 14:20:46 +0000729 failure_pipe_write: File,
730) -> Result<SharedChild, Error> {
Andrew Walbrand3a84182021-09-07 14:48:52 +0000731 validate_config(&config)?;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000732
733 let mut command = Command::new(CROSVM_PATH);
734 // TODO(qwandor): Remove --disable-sandbox.
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000735 command
736 .arg("--extended-status")
Jiyong Park6c60fea2022-10-24 16:10:01 +0900737 // Configure the logger for the crosvm process to silence logs from the disk crate which
738 // don't provide much information to us (but do spamming us).
739 .arg("--log-level")
Frederick Mayle138f53c2023-01-24 18:55:26 -0800740 .arg("info,disk=warn")
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000741 .arg("run")
742 .arg("--disable-sandbox")
743 .arg("--cid")
744 .arg(config.cid.to_string());
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000745
Keir Fraserf25cb922022-11-23 14:26:00 +0000746 if system_properties::read_bool("hypervisor.memory_reclaim.supported", false)? {
747 command.arg("--balloon-page-reporting");
748 } else {
749 command.arg("--no-balloon");
750 }
751
Andrew Walbranf8650422021-06-09 15:54:09 +0000752 if config.protected {
Jaewan Kim46422812022-11-25 10:59:39 +0900753 match system_properties::read(SYSPROP_CUSTOM_PVMFW_PATH)? {
754 Some(pvmfw_path) if !pvmfw_path.is_empty() => {
755 command.arg("--protected-vm-with-firmware").arg(pvmfw_path)
756 }
757 _ => command.arg("--protected-vm"),
758 };
Andrew Walbran0b5789f2022-02-04 13:57:57 +0000759
760 // 3 virtio-console devices + vsock = 4.
761 let virtio_pci_device_count = 4 + config.disks.len();
762 // crosvm virtio queue has 256 entries, so 2 MiB per device (2 pages per entry) should be
763 // enough.
Jiyong Park3115cdb2023-02-24 18:04:44 +0900764 let swiotlb_size_mib = 2 * virtio_pci_device_count as u32;
Andrew Walbran0b5789f2022-02-04 13:57:57 +0000765 command.arg("--swiotlb").arg(swiotlb_size_mib.to_string());
Frederick Mayle58baa302023-02-14 19:06:37 -0800766
767 // Workaround to keep crash_dump from trying to read protected guest memory.
768 // Context in b/238324526.
769 command.arg("--unmap-guest-memory-on-fork");
Jiyong Park3115cdb2023-02-24 18:04:44 +0900770
Jiyong Parked180932023-02-24 19:55:41 +0900771 if config.ramdump.is_some() {
Jaewan Kim3124ef02023-03-23 19:25:20 +0900772 // Protected VM needs to reserve memory for ramdump here. Note that we reserve more
Jiyong Parked180932023-02-24 19:55:41 +0900773 // memory for the restricted dma pool.
774 let ramdump_reserve = RAMDUMP_RESERVED_MIB + swiotlb_size_mib;
775 command.arg("--params").arg(format!("crashkernel={ramdump_reserve}M"));
776 }
Jaewan Kimd4dae652023-03-28 13:45:43 +0900777 } else if config.ramdump.is_some() {
778 command.arg("--params").arg(format!("crashkernel={RAMDUMP_RESERVED_MIB}M"));
779 }
Jaewan Kim61f86142023-03-28 15:12:52 +0900780 if config.debug_config.debug_level == DebugLevel::NONE
781 && config.debug_config.should_prepare_console_output()
782 {
Jaewan Kimd4dae652023-03-28 13:45:43 +0900783 // bootconfig.normal will be used, but we need log.
784 command.arg("--params").arg("printk.devkmsg=on");
785 command.arg("--params").arg("console=hvc0");
Andrew Walbranf8650422021-06-09 15:54:09 +0000786 }
787
Andrew Walbranb15cd6e2021-07-05 16:38:07 +0000788 if let Some(memory_mib) = config.memory_mib {
789 command.arg("--mem").arg(memory_mib.to_string());
790 }
791
Jiyong Park032615f2022-01-10 13:55:34 +0900792 if let Some(cpus) = config.cpus {
793 command.arg("--cpus").arg(cpus.to_string());
794 }
795
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000796 if config.host_cpu_topology {
David Brazdil25e8c052023-02-17 12:53:01 +0000797 // TODO(b/266664564): replace with --host-cpu-topology once available
798 if let Some(cpus) = get_num_cpus() {
799 command.arg("--cpus").arg(cpus.to_string());
800 } else {
801 bail!("Could not determine the number of CPUs in the system");
802 }
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000803 }
804
Jiyong Parkdfe16d62022-04-20 17:32:12 +0900805 if !config.task_profiles.is_empty() {
806 command.arg("--task-profiles").arg(config.task_profiles.join(","));
807 }
808
Nikita Ioffe5776f082023-02-10 21:38:26 +0000809 if let Some(gdb_port) = config.gdb_port {
810 command.arg("--gdb").arg(gdb_port.to_string());
811 }
812
Jiyong Parkfa91d702021-10-18 23:51:39 +0900813 // Keep track of what file descriptors should be mapped to the crosvm process.
814 let mut preserved_fds = config.indirect_files.iter().map(|file| file.as_raw_fd()).collect();
815
Jiyong Park747d6362021-10-19 17:12:52 +0900816 // Setup the serial devices.
817 // 1. uart device: used as the output device by bootloaders and as early console by linux
Andrew Walbranb27681f2022-02-23 15:11:52 +0000818 // 2. uart device: used to report the reason for the VM failing.
819 // 3. virtio-console device: used as the console device where kmsg is redirected to
Jiyong Park4afe2012022-07-08 05:38:49 +0900820 // 4. virtio-console device: used as the ramdump output
Andrew Walbranb27681f2022-02-23 15:11:52 +0000821 // 5. virtio-console device: used as the logcat output
Jiyong Park747d6362021-10-19 17:12:52 +0900822 //
Jiyong Parkb8182bb2021-10-26 22:53:08 +0900823 // When [console|log]_fd is not specified, the devices are attached to sink, which means what's
824 // written there is discarded.
Jiyong Parke6fb1672023-06-26 16:45:55 +0900825 let console_out_arg = format_serial_out_arg(&mut preserved_fds, &config.console_out_fd);
826 let console_in_arg = config
827 .console_in_fd
828 .as_ref()
829 .map(|fd| format!(",input={}", add_preserved_fd(&mut preserved_fds, fd)))
830 .unwrap_or_default();
831 let log_arg = format_serial_out_arg(&mut preserved_fds, &config.log_fd);
Andrew Walbranb27681f2022-02-23 15:11:52 +0000832 let failure_serial_path = add_preserved_fd(&mut preserved_fds, &failure_pipe_write);
Jiyong Parke6fb1672023-06-26 16:45:55 +0900833 let ramdump_arg = format_serial_out_arg(&mut preserved_fds, &config.ramdump);
Jiyong Parkfa91d702021-10-18 23:51:39 +0900834
Jiyong Park747d6362021-10-19 17:12:52 +0900835 // Warning: Adding more serial devices requires you to shift the PCI device ID of the boot
836 // disks in bootconfig.x86_64. This is because x86 crosvm puts serial devices and the block
837 // devices in the same PCI bus and serial devices comes before the block devices. Arm crosvm
838 // doesn't have the issue.
Jiyong Parkfa91d702021-10-18 23:51:39 +0900839 // /dev/ttyS0
Jiyong Park34cf4342023-07-03 15:03:15 +0900840 command.arg(format!("--serial={},hardware=serial,num=1", &console_out_arg));
Andrew Walbranb27681f2022-02-23 15:11:52 +0000841 // /dev/ttyS1
842 command.arg(format!("--serial=type=file,path={},hardware=serial,num=2", &failure_serial_path));
Jiyong Parkfa91d702021-10-18 23:51:39 +0900843 // /dev/hvc0
Jiyong Parke6fb1672023-06-26 16:45:55 +0900844 command.arg(format!(
845 "--serial={}{},hardware=virtio-console,num=1",
846 &console_out_arg, &console_in_arg
847 ));
Jiyong Park4afe2012022-07-08 05:38:49 +0900848 // /dev/hvc1
849 command.arg(format!("--serial={},hardware=virtio-console,num=2", &ramdump_arg));
Jiyong Parkae5a4ed2021-11-01 18:36:28 +0900850 // /dev/hvc2
851 command.arg(format!("--serial={},hardware=virtio-console,num=3", &log_arg));
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000852
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000853 if let Some(bootloader) = &config.bootloader {
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000854 command.arg("--bios").arg(add_preserved_fd(&mut preserved_fds, bootloader));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000855 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000856
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000857 if let Some(initrd) = &config.initrd {
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000858 command.arg("--initrd").arg(add_preserved_fd(&mut preserved_fds, initrd));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000859 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000860
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000861 if let Some(params) = &config.params {
862 command.arg("--params").arg(params);
863 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000864
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000865 for disk in &config.disks {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000866 command
867 .arg(if disk.writable { "--rwdisk" } else { "--disk" })
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000868 .arg(add_preserved_fd(&mut preserved_fds, &disk.image));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000869 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000870
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000871 if let Some(kernel) = &config.kernel {
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000872 command.arg(add_preserved_fd(&mut preserved_fds, kernel));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000873 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000874
Keir Frasercdd4b112022-11-24 14:02:25 +0000875 let control_server_socket = UnixSeqpacketListener::bind(crosvm_control_socket_path)
876 .context("failed to create control server")?;
Elie Kheirallah2d12ff32023-03-20 18:12:07 +0000877 command
878 .arg("--socket")
879 .arg(add_preserved_fd(&mut preserved_fds, &control_server_socket.as_raw_descriptor()));
Keir Fraser13a956a2022-07-14 14:20:46 +0000880
Inseob Kim6ef80972023-07-20 17:23:36 +0900881 append_platform_devices(&mut command, &config)?;
882
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000883 debug!("Preserving FDs {:?}", preserved_fds);
884 command.preserved_fds(preserved_fds);
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000885
Jiyong Park2d736562022-10-24 22:40:12 +0900886 print_crosvm_args(&command);
887
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000888 let result = SharedChild::spawn(&mut command)?;
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900889 debug!("Spawned crosvm({}).", result.id());
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000890 Ok(result)
891}
892
893/// Ensure that the configuration has a valid combination of fields set, or return an error if not.
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000894fn validate_config(config: &CrosvmConfig) -> Result<(), Error> {
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000895 if config.bootloader.is_none() && config.kernel.is_none() {
896 bail!("VM must have either a bootloader or a kernel image.");
897 }
898 if config.bootloader.is_some() && (config.kernel.is_some() || config.initrd.is_some()) {
899 bail!("Can't have both bootloader and kernel/initrd image.");
900 }
Jiyong Parkdcf17412022-02-08 15:07:23 +0900901 let version = Version::parse(CROSVM_PLATFORM_VERSION).unwrap();
902 if !config.platform_version.matches(&version) {
903 bail!(
904 "Incompatible platform version. The config is compatible with platform version(s) \
905 {}, but the actual platform version is {}",
906 config.platform_version,
907 version
908 );
909 }
910
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000911 Ok(())
912}
913
Jiyong Park2d736562022-10-24 22:40:12 +0900914/// Print arguments of the crosvm command. In doing so, /proc/self/fd/XX is annotated with the
915/// actual file path if the FD is backed by a regular file. If not, the /proc path is printed
916/// unmodified.
917fn print_crosvm_args(command: &Command) {
918 let re = Regex::new(r"/proc/self/fd/[\d]+").unwrap();
919 info!(
920 "Running crosvm with args: {:?}",
921 command
922 .get_args()
923 .map(|s| s.to_string_lossy())
924 .map(|s| {
925 re.replace_all(&s, |caps: &Captures| {
926 let path = &caps[0];
927 if let Ok(realpath) = std::fs::canonicalize(path) {
928 format!("{} ({})", path, realpath.to_string_lossy())
929 } else {
930 path.to_owned()
931 }
932 })
933 .into_owned()
934 })
935 .collect::<Vec<_>>()
936 );
937}
938
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000939/// Adds the file descriptor for `file` to `preserved_fds`, and returns a string of the form
940/// "/proc/self/fd/N" where N is the file descriptor.
Keir Fraser13a956a2022-07-14 14:20:46 +0000941fn add_preserved_fd(preserved_fds: &mut Vec<RawFd>, file: &dyn AsRawFd) -> String {
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000942 let fd = file.as_raw_fd();
Andrew Walbran02b8ec02021-06-22 13:07:02 +0000943 preserved_fds.push(fd);
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000944 format!("/proc/self/fd/{}", fd)
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000945}
Andrew Walbranb27681f2022-02-23 15:11:52 +0000946
947/// Adds the file descriptor for `file` (if any) to `preserved_fds`, and returns the appropriate
948/// string for a crosvm `--serial` flag. If `file` is none, creates a dummy sink device.
Jiyong Parke6fb1672023-06-26 16:45:55 +0900949fn format_serial_out_arg(preserved_fds: &mut Vec<RawFd>, file: &Option<File>) -> String {
Andrew Walbranb27681f2022-02-23 15:11:52 +0000950 if let Some(file) = file {
951 format!("type=file,path={}", add_preserved_fd(preserved_fds, file))
952 } else {
953 "type=sink".to_string()
954 }
955}
956
957/// Creates a new pipe with the `O_CLOEXEC` flag set, and returns the read side and write side.
958fn create_pipe() -> Result<(File, File), Error> {
959 let (raw_read, raw_write) = pipe2(OFlag::O_CLOEXEC)?;
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100960 // 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 +0000961 let read_fd = unsafe { File::from_raw_fd(raw_read) };
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100962 // 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 +0000963 let write_fd = unsafe { File::from_raw_fd(raw_write) };
964 Ok((read_fd, write_fd))
965}