blob: a9a91fe04ef08e7f0d4c4e777e02ffc0fedc660a [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
Seungjae Yoo3271f172024-06-11 10:14:07 +090017use crate::aidl::{remove_temporary_files, Cid, GLOBAL_SERVICE, 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};
Seungjae Yoo3271f172024-06-11 10:14:07 +090021use binder::ParcelFileDescriptor;
Andrew Walbran02b8ec02021-06-22 13:07:02 +000022use command_fds::CommandFdExt;
Jiyong Parke6ed0f92022-06-22 00:13:00 +090023use lazy_static::lazy_static;
Seungjae Yoo6d265d92022-11-15 10:51:33 +090024use libc::{sysconf, _SC_CLK_TCK};
Andrew Walbran3a5a9212021-05-04 17:09:08 +000025use log::{debug, error, info};
Jiyong Parkdcf17412022-02-08 15:07:23 +090026use semver::{Version, VersionReq};
Jiyong Park08eee7b2022-11-11 15:01:26 +090027use nix::{fcntl::OFlag, unistd::pipe2, unistd::Uid, unistd::User};
Jiyong Park2d736562022-10-24 22:40:12 +090028use regex::{Captures, Regex};
Keir Fraserf25cb922022-11-23 14:26:00 +000029use rustutils::system_properties;
Andrew Walbrandae07162021-03-12 17:05:20 +000030use shared_child::SharedChild;
Jiyong Parke6ed0f92022-06-22 00:13:00 +090031use std::borrow::Cow;
Seungjae Yoo6d265d92022-11-15 10:51:33 +090032use std::cmp::max;
Jiyong Park08eee7b2022-11-11 15:01:26 +090033use std::fmt;
David Brazdil4b4c5102022-12-19 22:56:20 +000034use std::fs::{read_to_string, File};
Andrew Walbranb27681f2022-02-23 15:11:52 +000035use std::io::{self, Read};
Andrew Walbranf8d94112021-09-07 11:45:36 +000036use std::mem;
Nikita Ioffe5776f082023-02-10 21:38:26 +000037use std::num::{NonZeroU16, NonZeroU32};
Seungjae Yoo3271f172024-06-11 10:14:07 +090038use std::os::unix::io::{AsRawFd, OwnedFd, RawFd};
Seungjae Yoo93430e82022-12-05 16:37:42 +090039use std::os::unix::process::ExitStatusExt;
Jiyong Park1612b902022-08-22 14:47:39 +090040use std::path::{Path, PathBuf};
Andrew Walbranc92d35f2022-01-12 12:45:19 +000041use std::process::{Command, ExitStatus};
Jiyong Parke6ed0f92022-06-22 00:13:00 +090042use std::sync::{Arc, Condvar, Mutex};
Seungjae Yoo2e7beea2022-08-24 16:09:12 +090043use std::time::{Duration, SystemTime};
David Brazdilf18e1162022-12-18 18:27:23 +000044use std::thread::{self, JoinHandle};
David Brazdil49f96f52022-12-16 21:29:13 +000045use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::DeathReason::DeathReason;
Jaewan Kim84b91212023-02-28 00:11:57 +090046use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{
47 MemoryTrimLevel::MemoryTrimLevel,
Jeongik Cha1df1c032024-04-03 16:03:12 +090048 VirtualMachineAppConfig::DebugLevel::DebugLevel,
Mu-Le Leeb2d5a312024-06-05 10:52:47 +080049 AudioConfig::AudioConfig as AudioConfigParcelable,
Jeongik Cha1df1c032024-04-03 16:03:12 +090050 DisplayConfig::DisplayConfig as DisplayConfigParcelable,
Jason Macnakea7b0fa2024-05-08 17:02:44 -070051 GpuConfig::GpuConfig as GpuConfigParcelable,
Jaewan Kim84b91212023-02-28 00:11:57 +090052};
David Brazdil528e0472022-10-10 15:06:02 +010053use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IGlobalVmContext::IGlobalVmContext;
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +000054use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IBoundDevice::IBoundDevice;
Alan Stokes0e82b502022-08-08 14:44:48 +010055use binder::Strong;
Inseob Kimc7d28c72021-10-25 14:28:10 +000056use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService;
Jiyong Park1612b902022-08-22 14:47:39 +090057use tombstoned_client::{TombstonedConnection, DebuggerdDumpType};
David Brazdil73988ea2022-11-11 15:10:32 +000058use rpcbinder::RpcServer;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000059
Keir Fraser13a956a2022-07-14 14:20:46 +000060/// external/crosvm
Elie Kheirallah2d12ff32023-03-20 18:12:07 +000061use base::AsRawDescriptor;
Keir Fraser13a956a2022-07-14 14:20:46 +000062use base::UnixSeqpacketListener;
Keir Frasercdd4b112022-11-24 14:02:25 +000063use vm_control::{BalloonControlCommand, VmRequest, VmResponse};
Keir Fraser13a956a2022-07-14 14:20:46 +000064
Andrew Walbrand6dce6f2021-03-05 16:39:08 +000065const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm";
66
Jiyong Parkdcf17412022-02-08 15:07:23 +090067/// Version of the platform that crosvm currently implements. The format follows SemVer. This
68/// should be updated when there is a platform change in the crosvm side. Having this value here is
69/// fine because virtualizationservice and crosvm are supposed to be updated together in the virt
70/// APEX.
71const CROSVM_PLATFORM_VERSION: &str = "1.0.0";
72
Andrew Walbrand15c5632022-02-03 13:38:31 +000073/// The exit status which crosvm returns when it has an error starting a VM.
Alan Stokes7c459e82022-12-06 12:21:49 +000074const CROSVM_START_ERROR_STATUS: i32 = 1;
Andrew Walbranc92d35f2022-01-12 12:45:19 +000075/// The exit status which crosvm returns when a VM requests a reboot.
76const CROSVM_REBOOT_STATUS: i32 = 32;
Andrew Walbrand15c5632022-02-03 13:38:31 +000077/// The exit status which crosvm returns when it crashes due to an error.
78const CROSVM_CRASH_STATUS: i32 = 33;
Sebastian Ene23167d82022-10-07 14:09:53 +000079/// The exit status which crosvm returns when vcpu is stalled.
80const CROSVM_WATCHDOG_REBOOT_STATUS: i32 = 36;
Jiyong Park3115cdb2023-02-24 18:04:44 +090081/// The size of memory (in MiB) reserved for ramdump
82const RAMDUMP_RESERVED_MIB: u32 = 17;
Andrew Walbranc92d35f2022-01-12 12:45:19 +000083
Seungjae Yoo6d265d92022-11-15 10:51:33 +090084const MILLIS_PER_SEC: i64 = 1000;
85
Jaewan Kim46422812022-11-25 10:59:39 +090086const SYSPROP_CUSTOM_PVMFW_PATH: &str = "hypervisor.pvmfw.path";
87
Yi-Yo Chiang8dd32552024-05-22 19:38:16 +080088/// Serial device for VM console input.
89/// Hypervisor (virtio-console)
90const CONSOLE_HVC0: &str = "hvc0";
91/// Serial (emulated uart)
92const CONSOLE_TTYS0: &str = "ttyS0";
93
Jiyong Parke6ed0f92022-06-22 00:13:00 +090094lazy_static! {
95 /// If the VM doesn't move to the Started state within this amount time, a hang-up error is
96 /// triggered.
Alan Stokesc3f2ac22022-06-23 12:19:46 +010097 static ref BOOT_HANGUP_TIMEOUT: Duration = if nested_virt::is_nested_virtualization().unwrap() {
Jiyong Parke6ed0f92022-06-22 00:13:00 +090098 // Nested virtualization is slow, so we need a longer timeout.
Inseob Kime557cec2023-01-26 22:49:58 +090099 Duration::from_secs(300)
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900100 } else {
Inseob Kime557cec2023-01-26 22:49:58 +0900101 Duration::from_secs(30)
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900102 };
103}
104
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000105/// Configuration for a VM to run with crosvm.
106#[derive(Debug)]
Andrew Walbrand3a84182021-09-07 14:48:52 +0000107pub struct CrosvmConfig {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000108 pub cid: Cid,
Seungjae Yoo62085c02022-08-12 04:44:52 +0000109 pub name: String,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000110 pub bootloader: Option<File>,
111 pub kernel: Option<File>,
112 pub initrd: Option<File>,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000113 pub disks: Vec<DiskFile>,
114 pub params: Option<String>,
Andrew Walbranf8650422021-06-09 15:54:09 +0000115 pub protected: bool,
Jaewan Kim61f86142023-03-28 15:12:52 +0900116 pub debug_config: DebugConfig,
Andrew Walbranb15cd6e2021-07-05 16:38:07 +0000117 pub memory_mib: Option<NonZeroU32>,
Jiyong Park032615f2022-01-10 13:55:34 +0900118 pub cpus: Option<NonZeroU32>,
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000119 pub host_cpu_topology: bool,
Jiyong Parke6fb1672023-06-26 16:45:55 +0900120 pub console_out_fd: Option<File>,
121 pub console_in_fd: Option<File>,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000122 pub log_fd: Option<File>,
Jiyong Parke558ab12022-07-07 20:18:55 +0900123 pub ramdump: Option<File>,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000124 pub indirect_files: Vec<File>,
Jiyong Parkdcf17412022-02-08 15:07:23 +0900125 pub platform_version: VersionReq,
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900126 pub detect_hangup: bool,
Nikita Ioffe5776f082023-02-10 21:38:26 +0000127 pub gdb_port: Option<NonZeroU16>,
Inseob Kim7307a892023-09-14 13:37:58 +0900128 pub vfio_devices: Vec<VfioDevice>,
David Brazdil2dfefd12023-11-17 14:07:36 +0000129 pub dtbo: Option<File>,
Shikha Panwar55e10ec2024-02-13 12:53:49 +0000130 pub device_tree_overlay: Option<File>,
Jeongik Cha1df1c032024-04-03 16:03:12 +0900131 pub display_config: Option<DisplayConfig>,
Jeongik Chac181be72024-03-27 00:18:30 +0900132 pub input_device_options: Vec<InputDeviceOption>,
Vincent Donnefort538a2c62024-03-20 16:01:10 +0000133 pub hugepages: bool,
Seungjae Yoo986d7a42024-05-28 14:06:58 +0900134 pub tap: Option<File>,
Yi-Yo Chiang8dd32552024-05-22 19:38:16 +0800135 pub console_input_device: Option<String>,
David Dai23cff712024-06-13 19:23:45 +0000136 pub boost_uclamp: bool,
Jason Macnakea7b0fa2024-05-08 17:02:44 -0700137 pub gpu_config: Option<GpuConfig>,
Mu-Le Leeb2d5a312024-06-05 10:52:47 +0800138 pub audio_config: Option<AudioConfig>,
139}
140
141#[derive(Debug)]
142pub struct AudioConfig {
143 pub use_microphone: bool,
144 pub use_speaker: bool,
145}
146
147impl AudioConfig {
148 pub fn new(raw_config: &AudioConfigParcelable) -> Self {
149 AudioConfig { use_microphone: raw_config.useMicrophone, use_speaker: raw_config.useSpeaker }
150 }
Jeongik Cha1df1c032024-04-03 16:03:12 +0900151}
152
153#[derive(Debug)]
154pub struct DisplayConfig {
155 pub width: NonZeroU32,
156 pub height: NonZeroU32,
157 pub horizontal_dpi: NonZeroU32,
158 pub vertical_dpi: NonZeroU32,
159 pub refresh_rate: NonZeroU32,
160}
161
162impl DisplayConfig {
163 pub fn new(raw_config: &DisplayConfigParcelable) -> Result<DisplayConfig> {
164 let width = try_into_non_zero_u32(raw_config.width)?;
165 let height = try_into_non_zero_u32(raw_config.height)?;
166 let horizontal_dpi = try_into_non_zero_u32(raw_config.horizontalDpi)?;
167 let vertical_dpi = try_into_non_zero_u32(raw_config.verticalDpi)?;
168 let refresh_rate = try_into_non_zero_u32(raw_config.refreshRate)?;
169 Ok(DisplayConfig { width, height, horizontal_dpi, vertical_dpi, refresh_rate })
170 }
171}
172
Jason Macnakea7b0fa2024-05-08 17:02:44 -0700173#[derive(Debug)]
174pub struct GpuConfig {
175 pub backend: Option<String>,
176 pub context_types: Option<Vec<String>>,
177 pub pci_address: Option<String>,
178 pub renderer_features: Option<String>,
179 pub renderer_use_egl: Option<bool>,
180 pub renderer_use_gles: Option<bool>,
181 pub renderer_use_glx: Option<bool>,
182 pub renderer_use_surfaceless: Option<bool>,
183 pub renderer_use_vulkan: Option<bool>,
184}
185
186impl GpuConfig {
187 pub fn new(raw_config: &GpuConfigParcelable) -> Result<GpuConfig> {
188 Ok(GpuConfig {
189 backend: raw_config.backend.clone(),
190 context_types: raw_config.contextTypes.clone().map(|context_types| {
191 context_types.iter().filter_map(|context_type| context_type.clone()).collect()
192 }),
193 pci_address: raw_config.pciAddress.clone(),
194 renderer_features: raw_config.rendererFeatures.clone(),
195 renderer_use_egl: Some(raw_config.rendererUseEgl),
196 renderer_use_gles: Some(raw_config.rendererUseGles),
197 renderer_use_glx: Some(raw_config.rendererUseGlx),
198 renderer_use_surfaceless: Some(raw_config.rendererUseSurfaceless),
199 renderer_use_vulkan: Some(raw_config.rendererUseVulkan),
200 })
201 }
202}
203
Jeongik Cha1df1c032024-04-03 16:03:12 +0900204fn try_into_non_zero_u32(value: i32) -> Result<NonZeroU32> {
205 let u32_value = value.try_into()?;
206 NonZeroU32::new(u32_value).ok_or(anyhow!("value should be greater than 0"))
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000207}
208
209/// A disk image to pass to crosvm for a VM.
210#[derive(Debug)]
211pub struct DiskFile {
212 pub image: File,
213 pub writable: bool,
214}
215
Jeongik Chac181be72024-03-27 00:18:30 +0900216/// virtio-input device configuration from `external/crosvm/src/crosvm/config.rs`
217#[derive(Debug)]
218#[allow(dead_code)]
219pub enum InputDeviceOption {
220 EvDev(File),
221 SingleTouch { file: File, width: u32, height: u32, name: Option<String> },
Jeongik Cha985b6402024-04-15 18:13:00 +0900222 Keyboard(File),
Jeongik Cha343894e2024-05-17 20:39:31 +0900223 Mouse(File),
Jiyong Park6c1b9f02024-07-05 16:21:10 +0900224 Switches(File),
Jeongik Chac181be72024-03-27 00:18:30 +0900225}
226
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000227type VfioDevice = Strong<dyn IBoundDevice>;
Inseob Kim7307a892023-09-14 13:37:58 +0900228
Andrew Walbran6b650662021-09-07 13:13:23 +0000229/// The lifecycle state which the payload in the VM has reported itself to be in.
230///
231/// Note that the order of enum variants is significant; only forward transitions are allowed by
232/// [`VmInstance::update_payload_state`].
233#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
234pub enum PayloadState {
235 Starting,
236 Started,
237 Ready,
238 Finished,
Jiyong Parka4eebde2022-07-12 18:01:12 +0900239 Hangup, // Hasn't reached to Ready before timeout expires
Andrew Walbran6b650662021-09-07 13:13:23 +0000240}
241
Andrew Walbranf8d94112021-09-07 11:45:36 +0000242/// The current state of the VM itself.
243#[derive(Debug)]
244pub enum VmState {
245 /// The VM has not yet tried to start.
246 NotStarted {
247 ///The configuration needed to start the VM, if it has not yet been started.
Inseob Kim7307a892023-09-14 13:37:58 +0900248 config: Box<CrosvmConfig>,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000249 },
250 /// The VM has been started.
251 Running {
252 /// The crosvm child process.
253 child: Arc<SharedChild>,
David Brazdilf18e1162022-12-18 18:27:23 +0000254 /// The thread waiting for crosvm to finish.
255 monitor_vm_exit_thread: Option<JoinHandle<()>>,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000256 },
257 /// The VM died or was killed.
258 Dead,
259 /// The VM failed to start.
260 Failed,
261}
262
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900263/// RSS values of VM and CrosVM process itself.
264#[derive(Copy, Clone, Debug, Default)]
265pub struct Rss {
266 pub vm: i64,
267 pub crosvm: i64,
268}
269
270/// Metrics regarding the VM.
271#[derive(Debug, Default)]
272pub struct VmMetric {
273 /// Recorded timestamp when the VM is started.
274 pub start_timestamp: Option<SystemTime>,
Pierre-Clément Tosi44aba642023-09-15 11:44:34 +0100275 /// Update most recent guest_time periodically from /proc/[crosvm pid]/stat while VM is
276 /// running.
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900277 pub cpu_guest_time: Option<i64>,
278 /// Update maximum RSS values periodically from /proc/[crosvm pid]/smaps while VM is running.
279 pub rss: Option<Rss>,
280}
281
Andrew Walbranf8d94112021-09-07 11:45:36 +0000282impl VmState {
283 /// Tries to start the VM, if it is in the `NotStarted` state.
284 ///
285 /// Returns an error if the VM is in the wrong state, or fails to start.
286 fn start(&mut self, instance: Arc<VmInstance>) -> Result<(), Error> {
287 let state = mem::replace(self, VmState::Failed);
288 if let VmState::NotStarted { config } = state {
Inseob Kim7307a892023-09-14 13:37:58 +0900289 let config = *config;
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900290 let detect_hangup = config.detect_hangup;
Andrew Walbranb27681f2022-02-23 15:11:52 +0000291 let (failure_pipe_read, failure_pipe_write) = create_pipe()?;
Inseob Kim6ef80972023-07-20 17:23:36 +0900292 let vfio_devices = config.vfio_devices.clone();
Seungjae Yoo3271f172024-06-11 10:14:07 +0900293 let tap =
294 if let Some(tap_file) = &config.tap { Some(tap_file.try_clone()?) } else { None };
Andrew Walbranb27681f2022-02-23 15:11:52 +0000295
Andrew Walbranf8d94112021-09-07 11:45:36 +0000296 // If this fails and returns an error, `self` will be left in the `Failed` state.
Keir Fraser13a956a2022-07-14 14:20:46 +0000297 let child =
Keir Frasercdd4b112022-11-24 14:02:25 +0000298 Arc::new(run_vm(config, &instance.crosvm_control_socket_path, failure_pipe_write)?);
Andrew Walbranf8d94112021-09-07 11:45:36 +0000299
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900300 let instance_monitor_status = instance.clone();
301 let child_monitor_status = child.clone();
302 thread::spawn(move || {
303 instance_monitor_status.clone().monitor_vm_status(child_monitor_status);
304 });
305
Andrew Walbranf8d94112021-09-07 11:45:36 +0000306 let child_clone = child.clone();
Jiyong Parka4eebde2022-07-12 18:01:12 +0900307 let instance_clone = instance.clone();
David Brazdilf18e1162022-12-18 18:27:23 +0000308 let monitor_vm_exit_thread = Some(thread::spawn(move || {
Seungjae Yoo3271f172024-06-11 10:14:07 +0900309 instance_clone.monitor_vm_exit(child_clone, failure_pipe_read, vfio_devices, tap);
David Brazdilf18e1162022-12-18 18:27:23 +0000310 }));
Andrew Walbranf8d94112021-09-07 11:45:36 +0000311
Jiyong Parka4eebde2022-07-12 18:01:12 +0900312 if detect_hangup {
313 let child_clone = child.clone();
314 thread::spawn(move || {
315 instance.monitor_payload_hangup(child_clone);
316 });
317 }
318
Andrew Walbranf8d94112021-09-07 11:45:36 +0000319 // If it started correctly, update the state.
David Brazdilf18e1162022-12-18 18:27:23 +0000320 *self = VmState::Running { child, monitor_vm_exit_thread };
Andrew Walbranf8d94112021-09-07 11:45:36 +0000321 Ok(())
322 } else {
323 *self = state;
324 bail!("VM already started or failed")
325 }
326 }
327}
328
David Brazdil8cf8f482022-11-23 14:21:26 +0000329/// Internal struct that holds the handles to globally unique resources of a VM.
330#[derive(Debug)]
331pub struct VmContext {
332 #[allow(dead_code)] // Keeps the global context alive
Yi-Yo Chiang2fbf0da2024-06-14 22:56:56 +0800333 pub(crate) global_context: Strong<dyn IGlobalVmContext>,
David Brazdil8cf8f482022-11-23 14:21:26 +0000334 #[allow(dead_code)] // Keeps the server alive
335 vm_server: RpcServer,
336}
337
338impl VmContext {
339 /// Construct new VmContext.
340 pub fn new(global_context: Strong<dyn IGlobalVmContext>, vm_server: RpcServer) -> VmContext {
341 VmContext { global_context, vm_server }
342 }
343}
344
Andrew Walbranf8d94112021-09-07 11:45:36 +0000345/// Information about a particular instance of a VM which may be running.
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000346#[derive(Debug)]
347pub struct VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000348 /// The current state of the VM.
349 pub vm_state: Mutex<VmState>,
David Brazdil8cf8f482022-11-23 14:21:26 +0000350 /// Global resources allocated for this VM.
351 #[allow(dead_code)] // Keeps the context alive
Yi-Yo Chiang2fbf0da2024-06-14 22:56:56 +0800352 pub(crate) vm_context: VmContext,
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000353 /// The CID assigned to the VM for vsock communication.
354 pub cid: Cid,
Keir Frasercdd4b112022-11-24 14:02:25 +0000355 /// Path to crosvm control socket
356 crosvm_control_socket_path: PathBuf,
Seungjae Yoo62085c02022-08-12 04:44:52 +0000357 /// The name of the VM.
358 pub name: String,
Andrew Walbranf8650422021-06-09 15:54:09 +0000359 /// Whether the VM is a protected VM.
360 pub protected: bool,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000361 /// Directory of temporary files used by the VM while it is running.
362 pub temporary_directory: PathBuf,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000363 /// The UID of the process which requested the VM.
364 pub requester_uid: u32,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000365 /// The PID of the process which requested the VM. Note that this process may no longer exist
366 /// and the PID may have been reused for a different process, so this should not be trusted.
Andrew Walbran02034492021-04-13 15:05:07 +0000367 pub requester_debug_pid: i32,
Andrew Walbrandae07162021-03-12 17:05:20 +0000368 /// Callbacks to clients of the VM.
369 pub callbacks: VirtualMachineCallbacks,
Inseob Kimc7d28c72021-10-25 14:28:10 +0000370 /// VirtualMachineService binder object for the VM.
371 pub vm_service: Mutex<Option<Strong<dyn IVirtualMachineService>>>,
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900372 /// Recorded metrics of VM such as timestamp or cpu / memory usage.
373 pub vm_metric: Mutex<VmMetric>,
Andrew Walbran6b650662021-09-07 13:13:23 +0000374 /// The latest lifecycle state which the payload reported itself to be in.
375 payload_state: Mutex<PayloadState>,
Jiyong Parka4eebde2022-07-12 18:01:12 +0900376 /// Represents the condition that payload_state was updated
377 payload_state_updated: Condvar,
Jiyong Park08eee7b2022-11-11 15:01:26 +0900378 /// The human readable name of requester_uid
379 requester_uid_name: String,
380}
381
382impl fmt::Display for VmInstance {
383 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
384 let adj = if self.protected { "Protected" } else { "Non-protected" };
385 write!(
386 f,
387 "{} virtual machine \"{}\" (owner: {}, cid: {})",
388 adj, self.name, self.requester_uid_name, self.cid
389 )
390 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000391}
392
393impl VmInstance {
Andrew Walbranf8d94112021-09-07 11:45:36 +0000394 /// Validates the given config and creates a new `VmInstance` but doesn't start running it.
395 pub fn new(
Andrew Walbrand3a84182021-09-07 14:48:52 +0000396 config: CrosvmConfig,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000397 temporary_directory: PathBuf,
Andrew Walbranf6a1eb92021-04-01 11:16:02 +0000398 requester_uid: u32,
Andrew Walbran02034492021-04-13 15:05:07 +0000399 requester_debug_pid: i32,
David Brazdil8cf8f482022-11-23 14:21:26 +0000400 vm_context: VmContext,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000401 ) -> Result<VmInstance, Error> {
402 validate_config(&config)?;
Andrew Walbrand3a84182021-09-07 14:48:52 +0000403 let cid = config.cid;
Seungjae Yoo62085c02022-08-12 04:44:52 +0000404 let name = config.name.clone();
Andrew Walbrand3a84182021-09-07 14:48:52 +0000405 let protected = config.protected;
Jiyong Park08eee7b2022-11-11 15:01:26 +0900406 let requester_uid_name = User::from_uid(Uid::from_raw(requester_uid))
407 .ok()
408 .flatten()
409 .map_or_else(|| format!("{}", requester_uid), |u| u.name);
410 let instance = VmInstance {
Inseob Kim7307a892023-09-14 13:37:58 +0900411 vm_state: Mutex::new(VmState::NotStarted { config: Box::new(config) }),
David Brazdil528e0472022-10-10 15:06:02 +0100412 vm_context,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000413 cid,
Keir Frasercdd4b112022-11-24 14:02:25 +0000414 crosvm_control_socket_path: temporary_directory.join("crosvm.sock"),
Seungjae Yoo62085c02022-08-12 04:44:52 +0000415 name,
Andrew Walbrand3a84182021-09-07 14:48:52 +0000416 protected,
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000417 temporary_directory,
Andrew Walbran02034492021-04-13 15:05:07 +0000418 requester_uid,
Andrew Walbran02034492021-04-13 15:05:07 +0000419 requester_debug_pid,
Andrew Walbranf8d94112021-09-07 11:45:36 +0000420 callbacks: Default::default(),
Inseob Kimc7d28c72021-10-25 14:28:10 +0000421 vm_service: Mutex::new(None),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900422 vm_metric: Mutex::new(Default::default()),
Andrew Walbranf8d94112021-09-07 11:45:36 +0000423 payload_state: Mutex::new(PayloadState::Starting),
Jiyong Parka4eebde2022-07-12 18:01:12 +0900424 payload_state_updated: Condvar::new(),
Jiyong Park08eee7b2022-11-11 15:01:26 +0900425 requester_uid_name,
426 };
427 info!("{} created", &instance);
428 Ok(instance)
Andrew Walbrandae07162021-03-12 17:05:20 +0000429 }
430
Andrew Walbranf8d94112021-09-07 11:45:36 +0000431 /// Starts an instance of `crosvm` to manage the VM. The `crosvm` instance will be killed when
432 /// the `VmInstance` is dropped.
433 pub fn start(self: &Arc<Self>) -> Result<(), Error> {
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900434 let mut vm_metric = self.vm_metric.lock().unwrap();
435 vm_metric.start_timestamp = Some(SystemTime::now());
Jiyong Park08eee7b2022-11-11 15:01:26 +0900436 let ret = self.vm_state.lock().unwrap().start(self.clone());
437 if ret.is_ok() {
438 info!("{} started", &self);
439 }
440 ret.with_context(|| format!("{} failed to start", &self))
Andrew Walbranf8d94112021-09-07 11:45:36 +0000441 }
442
Jiyong Parka4eebde2022-07-12 18:01:12 +0900443 /// Monitors the exit of the VM (i.e. termination of the `child` process). When that happens,
444 /// handles the event by updating the state, noityfing the event to clients by calling
445 /// callbacks, and removing temporary files for the VM.
Inseob Kim6ef80972023-07-20 17:23:36 +0900446 fn monitor_vm_exit(
447 &self,
448 child: Arc<SharedChild>,
449 mut failure_pipe_read: File,
Inseob Kim7307a892023-09-14 13:37:58 +0900450 vfio_devices: Vec<VfioDevice>,
Seungjae Yoo3271f172024-06-11 10:14:07 +0900451 tap: Option<File>,
Inseob Kim6ef80972023-07-20 17:23:36 +0900452 ) {
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000453 let result = child.wait();
454 match &result {
Jooyung Hanbfe086f2021-10-28 10:15:45 +0900455 Err(e) => error!("Error waiting for crosvm({}) instance to die: {}", child.id(), e),
Sebastian Ene23167d82022-10-07 14:09:53 +0000456 Ok(status) => {
457 info!("crosvm({}) exited with status {}", child.id(), status);
458 if let Some(exit_status_code) = status.code() {
459 if exit_status_code == CROSVM_WATCHDOG_REBOOT_STATUS {
460 info!("detected vcpu stall on crosvm");
461 }
462 }
463 }
Andrew Walbrandae07162021-03-12 17:05:20 +0000464 }
Andrew Walbranf8d94112021-09-07 11:45:36 +0000465
466 let mut vm_state = self.vm_state.lock().unwrap();
467 *vm_state = VmState::Dead;
468 // Ensure that the mutex is released before calling the callbacks.
469 drop(vm_state);
Jiyong Park08eee7b2022-11-11 15:01:26 +0900470 info!("{} exited", &self);
Andrew Walbranf8d94112021-09-07 11:45:36 +0000471
Jiyong Parka4eebde2022-07-12 18:01:12 +0900472 // Read the pipe to see if any failure reason is written
473 let mut failure_reason = String::new();
474 match failure_pipe_read.read_to_string(&mut failure_reason) {
475 Err(e) => error!("Error reading VM failure reason from pipe: {}", e),
476 Ok(len) if len > 0 => info!("VM returned failure reason '{}'", &failure_reason),
477 _ => (),
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900478 };
Andrew Walbranb27681f2022-02-23 15:11:52 +0000479
Jiyong Parka4eebde2022-07-12 18:01:12 +0900480 // In case of hangup, the pipe doesn't give us any information because the hangup can't be
481 // detected on the VM side (otherwise, it isn't a hangup), but in the
482 // monitor_payload_hangup function below which updates the payload state to Hangup.
483 let failure_reason =
484 if failure_reason.is_empty() && self.payload_state() == PayloadState::Hangup {
485 Cow::from("HANGUP")
486 } else {
487 Cow::from(failure_reason)
488 };
489
Jiyong Parke558ab12022-07-07 20:18:55 +0900490 self.handle_ramdump().unwrap_or_else(|e| error!("Error handling ramdump: {}", e));
Seungjae Yoob4c07ba2022-08-12 04:44:52 +0000491
492 let death_reason = death_reason(&result, &failure_reason);
Seungjae Yoo93430e82022-12-05 16:37:42 +0900493 let exit_signal = exit_signal(&result);
494
Seungjae Yoob4c07ba2022-08-12 04:44:52 +0000495 self.callbacks.callback_on_died(self.cid, death_reason);
Seungjae Yoo2e7beea2022-08-24 16:09:12 +0900496
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900497 let vm_metric = self.vm_metric.lock().unwrap();
Seungjae Yoob2db3d22023-04-06 18:05:43 +0900498 write_vm_exited_stats_sync(
Seungjae Yoo93430e82022-12-05 16:37:42 +0900499 self.requester_uid as i32,
500 &self.name,
501 death_reason,
502 exit_signal,
Chris Wailes75269622022-12-05 23:01:44 -0800503 &vm_metric,
Seungjae Yoo93430e82022-12-05 16:37:42 +0900504 );
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +0000505
David Brazdil4b4c5102022-12-19 22:56:20 +0000506 // Delete temporary files. The folder itself is removed by VirtualizationServiceInternal.
507 remove_temporary_files(&self.temporary_directory).unwrap_or_else(|e| {
508 error!("Error removing temporary files from {:?}: {}", self.temporary_directory, e);
509 });
Inseob Kim6ef80972023-07-20 17:23:36 +0900510
Seungjae Yoo3271f172024-06-11 10:14:07 +0900511 if let Some(tap_file) = tap {
512 GLOBAL_SERVICE
513 .deleteTapInterface(&ParcelFileDescriptor::new(OwnedFd::from(tap_file)))
514 .unwrap_or_else(|e| {
515 error!("Error deleting TAP interface: {e:?}");
516 });
517 }
518
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000519 drop(vfio_devices); // Cleanup devices.
Andrew Walbrandae07162021-03-12 17:05:20 +0000520 }
521
Jiyong Parka4eebde2022-07-12 18:01:12 +0900522 /// Waits until payload is started, or timeout expires. When timeout occurs, kill
523 /// the VM to prevent indefinite hangup and update the payload_state accordingly.
524 fn monitor_payload_hangup(&self, child: Arc<SharedChild>) {
525 debug!("Starting to monitor hangup for Microdroid({})", child.id());
Jiyong Parkcf975612024-04-07 13:27:10 +0900526 let (state, result) = self
Jiyong Parka4eebde2022-07-12 18:01:12 +0900527 .payload_state_updated
528 .wait_timeout_while(self.payload_state.lock().unwrap(), *BOOT_HANGUP_TIMEOUT, |s| {
529 *s < PayloadState::Started
530 })
531 .unwrap();
Jiyong Parkcf975612024-04-07 13:27:10 +0900532 drop(state); // we are not interested in state
Jiyong Parka4eebde2022-07-12 18:01:12 +0900533 let child_still_running = child.try_wait().ok() == Some(None);
534 if result.timed_out() && child_still_running {
535 error!(
536 "Microdroid({}) failed to start payload within {} secs timeout. Shutting down.",
537 child.id(),
538 BOOT_HANGUP_TIMEOUT.as_secs()
539 );
540 self.update_payload_state(PayloadState::Hangup).unwrap();
541 if let Err(e) = self.kill() {
542 error!("Error stopping timed-out VM with CID {}: {:?}", child.id(), e);
543 }
544 }
545 }
546
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900547 fn monitor_vm_status(&self, child: Arc<SharedChild>) {
548 let pid = child.id();
549
550 loop {
551 {
552 // Check VM state
553 let vm_state = &*self.vm_state.lock().unwrap();
554 if let VmState::Dead = vm_state {
555 break;
556 }
557
558 let mut vm_metric = self.vm_metric.lock().unwrap();
559
560 // Get CPU Information
Jiyong Park85ea5382024-02-19 15:04:23 +0900561 match get_guest_time(pid) {
562 Ok(guest_time) => vm_metric.cpu_guest_time = Some(guest_time),
563 Err(e) => error!("Failed to get guest CPU time: {e:?}"),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900564 }
565
566 // Get Memory Information
Jiyong Park85ea5382024-02-19 15:04:23 +0900567 match get_rss(pid) {
568 Ok(rss) => {
569 vm_metric.rss = match &vm_metric.rss {
570 Some(x) => Some(Rss::extract_max(x, &rss)),
571 None => Some(rss),
572 }
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900573 }
Jiyong Park85ea5382024-02-19 15:04:23 +0900574 Err(e) => error!("Failed to get guest RSS: {}", e),
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900575 }
576 }
577
578 thread::sleep(Duration::from_secs(1));
579 }
580 }
581
Andrew Walbran6b650662021-09-07 13:13:23 +0000582 /// Returns the last reported state of the VM payload.
583 pub fn payload_state(&self) -> PayloadState {
584 *self.payload_state.lock().unwrap()
585 }
586
587 /// Updates the payload state to the given value, if it is a valid state transition.
588 pub fn update_payload_state(&self, new_state: PayloadState) -> Result<(), Error> {
589 let mut state_locked = self.payload_state.lock().unwrap();
590 // Only allow forward transitions, e.g. from starting to started or finished, not back in
591 // the other direction.
592 if new_state > *state_locked {
593 *state_locked = new_state;
Jiyong Parka4eebde2022-07-12 18:01:12 +0900594 self.payload_state_updated.notify_all();
Andrew Walbran6b650662021-09-07 13:13:23 +0000595 Ok(())
596 } else {
597 bail!("Invalid payload state transition from {:?} to {:?}", *state_locked, new_state)
598 }
599 }
600
Andrew Walbranf8d94112021-09-07 11:45:36 +0000601 /// Kills the crosvm instance, if it is running.
Inseob Kima446f802022-07-11 19:46:37 +0900602 pub fn kill(&self) -> Result<(), Error> {
David Brazdilf18e1162022-12-18 18:27:23 +0000603 let monitor_vm_exit_thread = {
604 let vm_state = &mut *self.vm_state.lock().unwrap();
605 if let VmState::Running { child, monitor_vm_exit_thread } = vm_state {
606 let id = child.id();
607 debug!("Killing crosvm({})", id);
608 // TODO: Talk to crosvm to shutdown cleanly.
609 child.kill().with_context(|| format!("Error killing crosvm({id}) instance"))?;
610 monitor_vm_exit_thread.take()
Inseob Kima446f802022-07-11 19:46:37 +0900611 } else {
David Brazdilf18e1162022-12-18 18:27:23 +0000612 bail!("VM is not running")
Andrew Walbranf8d94112021-09-07 11:45:36 +0000613 }
David Brazdilf18e1162022-12-18 18:27:23 +0000614 };
615
616 // Wait for monitor_vm_exit() to finish. Must release vm_state lock
617 // first, as monitor_vm_exit() takes it as well.
618 monitor_vm_exit_thread.map(JoinHandle::join);
619
David Brazdil5af55832023-03-08 13:08:56 +0000620 // Now that the VM has been killed, shut down the VirtualMachineService
621 // server to eagerly free up the server threads.
622 self.vm_context.vm_server.shutdown()?;
623
David Brazdilf18e1162022-12-18 18:27:23 +0000624 Ok(())
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000625 }
Jiyong Parke558ab12022-07-07 20:18:55 +0900626
Keir Frasercdd4b112022-11-24 14:02:25 +0000627 /// Responds to memory-trimming notifications by inflating the virtio
628 /// balloon to reclaim guest memory.
629 pub fn trim_memory(&self, level: MemoryTrimLevel) -> Result<(), Error> {
630 let request = VmRequest::BalloonCommand(BalloonControlCommand::Stats {});
631 match vm_control::client::handle_request(&request, &self.crosvm_control_socket_path) {
632 Ok(VmResponse::BalloonStats { stats, balloon_actual: _ }) => {
633 if let Some(total_memory) = stats.total_memory {
634 // Reclaim up to 50% of total memory assuming worst case
635 // most memory is anonymous and must be swapped to zram
636 // with an approximate 2:1 compression ratio.
637 let pct = match level {
638 MemoryTrimLevel::TRIM_MEMORY_RUNNING_CRITICAL => 50,
639 MemoryTrimLevel::TRIM_MEMORY_RUNNING_LOW => 30,
640 MemoryTrimLevel::TRIM_MEMORY_RUNNING_MODERATE => 10,
641 _ => bail!("Invalid memory trim level {:?}", level),
642 };
Devin Moore30be4482023-08-21 22:44:26 +0000643 let command = BalloonControlCommand::Adjust {
644 num_bytes: total_memory * pct / 100,
645 wait_for_success: false,
646 };
Keir Frasercdd4b112022-11-24 14:02:25 +0000647 if let Err(e) = vm_control::client::handle_request(
648 &VmRequest::BalloonCommand(command),
649 &self.crosvm_control_socket_path,
650 ) {
651 bail!("Error sending balloon adjustment: {:?}", e);
652 }
653 }
654 }
655 Ok(VmResponse::Err(e)) => {
Alice Wangeff58392023-07-04 13:32:09 +0000656 // ENOTSUP is returned when the balloon protocol is not initialized. This
Keir Frasercdd4b112022-11-24 14:02:25 +0000657 // can occur for numerous reasons: Guest is still booting, guest doesn't
658 // support ballooning, host doesn't support ballooning. We don't log or
659 // raise an error in this case: trim is just a hint and we can ignore it.
660 if e.errno() != libc::ENOTSUP {
661 bail!("Errno return when requesting balloon stats: {}", e.errno())
662 }
663 }
664 e => bail!("Error requesting balloon stats: {:?}", e),
665 }
666 Ok(())
667 }
668
Alan Stokes3e98d292022-12-14 15:18:22 +0000669 /// Checks if ramdump has been created. If so, send it to tombstoned.
Jiyong Parke558ab12022-07-07 20:18:55 +0900670 fn handle_ramdump(&self) -> Result<(), Error> {
671 let ramdump_path = self.temporary_directory.join("ramdump");
Jiyong Park933d2b22023-02-28 11:41:19 +0900672 if !ramdump_path.as_path().try_exists()? {
673 return Ok(());
674 }
Jiyong Parke558ab12022-07-07 20:18:55 +0900675 if std::fs::metadata(&ramdump_path)?.len() > 0 {
Jiyong Park1612b902022-08-22 14:47:39 +0900676 Self::send_ramdump_to_tombstoned(&ramdump_path)?;
Jiyong Parke558ab12022-07-07 20:18:55 +0900677 }
678 Ok(())
679 }
Jiyong Park1612b902022-08-22 14:47:39 +0900680
681 fn send_ramdump_to_tombstoned(ramdump_path: &Path) -> Result<(), Error> {
682 let mut input = File::open(ramdump_path)
Alan Stokes3e98d292022-12-14 15:18:22 +0000683 .context(format!("Failed to open ramdump {:?} for reading", ramdump_path))?;
Jiyong Park1612b902022-08-22 14:47:39 +0900684
685 let pid = std::process::id() as i32;
686 let conn = TombstonedConnection::connect(pid, DebuggerdDumpType::Tombstone)
687 .context("Failed to connect to tombstoned")?;
688 let mut output = conn
689 .text_output
690 .as_ref()
691 .ok_or_else(|| anyhow!("Could not get file to write the tombstones on"))?;
692
693 std::io::copy(&mut input, &mut output).context("Failed to send ramdump to tombstoned")?;
694 info!("Ramdump {:?} sent to tombstoned", ramdump_path);
695
696 conn.notify_completion()?;
697 Ok(())
698 }
Jiyong Park23b67392024-07-04 13:51:42 +0900699
700 /// Suspends the VM
701 pub fn suspend(&self) -> Result<(), Error> {
702 match vm_control::client::handle_request(
703 &VmRequest::SuspendVcpus,
704 &self.crosvm_control_socket_path,
705 ) {
706 Ok(VmResponse::Ok) => Ok(()),
707 e => bail!("Failed to suspend VM: {e:?}"),
708 }
709 }
710
711 /// Resumes the suspended VM
712 pub fn resume(&self) -> Result<(), Error> {
713 match vm_control::client::handle_request(
714 &VmRequest::ResumeVcpus,
715 &self.crosvm_control_socket_path,
716 ) {
717 Ok(VmResponse::Ok) => Ok(()),
718 e => bail!("Failed to resume: {e:?}"),
719 }
720 }
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000721}
722
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900723impl Rss {
724 fn extract_max(x: &Rss, y: &Rss) -> Rss {
725 Rss { vm: max(x.vm, y.vm), crosvm: max(x.crosvm, y.crosvm) }
726 }
727}
728
David Daiaaecf652024-02-22 14:41:39 -0800729// Get Cpus_allowed mask
730fn check_if_all_cpus_allowed() -> Result<bool> {
731 let file = read_to_string("/proc/self/status")?;
732 let lines: Vec<_> = file.split('\n').collect();
733
734 for line in lines {
735 if line.contains("Cpus_allowed_list") {
736 let prop: Vec<_> = line.split_whitespace().collect();
737 if prop.len() != 2 {
738 return Ok(false);
739 }
740 let cpu_list: Vec<_> = prop[1].split('-').collect();
741 //Only contiguous Cpu list allowed
742 if cpu_list.len() != 2 {
743 return Ok(false);
744 }
745 if let Some(cpus) = get_num_cpus() {
746 let max_cpu = cpu_list[1].parse::<usize>()?;
747 if max_cpu == cpus - 1 {
748 return Ok(true);
749 } else {
750 return Ok(false);
751 }
752 }
753 }
754 }
755 Ok(false)
756}
757
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900758// Get guest time from /proc/[crosvm pid]/stat
759fn get_guest_time(pid: u32) -> Result<i64> {
760 let file = read_to_string(format!("/proc/{}/stat", pid))?;
761 let data_list: Vec<_> = file.split_whitespace().collect();
762
763 // Information about guest_time is at 43th place of the file split with the whitespace.
764 // Example of /proc/[pid]/stat :
765 // 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
766 // 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
767 if data_list.len() < 43 {
768 bail!("Failed to parse command result for getting guest time : {}", file);
769 }
770
771 let guest_time_ticks = data_list[42].parse::<i64>()?;
Andrew Walbranb58d1b42023-07-07 13:54:49 +0100772 // SAFETY: It just returns an integer about CPU tick information.
Charisee96113f32023-01-26 09:00:42 +0000773 let ticks_per_sec = unsafe { sysconf(_SC_CLK_TCK) };
Seungjae Yoo6d265d92022-11-15 10:51:33 +0900774 Ok(guest_time_ticks * MILLIS_PER_SEC / ticks_per_sec)
775}
776
777// Get rss from /proc/[crosvm pid]/smaps
778fn get_rss(pid: u32) -> Result<Rss> {
779 let file = read_to_string(format!("/proc/{}/smaps", pid))?;
780 let lines: Vec<_> = file.split('\n').collect();
781
782 let mut rss_vm_total = 0i64;
783 let mut rss_crosvm_total = 0i64;
784 let mut is_vm = false;
785 for line in lines {
786 if line.contains("crosvm_guest") {
787 is_vm = true;
788 } else if line.contains("Rss:") {
789 let data_list: Vec<_> = line.split_whitespace().collect();
790 if data_list.len() < 2 {
791 bail!("Failed to parse command result for getting rss :\n{}", line);
792 }
793 let rss = data_list[1].parse::<i64>()?;
794
795 if is_vm {
796 rss_vm_total += rss;
797 is_vm = false;
798 }
799 rss_crosvm_total += rss;
800 }
801 }
802
803 Ok(Rss { vm: rss_vm_total, crosvm: rss_crosvm_total })
804}
805
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100806fn death_reason(result: &Result<ExitStatus, io::Error>, mut failure_reason: &str) -> DeathReason {
Pierre-Clément Tosic0611e72023-09-15 11:41:07 +0100807 if let Some((reason, info)) = failure_reason.split_once('|') {
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100808 // Separator indicates extra context information is present after the failure name.
Pierre-Clément Tosic0611e72023-09-15 11:41:07 +0100809 error!("Failure info: {info}");
810 failure_reason = reason;
Alan Stokes3ba10fd2022-10-06 15:46:51 +0100811 }
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000812 if let Ok(status) = result {
Andrew Walbranb27681f2022-02-23 15:11:52 +0000813 match failure_reason {
814 "PVM_FIRMWARE_PUBLIC_KEY_MISMATCH" => {
815 return DeathReason::PVM_FIRMWARE_PUBLIC_KEY_MISMATCH
816 }
817 "PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED" => {
818 return DeathReason::PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED
819 }
Inseob Kim272f5722022-06-13 17:14:51 +0900820 "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE" => {
821 return DeathReason::MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE
822 }
823 "MICRODROID_PAYLOAD_HAS_CHANGED" => return DeathReason::MICRODROID_PAYLOAD_HAS_CHANGED,
824 "MICRODROID_PAYLOAD_VERIFICATION_FAILED" => {
825 return DeathReason::MICRODROID_PAYLOAD_VERIFICATION_FAILED
826 }
827 "MICRODROID_INVALID_PAYLOAD_CONFIG" => {
828 return DeathReason::MICRODROID_INVALID_PAYLOAD_CONFIG
829 }
830 "MICRODROID_UNKNOWN_RUNTIME_ERROR" => {
831 return DeathReason::MICRODROID_UNKNOWN_RUNTIME_ERROR
832 }
Jiyong Parke6ed0f92022-06-22 00:13:00 +0900833 "HANGUP" => return DeathReason::HANGUP,
Andrew Walbranb27681f2022-02-23 15:11:52 +0000834 _ => {}
835 }
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000836 match status.code() {
837 None => DeathReason::KILLED,
838 Some(0) => DeathReason::SHUTDOWN,
Alan Stokes7c459e82022-12-06 12:21:49 +0000839 Some(CROSVM_START_ERROR_STATUS) => DeathReason::START_FAILED,
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000840 Some(CROSVM_REBOOT_STATUS) => DeathReason::REBOOT,
Andrew Walbrand15c5632022-02-03 13:38:31 +0000841 Some(CROSVM_CRASH_STATUS) => DeathReason::CRASH,
Sebastian Ene23167d82022-10-07 14:09:53 +0000842 Some(CROSVM_WATCHDOG_REBOOT_STATUS) => DeathReason::WATCHDOG_REBOOT,
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000843 Some(_) => DeathReason::UNKNOWN,
844 }
845 } else {
846 DeathReason::INFRASTRUCTURE_ERROR
847 }
848}
849
Seungjae Yoo93430e82022-12-05 16:37:42 +0900850fn exit_signal(result: &Result<ExitStatus, io::Error>) -> Option<i32> {
851 match result {
852 Ok(status) => status.signal(),
853 Err(_) => None,
854 }
855}
856
Inseob Kim6ef80972023-07-20 17:23:36 +0900857const SYSFS_PLATFORM_DEVICES_PATH: &str = "/sys/devices/platform/";
858const VFIO_PLATFORM_DRIVER_PATH: &str = "/sys/bus/platform/drivers/vfio-platform";
859
Inseob Kim7307a892023-09-14 13:37:58 +0900860fn vfio_argument_for_platform_device(device: &VfioDevice) -> Result<String, Error> {
Inseob Kim6ef80972023-07-20 17:23:36 +0900861 // Check platform device exists
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000862 let path = Path::new(&device.getSysfsPath()?).canonicalize()?;
Inseob Kim6ef80972023-07-20 17:23:36 +0900863 if !path.starts_with(SYSFS_PLATFORM_DEVICES_PATH) {
864 bail!("{path:?} is not a platform device");
865 }
866
867 // Check platform device is bound to VFIO driver
868 let dev_driver_path = path.join("driver").canonicalize()?;
869 if dev_driver_path != Path::new(VFIO_PLATFORM_DRIVER_PATH) {
870 bail!("{path:?} is not bound to VFIO-platform driver");
871 }
872
873 if let Some(p) = path.to_str() {
Jakob Vukalovicd42aa2c2023-11-09 16:04:00 +0000874 Ok(format!("--vfio={p},iommu=pkvm-iommu,dt-symbol={0}", device.getDtboLabel()?))
Inseob Kim6ef80972023-07-20 17:23:36 +0900875 } else {
876 bail!("invalid path {path:?}");
877 }
878}
879
David Brazdil2dfefd12023-11-17 14:07:36 +0000880fn append_platform_devices(
881 command: &mut Command,
882 preserved_fds: &mut Vec<RawFd>,
883 config: &CrosvmConfig,
884) -> Result<(), Error> {
885 if config.vfio_devices.is_empty() {
886 return Ok(());
887 }
888
889 let Some(dtbo) = &config.dtbo else {
890 bail!("VFIO devices assigned but no DTBO available");
891 };
892 command.arg(format!("--device-tree-overlay={},filter", add_preserved_fd(preserved_fds, dtbo)));
893
Inseob Kim6ef80972023-07-20 17:23:36 +0900894 for device in &config.vfio_devices {
895 command.arg(vfio_argument_for_platform_device(device)?);
896 }
Inseob Kim6ef80972023-07-20 17:23:36 +0900897 Ok(())
898}
899
Andrew Walbrand3a84182021-09-07 14:48:52 +0000900/// Starts an instance of `crosvm` to manage a new VM.
Keir Fraser13a956a2022-07-14 14:20:46 +0000901fn run_vm(
902 config: CrosvmConfig,
Keir Frasercdd4b112022-11-24 14:02:25 +0000903 crosvm_control_socket_path: &Path,
Keir Fraser13a956a2022-07-14 14:20:46 +0000904 failure_pipe_write: File,
905) -> Result<SharedChild, Error> {
Andrew Walbrand3a84182021-09-07 14:48:52 +0000906 validate_config(&config)?;
Andrew Walbrand6dce6f2021-03-05 16:39:08 +0000907
908 let mut command = Command::new(CROSVM_PATH);
909 // TODO(qwandor): Remove --disable-sandbox.
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000910 command
911 .arg("--extended-status")
Jiyong Park6c60fea2022-10-24 16:10:01 +0900912 // Configure the logger for the crosvm process to silence logs from the disk crate which
913 // don't provide much information to us (but do spamming us).
914 .arg("--log-level")
Frederick Mayle138f53c2023-01-24 18:55:26 -0800915 .arg("info,disk=warn")
Andrew Walbranc92d35f2022-01-12 12:45:19 +0000916 .arg("run")
917 .arg("--disable-sandbox")
918 .arg("--cid")
919 .arg(config.cid.to_string());
Andrew Walbran3a5a9212021-05-04 17:09:08 +0000920
Keir Fraserf25cb922022-11-23 14:26:00 +0000921 if system_properties::read_bool("hypervisor.memory_reclaim.supported", false)? {
922 command.arg("--balloon-page-reporting");
923 } else {
924 command.arg("--no-balloon");
925 }
926
Jiyong Parkae625b62024-06-13 21:47:52 +0900927 let mut memory_mib = config.memory_mib;
928
Andrew Walbranf8650422021-06-09 15:54:09 +0000929 if config.protected {
Jaewan Kim46422812022-11-25 10:59:39 +0900930 match system_properties::read(SYSPROP_CUSTOM_PVMFW_PATH)? {
931 Some(pvmfw_path) if !pvmfw_path.is_empty() => {
932 command.arg("--protected-vm-with-firmware").arg(pvmfw_path)
933 }
934 _ => command.arg("--protected-vm"),
935 };
Andrew Walbran0b5789f2022-02-04 13:57:57 +0000936
937 // 3 virtio-console devices + vsock = 4.
938 let virtio_pci_device_count = 4 + config.disks.len();
939 // crosvm virtio queue has 256 entries, so 2 MiB per device (2 pages per entry) should be
940 // enough.
Jiyong Park3115cdb2023-02-24 18:04:44 +0900941 let swiotlb_size_mib = 2 * virtio_pci_device_count as u32;
Andrew Walbran0b5789f2022-02-04 13:57:57 +0000942 command.arg("--swiotlb").arg(swiotlb_size_mib.to_string());
Frederick Mayle58baa302023-02-14 19:06:37 -0800943
Jiyong Parkae625b62024-06-13 21:47:52 +0900944 // b/346770542 for consistent "usable" memory across protected and non-protected VMs under
945 // pKVM.
946 if hypervisor_props::is_pkvm()? {
947 memory_mib = memory_mib.map(|m| m.saturating_add(swiotlb_size_mib));
948 }
949
Frederick Mayle58baa302023-02-14 19:06:37 -0800950 // Workaround to keep crash_dump from trying to read protected guest memory.
951 // Context in b/238324526.
952 command.arg("--unmap-guest-memory-on-fork");
Jiyong Park3115cdb2023-02-24 18:04:44 +0900953
Jiyong Parked180932023-02-24 19:55:41 +0900954 if config.ramdump.is_some() {
Jaewan Kim3124ef02023-03-23 19:25:20 +0900955 // Protected VM needs to reserve memory for ramdump here. Note that we reserve more
Jiyong Parked180932023-02-24 19:55:41 +0900956 // memory for the restricted dma pool.
957 let ramdump_reserve = RAMDUMP_RESERVED_MIB + swiotlb_size_mib;
958 command.arg("--params").arg(format!("crashkernel={ramdump_reserve}M"));
959 }
Jaewan Kimd4dae652023-03-28 13:45:43 +0900960 } else if config.ramdump.is_some() {
961 command.arg("--params").arg(format!("crashkernel={RAMDUMP_RESERVED_MIB}M"));
962 }
Jaewan Kim61f86142023-03-28 15:12:52 +0900963 if config.debug_config.debug_level == DebugLevel::NONE
964 && config.debug_config.should_prepare_console_output()
965 {
Jaewan Kimd4dae652023-03-28 13:45:43 +0900966 // bootconfig.normal will be used, but we need log.
967 command.arg("--params").arg("printk.devkmsg=on");
968 command.arg("--params").arg("console=hvc0");
Andrew Walbranf8650422021-06-09 15:54:09 +0000969 }
970
Jiyong Parkae625b62024-06-13 21:47:52 +0900971 if let Some(memory_mib) = memory_mib {
Andrew Walbranb15cd6e2021-07-05 16:38:07 +0000972 command.arg("--mem").arg(memory_mib.to_string());
973 }
974
Jiyong Park032615f2022-01-10 13:55:34 +0900975 if let Some(cpus) = config.cpus {
976 command.arg("--cpus").arg(cpus.to_string());
977 }
978
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000979 if config.host_cpu_topology {
David Daiaaecf652024-02-22 14:41:39 -0800980 if cfg!(virt_cpufreq) && check_if_all_cpus_allowed()? {
David Daie6f5bb02024-01-25 19:17:02 -0800981 command.arg("--host-cpu-topology");
David Daic97e82d2024-02-17 12:10:31 -0800982 cfg_if::cfg_if! {
983 if #[cfg(any(target_arch = "aarch64"))] {
984 command.arg("--virt-cpufreq");
985 }
986 }
David Daie6f5bb02024-01-25 19:17:02 -0800987 } else if let Some(cpus) = get_num_cpus() {
David Brazdil25e8c052023-02-17 12:53:01 +0000988 command.arg("--cpus").arg(cpus.to_string());
989 } else {
990 bail!("Could not determine the number of CPUs in the system");
991 }
David Brazdil7d1e5ec2023-02-06 17:56:29 +0000992 }
993
Nikita Ioffe5776f082023-02-10 21:38:26 +0000994 if let Some(gdb_port) = config.gdb_port {
995 command.arg("--gdb").arg(gdb_port.to_string());
996 }
997
Jiyong Parkfa91d702021-10-18 23:51:39 +0900998 // Keep track of what file descriptors should be mapped to the crosvm process.
999 let mut preserved_fds = config.indirect_files.iter().map(|file| file.as_raw_fd()).collect();
1000
Jiyong Park747d6362021-10-19 17:12:52 +09001001 // Setup the serial devices.
1002 // 1. uart device: used as the output device by bootloaders and as early console by linux
Andrew Walbranb27681f2022-02-23 15:11:52 +00001003 // 2. uart device: used to report the reason for the VM failing.
1004 // 3. virtio-console device: used as the console device where kmsg is redirected to
Jiyong Park4afe2012022-07-08 05:38:49 +09001005 // 4. virtio-console device: used as the ramdump output
Andrew Walbranb27681f2022-02-23 15:11:52 +00001006 // 5. virtio-console device: used as the logcat output
Jiyong Park747d6362021-10-19 17:12:52 +09001007 //
Jiyong Parkb8182bb2021-10-26 22:53:08 +09001008 // When [console|log]_fd is not specified, the devices are attached to sink, which means what's
1009 // written there is discarded.
Jiyong Parke6fb1672023-06-26 16:45:55 +09001010 let console_out_arg = format_serial_out_arg(&mut preserved_fds, &config.console_out_fd);
1011 let console_in_arg = config
1012 .console_in_fd
1013 .as_ref()
1014 .map(|fd| format!(",input={}", add_preserved_fd(&mut preserved_fds, fd)))
1015 .unwrap_or_default();
1016 let log_arg = format_serial_out_arg(&mut preserved_fds, &config.log_fd);
Andrew Walbranb27681f2022-02-23 15:11:52 +00001017 let failure_serial_path = add_preserved_fd(&mut preserved_fds, &failure_pipe_write);
Jiyong Parke6fb1672023-06-26 16:45:55 +09001018 let ramdump_arg = format_serial_out_arg(&mut preserved_fds, &config.ramdump);
Yi-Yo Chiang8dd32552024-05-22 19:38:16 +08001019 let console_input_device = config.console_input_device.as_deref().unwrap_or(CONSOLE_HVC0);
1020 match console_input_device {
1021 CONSOLE_HVC0 | CONSOLE_TTYS0 => {}
1022 _ => bail!("Unsupported serial device {console_input_device}"),
1023 };
Jiyong Parkfa91d702021-10-18 23:51:39 +09001024
Jiyong Park747d6362021-10-19 17:12:52 +09001025 // Warning: Adding more serial devices requires you to shift the PCI device ID of the boot
1026 // disks in bootconfig.x86_64. This is because x86 crosvm puts serial devices and the block
1027 // devices in the same PCI bus and serial devices comes before the block devices. Arm crosvm
1028 // doesn't have the issue.
Jiyong Parkfa91d702021-10-18 23:51:39 +09001029 // /dev/ttyS0
Yi-Yo Chiang8dd32552024-05-22 19:38:16 +08001030 command.arg(format!(
1031 "--serial={}{},hardware=serial,num=1",
1032 &console_out_arg,
1033 if console_input_device == CONSOLE_TTYS0 { &console_in_arg } else { "" }
1034 ));
Andrew Walbranb27681f2022-02-23 15:11:52 +00001035 // /dev/ttyS1
1036 command.arg(format!("--serial=type=file,path={},hardware=serial,num=2", &failure_serial_path));
Jiyong Parkfa91d702021-10-18 23:51:39 +09001037 // /dev/hvc0
Jiyong Parke6fb1672023-06-26 16:45:55 +09001038 command.arg(format!(
1039 "--serial={}{},hardware=virtio-console,num=1",
Yi-Yo Chiang8dd32552024-05-22 19:38:16 +08001040 &console_out_arg,
1041 if console_input_device == CONSOLE_HVC0 { &console_in_arg } else { "" }
Jiyong Parke6fb1672023-06-26 16:45:55 +09001042 ));
Jiyong Park4afe2012022-07-08 05:38:49 +09001043 // /dev/hvc1
1044 command.arg(format!("--serial={},hardware=virtio-console,num=2", &ramdump_arg));
Jiyong Parkae5a4ed2021-11-01 18:36:28 +09001045 // /dev/hvc2
1046 command.arg(format!("--serial={},hardware=virtio-console,num=3", &log_arg));
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001047
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001048 if let Some(bootloader) = &config.bootloader {
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001049 command.arg("--bios").arg(add_preserved_fd(&mut preserved_fds, bootloader));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001050 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001051
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001052 if let Some(initrd) = &config.initrd {
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001053 command.arg("--initrd").arg(add_preserved_fd(&mut preserved_fds, initrd));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001054 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001055
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001056 if let Some(params) = &config.params {
1057 command.arg("--params").arg(params);
1058 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001059
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001060 for disk in &config.disks {
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +00001061 command
1062 .arg(if disk.writable { "--rwdisk" } else { "--disk" })
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001063 .arg(add_preserved_fd(&mut preserved_fds, &disk.image));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001064 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001065
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001066 if let Some(kernel) = &config.kernel {
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001067 command.arg(add_preserved_fd(&mut preserved_fds, kernel));
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001068 }
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001069
Keir Frasercdd4b112022-11-24 14:02:25 +00001070 let control_server_socket = UnixSeqpacketListener::bind(crosvm_control_socket_path)
1071 .context("failed to create control server")?;
Elie Kheirallah2d12ff32023-03-20 18:12:07 +00001072 command
1073 .arg("--socket")
1074 .arg(add_preserved_fd(&mut preserved_fds, &control_server_socket.as_raw_descriptor()));
Keir Fraser13a956a2022-07-14 14:20:46 +00001075
Shikha Panwar55e10ec2024-02-13 12:53:49 +00001076 if let Some(dt_overlay) = &config.device_tree_overlay {
1077 command.arg("--device-tree-overlay").arg(add_preserved_fd(&mut preserved_fds, dt_overlay));
Seungjae Yoo4dd38182023-11-09 15:05:45 +09001078 }
Jeongik Cha798401c2024-04-11 21:54:49 +09001079
1080 if cfg!(paravirtualized_devices) {
Jason Macnakea7b0fa2024-05-08 17:02:44 -07001081 if let Some(gpu_config) = &config.gpu_config {
1082 let mut gpu_args = Vec::new();
1083 if let Some(backend) = &gpu_config.backend {
1084 gpu_args.push(format!("backend={}", backend));
1085 }
1086 if let Some(context_types) = &gpu_config.context_types {
1087 gpu_args.push(format!("context-types={}", context_types.join(":")));
1088 }
1089 if let Some(pci_address) = &gpu_config.pci_address {
1090 gpu_args.push(format!("pci-address={}", pci_address));
1091 }
1092 if let Some(renderer_features) = &gpu_config.renderer_features {
1093 gpu_args.push(format!("renderer-features={}", renderer_features));
1094 }
1095 if gpu_config.renderer_use_egl.unwrap_or(false) {
1096 gpu_args.push("egl=true".to_string());
1097 }
1098 if gpu_config.renderer_use_gles.unwrap_or(false) {
1099 gpu_args.push("gles=true".to_string());
1100 }
1101 if gpu_config.renderer_use_glx.unwrap_or(false) {
1102 gpu_args.push("glx=true".to_string());
1103 }
1104 if gpu_config.renderer_use_surfaceless.unwrap_or(false) {
1105 gpu_args.push("surfaceless=true".to_string());
1106 }
1107 if gpu_config.renderer_use_vulkan.unwrap_or(false) {
1108 gpu_args.push("vulkan=true".to_string());
1109 }
1110 command.arg(format!("--gpu={}", gpu_args.join(",")));
1111 }
Jeongik Cha798401c2024-04-11 21:54:49 +09001112 if let Some(display_config) = &config.display_config {
Jason Macnakea7b0fa2024-05-08 17:02:44 -07001113 command
1114 .arg(format!(
1115 "--gpu-display=mode=windowed[{},{}],dpi=[{},{}],refresh-rate={}",
1116 display_config.width,
1117 display_config.height,
1118 display_config.horizontal_dpi,
1119 display_config.vertical_dpi,
1120 display_config.refresh_rate
1121 ))
1122 .arg(format!("--android-display-service={}", config.name));
Jeongik Cha798401c2024-04-11 21:54:49 +09001123 }
Jeongik Cha1df1c032024-04-03 16:03:12 +09001124 }
Seungjae Yooec3bc522023-11-09 10:14:30 +09001125
Seungjae Yoo986d7a42024-05-28 14:06:58 +09001126 if cfg!(network) {
1127 if let Some(tap) = &config.tap {
1128 let tap_fd = tap.as_raw_fd();
1129 preserved_fds.push(tap_fd);
1130 command.arg("--net").arg(format!("tap-fd={}", tap_fd));
1131 }
1132 }
1133
Jeongik Cha6be4f8b2024-04-16 01:13:13 +09001134 if cfg!(paravirtualized_devices) {
Jeongik Chac181be72024-03-27 00:18:30 +09001135 for input_device_option in config.input_device_options.iter() {
1136 command.arg("--input");
1137 command.arg(match input_device_option {
1138 InputDeviceOption::EvDev(file) => {
1139 format!("evdev[path={}]", add_preserved_fd(&mut preserved_fds, file))
1140 }
Jeongik Cha985b6402024-04-15 18:13:00 +09001141 InputDeviceOption::Keyboard(file) => {
1142 format!("keyboard[path={}]", add_preserved_fd(&mut preserved_fds, file))
1143 }
Jeongik Cha343894e2024-05-17 20:39:31 +09001144 InputDeviceOption::Mouse(file) => {
1145 format!("mouse[path={}]", add_preserved_fd(&mut preserved_fds, file))
1146 }
Jeongik Chac181be72024-03-27 00:18:30 +09001147 InputDeviceOption::SingleTouch { file, width, height, name } => format!(
1148 "single-touch[path={},width={},height={}{}]",
1149 add_preserved_fd(&mut preserved_fds, file),
1150 width,
1151 height,
1152 name.as_ref().map_or("".into(), |n| format!(",name={}", n))
1153 ),
Jiyong Park6c1b9f02024-07-05 16:21:10 +09001154 InputDeviceOption::Switches(file) => {
1155 format!("switches[path={}]", add_preserved_fd(&mut preserved_fds, file))
1156 }
Jeongik Chac181be72024-03-27 00:18:30 +09001157 });
1158 }
1159 }
Vincent Donnefort538a2c62024-03-20 16:01:10 +00001160
1161 if config.hugepages {
1162 command.arg("--hugepages");
1163 }
1164
David Dai23cff712024-06-13 19:23:45 +00001165 if config.boost_uclamp {
1166 command.arg("--boost-uclamp");
1167 }
1168
David Brazdil2dfefd12023-11-17 14:07:36 +00001169 append_platform_devices(&mut command, &mut preserved_fds, &config)?;
Inseob Kim6ef80972023-07-20 17:23:36 +09001170
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001171 debug!("Preserving FDs {:?}", preserved_fds);
1172 command.preserved_fds(preserved_fds);
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001173
Mu-Le Lee134180a2024-04-16 15:13:07 +08001174 if cfg!(paravirtualized_devices) {
Mu-Le Leeb2d5a312024-06-05 10:52:47 +08001175 if let Some(audio_config) = &config.audio_config {
1176 command.arg("--virtio-snd").arg(format!(
1177 "backend=aaudio,num_input_devices={},num_output_devices={}",
1178 if audio_config.use_microphone { 1 } else { 0 },
1179 if audio_config.use_speaker { 1 } else { 0 }
1180 ));
Mu-Le Lee134180a2024-04-16 15:13:07 +08001181 }
1182 }
1183
Jiyong Park2d736562022-10-24 22:40:12 +09001184 print_crosvm_args(&command);
1185
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001186 let result = SharedChild::spawn(&mut command)?;
Jooyung Hanbfe086f2021-10-28 10:15:45 +09001187 debug!("Spawned crosvm({}).", result.id());
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001188 Ok(result)
1189}
1190
1191/// Ensure that the configuration has a valid combination of fields set, or return an error if not.
Andrew Walbranf5fbb7d2021-05-12 17:15:48 +00001192fn validate_config(config: &CrosvmConfig) -> Result<(), Error> {
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001193 if config.bootloader.is_none() && config.kernel.is_none() {
1194 bail!("VM must have either a bootloader or a kernel image.");
1195 }
1196 if config.bootloader.is_some() && (config.kernel.is_some() || config.initrd.is_some()) {
1197 bail!("Can't have both bootloader and kernel/initrd image.");
1198 }
Jiyong Parkdcf17412022-02-08 15:07:23 +09001199 let version = Version::parse(CROSVM_PLATFORM_VERSION).unwrap();
1200 if !config.platform_version.matches(&version) {
1201 bail!(
1202 "Incompatible platform version. The config is compatible with platform version(s) \
1203 {}, but the actual platform version is {}",
1204 config.platform_version,
1205 version
1206 );
1207 }
1208
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001209 Ok(())
1210}
1211
Jiyong Park2d736562022-10-24 22:40:12 +09001212/// Print arguments of the crosvm command. In doing so, /proc/self/fd/XX is annotated with the
1213/// actual file path if the FD is backed by a regular file. If not, the /proc path is printed
1214/// unmodified.
1215fn print_crosvm_args(command: &Command) {
1216 let re = Regex::new(r"/proc/self/fd/[\d]+").unwrap();
1217 info!(
1218 "Running crosvm with args: {:?}",
1219 command
1220 .get_args()
1221 .map(|s| s.to_string_lossy())
1222 .map(|s| {
1223 re.replace_all(&s, |caps: &Captures| {
1224 let path = &caps[0];
1225 if let Ok(realpath) = std::fs::canonicalize(path) {
1226 format!("{} ({})", path, realpath.to_string_lossy())
1227 } else {
1228 path.to_owned()
1229 }
1230 })
1231 .into_owned()
1232 })
1233 .collect::<Vec<_>>()
1234 );
1235}
1236
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001237/// Adds the file descriptor for `file` to `preserved_fds`, and returns a string of the form
1238/// "/proc/self/fd/N" where N is the file descriptor.
Keir Fraser13a956a2022-07-14 14:20:46 +00001239fn add_preserved_fd(preserved_fds: &mut Vec<RawFd>, file: &dyn AsRawFd) -> String {
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001240 let fd = file.as_raw_fd();
Andrew Walbran02b8ec02021-06-22 13:07:02 +00001241 preserved_fds.push(fd);
Andrew Walbran3a5a9212021-05-04 17:09:08 +00001242 format!("/proc/self/fd/{}", fd)
Andrew Walbrand6dce6f2021-03-05 16:39:08 +00001243}
Andrew Walbranb27681f2022-02-23 15:11:52 +00001244
1245/// Adds the file descriptor for `file` (if any) to `preserved_fds`, and returns the appropriate
1246/// string for a crosvm `--serial` flag. If `file` is none, creates a dummy sink device.
Jiyong Parke6fb1672023-06-26 16:45:55 +09001247fn format_serial_out_arg(preserved_fds: &mut Vec<RawFd>, file: &Option<File>) -> String {
Andrew Walbranb27681f2022-02-23 15:11:52 +00001248 if let Some(file) = file {
1249 format!("type=file,path={}", add_preserved_fd(preserved_fds, file))
1250 } else {
1251 "type=sink".to_string()
1252 }
1253}
1254
1255/// Creates a new pipe with the `O_CLOEXEC` flag set, and returns the read side and write side.
1256fn create_pipe() -> Result<(File, File), Error> {
Frederick Maylefbbcfcd2024-04-08 16:31:54 -07001257 let (read_fd, write_fd) = pipe2(OFlag::O_CLOEXEC)?;
1258 Ok((read_fd.into(), write_fd.into()))
Andrew Walbranb27681f2022-02-23 15:11:52 +00001259}