Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1 | // Copyright 2021, The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | //! Functions for running instances of `crosvm`. |
| 16 | |
Seungjae Yoo | 3271f17 | 2024-06-11 10:14:07 +0900 | [diff] [blame] | 17 | use crate::aidl::{remove_temporary_files, Cid, GLOBAL_SERVICE, VirtualMachineCallbacks}; |
Seungjae Yoo | b2db3d2 | 2023-04-06 18:05:43 +0900 | [diff] [blame] | 18 | use crate::atom::{get_num_cpus, write_vm_exited_stats_sync}; |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 19 | use crate::debug_config::DebugConfig; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 20 | use anyhow::{anyhow, bail, Context, Error, Result}; |
Seungjae Yoo | 3271f17 | 2024-06-11 10:14:07 +0900 | [diff] [blame] | 21 | use binder::ParcelFileDescriptor; |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 22 | use command_fds::CommandFdExt; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 23 | use libc::{sysconf, _SC_CLK_TCK}; |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 24 | use log::{debug, error, info}; |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 25 | use semver::{Version, VersionReq}; |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 26 | use nix::{fcntl::OFlag, unistd::pipe2, unistd::Uid, unistd::User}; |
Jiyong Park | 2d73656 | 2022-10-24 22:40:12 +0900 | [diff] [blame] | 27 | use regex::{Captures, Regex}; |
Keir Fraser | f25cb92 | 2022-11-23 14:26:00 +0000 | [diff] [blame] | 28 | use rustutils::system_properties; |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 29 | use shared_child::SharedChild; |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 30 | use std::borrow::Cow; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 31 | use std::cmp::max; |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 32 | use std::ffi::CString; |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 33 | use std::fmt; |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 34 | use std::fs::{read_to_string, File}; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 35 | use std::io::{self, Read}; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 36 | use std::mem; |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 37 | use std::num::{NonZeroU16, NonZeroU32}; |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 38 | use std::os::unix::io::{AsRawFd, OwnedFd}; |
Jiyong Park | f50ec33 | 2024-10-23 17:54:03 +0900 | [diff] [blame] | 39 | use std::os::unix::process::CommandExt; |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 40 | use std::os::unix::process::ExitStatusExt; |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 41 | use std::path::{Path, PathBuf}; |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 42 | use std::process::{Command, ExitStatus}; |
Andrew Walbran | 9c03a3a | 2024-09-03 12:12:59 +0100 | [diff] [blame] | 43 | use std::sync::{Arc, Condvar, Mutex, LazyLock}; |
Seungjae Yoo | 2e7beea | 2022-08-24 16:09:12 +0900 | [diff] [blame] | 44 | use std::time::{Duration, SystemTime}; |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 45 | use std::thread::{self, JoinHandle}; |
David Brazdil | 49f96f5 | 2022-12-16 21:29:13 +0000 | [diff] [blame] | 46 | use android_system_virtualizationcommon::aidl::android::system::virtualizationcommon::DeathReason::DeathReason; |
Jaewan Kim | 84b9121 | 2023-02-28 00:11:57 +0900 | [diff] [blame] | 47 | use android_system_virtualizationservice::aidl::android::system::virtualizationservice::{ |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 48 | VirtualMachineAppConfig::DebugLevel::DebugLevel, |
Mu-Le Lee | b2d5a31 | 2024-06-05 10:52:47 +0800 | [diff] [blame] | 49 | AudioConfig::AudioConfig as AudioConfigParcelable, |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 50 | DisplayConfig::DisplayConfig as DisplayConfigParcelable, |
Jason Macnak | ea7b0fa | 2024-05-08 17:02:44 -0700 | [diff] [blame] | 51 | GpuConfig::GpuConfig as GpuConfigParcelable, |
Elie Kheirallah | 29d7291 | 2024-08-07 20:17:26 +0000 | [diff] [blame] | 52 | UsbConfig::UsbConfig as UsbConfigParcelable, |
Jaewan Kim | 84b9121 | 2023-02-28 00:11:57 +0900 | [diff] [blame] | 53 | }; |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 54 | use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IGlobalVmContext::IGlobalVmContext; |
Jakob Vukalovic | d42aa2c | 2023-11-09 16:04:00 +0000 | [diff] [blame] | 55 | use android_system_virtualizationservice_internal::aidl::android::system::virtualizationservice_internal::IBoundDevice::IBoundDevice; |
Alan Stokes | 0e82b50 | 2022-08-08 14:44:48 +0100 | [diff] [blame] | 56 | use binder::Strong; |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 57 | use android_system_virtualmachineservice::aidl::android::system::virtualmachineservice::IVirtualMachineService::IVirtualMachineService; |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 58 | use tombstoned_client::{TombstonedConnection, DebuggerdDumpType}; |
David Brazdil | 73988ea | 2022-11-11 15:10:32 +0000 | [diff] [blame] | 59 | use rpcbinder::RpcServer; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 60 | |
| 61 | const CROSVM_PATH: &str = "/apex/com.android.virt/bin/crosvm"; |
| 62 | |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 63 | /// Version of the platform that crosvm currently implements. The format follows SemVer. This |
| 64 | /// should be updated when there is a platform change in the crosvm side. Having this value here is |
| 65 | /// fine because virtualizationservice and crosvm are supposed to be updated together in the virt |
| 66 | /// APEX. |
| 67 | const CROSVM_PLATFORM_VERSION: &str = "1.0.0"; |
| 68 | |
Andrew Walbran | d15c563 | 2022-02-03 13:38:31 +0000 | [diff] [blame] | 69 | /// The exit status which crosvm returns when it has an error starting a VM. |
Alan Stokes | 7c459e8 | 2022-12-06 12:21:49 +0000 | [diff] [blame] | 70 | const CROSVM_START_ERROR_STATUS: i32 = 1; |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 71 | /// The exit status which crosvm returns when a VM requests a reboot. |
| 72 | const CROSVM_REBOOT_STATUS: i32 = 32; |
Andrew Walbran | d15c563 | 2022-02-03 13:38:31 +0000 | [diff] [blame] | 73 | /// The exit status which crosvm returns when it crashes due to an error. |
| 74 | const CROSVM_CRASH_STATUS: i32 = 33; |
Sebastian Ene | 23167d8 | 2022-10-07 14:09:53 +0000 | [diff] [blame] | 75 | /// The exit status which crosvm returns when vcpu is stalled. |
| 76 | const CROSVM_WATCHDOG_REBOOT_STATUS: i32 = 36; |
Jiyong Park | 3115cdb | 2023-02-24 18:04:44 +0900 | [diff] [blame] | 77 | /// The size of memory (in MiB) reserved for ramdump |
| 78 | const RAMDUMP_RESERVED_MIB: u32 = 17; |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 79 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 80 | const MILLIS_PER_SEC: i64 = 1000; |
| 81 | |
Jaewan Kim | 4642281 | 2022-11-25 10:59:39 +0900 | [diff] [blame] | 82 | const SYSPROP_CUSTOM_PVMFW_PATH: &str = "hypervisor.pvmfw.path"; |
| 83 | |
Yi-Yo Chiang | 8dd3255 | 2024-05-22 19:38:16 +0800 | [diff] [blame] | 84 | /// Serial device for VM console input. |
| 85 | /// Hypervisor (virtio-console) |
| 86 | const CONSOLE_HVC0: &str = "hvc0"; |
| 87 | /// Serial (emulated uart) |
| 88 | const CONSOLE_TTYS0: &str = "ttyS0"; |
| 89 | |
Andrew Walbran | 9c03a3a | 2024-09-03 12:12:59 +0100 | [diff] [blame] | 90 | /// If the VM doesn't move to the Started state within this amount time, a hang-up error is |
| 91 | /// triggered. |
| 92 | static BOOT_HANGUP_TIMEOUT: LazyLock<Duration> = LazyLock::new(|| { |
| 93 | if nested_virt::is_nested_virtualization().unwrap() { |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 94 | // Nested virtualization is slow, so we need a longer timeout. |
Inseob Kim | e557cec | 2023-01-26 22:49:58 +0900 | [diff] [blame] | 95 | Duration::from_secs(300) |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 96 | } else { |
Inseob Kim | e557cec | 2023-01-26 22:49:58 +0900 | [diff] [blame] | 97 | Duration::from_secs(30) |
Andrew Walbran | 9c03a3a | 2024-09-03 12:12:59 +0100 | [diff] [blame] | 98 | } |
| 99 | }); |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 100 | |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 101 | /// Configuration for a VM to run with crosvm. |
| 102 | #[derive(Debug)] |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 103 | pub struct CrosvmConfig { |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 104 | pub cid: Cid, |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 105 | pub name: String, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 106 | pub bootloader: Option<File>, |
| 107 | pub kernel: Option<File>, |
| 108 | pub initrd: Option<File>, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 109 | pub disks: Vec<DiskFile>, |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 110 | pub shared_paths: Vec<SharedPathConfig>, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 111 | pub params: Option<String>, |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 112 | pub protected: bool, |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 113 | pub debug_config: DebugConfig, |
Frederick Mayle | 68d06e7 | 2024-07-12 17:18:11 -0700 | [diff] [blame] | 114 | pub memory_mib: NonZeroU32, |
Frederick Mayle | 384f5b5 | 2024-12-06 16:23:23 -0800 | [diff] [blame] | 115 | pub swiotlb_mib: Option<NonZeroU32>, |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 116 | pub cpus: Option<NonZeroU32>, |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 117 | pub host_cpu_topology: bool, |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 118 | pub console_out_fd: Option<File>, |
| 119 | pub console_in_fd: Option<File>, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 120 | pub log_fd: Option<File>, |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 121 | pub ramdump: Option<File>, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 122 | pub indirect_files: Vec<File>, |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 123 | pub platform_version: VersionReq, |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 124 | pub detect_hangup: bool, |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 125 | pub gdb_port: Option<NonZeroU16>, |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 126 | pub vfio_devices: Vec<VfioDevice>, |
David Brazdil | 2dfefd1 | 2023-11-17 14:07:36 +0000 | [diff] [blame] | 127 | pub dtbo: Option<File>, |
Jaewan Kim | f43372b | 2024-12-13 18:33:58 +0900 | [diff] [blame] | 128 | pub device_tree_overlays: Vec<File>, |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 129 | pub display_config: Option<DisplayConfig>, |
Jeongik Cha | c181be7 | 2024-03-27 00:18:30 +0900 | [diff] [blame] | 130 | pub input_device_options: Vec<InputDeviceOption>, |
Vincent Donnefort | 538a2c6 | 2024-03-20 16:01:10 +0000 | [diff] [blame] | 131 | pub hugepages: bool, |
Seungjae Yoo | 986d7a4 | 2024-05-28 14:06:58 +0900 | [diff] [blame] | 132 | pub tap: Option<File>, |
Yi-Yo Chiang | 8dd3255 | 2024-05-22 19:38:16 +0800 | [diff] [blame] | 133 | pub console_input_device: Option<String>, |
David Dai | 23cff71 | 2024-06-13 19:23:45 +0000 | [diff] [blame] | 134 | pub boost_uclamp: bool, |
Jason Macnak | ea7b0fa | 2024-05-08 17:02:44 -0700 | [diff] [blame] | 135 | pub gpu_config: Option<GpuConfig>, |
Mu-Le Lee | b2d5a31 | 2024-06-05 10:52:47 +0800 | [diff] [blame] | 136 | pub audio_config: Option<AudioConfig>, |
Frederick Mayle | cc4e2d7 | 2024-12-06 16:54:40 -0800 | [diff] [blame] | 137 | pub balloon: bool, |
Elie Kheirallah | 29d7291 | 2024-08-07 20:17:26 +0000 | [diff] [blame] | 138 | pub usb_config: UsbConfig, |
Elie Kheirallah | 5c807a2 | 2024-09-23 20:40:42 +0000 | [diff] [blame] | 139 | pub dump_dt_fd: Option<File>, |
Frederick Mayle | 196ca2b | 2024-12-18 15:27:43 -0800 | [diff] [blame] | 140 | pub enable_hypervisor_specific_auth_method: bool, |
| 141 | pub instance_id: [u8; 64], |
Mu-Le Lee | b2d5a31 | 2024-06-05 10:52:47 +0800 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | #[derive(Debug)] |
| 145 | pub struct AudioConfig { |
| 146 | pub use_microphone: bool, |
| 147 | pub use_speaker: bool, |
| 148 | } |
| 149 | |
| 150 | impl AudioConfig { |
| 151 | pub fn new(raw_config: &AudioConfigParcelable) -> Self { |
| 152 | AudioConfig { use_microphone: raw_config.useMicrophone, use_speaker: raw_config.useSpeaker } |
| 153 | } |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | #[derive(Debug)] |
Elie Kheirallah | 29d7291 | 2024-08-07 20:17:26 +0000 | [diff] [blame] | 157 | pub struct UsbConfig { |
| 158 | pub controller: bool, |
| 159 | } |
| 160 | |
| 161 | impl UsbConfig { |
| 162 | pub fn new(raw_config: &UsbConfigParcelable) -> Result<UsbConfig> { |
| 163 | Ok(UsbConfig { controller: raw_config.controller }) |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | #[derive(Debug)] |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 168 | pub struct DisplayConfig { |
| 169 | pub width: NonZeroU32, |
| 170 | pub height: NonZeroU32, |
| 171 | pub horizontal_dpi: NonZeroU32, |
| 172 | pub vertical_dpi: NonZeroU32, |
| 173 | pub refresh_rate: NonZeroU32, |
| 174 | } |
| 175 | |
| 176 | impl DisplayConfig { |
| 177 | pub fn new(raw_config: &DisplayConfigParcelable) -> Result<DisplayConfig> { |
| 178 | let width = try_into_non_zero_u32(raw_config.width)?; |
| 179 | let height = try_into_non_zero_u32(raw_config.height)?; |
| 180 | let horizontal_dpi = try_into_non_zero_u32(raw_config.horizontalDpi)?; |
| 181 | let vertical_dpi = try_into_non_zero_u32(raw_config.verticalDpi)?; |
| 182 | let refresh_rate = try_into_non_zero_u32(raw_config.refreshRate)?; |
| 183 | Ok(DisplayConfig { width, height, horizontal_dpi, vertical_dpi, refresh_rate }) |
| 184 | } |
| 185 | } |
| 186 | |
Jason Macnak | ea7b0fa | 2024-05-08 17:02:44 -0700 | [diff] [blame] | 187 | #[derive(Debug)] |
| 188 | pub struct GpuConfig { |
| 189 | pub backend: Option<String>, |
| 190 | pub context_types: Option<Vec<String>>, |
| 191 | pub pci_address: Option<String>, |
| 192 | pub renderer_features: Option<String>, |
| 193 | pub renderer_use_egl: Option<bool>, |
| 194 | pub renderer_use_gles: Option<bool>, |
| 195 | pub renderer_use_glx: Option<bool>, |
| 196 | pub renderer_use_surfaceless: Option<bool>, |
| 197 | pub renderer_use_vulkan: Option<bool>, |
| 198 | } |
| 199 | |
| 200 | impl GpuConfig { |
| 201 | pub fn new(raw_config: &GpuConfigParcelable) -> Result<GpuConfig> { |
| 202 | Ok(GpuConfig { |
| 203 | backend: raw_config.backend.clone(), |
| 204 | context_types: raw_config.contextTypes.clone().map(|context_types| { |
| 205 | context_types.iter().filter_map(|context_type| context_type.clone()).collect() |
| 206 | }), |
| 207 | pci_address: raw_config.pciAddress.clone(), |
| 208 | renderer_features: raw_config.rendererFeatures.clone(), |
| 209 | renderer_use_egl: Some(raw_config.rendererUseEgl), |
| 210 | renderer_use_gles: Some(raw_config.rendererUseGles), |
| 211 | renderer_use_glx: Some(raw_config.rendererUseGlx), |
| 212 | renderer_use_surfaceless: Some(raw_config.rendererUseSurfaceless), |
| 213 | renderer_use_vulkan: Some(raw_config.rendererUseVulkan), |
| 214 | }) |
| 215 | } |
| 216 | } |
| 217 | |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 218 | fn try_into_non_zero_u32(value: i32) -> Result<NonZeroU32> { |
| 219 | let u32_value = value.try_into()?; |
| 220 | NonZeroU32::new(u32_value).ok_or(anyhow!("value should be greater than 0")) |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | /// A disk image to pass to crosvm for a VM. |
| 224 | #[derive(Debug)] |
| 225 | pub struct DiskFile { |
| 226 | pub image: File, |
| 227 | pub writable: bool, |
| 228 | } |
| 229 | |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 230 | /// Shared path between host and guest VM. |
| 231 | #[derive(Debug)] |
| 232 | pub struct SharedPathConfig { |
| 233 | pub path: String, |
| 234 | pub host_uid: i32, |
| 235 | pub host_gid: i32, |
| 236 | pub guest_uid: i32, |
| 237 | pub guest_gid: i32, |
| 238 | pub mask: i32, |
| 239 | pub tag: String, |
| 240 | pub socket_path: String, |
Akilesh Kailash | c9aa068 | 2024-11-25 10:27:24 -0800 | [diff] [blame] | 241 | pub socket_fd: Option<File>, |
| 242 | pub app_domain: bool, |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 243 | } |
| 244 | |
Jeongik Cha | c181be7 | 2024-03-27 00:18:30 +0900 | [diff] [blame] | 245 | /// virtio-input device configuration from `external/crosvm/src/crosvm/config.rs` |
| 246 | #[derive(Debug)] |
| 247 | #[allow(dead_code)] |
| 248 | pub enum InputDeviceOption { |
| 249 | EvDev(File), |
| 250 | SingleTouch { file: File, width: u32, height: u32, name: Option<String> }, |
Jeongik Cha | 985b640 | 2024-04-15 18:13:00 +0900 | [diff] [blame] | 251 | Keyboard(File), |
Jeongik Cha | 343894e | 2024-05-17 20:39:31 +0900 | [diff] [blame] | 252 | Mouse(File), |
Jiyong Park | 6c1b9f0 | 2024-07-05 16:21:10 +0900 | [diff] [blame] | 253 | Switches(File), |
Jeongik Cha | 112a268 | 2024-07-09 12:28:45 +0900 | [diff] [blame] | 254 | MultiTouchTrackpad { file: File, width: u32, height: u32, name: Option<String> }, |
Jeongik Cha | 1049491 | 2024-07-16 11:19:50 +0900 | [diff] [blame] | 255 | MultiTouch { file: File, width: u32, height: u32, name: Option<String> }, |
Jeongik Cha | c181be7 | 2024-03-27 00:18:30 +0900 | [diff] [blame] | 256 | } |
| 257 | |
Jakob Vukalovic | d42aa2c | 2023-11-09 16:04:00 +0000 | [diff] [blame] | 258 | type VfioDevice = Strong<dyn IBoundDevice>; |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 259 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 260 | /// The lifecycle state which the payload in the VM has reported itself to be in. |
| 261 | /// |
| 262 | /// Note that the order of enum variants is significant; only forward transitions are allowed by |
| 263 | /// [`VmInstance::update_payload_state`]. |
| 264 | #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] |
| 265 | pub enum PayloadState { |
| 266 | Starting, |
| 267 | Started, |
| 268 | Ready, |
| 269 | Finished, |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 270 | Hangup, // Hasn't reached to Ready before timeout expires |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 271 | } |
| 272 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 273 | /// The current state of the VM itself. |
| 274 | #[derive(Debug)] |
| 275 | pub enum VmState { |
| 276 | /// The VM has not yet tried to start. |
| 277 | NotStarted { |
| 278 | ///The configuration needed to start the VM, if it has not yet been started. |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 279 | config: Box<CrosvmConfig>, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 280 | }, |
| 281 | /// The VM has been started. |
| 282 | Running { |
| 283 | /// The crosvm child process. |
| 284 | child: Arc<SharedChild>, |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 285 | /// The thread waiting for crosvm to finish. |
| 286 | monitor_vm_exit_thread: Option<JoinHandle<()>>, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 287 | }, |
| 288 | /// The VM died or was killed. |
| 289 | Dead, |
| 290 | /// The VM failed to start. |
| 291 | Failed, |
| 292 | } |
| 293 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 294 | /// RSS values of VM and CrosVM process itself. |
| 295 | #[derive(Copy, Clone, Debug, Default)] |
| 296 | pub struct Rss { |
| 297 | pub vm: i64, |
| 298 | pub crosvm: i64, |
| 299 | } |
| 300 | |
| 301 | /// Metrics regarding the VM. |
| 302 | #[derive(Debug, Default)] |
| 303 | pub struct VmMetric { |
| 304 | /// Recorded timestamp when the VM is started. |
| 305 | pub start_timestamp: Option<SystemTime>, |
Pierre-Clément Tosi | 44aba64 | 2023-09-15 11:44:34 +0100 | [diff] [blame] | 306 | /// Update most recent guest_time periodically from /proc/[crosvm pid]/stat while VM is |
| 307 | /// running. |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 308 | pub cpu_guest_time: Option<i64>, |
| 309 | /// Update maximum RSS values periodically from /proc/[crosvm pid]/smaps while VM is running. |
| 310 | pub rss: Option<Rss>, |
| 311 | } |
| 312 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 313 | impl VmState { |
| 314 | /// Tries to start the VM, if it is in the `NotStarted` state. |
| 315 | /// |
| 316 | /// Returns an error if the VM is in the wrong state, or fails to start. |
| 317 | fn start(&mut self, instance: Arc<VmInstance>) -> Result<(), Error> { |
| 318 | let state = mem::replace(self, VmState::Failed); |
| 319 | if let VmState::NotStarted { config } = state { |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 320 | let config = *config; |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 321 | let detect_hangup = config.detect_hangup; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 322 | let (failure_pipe_read, failure_pipe_write) = create_pipe()?; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 323 | let vfio_devices = config.vfio_devices.clone(); |
Seungjae Yoo | 3271f17 | 2024-06-11 10:14:07 +0900 | [diff] [blame] | 324 | let tap = |
| 325 | if let Some(tap_file) = &config.tap { Some(tap_file.try_clone()?) } else { None }; |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 326 | |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 327 | let vhost_fs_devices = run_virtiofs(&config)?; |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 328 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 329 | // If this fails and returns an error, `self` will be left in the `Failed` state. |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 330 | let child = |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 331 | Arc::new(run_vm(config, &instance.crosvm_control_socket_path, failure_pipe_write)?); |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 332 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 333 | let instance_monitor_status = instance.clone(); |
| 334 | let child_monitor_status = child.clone(); |
| 335 | thread::spawn(move || { |
| 336 | instance_monitor_status.clone().monitor_vm_status(child_monitor_status); |
| 337 | }); |
| 338 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 339 | let child_clone = child.clone(); |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 340 | let instance_clone = instance.clone(); |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 341 | let monitor_vm_exit_thread = Some(thread::spawn(move || { |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 342 | instance_clone.monitor_vm_exit( |
| 343 | child_clone, |
| 344 | failure_pipe_read, |
| 345 | vfio_devices, |
| 346 | tap, |
| 347 | vhost_fs_devices, |
| 348 | ); |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 349 | })); |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 350 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 351 | if detect_hangup { |
| 352 | let child_clone = child.clone(); |
| 353 | thread::spawn(move || { |
| 354 | instance.monitor_payload_hangup(child_clone); |
| 355 | }); |
| 356 | } |
| 357 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 358 | // If it started correctly, update the state. |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 359 | *self = VmState::Running { child, monitor_vm_exit_thread }; |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 360 | Ok(()) |
| 361 | } else { |
| 362 | *self = state; |
| 363 | bail!("VM already started or failed") |
| 364 | } |
| 365 | } |
| 366 | } |
| 367 | |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 368 | /// Internal struct that holds the handles to globally unique resources of a VM. |
| 369 | #[derive(Debug)] |
| 370 | pub struct VmContext { |
| 371 | #[allow(dead_code)] // Keeps the global context alive |
Yi-Yo Chiang | 2fbf0da | 2024-06-14 22:56:56 +0800 | [diff] [blame] | 372 | pub(crate) global_context: Strong<dyn IGlobalVmContext>, |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 373 | #[allow(dead_code)] // Keeps the server alive |
Jiyong Park | 690c1ca | 2024-11-28 18:06:50 +0900 | [diff] [blame] | 374 | vm_server: Option<RpcServer>, |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 375 | } |
| 376 | |
| 377 | impl VmContext { |
| 378 | /// Construct new VmContext. |
Jiyong Park | 690c1ca | 2024-11-28 18:06:50 +0900 | [diff] [blame] | 379 | pub fn new( |
| 380 | global_context: Strong<dyn IGlobalVmContext>, |
| 381 | vm_server: Option<RpcServer>, |
| 382 | ) -> VmContext { |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 383 | VmContext { global_context, vm_server } |
| 384 | } |
| 385 | } |
| 386 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 387 | /// Information about a particular instance of a VM which may be running. |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 388 | #[derive(Debug)] |
| 389 | pub struct VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 390 | /// The current state of the VM. |
| 391 | pub vm_state: Mutex<VmState>, |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 392 | /// Global resources allocated for this VM. |
| 393 | #[allow(dead_code)] // Keeps the context alive |
Yi-Yo Chiang | 2fbf0da | 2024-06-14 22:56:56 +0800 | [diff] [blame] | 394 | pub(crate) vm_context: VmContext, |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 395 | /// The CID assigned to the VM for vsock communication. |
| 396 | pub cid: Cid, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 397 | /// Path to crosvm control socket |
| 398 | crosvm_control_socket_path: PathBuf, |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 399 | /// The name of the VM. |
| 400 | pub name: String, |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 401 | /// Whether the VM is a protected VM. |
| 402 | pub protected: bool, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 403 | /// Directory of temporary files used by the VM while it is running. |
| 404 | pub temporary_directory: PathBuf, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 405 | /// The UID of the process which requested the VM. |
| 406 | pub requester_uid: u32, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 407 | /// The PID of the process which requested the VM. Note that this process may no longer exist |
| 408 | /// and the PID may have been reused for a different process, so this should not be trusted. |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 409 | pub requester_debug_pid: i32, |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 410 | /// Callbacks to clients of the VM. |
| 411 | pub callbacks: VirtualMachineCallbacks, |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 412 | /// VirtualMachineService binder object for the VM. |
Stephen Hines | af21e51 | 2024-07-30 15:43:39 -0700 | [diff] [blame] | 413 | #[allow(dead_code)] |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 414 | pub vm_service: Mutex<Option<Strong<dyn IVirtualMachineService>>>, |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 415 | /// Recorded metrics of VM such as timestamp or cpu / memory usage. |
| 416 | pub vm_metric: Mutex<VmMetric>, |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 417 | /// The latest lifecycle state which the payload reported itself to be in. |
| 418 | payload_state: Mutex<PayloadState>, |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 419 | /// Represents the condition that payload_state was updated |
| 420 | payload_state_updated: Condvar, |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 421 | /// The human readable name of requester_uid |
| 422 | requester_uid_name: String, |
| 423 | } |
| 424 | |
| 425 | impl fmt::Display for VmInstance { |
| 426 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 427 | let adj = if self.protected { "Protected" } else { "Non-protected" }; |
| 428 | write!( |
| 429 | f, |
| 430 | "{} virtual machine \"{}\" (owner: {}, cid: {})", |
| 431 | adj, self.name, self.requester_uid_name, self.cid |
| 432 | ) |
| 433 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 434 | } |
| 435 | |
| 436 | impl VmInstance { |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 437 | /// Validates the given config and creates a new `VmInstance` but doesn't start running it. |
| 438 | pub fn new( |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 439 | config: CrosvmConfig, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 440 | temporary_directory: PathBuf, |
Andrew Walbran | f6a1eb9 | 2021-04-01 11:16:02 +0000 | [diff] [blame] | 441 | requester_uid: u32, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 442 | requester_debug_pid: i32, |
David Brazdil | 8cf8f48 | 2022-11-23 14:21:26 +0000 | [diff] [blame] | 443 | vm_context: VmContext, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 444 | ) -> Result<VmInstance, Error> { |
| 445 | validate_config(&config)?; |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 446 | let cid = config.cid; |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 447 | let name = config.name.clone(); |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 448 | let protected = config.protected; |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 449 | let requester_uid_name = User::from_uid(Uid::from_raw(requester_uid)) |
| 450 | .ok() |
| 451 | .flatten() |
| 452 | .map_or_else(|| format!("{}", requester_uid), |u| u.name); |
| 453 | let instance = VmInstance { |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 454 | vm_state: Mutex::new(VmState::NotStarted { config: Box::new(config) }), |
David Brazdil | 528e047 | 2022-10-10 15:06:02 +0100 | [diff] [blame] | 455 | vm_context, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 456 | cid, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 457 | crosvm_control_socket_path: temporary_directory.join("crosvm.sock"), |
Seungjae Yoo | 62085c0 | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 458 | name, |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 459 | protected, |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 460 | temporary_directory, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 461 | requester_uid, |
Andrew Walbran | 0203449 | 2021-04-13 15:05:07 +0000 | [diff] [blame] | 462 | requester_debug_pid, |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 463 | callbacks: Default::default(), |
Inseob Kim | c7d28c7 | 2021-10-25 14:28:10 +0000 | [diff] [blame] | 464 | vm_service: Mutex::new(None), |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 465 | vm_metric: Mutex::new(Default::default()), |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 466 | payload_state: Mutex::new(PayloadState::Starting), |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 467 | payload_state_updated: Condvar::new(), |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 468 | requester_uid_name, |
| 469 | }; |
| 470 | info!("{} created", &instance); |
| 471 | Ok(instance) |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 472 | } |
| 473 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 474 | /// Starts an instance of `crosvm` to manage the VM. The `crosvm` instance will be killed when |
| 475 | /// the `VmInstance` is dropped. |
| 476 | pub fn start(self: &Arc<Self>) -> Result<(), Error> { |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 477 | let mut vm_metric = self.vm_metric.lock().unwrap(); |
| 478 | vm_metric.start_timestamp = Some(SystemTime::now()); |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 479 | let ret = self.vm_state.lock().unwrap().start(self.clone()); |
| 480 | if ret.is_ok() { |
| 481 | info!("{} started", &self); |
| 482 | } |
| 483 | ret.with_context(|| format!("{} failed to start", &self)) |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 484 | } |
| 485 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 486 | /// Monitors the exit of the VM (i.e. termination of the `child` process). When that happens, |
| 487 | /// handles the event by updating the state, noityfing the event to clients by calling |
| 488 | /// callbacks, and removing temporary files for the VM. |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 489 | fn monitor_vm_exit( |
| 490 | &self, |
| 491 | child: Arc<SharedChild>, |
Frederick Mayle | 402fd2e | 2024-11-14 17:56:32 -0800 | [diff] [blame] | 492 | failure_pipe_read: File, |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 493 | vfio_devices: Vec<VfioDevice>, |
Seungjae Yoo | 3271f17 | 2024-06-11 10:14:07 +0900 | [diff] [blame] | 494 | tap: Option<File>, |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 495 | vhost_user_devices: Vec<SharedChild>, |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 496 | ) { |
Frederick Mayle | 402fd2e | 2024-11-14 17:56:32 -0800 | [diff] [blame] | 497 | let failure_reason_thread = std::thread::spawn(move || { |
| 498 | // Read the pipe to see if any failure reason is written |
| 499 | let mut failure_reason = String::new(); |
| 500 | // Arbitrary max size in case of misbehaving guest. |
| 501 | const MAX_SIZE: u64 = 50_000; |
| 502 | match failure_pipe_read.take(MAX_SIZE).read_to_string(&mut failure_reason) { |
| 503 | Err(e) => error!("Error reading VM failure reason from pipe: {}", e), |
| 504 | Ok(len) if len > 0 => error!("VM returned failure reason '{}'", &failure_reason), |
| 505 | _ => (), |
| 506 | }; |
| 507 | failure_reason |
| 508 | }); |
| 509 | |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 510 | let result = child.wait(); |
| 511 | match &result { |
Jooyung Han | bfe086f | 2021-10-28 10:15:45 +0900 | [diff] [blame] | 512 | Err(e) => error!("Error waiting for crosvm({}) instance to die: {}", child.id(), e), |
Sebastian Ene | 23167d8 | 2022-10-07 14:09:53 +0000 | [diff] [blame] | 513 | Ok(status) => { |
| 514 | info!("crosvm({}) exited with status {}", child.id(), status); |
| 515 | if let Some(exit_status_code) = status.code() { |
| 516 | if exit_status_code == CROSVM_WATCHDOG_REBOOT_STATUS { |
| 517 | info!("detected vcpu stall on crosvm"); |
| 518 | } |
| 519 | } |
| 520 | } |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 521 | } |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 522 | |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 523 | // In crosvm, when vhost_user frontend is dead, vhost_user backend device will detect and |
| 524 | // exit. We can safely wait() for vhost user device after waiting crosvm main |
| 525 | // process. |
| 526 | for device in vhost_user_devices { |
| 527 | match device.wait() { |
| 528 | Ok(status) => { |
| 529 | info!("Vhost user device({}) exited with status {}", device.id(), status); |
| 530 | if !status.success() { |
| 531 | if let Some(code) = status.code() { |
| 532 | // vhost_user backend device exit with error code |
| 533 | error!( |
| 534 | "vhost user device({}) exited with error code: {}", |
| 535 | device.id(), |
| 536 | code |
| 537 | ); |
| 538 | } else { |
| 539 | // The spawned child process of vhost_user backend device is |
| 540 | // killed by signal |
| 541 | error!("vhost user device({}) killed by signal", device.id()); |
| 542 | } |
| 543 | } |
| 544 | } |
| 545 | Err(e) => { |
| 546 | error!("Error waiting for vhost user device({}) to die: {}", device.id(), e); |
| 547 | } |
| 548 | } |
| 549 | } |
| 550 | |
Frederick Mayle | 402fd2e | 2024-11-14 17:56:32 -0800 | [diff] [blame] | 551 | let failure_reason = failure_reason_thread.join().expect("failure_reason_thread panic'd"); |
| 552 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 553 | let mut vm_state = self.vm_state.lock().unwrap(); |
| 554 | *vm_state = VmState::Dead; |
| 555 | // Ensure that the mutex is released before calling the callbacks. |
| 556 | drop(vm_state); |
Jiyong Park | 08eee7b | 2022-11-11 15:01:26 +0900 | [diff] [blame] | 557 | info!("{} exited", &self); |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 558 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 559 | // In case of hangup, the pipe doesn't give us any information because the hangup can't be |
| 560 | // detected on the VM side (otherwise, it isn't a hangup), but in the |
| 561 | // monitor_payload_hangup function below which updates the payload state to Hangup. |
| 562 | let failure_reason = |
| 563 | if failure_reason.is_empty() && self.payload_state() == PayloadState::Hangup { |
| 564 | Cow::from("HANGUP") |
| 565 | } else { |
| 566 | Cow::from(failure_reason) |
| 567 | }; |
| 568 | |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 569 | self.handle_ramdump().unwrap_or_else(|e| error!("Error handling ramdump: {}", e)); |
Seungjae Yoo | b4c07ba | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 570 | |
| 571 | let death_reason = death_reason(&result, &failure_reason); |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 572 | let exit_signal = exit_signal(&result); |
| 573 | |
Seungjae Yoo | b4c07ba | 2022-08-12 04:44:52 +0000 | [diff] [blame] | 574 | self.callbacks.callback_on_died(self.cid, death_reason); |
Seungjae Yoo | 2e7beea | 2022-08-24 16:09:12 +0900 | [diff] [blame] | 575 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 576 | let vm_metric = self.vm_metric.lock().unwrap(); |
Seungjae Yoo | b2db3d2 | 2023-04-06 18:05:43 +0900 | [diff] [blame] | 577 | write_vm_exited_stats_sync( |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 578 | self.requester_uid as i32, |
| 579 | &self.name, |
| 580 | death_reason, |
| 581 | exit_signal, |
Chris Wailes | 7526962 | 2022-12-05 23:01:44 -0800 | [diff] [blame] | 582 | &vm_metric, |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 583 | ); |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 584 | |
David Brazdil | 4b4c510 | 2022-12-19 22:56:20 +0000 | [diff] [blame] | 585 | // Delete temporary files. The folder itself is removed by VirtualizationServiceInternal. |
| 586 | remove_temporary_files(&self.temporary_directory).unwrap_or_else(|e| { |
| 587 | error!("Error removing temporary files from {:?}: {}", self.temporary_directory, e); |
| 588 | }); |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 589 | |
Seungjae Yoo | 3271f17 | 2024-06-11 10:14:07 +0900 | [diff] [blame] | 590 | if let Some(tap_file) = tap { |
| 591 | GLOBAL_SERVICE |
| 592 | .deleteTapInterface(&ParcelFileDescriptor::new(OwnedFd::from(tap_file))) |
| 593 | .unwrap_or_else(|e| { |
| 594 | error!("Error deleting TAP interface: {e:?}"); |
| 595 | }); |
| 596 | } |
| 597 | |
Jakob Vukalovic | d42aa2c | 2023-11-09 16:04:00 +0000 | [diff] [blame] | 598 | drop(vfio_devices); // Cleanup devices. |
Andrew Walbran | dae0716 | 2021-03-12 17:05:20 +0000 | [diff] [blame] | 599 | } |
| 600 | |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 601 | /// Waits until payload is started, or timeout expires. When timeout occurs, kill |
| 602 | /// the VM to prevent indefinite hangup and update the payload_state accordingly. |
| 603 | fn monitor_payload_hangup(&self, child: Arc<SharedChild>) { |
| 604 | debug!("Starting to monitor hangup for Microdroid({})", child.id()); |
Jiyong Park | cf97561 | 2024-04-07 13:27:10 +0900 | [diff] [blame] | 605 | let (state, result) = self |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 606 | .payload_state_updated |
| 607 | .wait_timeout_while(self.payload_state.lock().unwrap(), *BOOT_HANGUP_TIMEOUT, |s| { |
| 608 | *s < PayloadState::Started |
| 609 | }) |
| 610 | .unwrap(); |
Jiyong Park | cf97561 | 2024-04-07 13:27:10 +0900 | [diff] [blame] | 611 | drop(state); // we are not interested in state |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 612 | let child_still_running = child.try_wait().ok() == Some(None); |
| 613 | if result.timed_out() && child_still_running { |
| 614 | error!( |
| 615 | "Microdroid({}) failed to start payload within {} secs timeout. Shutting down.", |
| 616 | child.id(), |
| 617 | BOOT_HANGUP_TIMEOUT.as_secs() |
| 618 | ); |
| 619 | self.update_payload_state(PayloadState::Hangup).unwrap(); |
| 620 | if let Err(e) = self.kill() { |
| 621 | error!("Error stopping timed-out VM with CID {}: {:?}", child.id(), e); |
| 622 | } |
| 623 | } |
| 624 | } |
| 625 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 626 | fn monitor_vm_status(&self, child: Arc<SharedChild>) { |
| 627 | let pid = child.id(); |
| 628 | |
| 629 | loop { |
| 630 | { |
| 631 | // Check VM state |
| 632 | let vm_state = &*self.vm_state.lock().unwrap(); |
| 633 | if let VmState::Dead = vm_state { |
| 634 | break; |
| 635 | } |
| 636 | |
| 637 | let mut vm_metric = self.vm_metric.lock().unwrap(); |
| 638 | |
| 639 | // Get CPU Information |
Jiyong Park | 85ea538 | 2024-02-19 15:04:23 +0900 | [diff] [blame] | 640 | match get_guest_time(pid) { |
| 641 | Ok(guest_time) => vm_metric.cpu_guest_time = Some(guest_time), |
| 642 | Err(e) => error!("Failed to get guest CPU time: {e:?}"), |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 643 | } |
| 644 | |
| 645 | // Get Memory Information |
Jiyong Park | 85ea538 | 2024-02-19 15:04:23 +0900 | [diff] [blame] | 646 | match get_rss(pid) { |
| 647 | Ok(rss) => { |
| 648 | vm_metric.rss = match &vm_metric.rss { |
| 649 | Some(x) => Some(Rss::extract_max(x, &rss)), |
| 650 | None => Some(rss), |
| 651 | } |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 652 | } |
Jiyong Park | 85ea538 | 2024-02-19 15:04:23 +0900 | [diff] [blame] | 653 | Err(e) => error!("Failed to get guest RSS: {}", e), |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 654 | } |
| 655 | } |
| 656 | |
| 657 | thread::sleep(Duration::from_secs(1)); |
| 658 | } |
| 659 | } |
| 660 | |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 661 | /// Returns the last reported state of the VM payload. |
| 662 | pub fn payload_state(&self) -> PayloadState { |
| 663 | *self.payload_state.lock().unwrap() |
| 664 | } |
| 665 | |
| 666 | /// Updates the payload state to the given value, if it is a valid state transition. |
| 667 | pub fn update_payload_state(&self, new_state: PayloadState) -> Result<(), Error> { |
| 668 | let mut state_locked = self.payload_state.lock().unwrap(); |
| 669 | // Only allow forward transitions, e.g. from starting to started or finished, not back in |
| 670 | // the other direction. |
| 671 | if new_state > *state_locked { |
| 672 | *state_locked = new_state; |
Jiyong Park | a4eebde | 2022-07-12 18:01:12 +0900 | [diff] [blame] | 673 | self.payload_state_updated.notify_all(); |
Andrew Walbran | 6b65066 | 2021-09-07 13:13:23 +0000 | [diff] [blame] | 674 | Ok(()) |
| 675 | } else { |
| 676 | bail!("Invalid payload state transition from {:?} to {:?}", *state_locked, new_state) |
| 677 | } |
| 678 | } |
| 679 | |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 680 | /// Kills the crosvm instance, if it is running. |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 681 | pub fn kill(&self) -> Result<(), Error> { |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 682 | let monitor_vm_exit_thread = { |
| 683 | let vm_state = &mut *self.vm_state.lock().unwrap(); |
| 684 | if let VmState::Running { child, monitor_vm_exit_thread } = vm_state { |
| 685 | let id = child.id(); |
| 686 | debug!("Killing crosvm({})", id); |
| 687 | // TODO: Talk to crosvm to shutdown cleanly. |
| 688 | child.kill().with_context(|| format!("Error killing crosvm({id}) instance"))?; |
| 689 | monitor_vm_exit_thread.take() |
Inseob Kim | a446f80 | 2022-07-11 19:46:37 +0900 | [diff] [blame] | 690 | } else { |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 691 | bail!("VM is not running") |
Andrew Walbran | f8d9411 | 2021-09-07 11:45:36 +0000 | [diff] [blame] | 692 | } |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 693 | }; |
| 694 | |
| 695 | // Wait for monitor_vm_exit() to finish. Must release vm_state lock |
| 696 | // first, as monitor_vm_exit() takes it as well. |
| 697 | monitor_vm_exit_thread.map(JoinHandle::join); |
| 698 | |
David Brazdil | 5af5583 | 2023-03-08 13:08:56 +0000 | [diff] [blame] | 699 | // Now that the VM has been killed, shut down the VirtualMachineService |
| 700 | // server to eagerly free up the server threads. |
Jiyong Park | 690c1ca | 2024-11-28 18:06:50 +0900 | [diff] [blame] | 701 | if let Some(vm_server) = &self.vm_context.vm_server { |
| 702 | vm_server.shutdown()?; |
| 703 | } |
David Brazdil | 5af5583 | 2023-03-08 13:08:56 +0000 | [diff] [blame] | 704 | |
David Brazdil | f18e116 | 2022-12-18 18:27:23 +0000 | [diff] [blame] | 705 | Ok(()) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 706 | } |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 707 | |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 708 | /// Returns current virtio-balloon size. |
Keir Fraser | 48221ba | 2024-07-12 14:05:02 +0000 | [diff] [blame] | 709 | pub fn get_memory_balloon(&self) -> Result<u64, Error> { |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 710 | let socket_path_cstring = path_to_cstring(&self.crosvm_control_socket_path); |
| 711 | let mut balloon_actual = 0u64; |
| 712 | // SAFETY: Pointers are valid for the lifetime of the call. Null `stats` is valid. |
| 713 | let success = unsafe { |
| 714 | crosvm_control::crosvm_client_balloon_stats( |
| 715 | socket_path_cstring.as_ptr(), |
| 716 | /* stats= */ std::ptr::null_mut(), |
| 717 | &mut balloon_actual, |
| 718 | ) |
| 719 | }; |
| 720 | if !success { |
| 721 | bail!("Error requesting balloon stats"); |
| 722 | } |
| 723 | Ok(balloon_actual) |
Keir Fraser | 48221ba | 2024-07-12 14:05:02 +0000 | [diff] [blame] | 724 | } |
| 725 | |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 726 | /// Inflates the virtio-balloon by `num_bytes` to reclaim guest memory. Called in response to |
| 727 | /// memory-trimming notifications. |
Keir Fraser | 48221ba | 2024-07-12 14:05:02 +0000 | [diff] [blame] | 728 | pub fn set_memory_balloon(&self, num_bytes: u64) -> Result<(), Error> { |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 729 | let socket_path_cstring = path_to_cstring(&self.crosvm_control_socket_path); |
| 730 | // SAFETY: Pointer is valid for the lifetime of the call. |
| 731 | let success = unsafe { |
| 732 | crosvm_control::crosvm_client_balloon_vms(socket_path_cstring.as_ptr(), num_bytes) |
| 733 | }; |
| 734 | if !success { |
| 735 | bail!("Error sending balloon adjustment"); |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 736 | } |
| 737 | Ok(()) |
| 738 | } |
| 739 | |
Alan Stokes | 3e98d29 | 2022-12-14 15:18:22 +0000 | [diff] [blame] | 740 | /// Checks if ramdump has been created. If so, send it to tombstoned. |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 741 | fn handle_ramdump(&self) -> Result<(), Error> { |
| 742 | let ramdump_path = self.temporary_directory.join("ramdump"); |
Jiyong Park | 933d2b2 | 2023-02-28 11:41:19 +0900 | [diff] [blame] | 743 | if !ramdump_path.as_path().try_exists()? { |
| 744 | return Ok(()); |
| 745 | } |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 746 | if std::fs::metadata(&ramdump_path)?.len() > 0 { |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 747 | Self::send_ramdump_to_tombstoned(&ramdump_path)?; |
Jiyong Park | e558ab1 | 2022-07-07 20:18:55 +0900 | [diff] [blame] | 748 | } |
| 749 | Ok(()) |
| 750 | } |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 751 | |
| 752 | fn send_ramdump_to_tombstoned(ramdump_path: &Path) -> Result<(), Error> { |
| 753 | let mut input = File::open(ramdump_path) |
Alan Stokes | 3e98d29 | 2022-12-14 15:18:22 +0000 | [diff] [blame] | 754 | .context(format!("Failed to open ramdump {:?} for reading", ramdump_path))?; |
Jiyong Park | 1612b90 | 2022-08-22 14:47:39 +0900 | [diff] [blame] | 755 | |
| 756 | let pid = std::process::id() as i32; |
| 757 | let conn = TombstonedConnection::connect(pid, DebuggerdDumpType::Tombstone) |
| 758 | .context("Failed to connect to tombstoned")?; |
| 759 | let mut output = conn |
| 760 | .text_output |
| 761 | .as_ref() |
| 762 | .ok_or_else(|| anyhow!("Could not get file to write the tombstones on"))?; |
| 763 | |
| 764 | std::io::copy(&mut input, &mut output).context("Failed to send ramdump to tombstoned")?; |
| 765 | info!("Ramdump {:?} sent to tombstoned", ramdump_path); |
| 766 | |
| 767 | conn.notify_completion()?; |
| 768 | Ok(()) |
| 769 | } |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 770 | |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 771 | /// Suspends the VM's vCPUs. |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 772 | pub fn suspend(&self) -> Result<(), Error> { |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 773 | let socket_path_cstring = path_to_cstring(&self.crosvm_control_socket_path); |
| 774 | // SAFETY: Pointer is valid for the lifetime of the call. |
| 775 | let success = |
| 776 | unsafe { crosvm_control::crosvm_client_suspend_vm(socket_path_cstring.as_ptr()) }; |
| 777 | if !success { |
| 778 | bail!("Failed to suspend VM"); |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 779 | } |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 780 | Ok(()) |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 781 | } |
| 782 | |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 783 | /// Resumes the VM's vCPUs. |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 784 | pub fn resume(&self) -> Result<(), Error> { |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 785 | let socket_path_cstring = path_to_cstring(&self.crosvm_control_socket_path); |
| 786 | // SAFETY: Pointer is valid for the lifetime of the call. |
| 787 | let success = |
| 788 | unsafe { crosvm_control::crosvm_client_resume_vm(socket_path_cstring.as_ptr()) }; |
| 789 | if !success { |
| 790 | bail!("Failed to resume VM"); |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 791 | } |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 792 | Ok(()) |
Jiyong Park | 23b6739 | 2024-07-04 13:51:42 +0900 | [diff] [blame] | 793 | } |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 794 | } |
| 795 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 796 | impl Rss { |
| 797 | fn extract_max(x: &Rss, y: &Rss) -> Rss { |
| 798 | Rss { vm: max(x.vm, y.vm), crosvm: max(x.crosvm, y.crosvm) } |
| 799 | } |
| 800 | } |
| 801 | |
David Dai | aaecf65 | 2024-02-22 14:41:39 -0800 | [diff] [blame] | 802 | // Get Cpus_allowed mask |
| 803 | fn check_if_all_cpus_allowed() -> Result<bool> { |
| 804 | let file = read_to_string("/proc/self/status")?; |
| 805 | let lines: Vec<_> = file.split('\n').collect(); |
| 806 | |
| 807 | for line in lines { |
| 808 | if line.contains("Cpus_allowed_list") { |
| 809 | let prop: Vec<_> = line.split_whitespace().collect(); |
| 810 | if prop.len() != 2 { |
| 811 | return Ok(false); |
| 812 | } |
| 813 | let cpu_list: Vec<_> = prop[1].split('-').collect(); |
| 814 | //Only contiguous Cpu list allowed |
| 815 | if cpu_list.len() != 2 { |
| 816 | return Ok(false); |
| 817 | } |
| 818 | if let Some(cpus) = get_num_cpus() { |
| 819 | let max_cpu = cpu_list[1].parse::<usize>()?; |
| 820 | if max_cpu == cpus - 1 { |
| 821 | return Ok(true); |
| 822 | } else { |
| 823 | return Ok(false); |
| 824 | } |
| 825 | } |
| 826 | } |
| 827 | } |
| 828 | Ok(false) |
| 829 | } |
| 830 | |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 831 | // Get guest time from /proc/[crosvm pid]/stat |
| 832 | fn get_guest_time(pid: u32) -> Result<i64> { |
| 833 | let file = read_to_string(format!("/proc/{}/stat", pid))?; |
| 834 | let data_list: Vec<_> = file.split_whitespace().collect(); |
| 835 | |
| 836 | // Information about guest_time is at 43th place of the file split with the whitespace. |
| 837 | // Example of /proc/[pid]/stat : |
| 838 | // 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 |
| 839 | // 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 |
| 840 | if data_list.len() < 43 { |
| 841 | bail!("Failed to parse command result for getting guest time : {}", file); |
| 842 | } |
| 843 | |
| 844 | let guest_time_ticks = data_list[42].parse::<i64>()?; |
Andrew Walbran | b58d1b4 | 2023-07-07 13:54:49 +0100 | [diff] [blame] | 845 | // SAFETY: It just returns an integer about CPU tick information. |
Charisee | 96113f3 | 2023-01-26 09:00:42 +0000 | [diff] [blame] | 846 | let ticks_per_sec = unsafe { sysconf(_SC_CLK_TCK) }; |
Seungjae Yoo | 6d265d9 | 2022-11-15 10:51:33 +0900 | [diff] [blame] | 847 | Ok(guest_time_ticks * MILLIS_PER_SEC / ticks_per_sec) |
| 848 | } |
| 849 | |
| 850 | // Get rss from /proc/[crosvm pid]/smaps |
| 851 | fn get_rss(pid: u32) -> Result<Rss> { |
| 852 | let file = read_to_string(format!("/proc/{}/smaps", pid))?; |
| 853 | let lines: Vec<_> = file.split('\n').collect(); |
| 854 | |
| 855 | let mut rss_vm_total = 0i64; |
| 856 | let mut rss_crosvm_total = 0i64; |
| 857 | let mut is_vm = false; |
| 858 | for line in lines { |
| 859 | if line.contains("crosvm_guest") { |
| 860 | is_vm = true; |
| 861 | } else if line.contains("Rss:") { |
| 862 | let data_list: Vec<_> = line.split_whitespace().collect(); |
| 863 | if data_list.len() < 2 { |
| 864 | bail!("Failed to parse command result for getting rss :\n{}", line); |
| 865 | } |
| 866 | let rss = data_list[1].parse::<i64>()?; |
| 867 | |
| 868 | if is_vm { |
| 869 | rss_vm_total += rss; |
| 870 | is_vm = false; |
| 871 | } |
| 872 | rss_crosvm_total += rss; |
| 873 | } |
| 874 | } |
| 875 | |
| 876 | Ok(Rss { vm: rss_vm_total, crosvm: rss_crosvm_total }) |
| 877 | } |
| 878 | |
Alan Stokes | 3ba10fd | 2022-10-06 15:46:51 +0100 | [diff] [blame] | 879 | fn death_reason(result: &Result<ExitStatus, io::Error>, mut failure_reason: &str) -> DeathReason { |
Pierre-Clément Tosi | c0611e7 | 2023-09-15 11:41:07 +0100 | [diff] [blame] | 880 | if let Some((reason, info)) = failure_reason.split_once('|') { |
Alan Stokes | 3ba10fd | 2022-10-06 15:46:51 +0100 | [diff] [blame] | 881 | // Separator indicates extra context information is present after the failure name. |
Pierre-Clément Tosi | c0611e7 | 2023-09-15 11:41:07 +0100 | [diff] [blame] | 882 | error!("Failure info: {info}"); |
| 883 | failure_reason = reason; |
Alan Stokes | 3ba10fd | 2022-10-06 15:46:51 +0100 | [diff] [blame] | 884 | } |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 885 | if let Ok(status) = result { |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 886 | match failure_reason { |
| 887 | "PVM_FIRMWARE_PUBLIC_KEY_MISMATCH" => { |
| 888 | return DeathReason::PVM_FIRMWARE_PUBLIC_KEY_MISMATCH |
| 889 | } |
| 890 | "PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED" => { |
| 891 | return DeathReason::PVM_FIRMWARE_INSTANCE_IMAGE_CHANGED |
| 892 | } |
Inseob Kim | 272f572 | 2022-06-13 17:14:51 +0900 | [diff] [blame] | 893 | "MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE" => { |
| 894 | return DeathReason::MICRODROID_FAILED_TO_CONNECT_TO_VIRTUALIZATION_SERVICE |
| 895 | } |
| 896 | "MICRODROID_PAYLOAD_HAS_CHANGED" => return DeathReason::MICRODROID_PAYLOAD_HAS_CHANGED, |
| 897 | "MICRODROID_PAYLOAD_VERIFICATION_FAILED" => { |
| 898 | return DeathReason::MICRODROID_PAYLOAD_VERIFICATION_FAILED |
| 899 | } |
| 900 | "MICRODROID_INVALID_PAYLOAD_CONFIG" => { |
| 901 | return DeathReason::MICRODROID_INVALID_PAYLOAD_CONFIG |
| 902 | } |
| 903 | "MICRODROID_UNKNOWN_RUNTIME_ERROR" => { |
| 904 | return DeathReason::MICRODROID_UNKNOWN_RUNTIME_ERROR |
| 905 | } |
Jiyong Park | e6ed0f9 | 2022-06-22 00:13:00 +0900 | [diff] [blame] | 906 | "HANGUP" => return DeathReason::HANGUP, |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 907 | _ => {} |
| 908 | } |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 909 | match status.code() { |
| 910 | None => DeathReason::KILLED, |
| 911 | Some(0) => DeathReason::SHUTDOWN, |
Alan Stokes | 7c459e8 | 2022-12-06 12:21:49 +0000 | [diff] [blame] | 912 | Some(CROSVM_START_ERROR_STATUS) => DeathReason::START_FAILED, |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 913 | Some(CROSVM_REBOOT_STATUS) => DeathReason::REBOOT, |
Andrew Walbran | d15c563 | 2022-02-03 13:38:31 +0000 | [diff] [blame] | 914 | Some(CROSVM_CRASH_STATUS) => DeathReason::CRASH, |
Sebastian Ene | 23167d8 | 2022-10-07 14:09:53 +0000 | [diff] [blame] | 915 | Some(CROSVM_WATCHDOG_REBOOT_STATUS) => DeathReason::WATCHDOG_REBOOT, |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 916 | Some(_) => DeathReason::UNKNOWN, |
| 917 | } |
| 918 | } else { |
| 919 | DeathReason::INFRASTRUCTURE_ERROR |
| 920 | } |
| 921 | } |
| 922 | |
Seungjae Yoo | 93430e8 | 2022-12-05 16:37:42 +0900 | [diff] [blame] | 923 | fn exit_signal(result: &Result<ExitStatus, io::Error>) -> Option<i32> { |
| 924 | match result { |
| 925 | Ok(status) => status.signal(), |
| 926 | Err(_) => None, |
| 927 | } |
| 928 | } |
| 929 | |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 930 | const SYSFS_PLATFORM_DEVICES_PATH: &str = "/sys/devices/platform/"; |
| 931 | const VFIO_PLATFORM_DRIVER_PATH: &str = "/sys/bus/platform/drivers/vfio-platform"; |
| 932 | |
Inseob Kim | 7307a89 | 2023-09-14 13:37:58 +0900 | [diff] [blame] | 933 | fn vfio_argument_for_platform_device(device: &VfioDevice) -> Result<String, Error> { |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 934 | // Check platform device exists |
Jakob Vukalovic | d42aa2c | 2023-11-09 16:04:00 +0000 | [diff] [blame] | 935 | let path = Path::new(&device.getSysfsPath()?).canonicalize()?; |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 936 | if !path.starts_with(SYSFS_PLATFORM_DEVICES_PATH) { |
| 937 | bail!("{path:?} is not a platform device"); |
| 938 | } |
| 939 | |
| 940 | // Check platform device is bound to VFIO driver |
| 941 | let dev_driver_path = path.join("driver").canonicalize()?; |
| 942 | if dev_driver_path != Path::new(VFIO_PLATFORM_DRIVER_PATH) { |
| 943 | bail!("{path:?} is not bound to VFIO-platform driver"); |
| 944 | } |
| 945 | |
| 946 | if let Some(p) = path.to_str() { |
Jakob Vukalovic | d42aa2c | 2023-11-09 16:04:00 +0000 | [diff] [blame] | 947 | Ok(format!("--vfio={p},iommu=pkvm-iommu,dt-symbol={0}", device.getDtboLabel()?)) |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 948 | } else { |
| 949 | bail!("invalid path {path:?}"); |
| 950 | } |
| 951 | } |
| 952 | |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 953 | fn run_virtiofs(config: &CrosvmConfig) -> io::Result<Vec<SharedChild>> { |
| 954 | let mut devices: Vec<SharedChild> = Vec::new(); |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 955 | for shared_path in &config.shared_paths { |
Akilesh Kailash | c9aa068 | 2024-11-25 10:27:24 -0800 | [diff] [blame] | 956 | if shared_path.app_domain { |
| 957 | continue; |
| 958 | } |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 959 | let ugid_map_value = format!( |
| 960 | "{} {} {} {} {} /", |
| 961 | shared_path.guest_uid, |
| 962 | shared_path.guest_gid, |
| 963 | shared_path.host_uid, |
| 964 | shared_path.host_gid, |
| 965 | shared_path.mask, |
| 966 | ); |
| 967 | |
Akilesh Kailash | 8790ea7 | 2024-10-28 21:34:39 -0700 | [diff] [blame] | 968 | let cfg_arg = format!("ugid_map='{}'", ugid_map_value); |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 969 | |
| 970 | let mut command = Command::new(CROSVM_PATH); |
| 971 | command |
| 972 | .arg("device") |
| 973 | .arg("fs") |
| 974 | .arg(format!("--socket={}", &shared_path.socket_path)) |
| 975 | .arg(format!("--tag={}", &shared_path.tag)) |
| 976 | .arg(format!("--shared-dir={}", &shared_path.path)) |
| 977 | .arg("--cfg") |
| 978 | .arg(cfg_arg.as_str()) |
Akilesh Kailash | 6676ea8 | 2024-10-25 17:14:33 -0700 | [diff] [blame] | 979 | .arg("--disable-sandbox") |
| 980 | .arg("--skip-pivot-root=true"); |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 981 | |
| 982 | print_crosvm_args(&command); |
| 983 | |
| 984 | let result = SharedChild::spawn(&mut command)?; |
| 985 | info!("Spawned virtiofs crosvm({})", result.id()); |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 986 | devices.push(result); |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 987 | } |
| 988 | |
Yuan Yao | 2b65400 | 2024-12-25 05:19:12 +0000 | [diff] [blame] | 989 | Ok(devices) |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 990 | } |
| 991 | |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 992 | /// Starts an instance of `crosvm` to manage a new VM. |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 993 | fn run_vm( |
| 994 | config: CrosvmConfig, |
Keir Fraser | cdd4b11 | 2022-11-24 14:02:25 +0000 | [diff] [blame] | 995 | crosvm_control_socket_path: &Path, |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 996 | failure_pipe_write: File, |
| 997 | ) -> Result<SharedChild, Error> { |
Andrew Walbran | d3a8418 | 2021-09-07 14:48:52 +0000 | [diff] [blame] | 998 | validate_config(&config)?; |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 999 | |
| 1000 | let mut command = Command::new(CROSVM_PATH); |
Jiyong Park | f50ec33 | 2024-10-23 17:54:03 +0900 | [diff] [blame] | 1001 | |
| 1002 | let vm_name = "crosvm_".to_owned() + &config.name; |
| 1003 | command.arg0(vm_name.clone()); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1004 | // TODO(qwandor): Remove --disable-sandbox. |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 1005 | command |
| 1006 | .arg("--extended-status") |
Jiyong Park | 6c60fea | 2022-10-24 16:10:01 +0900 | [diff] [blame] | 1007 | // Configure the logger for the crosvm process to silence logs from the disk crate which |
| 1008 | // don't provide much information to us (but do spamming us). |
| 1009 | .arg("--log-level") |
Frederick Mayle | 138f53c | 2023-01-24 18:55:26 -0800 | [diff] [blame] | 1010 | .arg("info,disk=warn") |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 1011 | .arg("run") |
Jiyong Park | f50ec33 | 2024-10-23 17:54:03 +0900 | [diff] [blame] | 1012 | .arg("--name") |
| 1013 | .arg(vm_name) |
Andrew Walbran | c92d35f | 2022-01-12 12:45:19 +0000 | [diff] [blame] | 1014 | .arg("--disable-sandbox") |
| 1015 | .arg("--cid") |
| 1016 | .arg(config.cid.to_string()); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1017 | |
Frederick Mayle | cc4e2d7 | 2024-12-06 16:54:40 -0800 | [diff] [blame] | 1018 | if system_properties::read_bool("hypervisor.memory_reclaim.supported", false)? && config.balloon |
Jeongik Cha | 7505745 | 2024-09-03 11:26:04 +0900 | [diff] [blame] | 1019 | { |
Keir Fraser | f25cb92 | 2022-11-23 14:26:00 +0000 | [diff] [blame] | 1020 | command.arg("--balloon-page-reporting"); |
| 1021 | } else { |
| 1022 | command.arg("--no-balloon"); |
| 1023 | } |
| 1024 | |
Elie Kheirallah | 29d7291 | 2024-08-07 20:17:26 +0000 | [diff] [blame] | 1025 | if !config.usb_config.controller { |
| 1026 | command.arg("--no-usb"); |
| 1027 | } |
| 1028 | |
Jiyong Park | ae625b6 | 2024-06-13 21:47:52 +0900 | [diff] [blame] | 1029 | let mut memory_mib = config.memory_mib; |
| 1030 | |
Frederick Mayle | 196ca2b | 2024-12-18 15:27:43 -0800 | [diff] [blame] | 1031 | if config.enable_hypervisor_specific_auth_method && !config.protected { |
| 1032 | bail!("hypervisor specific auth method only supported for protected VMs"); |
| 1033 | } |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 1034 | if config.protected { |
Frederick Mayle | 196ca2b | 2024-12-18 15:27:43 -0800 | [diff] [blame] | 1035 | if config.enable_hypervisor_specific_auth_method { |
| 1036 | if !hypervisor_props::is_gunyah()? { |
| 1037 | bail!("hypervisor specific auth method not supported for current hypervisor"); |
| 1038 | } |
| 1039 | // "QCOM Trusted VM" compatibility mode. |
| 1040 | // |
| 1041 | // When this mode is enabled, two hypervisor specific IDs are expected to be packed |
| 1042 | // into the instance ID. We extract them here and pass along to crosvm so they can be |
| 1043 | // given to the hypervisor driver via an ioctl. |
| 1044 | let vm_id = u32::from_le_bytes(config.instance_id[60..64].try_into().unwrap()); |
| 1045 | let pas_id = u16::from_le_bytes(config.instance_id[58..60].try_into().unwrap()); |
| 1046 | command.arg("--hypervisor").arg( |
| 1047 | format!("gunyah[device=/dev/gunyah,qcom_trusted_vm_id={vm_id},qcom_trusted_vm_pas_id={pas_id}]"), |
| 1048 | ); |
| 1049 | // Put the FDT close to the payload (default is end of RAM) to so that CMA can be used |
| 1050 | // without bloating memory usage. |
| 1051 | command.arg("--fdt-position").arg("after-payload"); |
| 1052 | } |
| 1053 | |
Jaewan Kim | 4642281 | 2022-11-25 10:59:39 +0900 | [diff] [blame] | 1054 | match system_properties::read(SYSPROP_CUSTOM_PVMFW_PATH)? { |
| 1055 | Some(pvmfw_path) if !pvmfw_path.is_empty() => { |
Nikita Ioffe | 5f8e75d | 2024-11-04 17:38:05 +0000 | [diff] [blame] | 1056 | if pvmfw_path == "none" { |
| 1057 | command.arg("--protected-vm-without-firmware") |
| 1058 | } else { |
| 1059 | command.arg("--protected-vm-with-firmware").arg(pvmfw_path) |
| 1060 | } |
Jaewan Kim | 4642281 | 2022-11-25 10:59:39 +0900 | [diff] [blame] | 1061 | } |
| 1062 | _ => command.arg("--protected-vm"), |
| 1063 | }; |
Andrew Walbran | 0b5789f | 2022-02-04 13:57:57 +0000 | [diff] [blame] | 1064 | |
Frederick Mayle | 384f5b5 | 2024-12-06 16:23:23 -0800 | [diff] [blame] | 1065 | let swiotlb_size_mib = config.swiotlb_mib.map(u32::from).unwrap_or({ |
| 1066 | // 3 virtio-console devices + vsock = 4. |
| 1067 | // TODO: Count more device types, like balloon, input, and sound. |
| 1068 | let virtio_pci_device_count = 4 + config.disks.len(); |
| 1069 | // crosvm virtio queue has 256 entries, so 2 MiB per device (2 pages per entry) should |
| 1070 | // be enough. |
| 1071 | // NOTE: The above explanation isn't completely accurate, e.g., circa 2024q4, each |
| 1072 | // virtio-block has 16 queues with 256 entries each and each virito-console has 2 |
| 1073 | // queues of 256 entries each. So, it is allocating less than 2 pages per entry, but |
| 1074 | // seems to work well enough in practice. |
| 1075 | 2 * virtio_pci_device_count as u32 |
| 1076 | }); |
Andrew Walbran | 0b5789f | 2022-02-04 13:57:57 +0000 | [diff] [blame] | 1077 | command.arg("--swiotlb").arg(swiotlb_size_mib.to_string()); |
Frederick Mayle | 58baa30 | 2023-02-14 19:06:37 -0800 | [diff] [blame] | 1078 | |
Frederick Mayle | a24bbe0 | 2024-07-12 16:50:48 -0700 | [diff] [blame] | 1079 | // b/346770542 for consistent "usable" memory across protected and non-protected VMs. |
Frederick Mayle | 68d06e7 | 2024-07-12 17:18:11 -0700 | [diff] [blame] | 1080 | memory_mib = memory_mib.saturating_add(swiotlb_size_mib); |
Jiyong Park | ae625b6 | 2024-06-13 21:47:52 +0900 | [diff] [blame] | 1081 | |
Frederick Mayle | 58baa30 | 2023-02-14 19:06:37 -0800 | [diff] [blame] | 1082 | // Workaround to keep crash_dump from trying to read protected guest memory. |
| 1083 | // Context in b/238324526. |
| 1084 | command.arg("--unmap-guest-memory-on-fork"); |
Jiyong Park | 3115cdb | 2023-02-24 18:04:44 +0900 | [diff] [blame] | 1085 | |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 1086 | if config.ramdump.is_some() { |
Jaewan Kim | 3124ef0 | 2023-03-23 19:25:20 +0900 | [diff] [blame] | 1087 | // Protected VM needs to reserve memory for ramdump here. Note that we reserve more |
Jiyong Park | ed18093 | 2023-02-24 19:55:41 +0900 | [diff] [blame] | 1088 | // memory for the restricted dma pool. |
| 1089 | let ramdump_reserve = RAMDUMP_RESERVED_MIB + swiotlb_size_mib; |
| 1090 | command.arg("--params").arg(format!("crashkernel={ramdump_reserve}M")); |
| 1091 | } |
Jaewan Kim | d4dae65 | 2023-03-28 13:45:43 +0900 | [diff] [blame] | 1092 | } else if config.ramdump.is_some() { |
| 1093 | command.arg("--params").arg(format!("crashkernel={RAMDUMP_RESERVED_MIB}M")); |
| 1094 | } |
Jaewan Kim | 61f8614 | 2023-03-28 15:12:52 +0900 | [diff] [blame] | 1095 | if config.debug_config.debug_level == DebugLevel::NONE |
| 1096 | && config.debug_config.should_prepare_console_output() |
| 1097 | { |
Jaewan Kim | d4dae65 | 2023-03-28 13:45:43 +0900 | [diff] [blame] | 1098 | // bootconfig.normal will be used, but we need log. |
| 1099 | command.arg("--params").arg("printk.devkmsg=on"); |
| 1100 | command.arg("--params").arg("console=hvc0"); |
Andrew Walbran | f865042 | 2021-06-09 15:54:09 +0000 | [diff] [blame] | 1101 | } |
| 1102 | |
Frederick Mayle | 803aa8c | 2024-11-22 13:45:55 -0800 | [diff] [blame] | 1103 | // Move the PCI MMIO regions to near the end of the low-MMIO space. |
| 1104 | // This is done to accommodate a limitation in a partner's hypervisor. |
| 1105 | #[cfg(target_arch = "aarch64")] |
| 1106 | command |
| 1107 | .arg("--pci") |
| 1108 | .arg("mem=[start=0x70000000,size=0x2000000],cam=[start=0x72000000,size=0x1000000]"); |
| 1109 | |
Frederick Mayle | 68d06e7 | 2024-07-12 17:18:11 -0700 | [diff] [blame] | 1110 | command.arg("--mem").arg(memory_mib.to_string()); |
Andrew Walbran | b15cd6e | 2021-07-05 16:38:07 +0000 | [diff] [blame] | 1111 | |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 1112 | if let Some(cpus) = config.cpus { |
Elie Kheirallah | f240264 | 2025-01-22 17:51:10 +0000 | [diff] [blame^] | 1113 | command.arg("--cpus").arg(cpus.to_string() + ",sve=[auto=true]"); |
Jiyong Park | 032615f | 2022-01-10 13:55:34 +0900 | [diff] [blame] | 1114 | } |
| 1115 | |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 1116 | if config.host_cpu_topology { |
David Dai | aaecf65 | 2024-02-22 14:41:39 -0800 | [diff] [blame] | 1117 | if cfg!(virt_cpufreq) && check_if_all_cpus_allowed()? { |
David Dai | e6f5bb0 | 2024-01-25 19:17:02 -0800 | [diff] [blame] | 1118 | command.arg("--host-cpu-topology"); |
David Dai | c97e82d | 2024-02-17 12:10:31 -0800 | [diff] [blame] | 1119 | cfg_if::cfg_if! { |
| 1120 | if #[cfg(any(target_arch = "aarch64"))] { |
| 1121 | command.arg("--virt-cpufreq"); |
| 1122 | } |
| 1123 | } |
Elie Kheirallah | f240264 | 2025-01-22 17:51:10 +0000 | [diff] [blame^] | 1124 | command.arg("--cpus").arg("sve=[auto=true]"); |
David Dai | e6f5bb0 | 2024-01-25 19:17:02 -0800 | [diff] [blame] | 1125 | } else if let Some(cpus) = get_num_cpus() { |
Elie Kheirallah | f240264 | 2025-01-22 17:51:10 +0000 | [diff] [blame^] | 1126 | command.arg("--cpus").arg(cpus.to_string() + ",sve=[auto=true]"); |
David Brazdil | 25e8c05 | 2023-02-17 12:53:01 +0000 | [diff] [blame] | 1127 | } else { |
| 1128 | bail!("Could not determine the number of CPUs in the system"); |
| 1129 | } |
David Brazdil | 7d1e5ec | 2023-02-06 17:56:29 +0000 | [diff] [blame] | 1130 | } |
| 1131 | |
Nikita Ioffe | 5776f08 | 2023-02-10 21:38:26 +0000 | [diff] [blame] | 1132 | if let Some(gdb_port) = config.gdb_port { |
| 1133 | command.arg("--gdb").arg(gdb_port.to_string()); |
| 1134 | } |
| 1135 | |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 1136 | // Keep track of what file descriptors should be mapped to the crosvm process. |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1137 | let mut preserved_fds = config.indirect_files.into_iter().map(|f| f.into()).collect(); |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 1138 | |
Elie Kheirallah | 5c807a2 | 2024-09-23 20:40:42 +0000 | [diff] [blame] | 1139 | if let Some(dump_dt_fd) = config.dump_dt_fd { |
| 1140 | let dump_dt_fd = add_preserved_fd(&mut preserved_fds, dump_dt_fd); |
| 1141 | command.arg("--dump-device-tree-blob").arg(dump_dt_fd); |
| 1142 | } |
| 1143 | |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 1144 | // Setup the serial devices. |
| 1145 | // 1. uart device: used as the output device by bootloaders and as early console by linux |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 1146 | // 2. uart device: used to report the reason for the VM failing. |
| 1147 | // 3. virtio-console device: used as the console device where kmsg is redirected to |
Jiyong Park | 4afe201 | 2022-07-08 05:38:49 +0900 | [diff] [blame] | 1148 | // 4. virtio-console device: used as the ramdump output |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 1149 | // 5. virtio-console device: used as the logcat output |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 1150 | // |
Jiyong Park | b8182bb | 2021-10-26 22:53:08 +0900 | [diff] [blame] | 1151 | // When [console|log]_fd is not specified, the devices are attached to sink, which means what's |
| 1152 | // written there is discarded. |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1153 | let console_out_arg = format_serial_out_arg(&mut preserved_fds, config.console_out_fd); |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 1154 | let console_in_arg = config |
| 1155 | .console_in_fd |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 1156 | .map(|fd| format!(",input={}", add_preserved_fd(&mut preserved_fds, fd))) |
| 1157 | .unwrap_or_default(); |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1158 | let log_arg = format_serial_out_arg(&mut preserved_fds, config.log_fd); |
| 1159 | let failure_serial_path = add_preserved_fd(&mut preserved_fds, failure_pipe_write); |
| 1160 | let ramdump_arg = format_serial_out_arg(&mut preserved_fds, config.ramdump); |
Yi-Yo Chiang | 8dd3255 | 2024-05-22 19:38:16 +0800 | [diff] [blame] | 1161 | let console_input_device = config.console_input_device.as_deref().unwrap_or(CONSOLE_HVC0); |
| 1162 | match console_input_device { |
| 1163 | CONSOLE_HVC0 | CONSOLE_TTYS0 => {} |
| 1164 | _ => bail!("Unsupported serial device {console_input_device}"), |
| 1165 | }; |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 1166 | |
Jiyong Park | 747d636 | 2021-10-19 17:12:52 +0900 | [diff] [blame] | 1167 | // Warning: Adding more serial devices requires you to shift the PCI device ID of the boot |
| 1168 | // disks in bootconfig.x86_64. This is because x86 crosvm puts serial devices and the block |
| 1169 | // devices in the same PCI bus and serial devices comes before the block devices. Arm crosvm |
| 1170 | // doesn't have the issue. |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 1171 | // /dev/ttyS0 |
Yi-Yo Chiang | 8dd3255 | 2024-05-22 19:38:16 +0800 | [diff] [blame] | 1172 | command.arg(format!( |
| 1173 | "--serial={}{},hardware=serial,num=1", |
| 1174 | &console_out_arg, |
| 1175 | if console_input_device == CONSOLE_TTYS0 { &console_in_arg } else { "" } |
| 1176 | )); |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 1177 | // /dev/ttyS1 |
| 1178 | command.arg(format!("--serial=type=file,path={},hardware=serial,num=2", &failure_serial_path)); |
Jiyong Park | fa91d70 | 2021-10-18 23:51:39 +0900 | [diff] [blame] | 1179 | // /dev/hvc0 |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 1180 | command.arg(format!( |
| 1181 | "--serial={}{},hardware=virtio-console,num=1", |
Yi-Yo Chiang | 8dd3255 | 2024-05-22 19:38:16 +0800 | [diff] [blame] | 1182 | &console_out_arg, |
| 1183 | if console_input_device == CONSOLE_HVC0 { &console_in_arg } else { "" } |
Jiyong Park | e6fb167 | 2023-06-26 16:45:55 +0900 | [diff] [blame] | 1184 | )); |
Jiyong Park | 4afe201 | 2022-07-08 05:38:49 +0900 | [diff] [blame] | 1185 | // /dev/hvc1 |
| 1186 | command.arg(format!("--serial={},hardware=virtio-console,num=2", &ramdump_arg)); |
Jiyong Park | ae5a4ed | 2021-11-01 18:36:28 +0900 | [diff] [blame] | 1187 | // /dev/hvc2 |
| 1188 | command.arg(format!("--serial={},hardware=virtio-console,num=3", &log_arg)); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1189 | |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1190 | if let Some(bootloader) = config.bootloader { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 1191 | command.arg("--bios").arg(add_preserved_fd(&mut preserved_fds, bootloader)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1192 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1193 | |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1194 | if let Some(initrd) = config.initrd { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 1195 | command.arg("--initrd").arg(add_preserved_fd(&mut preserved_fds, initrd)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1196 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1197 | |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1198 | if let Some(params) = &config.params { |
| 1199 | command.arg("--params").arg(params); |
| 1200 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1201 | |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1202 | for disk in config.disks { |
Frederick Mayle | eae6d2d | 2024-09-12 11:05:36 -0700 | [diff] [blame] | 1203 | // Disk file locking is disabled because of missing SELinux policies. |
Frederick Mayle | 1ff7b84 | 2024-07-12 16:20:09 -0700 | [diff] [blame] | 1204 | command.arg("--block").arg(format!( |
Frederick Mayle | eae6d2d | 2024-09-12 11:05:36 -0700 | [diff] [blame] | 1205 | "path={},ro={},lock=false", |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1206 | add_preserved_fd(&mut preserved_fds, disk.image), |
Frederick Mayle | 1ff7b84 | 2024-07-12 16:20:09 -0700 | [diff] [blame] | 1207 | !disk.writable, |
| 1208 | )); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1209 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1210 | |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1211 | if let Some(kernel) = config.kernel { |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 1212 | command.arg(add_preserved_fd(&mut preserved_fds, kernel)); |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1213 | } |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1214 | |
Elie Kheirallah | 35dbb8e | 2024-10-23 00:15:14 +0000 | [diff] [blame] | 1215 | #[cfg(target_arch = "aarch64")] |
| 1216 | command.arg("--no-pmu"); |
| 1217 | |
Frederick Mayle | e0ed235 | 2024-09-12 16:16:00 -0700 | [diff] [blame] | 1218 | let control_sock = create_crosvm_control_listener(crosvm_control_socket_path) |
| 1219 | .context("failed to create control listener")?; |
Jiyong Park | cd0f74b | 2024-08-20 11:06:52 +0900 | [diff] [blame] | 1220 | command.arg("--socket").arg(add_preserved_fd(&mut preserved_fds, control_sock)); |
Keir Fraser | 13a956a | 2022-07-14 14:20:46 +0000 | [diff] [blame] | 1221 | |
Jaewan Kim | f43372b | 2024-12-13 18:33:58 +0900 | [diff] [blame] | 1222 | config.device_tree_overlays.into_iter().for_each(|dt_overlay| { |
| 1223 | let arg = add_preserved_fd(&mut preserved_fds, dt_overlay); |
| 1224 | command.arg("--device-tree-overlay").arg(arg); |
| 1225 | }); |
Jeongik Cha | 798401c | 2024-04-11 21:54:49 +0900 | [diff] [blame] | 1226 | |
| 1227 | if cfg!(paravirtualized_devices) { |
Jason Macnak | ea7b0fa | 2024-05-08 17:02:44 -0700 | [diff] [blame] | 1228 | if let Some(gpu_config) = &config.gpu_config { |
| 1229 | let mut gpu_args = Vec::new(); |
| 1230 | if let Some(backend) = &gpu_config.backend { |
| 1231 | gpu_args.push(format!("backend={}", backend)); |
| 1232 | } |
| 1233 | if let Some(context_types) = &gpu_config.context_types { |
| 1234 | gpu_args.push(format!("context-types={}", context_types.join(":"))); |
| 1235 | } |
| 1236 | if let Some(pci_address) = &gpu_config.pci_address { |
| 1237 | gpu_args.push(format!("pci-address={}", pci_address)); |
| 1238 | } |
| 1239 | if let Some(renderer_features) = &gpu_config.renderer_features { |
| 1240 | gpu_args.push(format!("renderer-features={}", renderer_features)); |
| 1241 | } |
| 1242 | if gpu_config.renderer_use_egl.unwrap_or(false) { |
| 1243 | gpu_args.push("egl=true".to_string()); |
| 1244 | } |
| 1245 | if gpu_config.renderer_use_gles.unwrap_or(false) { |
| 1246 | gpu_args.push("gles=true".to_string()); |
| 1247 | } |
| 1248 | if gpu_config.renderer_use_glx.unwrap_or(false) { |
| 1249 | gpu_args.push("glx=true".to_string()); |
| 1250 | } |
| 1251 | if gpu_config.renderer_use_surfaceless.unwrap_or(false) { |
| 1252 | gpu_args.push("surfaceless=true".to_string()); |
| 1253 | } |
| 1254 | if gpu_config.renderer_use_vulkan.unwrap_or(false) { |
| 1255 | gpu_args.push("vulkan=true".to_string()); |
| 1256 | } |
| 1257 | command.arg(format!("--gpu={}", gpu_args.join(","))); |
| 1258 | } |
Jeongik Cha | 798401c | 2024-04-11 21:54:49 +0900 | [diff] [blame] | 1259 | if let Some(display_config) = &config.display_config { |
Jason Macnak | ea7b0fa | 2024-05-08 17:02:44 -0700 | [diff] [blame] | 1260 | command |
| 1261 | .arg(format!( |
| 1262 | "--gpu-display=mode=windowed[{},{}],dpi=[{},{}],refresh-rate={}", |
| 1263 | display_config.width, |
| 1264 | display_config.height, |
| 1265 | display_config.horizontal_dpi, |
| 1266 | display_config.vertical_dpi, |
| 1267 | display_config.refresh_rate |
| 1268 | )) |
| 1269 | .arg(format!("--android-display-service={}", config.name)); |
Jeongik Cha | 798401c | 2024-04-11 21:54:49 +0900 | [diff] [blame] | 1270 | } |
Jeongik Cha | 1df1c03 | 2024-04-03 16:03:12 +0900 | [diff] [blame] | 1271 | } |
Seungjae Yoo | ec3bc52 | 2023-11-09 10:14:30 +0900 | [diff] [blame] | 1272 | |
Seungjae Yoo | 986d7a4 | 2024-05-28 14:06:58 +0900 | [diff] [blame] | 1273 | if cfg!(network) { |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1274 | if let Some(tap) = config.tap { |
Andreas Huber | 487810d | 2024-08-22 07:43:01 -0700 | [diff] [blame] | 1275 | add_preserved_fd(&mut preserved_fds, tap); |
| 1276 | let tap_fd = preserved_fds.last().unwrap().as_raw_fd(); |
| 1277 | command.arg("--net").arg(format!("tap-fd={tap_fd}")); |
Seungjae Yoo | 986d7a4 | 2024-05-28 14:06:58 +0900 | [diff] [blame] | 1278 | } |
| 1279 | } |
| 1280 | |
Jeongik Cha | 6be4f8b | 2024-04-16 01:13:13 +0900 | [diff] [blame] | 1281 | if cfg!(paravirtualized_devices) { |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1282 | for input_device_option in config.input_device_options.into_iter() { |
Jeongik Cha | c181be7 | 2024-03-27 00:18:30 +0900 | [diff] [blame] | 1283 | command.arg("--input"); |
| 1284 | command.arg(match input_device_option { |
| 1285 | InputDeviceOption::EvDev(file) => { |
| 1286 | format!("evdev[path={}]", add_preserved_fd(&mut preserved_fds, file)) |
| 1287 | } |
Jeongik Cha | 985b640 | 2024-04-15 18:13:00 +0900 | [diff] [blame] | 1288 | InputDeviceOption::Keyboard(file) => { |
| 1289 | format!("keyboard[path={}]", add_preserved_fd(&mut preserved_fds, file)) |
| 1290 | } |
Jeongik Cha | 343894e | 2024-05-17 20:39:31 +0900 | [diff] [blame] | 1291 | InputDeviceOption::Mouse(file) => { |
| 1292 | format!("mouse[path={}]", add_preserved_fd(&mut preserved_fds, file)) |
| 1293 | } |
Jeongik Cha | c181be7 | 2024-03-27 00:18:30 +0900 | [diff] [blame] | 1294 | InputDeviceOption::SingleTouch { file, width, height, name } => format!( |
| 1295 | "single-touch[path={},width={},height={}{}]", |
| 1296 | add_preserved_fd(&mut preserved_fds, file), |
| 1297 | width, |
| 1298 | height, |
| 1299 | name.as_ref().map_or("".into(), |n| format!(",name={}", n)) |
| 1300 | ), |
Jiyong Park | 6c1b9f0 | 2024-07-05 16:21:10 +0900 | [diff] [blame] | 1301 | InputDeviceOption::Switches(file) => { |
| 1302 | format!("switches[path={}]", add_preserved_fd(&mut preserved_fds, file)) |
| 1303 | } |
Jeongik Cha | 112a268 | 2024-07-09 12:28:45 +0900 | [diff] [blame] | 1304 | InputDeviceOption::MultiTouchTrackpad { file, width, height, name } => format!( |
| 1305 | "multi-touch-trackpad[path={},width={},height={}{}]", |
| 1306 | add_preserved_fd(&mut preserved_fds, file), |
| 1307 | width, |
| 1308 | height, |
| 1309 | name.as_ref().map_or("".into(), |n| format!(",name={}", n)) |
| 1310 | ), |
Jeongik Cha | 1049491 | 2024-07-16 11:19:50 +0900 | [diff] [blame] | 1311 | InputDeviceOption::MultiTouch { file, width, height, name } => format!( |
| 1312 | "multi-touch[path={},width={},height={}{}]", |
| 1313 | add_preserved_fd(&mut preserved_fds, file), |
| 1314 | width, |
| 1315 | height, |
| 1316 | name.as_ref().map_or("".into(), |n| format!(",name={}", n)) |
| 1317 | ), |
Jeongik Cha | c181be7 | 2024-03-27 00:18:30 +0900 | [diff] [blame] | 1318 | }); |
| 1319 | } |
| 1320 | } |
Vincent Donnefort | 538a2c6 | 2024-03-20 16:01:10 +0000 | [diff] [blame] | 1321 | |
| 1322 | if config.hugepages { |
| 1323 | command.arg("--hugepages"); |
| 1324 | } |
| 1325 | |
David Dai | 23cff71 | 2024-06-13 19:23:45 +0000 | [diff] [blame] | 1326 | if config.boost_uclamp { |
| 1327 | command.arg("--boost-uclamp"); |
| 1328 | } |
| 1329 | |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1330 | if !config.vfio_devices.is_empty() { |
| 1331 | if let Some(dtbo) = config.dtbo { |
| 1332 | command.arg(format!( |
| 1333 | "--device-tree-overlay={},filter", |
| 1334 | add_preserved_fd(&mut preserved_fds, dtbo) |
| 1335 | )); |
| 1336 | } else { |
| 1337 | bail!("VFIO devices assigned but no DTBO available"); |
| 1338 | } |
| 1339 | }; |
| 1340 | for device in config.vfio_devices { |
| 1341 | command.arg(vfio_argument_for_platform_device(&device)?); |
| 1342 | } |
Inseob Kim | 6ef8097 | 2023-07-20 17:23:36 +0900 | [diff] [blame] | 1343 | |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 1344 | for shared_path in &config.shared_paths { |
Akilesh Kailash | c9aa068 | 2024-11-25 10:27:24 -0800 | [diff] [blame] | 1345 | if shared_path.app_domain { |
| 1346 | if let Some(socket_fd) = &shared_path.socket_fd { |
| 1347 | let socket_path = |
| 1348 | add_preserved_fd(&mut preserved_fds, socket_fd.try_clone().unwrap()); |
| 1349 | let raw_fd: i32 = socket_path.rsplit_once('/').unwrap().1.parse().unwrap(); |
| 1350 | command |
| 1351 | .arg("--vhost-user-fs") |
| 1352 | .arg(format!("tag={},socket-fd={}", &shared_path.tag, raw_fd)); |
| 1353 | } |
| 1354 | } else { |
| 1355 | if let Err(e) = wait_for_file(&shared_path.socket_path, 5) { |
| 1356 | bail!("Error waiting for file: {}", e); |
| 1357 | } |
| 1358 | command |
| 1359 | .arg("--vhost-user-fs") |
| 1360 | .arg(format!("{},tag={}", &shared_path.socket_path, &shared_path.tag)); |
Akilesh Kailash | 5fcb634 | 2024-10-30 15:32:09 -0700 | [diff] [blame] | 1361 | } |
Akilesh Kailash | 05515dc | 2024-10-22 21:42:52 -0700 | [diff] [blame] | 1362 | } |
| 1363 | |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 1364 | debug!("Preserving FDs {:?}", preserved_fds); |
| 1365 | command.preserved_fds(preserved_fds); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1366 | |
Mu-Le Lee | 134180a | 2024-04-16 15:13:07 +0800 | [diff] [blame] | 1367 | if cfg!(paravirtualized_devices) { |
Mu-Le Lee | b2d5a31 | 2024-06-05 10:52:47 +0800 | [diff] [blame] | 1368 | if let Some(audio_config) = &config.audio_config { |
| 1369 | command.arg("--virtio-snd").arg(format!( |
| 1370 | "backend=aaudio,num_input_devices={},num_output_devices={}", |
| 1371 | if audio_config.use_microphone { 1 } else { 0 }, |
| 1372 | if audio_config.use_speaker { 1 } else { 0 } |
| 1373 | )); |
Mu-Le Lee | 134180a | 2024-04-16 15:13:07 +0800 | [diff] [blame] | 1374 | } |
| 1375 | } |
| 1376 | |
Jiyong Park | 2d73656 | 2022-10-24 22:40:12 +0900 | [diff] [blame] | 1377 | print_crosvm_args(&command); |
| 1378 | |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1379 | let result = SharedChild::spawn(&mut command)?; |
Jooyung Han | bfe086f | 2021-10-28 10:15:45 +0900 | [diff] [blame] | 1380 | debug!("Spawned crosvm({}).", result.id()); |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1381 | Ok(result) |
| 1382 | } |
| 1383 | |
Akilesh Kailash | 5fcb634 | 2024-10-30 15:32:09 -0700 | [diff] [blame] | 1384 | fn wait_for_file(path: &str, timeout_secs: u64) -> Result<(), std::io::Error> { |
| 1385 | let start_time = std::time::Instant::now(); |
| 1386 | let timeout = Duration::from_secs(timeout_secs); |
| 1387 | |
| 1388 | while start_time.elapsed() < timeout { |
| 1389 | if std::fs::metadata(path).is_ok() { |
| 1390 | return Ok(()); // File exists |
| 1391 | } |
| 1392 | thread::sleep(Duration::from_millis(100)); |
| 1393 | } |
| 1394 | |
| 1395 | Err(std::io::Error::new( |
| 1396 | std::io::ErrorKind::NotFound, |
| 1397 | format!("File not found within {} seconds: {}", timeout_secs, path), |
| 1398 | )) |
| 1399 | } |
| 1400 | |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1401 | /// Ensure that the configuration has a valid combination of fields set, or return an error if not. |
Andrew Walbran | f5fbb7d | 2021-05-12 17:15:48 +0000 | [diff] [blame] | 1402 | fn validate_config(config: &CrosvmConfig) -> Result<(), Error> { |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1403 | if config.bootloader.is_none() && config.kernel.is_none() { |
| 1404 | bail!("VM must have either a bootloader or a kernel image."); |
| 1405 | } |
| 1406 | if config.bootloader.is_some() && (config.kernel.is_some() || config.initrd.is_some()) { |
| 1407 | bail!("Can't have both bootloader and kernel/initrd image."); |
| 1408 | } |
Jiyong Park | dcf1741 | 2022-02-08 15:07:23 +0900 | [diff] [blame] | 1409 | let version = Version::parse(CROSVM_PLATFORM_VERSION).unwrap(); |
| 1410 | if !config.platform_version.matches(&version) { |
| 1411 | bail!( |
| 1412 | "Incompatible platform version. The config is compatible with platform version(s) \ |
| 1413 | {}, but the actual platform version is {}", |
| 1414 | config.platform_version, |
| 1415 | version |
| 1416 | ); |
| 1417 | } |
| 1418 | |
Andrew Walbran | 3a5a921 | 2021-05-04 17:09:08 +0000 | [diff] [blame] | 1419 | Ok(()) |
| 1420 | } |
| 1421 | |
Jiyong Park | 2d73656 | 2022-10-24 22:40:12 +0900 | [diff] [blame] | 1422 | /// Print arguments of the crosvm command. In doing so, /proc/self/fd/XX is annotated with the |
| 1423 | /// actual file path if the FD is backed by a regular file. If not, the /proc path is printed |
| 1424 | /// unmodified. |
| 1425 | fn print_crosvm_args(command: &Command) { |
| 1426 | let re = Regex::new(r"/proc/self/fd/[\d]+").unwrap(); |
| 1427 | info!( |
| 1428 | "Running crosvm with args: {:?}", |
| 1429 | command |
| 1430 | .get_args() |
| 1431 | .map(|s| s.to_string_lossy()) |
| 1432 | .map(|s| { |
| 1433 | re.replace_all(&s, |caps: &Captures| { |
| 1434 | let path = &caps[0]; |
| 1435 | if let Ok(realpath) = std::fs::canonicalize(path) { |
| 1436 | format!("{} ({})", path, realpath.to_string_lossy()) |
| 1437 | } else { |
| 1438 | path.to_owned() |
| 1439 | } |
| 1440 | }) |
| 1441 | .into_owned() |
| 1442 | }) |
| 1443 | .collect::<Vec<_>>() |
| 1444 | ); |
| 1445 | } |
| 1446 | |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 1447 | /// Adds the file descriptor for `file` to `preserved_fds`, and returns a string of the form |
| 1448 | /// "/proc/self/fd/N" where N is the file descriptor. |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1449 | fn add_preserved_fd<F: Into<OwnedFd>>(preserved_fds: &mut Vec<OwnedFd>, file: F) -> String { |
| 1450 | let fd = file.into(); |
| 1451 | let raw_fd = fd.as_raw_fd(); |
Andrew Walbran | 02b8ec0 | 2021-06-22 13:07:02 +0000 | [diff] [blame] | 1452 | preserved_fds.push(fd); |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1453 | format!("/proc/self/fd/{}", raw_fd) |
Andrew Walbran | d6dce6f | 2021-03-05 16:39:08 +0000 | [diff] [blame] | 1454 | } |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 1455 | |
| 1456 | /// Adds the file descriptor for `file` (if any) to `preserved_fds`, and returns the appropriate |
| 1457 | /// string for a crosvm `--serial` flag. If `file` is none, creates a dummy sink device. |
Jiyong Park | 69001a2 | 2024-08-16 20:45:34 +0900 | [diff] [blame] | 1458 | fn format_serial_out_arg(preserved_fds: &mut Vec<OwnedFd>, file: Option<File>) -> String { |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 1459 | if let Some(file) = file { |
| 1460 | format!("type=file,path={}", add_preserved_fd(preserved_fds, file)) |
| 1461 | } else { |
| 1462 | "type=sink".to_string() |
| 1463 | } |
| 1464 | } |
| 1465 | |
| 1466 | /// Creates a new pipe with the `O_CLOEXEC` flag set, and returns the read side and write side. |
| 1467 | fn create_pipe() -> Result<(File, File), Error> { |
Frederick Mayle | fbbcfcd | 2024-04-08 16:31:54 -0700 | [diff] [blame] | 1468 | let (read_fd, write_fd) = pipe2(OFlag::O_CLOEXEC)?; |
| 1469 | Ok((read_fd.into(), write_fd.into())) |
Andrew Walbran | b27681f | 2022-02-23 15:11:52 +0000 | [diff] [blame] | 1470 | } |
Frederick Mayle | e0ed235 | 2024-09-12 16:16:00 -0700 | [diff] [blame] | 1471 | |
| 1472 | /// Creates and binds a unix seqpacket listening socket to be passed as crosvm's `--socket` |
| 1473 | /// argument. See `UnixSeqpacketListener::bind` in crosvm's code for reference. |
| 1474 | fn create_crosvm_control_listener(crosvm_control_socket_path: &Path) -> Result<OwnedFd> { |
| 1475 | use nix::sys::socket; |
| 1476 | let fd = socket::socket( |
| 1477 | socket::AddressFamily::Unix, |
| 1478 | socket::SockType::SeqPacket, |
| 1479 | socket::SockFlag::empty(), |
| 1480 | None, |
| 1481 | ) |
| 1482 | .context("socket failed")?; |
| 1483 | socket::bind(fd.as_raw_fd(), &socket::UnixAddr::new(crosvm_control_socket_path)?) |
| 1484 | .context("bind failed")?; |
| 1485 | // The exact backlog size isn't imporant. crosvm uses 128 internally. We use 127 here |
| 1486 | // because of a `nix` bug. |
| 1487 | socket::listen(&fd, socket::Backlog::new(127).unwrap()).context("listen failed")?; |
| 1488 | Ok(fd) |
| 1489 | } |
Frederick Mayle | f375ef1 | 2024-10-21 16:07:21 -0700 | [diff] [blame] | 1490 | |
| 1491 | fn path_to_cstring(path: &Path) -> CString { |
| 1492 | if let Some(s) = path.to_str() { |
| 1493 | if let Ok(s) = CString::new(s) { |
| 1494 | return s; |
| 1495 | } |
| 1496 | } |
| 1497 | // The path contains invalid utf8 or a null, which should never happen. |
| 1498 | panic!("bad path: {path:?}"); |
| 1499 | } |