Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 1 | // Copyright 2017 The Chromium OS Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Hikaru Nishida | 584e52c | 2021-04-27 17:37:08 +0900 | [diff] [blame] | 5 | use std::cmp::Reverse; |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 6 | use std::collections::BTreeMap; |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 7 | use std::convert::TryFrom; |
John Bates | b220eac | 2020-09-14 17:03:02 -0700 | [diff] [blame] | 8 | #[cfg(feature = "gpu")] |
| 9 | use std::env; |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 10 | use std::fs::{File, OpenOptions}; |
Federico 'Morg' Pareschi | a118482 | 2021-09-09 10:52:58 +0900 | [diff] [blame] | 11 | use std::io::stdin; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 12 | use std::iter; |
Daniel Verkamp | 94c3527 | 2019-09-12 13:31:30 -0700 | [diff] [blame] | 13 | use std::mem; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 14 | use std::net::Ipv4Addr; |
Christian Blichmann | 50f9591 | 2021-11-05 16:59:39 +0100 | [diff] [blame] | 15 | use std::os::unix::{io::FromRawFd, net::UnixStream, prelude::OpenOptionsExt}; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 16 | use std::path::{Path, PathBuf}; |
Chirantan Ekbote | 448516e | 2018-07-24 16:07:42 -0700 | [diff] [blame] | 17 | use std::str; |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 18 | use std::sync::{mpsc, Arc, Barrier}; |
Hikaru Nishida | 584e52c | 2021-04-27 17:37:08 +0900 | [diff] [blame] | 19 | use std::time::Duration; |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 20 | |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 21 | use std::thread; |
| 22 | use std::thread::JoinHandle; |
| 23 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 24 | use libc::{self, c_int, gid_t, uid_t}; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 25 | |
Tomasz Jeznach | 4264464 | 2020-05-20 23:27:59 -0700 | [diff] [blame] | 26 | use acpi_tables::sdt::SDT; |
| 27 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 28 | use anyhow::{anyhow, bail, Context, Result}; |
Chirantan Ekbote | 2ee9dcd | 2021-05-26 18:21:44 +0900 | [diff] [blame] | 29 | use base::net::{UnixSeqpacket, UnixSeqpacketListener, UnlinkUnixSeqpacketListener}; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 30 | use base::*; |
Keiichi Watanabe | 553d219 | 2021-08-16 16:42:27 +0900 | [diff] [blame] | 31 | use devices::serial_device::{SerialHardware, SerialParameters}; |
Zide Chen | afdb938 | 2021-06-17 12:04:43 -0700 | [diff] [blame] | 32 | use devices::vfio::{VfioCommonSetup, VfioCommonTrait}; |
Woody Chow | 0b2b606 | 2021-09-03 15:40:02 +0900 | [diff] [blame] | 33 | #[cfg(feature = "audio_cras")] |
| 34 | use devices::virtio::snd::cras_backend::Parameters as CrasSndParameters; |
Woody Chow | 1b16db1 | 2021-04-02 16:59:59 +0900 | [diff] [blame] | 35 | #[cfg(feature = "audio")] |
| 36 | use devices::virtio::vhost::user::vmm::Snd as VhostUserSnd; |
Keiichi Watanabe | fb36e0c | 2021-08-13 18:48:31 +0900 | [diff] [blame] | 37 | use devices::virtio::vhost::user::vmm::{ |
Richard | 5afeafa | 2021-07-26 19:02:09 -0700 | [diff] [blame] | 38 | Block as VhostUserBlock, Console as VhostUserConsole, Fs as VhostUserFs, |
Chirantan Ekbote | 84091e5 | 2021-09-10 18:43:17 +0900 | [diff] [blame] | 39 | Mac80211Hwsim as VhostUserMac80211Hwsim, Net as VhostUserNet, Vsock as VhostUserVsock, |
| 40 | Wl as VhostUserWl, |
Keiichi Watanabe | 6068658 | 2021-03-12 04:53:51 +0900 | [diff] [blame] | 41 | }; |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 42 | #[cfg(any(feature = "video-decoder", feature = "video-encoder"))] |
| 43 | use devices::virtio::VideoBackendType; |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 44 | use devices::virtio::{self, Console, VirtioDevice}; |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 45 | #[cfg(feature = "gpu")] |
| 46 | use devices::virtio::{ |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 47 | gpu::{GpuRenderServerParameters, DEFAULT_DISPLAY_HEIGHT, DEFAULT_DISPLAY_WIDTH}, |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 48 | vhost::user::vmm::Gpu as VhostUserGpu, |
| 49 | EventDevice, |
| 50 | }; |
paulhsia | ce17e6e | 2020-08-28 18:37:45 +0800 | [diff] [blame] | 51 | #[cfg(feature = "audio")] |
| 52 | use devices::Ac97Dev; |
Xiong Zhang | 17b0daf | 2019-04-23 17:14:50 +0800 | [diff] [blame] | 53 | use devices::{ |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 54 | self, BusDeviceObj, HostHotPlugKey, HotPlugBus, IrqChip, IrqEventIndex, KvmKernelIrqChip, |
| 55 | PciAddress, PciBridge, PciDevice, PcieRootPort, StubPciDevice, VcpuRunState, VfioContainer, |
| 56 | VfioDevice, VfioPciDevice, VfioPlatformDevice, VirtioPciDevice, |
Xiong Zhang | 17b0daf | 2019-04-23 17:14:50 +0800 | [diff] [blame] | 57 | }; |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 58 | #[cfg(feature = "usb")] |
| 59 | use devices::{HostBackendDeviceProvider, XhciController}; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 60 | use hypervisor::kvm::{Kvm, KvmVcpu, KvmVm}; |
Andrew Walbran | 00f1c9f | 2021-12-10 17:13:08 +0000 | [diff] [blame] | 61 | use hypervisor::{HypervisorCap, ProtectionType, Vcpu, VcpuExit, VcpuRunHandle, Vm, VmCap}; |
Allen Webb | f3024c8 | 2020-06-19 07:19:48 -0700 | [diff] [blame] | 62 | use minijail::{self, Minijail}; |
Richard | 5afeafa | 2021-07-26 19:02:09 -0700 | [diff] [blame] | 63 | use net_util::{MacAddress, Tap}; |
Xiong Zhang | 87a3b44 | 2019-10-29 17:32:44 +0800 | [diff] [blame] | 64 | use resources::{Alloc, MmioType, SystemAllocator}; |
Gurchetan Singh | 293913c | 2020-12-09 10:44:13 -0800 | [diff] [blame] | 65 | use rutabaga_gfx::RutabagaGralloc; |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 66 | use sync::Mutex; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 67 | use vm_control::*; |
Sergey Senozhatsky | d78d05b | 2021-04-13 20:59:58 +0900 | [diff] [blame] | 68 | use vm_memory::{GuestAddress, GuestMemory, MemoryPolicy}; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 69 | |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 70 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 71 | use crate::gdb::{gdb_thread, GdbStub}; |
Keiichi Watanabe | f3a37f4 | 2021-01-21 15:41:11 +0900 | [diff] [blame] | 72 | use crate::{ |
Tomasz Nowicki | 71aca79 | 2021-06-09 18:53:49 +0000 | [diff] [blame] | 73 | Config, DiskOption, Executable, SharedDir, SharedDirKind, TouchDeviceOption, VfioType, |
Christian Blichmann | 50f9591 | 2021-11-05 16:59:39 +0100 | [diff] [blame] | 74 | VhostUserFsOption, VhostUserOption, VhostUserWlOption, VhostVsockDeviceParameter, |
Keiichi Watanabe | f3a37f4 | 2021-01-21 15:41:11 +0900 | [diff] [blame] | 75 | }; |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 76 | use arch::{ |
Keiichi Watanabe | 553d219 | 2021-08-16 16:42:27 +0900 | [diff] [blame] | 77 | self, LinuxArch, RunnableLinuxVm, VcpuAffinity, VirtioDeviceStub, VmComponents, VmImage, |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 78 | }; |
Sonny Rao | ed517d1 | 2018-02-13 22:09:43 -0800 | [diff] [blame] | 79 | |
Sonny Rao | 2ffa0cb | 2018-02-26 17:27:40 -0800 | [diff] [blame] | 80 | #[cfg(any(target_arch = "arm", target_arch = "aarch64"))] |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 81 | use { |
| 82 | aarch64::AArch64 as Arch, |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 83 | devices::IrqChipAArch64 as IrqChipArch, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 84 | hypervisor::{VcpuAArch64 as VcpuArch, VmAArch64 as VmArch}, |
| 85 | }; |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 86 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 87 | use { |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 88 | devices::{IrqChipX86_64 as IrqChipArch, KvmSplitIrqChip}, |
| 89 | hypervisor::{VcpuX86_64 as VcpuArch, VmX86_64 as VmArch}, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 90 | x86_64::X8664arch as Arch, |
| 91 | }; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 92 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 93 | enum TaggedControlTube { |
| 94 | Fs(Tube), |
| 95 | Vm(Tube), |
| 96 | VmMemory(Tube), |
| 97 | VmIrq(Tube), |
| 98 | VmMsync(Tube), |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 99 | } |
| 100 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 101 | impl AsRef<Tube> for TaggedControlTube { |
| 102 | fn as_ref(&self) -> &Tube { |
| 103 | use self::TaggedControlTube::*; |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 104 | match &self { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 105 | Fs(tube) | Vm(tube) | VmMemory(tube) | VmIrq(tube) | VmMsync(tube) => tube, |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 106 | } |
| 107 | } |
| 108 | } |
| 109 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 110 | impl AsRawDescriptor for TaggedControlTube { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 111 | fn as_raw_descriptor(&self) -> RawDescriptor { |
Michael Hoyle | a596a07 | 2020-11-10 19:32:45 -0800 | [diff] [blame] | 112 | self.as_ref().as_raw_descriptor() |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 113 | } |
| 114 | } |
| 115 | |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 116 | struct SandboxConfig<'a> { |
| 117 | limit_caps: bool, |
| 118 | log_failures: bool, |
| 119 | seccomp_policy: &'a Path, |
| 120 | uid_map: Option<&'a str>, |
| 121 | gid_map: Option<&'a str>, |
| 122 | } |
| 123 | |
Zach Reizner | 4486379 | 2019-06-26 14:22:08 -0700 | [diff] [blame] | 124 | fn create_base_minijail( |
| 125 | root: &Path, |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 126 | r_limit: Option<u64>, |
| 127 | config: Option<&SandboxConfig>, |
Zach Reizner | 4486379 | 2019-06-26 14:22:08 -0700 | [diff] [blame] | 128 | ) -> Result<Minijail> { |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 129 | // All child jails run in a new user namespace without any users mapped, |
| 130 | // they run as nobody unless otherwise configured. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 131 | let mut j = Minijail::new().context("failed to jail device")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 132 | |
| 133 | if let Some(config) = config { |
| 134 | j.namespace_pids(); |
| 135 | j.namespace_user(); |
| 136 | j.namespace_user_disable_setgroups(); |
| 137 | if config.limit_caps { |
| 138 | // Don't need any capabilities. |
| 139 | j.use_caps(0); |
| 140 | } |
| 141 | if let Some(uid_map) = config.uid_map { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 142 | j.uidmap(uid_map).context("error setting UID map")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 143 | } |
| 144 | if let Some(gid_map) = config.gid_map { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 145 | j.gidmap(gid_map).context("error setting GID map")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 146 | } |
Chirantan Ekbote | f84c229 | 2020-02-21 16:37:27 +0900 | [diff] [blame] | 147 | // Run in a new mount namespace. |
| 148 | j.namespace_vfs(); |
| 149 | |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 150 | // Run in an empty network namespace. |
| 151 | j.namespace_net(); |
Chirantan Ekbote | f84c229 | 2020-02-21 16:37:27 +0900 | [diff] [blame] | 152 | |
| 153 | // Don't allow the device to gain new privileges. |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 154 | j.no_new_privs(); |
| 155 | |
| 156 | // By default we'll prioritize using the pre-compiled .bpf over the .policy |
| 157 | // file (the .bpf is expected to be compiled using "trap" as the failure |
| 158 | // behavior instead of the default "kill" behavior). |
| 159 | // Refer to the code comment for the "seccomp-log-failures" |
| 160 | // command-line parameter for an explanation about why the |log_failures| |
| 161 | // flag forces the use of .policy files (and the build-time alternative to |
| 162 | // this run-time flag). |
| 163 | let bpf_policy_file = config.seccomp_policy.with_extension("bpf"); |
| 164 | if bpf_policy_file.exists() && !config.log_failures { |
| 165 | j.parse_seccomp_program(&bpf_policy_file) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 166 | .context("failed to parse precompiled seccomp policy")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 167 | } else { |
| 168 | // Use TSYNC only for the side effect of it using SECCOMP_RET_TRAP, |
| 169 | // which will correctly kill the entire device process if a worker |
| 170 | // thread commits a seccomp violation. |
| 171 | j.set_seccomp_filter_tsync(); |
| 172 | if config.log_failures { |
| 173 | j.log_seccomp_filter_failures(); |
| 174 | } |
| 175 | j.parse_seccomp_filters(&config.seccomp_policy.with_extension("policy")) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 176 | .context("failed to parse seccomp policy")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 177 | } |
| 178 | j.use_seccomp_filter(); |
| 179 | // Don't do init setup. |
| 180 | j.run_as_init(); |
| 181 | } |
| 182 | |
Chirantan Ekbote | f84c229 | 2020-02-21 16:37:27 +0900 | [diff] [blame] | 183 | // Only pivot_root if we are not re-using the current root directory. |
| 184 | if root != Path::new("/") { |
| 185 | // It's safe to call `namespace_vfs` multiple times. |
| 186 | j.namespace_vfs(); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 187 | j.enter_pivot_root(root) |
| 188 | .context("failed to pivot root device")?; |
Chirantan Ekbote | f84c229 | 2020-02-21 16:37:27 +0900 | [diff] [blame] | 189 | } |
Matt Delco | 45caf91 | 2019-11-13 08:11:09 -0800 | [diff] [blame] | 190 | |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 191 | // Most devices don't need to open many fds. |
| 192 | let limit = if let Some(r) = r_limit { r } else { 1024u64 }; |
| 193 | j.set_rlimit(libc::RLIMIT_NOFILE as i32, limit, limit) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 194 | .context("error setting max open files")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 195 | |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 196 | Ok(j) |
| 197 | } |
| 198 | |
Jianxun Zhang | 8f4d768 | 2019-02-21 12:55:31 -0800 | [diff] [blame] | 199 | fn simple_jail(cfg: &Config, policy: &str) -> Result<Option<Minijail>> { |
Lepton Wu | 9105e9f | 2019-03-14 11:38:31 -0700 | [diff] [blame] | 200 | if cfg.sandbox { |
Jianxun Zhang | 8f4d768 | 2019-02-21 12:55:31 -0800 | [diff] [blame] | 201 | let pivot_root: &str = option_env!("DEFAULT_PIVOT_ROOT").unwrap_or("/var/empty"); |
| 202 | // A directory for a jailed device's pivot root. |
| 203 | let root_path = Path::new(pivot_root); |
| 204 | if !root_path.exists() { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 205 | bail!("{} doesn't exist, can't jail devices", pivot_root); |
Jianxun Zhang | 8f4d768 | 2019-02-21 12:55:31 -0800 | [diff] [blame] | 206 | } |
| 207 | let policy_path: PathBuf = cfg.seccomp_policy_dir.join(policy); |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 208 | let config = SandboxConfig { |
| 209 | limit_caps: true, |
| 210 | log_failures: cfg.seccomp_log_failures, |
| 211 | seccomp_policy: &policy_path, |
| 212 | uid_map: None, |
| 213 | gid_map: None, |
| 214 | }; |
| 215 | Ok(Some(create_base_minijail(root_path, None, Some(&config))?)) |
Jianxun Zhang | 8f4d768 | 2019-02-21 12:55:31 -0800 | [diff] [blame] | 216 | } else { |
| 217 | Ok(None) |
| 218 | } |
| 219 | } |
| 220 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 221 | type DeviceResult<T = VirtioDeviceStub> = Result<T>; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 222 | |
Andrew Walbran | 4cad30a | 2021-06-28 15:58:08 +0000 | [diff] [blame] | 223 | fn create_block_device(cfg: &Config, disk: &DiskOption, disk_device_tube: Tube) -> DeviceResult { |
Junichi Uekawa | 7bea39f | 2021-07-16 14:05:06 +0900 | [diff] [blame] | 224 | let raw_image: File = open_file(&disk.path, disk.read_only, disk.o_direct) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 225 | .with_context(|| format!("failed to load disk image {}", disk.path.display()))?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 226 | // Lock the disk image to prevent other crosvm instances from using it. |
| 227 | let lock_op = if disk.read_only { |
| 228 | FlockOperation::LockShared |
| 229 | } else { |
| 230 | FlockOperation::LockExclusive |
| 231 | }; |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 232 | flock(&raw_image, lock_op, true).context("failed to lock disk image")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 233 | |
Junichi Uekawa | 52437db | 2021-09-29 17:33:07 +0900 | [diff] [blame] | 234 | info!("Trying to attach block device: {}", disk.path.display()); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 235 | let dev = if disk::async_ok(&raw_image).context("failed to check disk async_ok")? { |
| 236 | let async_file = disk::create_async_disk_file(raw_image) |
| 237 | .context("failed to create async virtual disk")?; |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 238 | Box::new( |
| 239 | virtio::BlockAsync::new( |
| 240 | virtio::base_features(cfg.protected_vm), |
| 241 | async_file, |
| 242 | disk.read_only, |
| 243 | disk.sparse, |
| 244 | disk.block_size, |
Daniel Verkamp | dd0ee59 | 2021-03-29 13:05:22 -0700 | [diff] [blame] | 245 | disk.id, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 246 | Some(disk_device_tube), |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 247 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 248 | .context("failed to create block device")?, |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 249 | ) as Box<dyn VirtioDevice> |
| 250 | } else { |
Daniel Verkamp | eb1640e | 2021-09-07 14:09:31 -0700 | [diff] [blame] | 251 | let disk_file = disk::create_disk_file(raw_image, disk::MAX_NESTING_DEPTH) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 252 | .context("failed to create virtual disk")?; |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 253 | Box::new( |
| 254 | virtio::Block::new( |
| 255 | virtio::base_features(cfg.protected_vm), |
| 256 | disk_file, |
| 257 | disk.read_only, |
| 258 | disk.sparse, |
| 259 | disk.block_size, |
| 260 | disk.id, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 261 | Some(disk_device_tube), |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 262 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 263 | .context("failed to create block device")?, |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 264 | ) as Box<dyn VirtioDevice> |
| 265 | }; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 266 | |
| 267 | Ok(VirtioDeviceStub { |
Dylan Reid | 503c5ab | 2020-07-17 11:20:07 -0700 | [diff] [blame] | 268 | dev, |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 269 | jail: simple_jail(cfg, "block_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 270 | }) |
| 271 | } |
| 272 | |
Keiichi Watanabe | f3a37f4 | 2021-01-21 15:41:11 +0900 | [diff] [blame] | 273 | fn create_vhost_user_block_device(cfg: &Config, opt: &VhostUserOption) -> DeviceResult { |
| 274 | let dev = VhostUserBlock::new(virtio::base_features(cfg.protected_vm), &opt.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 275 | .context("failed to set up vhost-user block device")?; |
Keiichi Watanabe | f3a37f4 | 2021-01-21 15:41:11 +0900 | [diff] [blame] | 276 | |
| 277 | Ok(VirtioDeviceStub { |
| 278 | dev: Box::new(dev), |
| 279 | // no sandbox here because virtqueue handling is exported to a different process. |
| 280 | jail: None, |
| 281 | }) |
| 282 | } |
| 283 | |
Federico 'Morg' Pareschi | 70fc7de | 2021-04-08 15:43:13 +0900 | [diff] [blame] | 284 | fn create_vhost_user_console_device(cfg: &Config, opt: &VhostUserOption) -> DeviceResult { |
| 285 | let dev = VhostUserConsole::new(virtio::base_features(cfg.protected_vm), &opt.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 286 | .context("failed to set up vhost-user console device")?; |
Federico 'Morg' Pareschi | 70fc7de | 2021-04-08 15:43:13 +0900 | [diff] [blame] | 287 | |
| 288 | Ok(VirtioDeviceStub { |
| 289 | dev: Box::new(dev), |
| 290 | // no sandbox here because virtqueue handling is exported to a different process. |
| 291 | jail: None, |
| 292 | }) |
| 293 | } |
| 294 | |
Woody Chow | 5890b70 | 2021-02-12 14:57:02 +0900 | [diff] [blame] | 295 | fn create_vhost_user_fs_device(cfg: &Config, option: &VhostUserFsOption) -> DeviceResult { |
| 296 | let dev = VhostUserFs::new( |
| 297 | virtio::base_features(cfg.protected_vm), |
| 298 | &option.socket, |
| 299 | &option.tag, |
| 300 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 301 | .context("failed to set up vhost-user fs device")?; |
Woody Chow | 5890b70 | 2021-02-12 14:57:02 +0900 | [diff] [blame] | 302 | |
| 303 | Ok(VirtioDeviceStub { |
| 304 | dev: Box::new(dev), |
| 305 | // no sandbox here because virtqueue handling is exported to a different process. |
| 306 | jail: None, |
| 307 | }) |
| 308 | } |
| 309 | |
JaeMan Park | eb9cc53 | 2021-07-02 15:02:59 +0900 | [diff] [blame] | 310 | fn create_vhost_user_mac80211_hwsim_device(cfg: &Config, opt: &VhostUserOption) -> DeviceResult { |
| 311 | let dev = VhostUserMac80211Hwsim::new(virtio::base_features(cfg.protected_vm), &opt.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 312 | .context("failed to set up vhost-user mac80211_hwsim device")?; |
JaeMan Park | eb9cc53 | 2021-07-02 15:02:59 +0900 | [diff] [blame] | 313 | |
| 314 | Ok(VirtioDeviceStub { |
| 315 | dev: Box::new(dev), |
| 316 | // no sandbox here because virtqueue handling is exported to a different process. |
| 317 | jail: None, |
| 318 | }) |
| 319 | } |
| 320 | |
Woody Chow | 1b16db1 | 2021-04-02 16:59:59 +0900 | [diff] [blame] | 321 | #[cfg(feature = "audio")] |
| 322 | fn create_vhost_user_snd_device(cfg: &Config, option: &VhostUserOption) -> DeviceResult { |
| 323 | let dev = VhostUserSnd::new(virtio::base_features(cfg.protected_vm), &option.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 324 | .context("failed to set up vhost-user snd device")?; |
Woody Chow | 1b16db1 | 2021-04-02 16:59:59 +0900 | [diff] [blame] | 325 | |
| 326 | Ok(VirtioDeviceStub { |
| 327 | dev: Box::new(dev), |
| 328 | // no sandbox here because virtqueue handling is exported to a different process. |
| 329 | jail: None, |
| 330 | }) |
| 331 | } |
| 332 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 333 | fn create_rng_device(cfg: &Config) -> DeviceResult { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 334 | let dev = virtio::Rng::new(virtio::base_features(cfg.protected_vm)) |
| 335 | .context("failed to set up rng")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 336 | |
| 337 | Ok(VirtioDeviceStub { |
| 338 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 339 | jail: simple_jail(cfg, "rng_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 340 | }) |
| 341 | } |
| 342 | |
Woody Chow | 737ff12 | 2021-03-22 17:49:57 +0900 | [diff] [blame] | 343 | #[cfg(feature = "audio_cras")] |
Woody Chow | 0b2b606 | 2021-09-03 15:40:02 +0900 | [diff] [blame] | 344 | fn create_cras_snd_device(cfg: &Config, cras_snd: CrasSndParameters) -> DeviceResult { |
| 345 | let dev = virtio::snd::cras_backend::VirtioSndCras::new( |
| 346 | virtio::base_features(cfg.protected_vm), |
| 347 | cras_snd, |
| 348 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 349 | .context("failed to create cras sound device")?; |
Woody Chow | 737ff12 | 2021-03-22 17:49:57 +0900 | [diff] [blame] | 350 | |
| 351 | let jail = match simple_jail(&cfg, "cras_snd_device")? { |
| 352 | Some(mut jail) => { |
| 353 | // Create a tmpfs in the device's root directory for cras_snd_device. |
| 354 | // The size is 20*1024, or 20 KB. |
| 355 | jail.mount_with_data( |
| 356 | Path::new("none"), |
| 357 | Path::new("/"), |
| 358 | "tmpfs", |
| 359 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC) as usize, |
| 360 | "size=20480", |
| 361 | )?; |
| 362 | |
| 363 | let run_cras_path = Path::new("/run/cras"); |
| 364 | jail.mount_bind(run_cras_path, run_cras_path, true)?; |
| 365 | |
| 366 | add_current_user_to_jail(&mut jail)?; |
| 367 | |
| 368 | Some(jail) |
| 369 | } |
| 370 | None => None, |
| 371 | }; |
| 372 | |
| 373 | Ok(VirtioDeviceStub { |
| 374 | dev: Box::new(dev), |
| 375 | jail, |
| 376 | }) |
| 377 | } |
| 378 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 379 | #[cfg(feature = "tpm")] |
| 380 | fn create_tpm_device(cfg: &Config) -> DeviceResult { |
| 381 | use std::ffi::CString; |
| 382 | use std::fs; |
| 383 | use std::process; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 384 | |
| 385 | let tpm_storage: PathBuf; |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 386 | let mut tpm_jail = simple_jail(cfg, "tpm_device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 387 | |
| 388 | match &mut tpm_jail { |
| 389 | Some(jail) => { |
| 390 | // Create a tmpfs in the device's root directory for tpm |
| 391 | // simulator storage. The size is 20*1024, or 20 KB. |
| 392 | jail.mount_with_data( |
| 393 | Path::new("none"), |
| 394 | Path::new("/"), |
| 395 | "tmpfs", |
| 396 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC) as usize, |
| 397 | "size=20480", |
| 398 | )?; |
| 399 | |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 400 | let crosvm_ids = add_current_user_to_jail(jail)?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 401 | |
| 402 | let pid = process::id(); |
| 403 | let tpm_pid_dir = format!("/run/vm/tpm.{}", pid); |
| 404 | tpm_storage = Path::new(&tpm_pid_dir).to_owned(); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 405 | fs::create_dir_all(&tpm_storage).with_context(|| { |
| 406 | format!("failed to create tpm storage dir {}", tpm_storage.display()) |
| 407 | })?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 408 | let tpm_pid_dir_c = CString::new(tpm_pid_dir).expect("no nul bytes"); |
David Tolnay | fd0971d | 2019-03-04 17:15:57 -0800 | [diff] [blame] | 409 | chown(&tpm_pid_dir_c, crosvm_ids.uid, crosvm_ids.gid) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 410 | .context("failed to chown tpm storage")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 411 | |
| 412 | jail.mount_bind(&tpm_storage, &tpm_storage, true)?; |
| 413 | } |
| 414 | None => { |
| 415 | // Path used inside cros_sdk which does not have /run/vm. |
| 416 | tpm_storage = Path::new("/tmp/tpm-simulator").to_owned(); |
| 417 | } |
| 418 | } |
| 419 | |
| 420 | let dev = virtio::Tpm::new(tpm_storage); |
| 421 | |
| 422 | Ok(VirtioDeviceStub { |
| 423 | dev: Box::new(dev), |
| 424 | jail: tpm_jail, |
| 425 | }) |
| 426 | } |
| 427 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 428 | fn create_single_touch_device( |
| 429 | cfg: &Config, |
| 430 | single_touch_spec: &TouchDeviceOption, |
| 431 | idx: u32, |
| 432 | ) -> DeviceResult { |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 433 | let socket = single_touch_spec |
| 434 | .get_path() |
| 435 | .into_unix_stream() |
| 436 | .map_err(|e| { |
| 437 | error!("failed configuring virtio single touch: {:?}", e); |
| 438 | e |
| 439 | })?; |
Jorge E. Moreira | 99d3f08 | 2019-03-07 10:59:54 -0800 | [diff] [blame] | 440 | |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 441 | let (width, height) = single_touch_spec.get_size(); |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 442 | let dev = virtio::new_single_touch( |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 443 | idx, |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 444 | socket, |
| 445 | width, |
| 446 | height, |
| 447 | virtio::base_features(cfg.protected_vm), |
| 448 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 449 | .context("failed to set up input device")?; |
Jorge E. Moreira | 99d3f08 | 2019-03-07 10:59:54 -0800 | [diff] [blame] | 450 | Ok(VirtioDeviceStub { |
| 451 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 452 | jail: simple_jail(cfg, "input_device")?, |
Jorge E. Moreira | 99d3f08 | 2019-03-07 10:59:54 -0800 | [diff] [blame] | 453 | }) |
| 454 | } |
| 455 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 456 | fn create_multi_touch_device( |
| 457 | cfg: &Config, |
| 458 | multi_touch_spec: &TouchDeviceOption, |
| 459 | idx: u32, |
| 460 | ) -> DeviceResult { |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 461 | let socket = multi_touch_spec |
| 462 | .get_path() |
| 463 | .into_unix_stream() |
| 464 | .map_err(|e| { |
| 465 | error!("failed configuring virtio multi touch: {:?}", e); |
| 466 | e |
| 467 | })?; |
| 468 | |
| 469 | let (width, height) = multi_touch_spec.get_size(); |
| 470 | let dev = virtio::new_multi_touch( |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 471 | idx, |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 472 | socket, |
| 473 | width, |
| 474 | height, |
| 475 | virtio::base_features(cfg.protected_vm), |
| 476 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 477 | .context("failed to set up input device")?; |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 478 | |
| 479 | Ok(VirtioDeviceStub { |
| 480 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 481 | jail: simple_jail(cfg, "input_device")?, |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 482 | }) |
| 483 | } |
| 484 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 485 | fn create_trackpad_device( |
| 486 | cfg: &Config, |
| 487 | trackpad_spec: &TouchDeviceOption, |
| 488 | idx: u32, |
| 489 | ) -> DeviceResult { |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 490 | let socket = trackpad_spec.get_path().into_unix_stream().map_err(|e| { |
Maciek Swiech | c301122 | 2021-11-24 21:01:04 +0000 | [diff] [blame] | 491 | error!("failed configuring virtio trackpad: {:#}", e); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 492 | e |
| 493 | })?; |
| 494 | |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 495 | let (width, height) = trackpad_spec.get_size(); |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 496 | let dev = virtio::new_trackpad( |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 497 | idx, |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 498 | socket, |
| 499 | width, |
| 500 | height, |
| 501 | virtio::base_features(cfg.protected_vm), |
| 502 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 503 | .context("failed to set up input device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 504 | |
| 505 | Ok(VirtioDeviceStub { |
| 506 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 507 | jail: simple_jail(cfg, "input_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 508 | }) |
| 509 | } |
| 510 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 511 | fn create_mouse_device<T: IntoUnixStream>(cfg: &Config, mouse_socket: T, idx: u32) -> DeviceResult { |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 512 | let socket = mouse_socket.into_unix_stream().map_err(|e| { |
Maciek Swiech | c301122 | 2021-11-24 21:01:04 +0000 | [diff] [blame] | 513 | error!("failed configuring virtio mouse: {:#}", e); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 514 | e |
| 515 | })?; |
| 516 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 517 | let dev = virtio::new_mouse(idx, socket, virtio::base_features(cfg.protected_vm)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 518 | .context("failed to set up input device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 519 | |
| 520 | Ok(VirtioDeviceStub { |
| 521 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 522 | jail: simple_jail(cfg, "input_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 523 | }) |
| 524 | } |
| 525 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 526 | fn create_keyboard_device<T: IntoUnixStream>( |
| 527 | cfg: &Config, |
| 528 | keyboard_socket: T, |
| 529 | idx: u32, |
| 530 | ) -> DeviceResult { |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 531 | let socket = keyboard_socket.into_unix_stream().map_err(|e| { |
Maciek Swiech | c301122 | 2021-11-24 21:01:04 +0000 | [diff] [blame] | 532 | error!("failed configuring virtio keyboard: {:#}", e); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 533 | e |
| 534 | })?; |
| 535 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 536 | let dev = virtio::new_keyboard(idx, socket, virtio::base_features(cfg.protected_vm)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 537 | .context("failed to set up input device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 538 | |
| 539 | Ok(VirtioDeviceStub { |
| 540 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 541 | jail: simple_jail(cfg, "input_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 542 | }) |
| 543 | } |
| 544 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 545 | fn create_switches_device<T: IntoUnixStream>( |
| 546 | cfg: &Config, |
| 547 | switches_socket: T, |
| 548 | idx: u32, |
| 549 | ) -> DeviceResult { |
Daniel Norman | 5e23df7 | 2021-03-11 10:11:02 -0800 | [diff] [blame] | 550 | let socket = switches_socket.into_unix_stream().map_err(|e| { |
Maciek Swiech | c301122 | 2021-11-24 21:01:04 +0000 | [diff] [blame] | 551 | error!("failed configuring virtio switches: {:#}", e); |
Daniel Norman | 5e23df7 | 2021-03-11 10:11:02 -0800 | [diff] [blame] | 552 | e |
| 553 | })?; |
| 554 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 555 | let dev = virtio::new_switches(idx, socket, virtio::base_features(cfg.protected_vm)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 556 | .context("failed to set up input device")?; |
Daniel Norman | 5e23df7 | 2021-03-11 10:11:02 -0800 | [diff] [blame] | 557 | |
| 558 | Ok(VirtioDeviceStub { |
| 559 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 560 | jail: simple_jail(cfg, "input_device")?, |
Daniel Norman | 5e23df7 | 2021-03-11 10:11:02 -0800 | [diff] [blame] | 561 | }) |
| 562 | } |
| 563 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 564 | fn create_vinput_device(cfg: &Config, dev_path: &Path) -> DeviceResult { |
| 565 | let dev_file = OpenOptions::new() |
| 566 | .read(true) |
| 567 | .write(true) |
| 568 | .open(dev_path) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 569 | .with_context(|| format!("failed to open vinput device {}", dev_path.display()))?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 570 | |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 571 | let dev = virtio::new_evdev(dev_file, virtio::base_features(cfg.protected_vm)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 572 | .context("failed to set up input device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 573 | |
| 574 | Ok(VirtioDeviceStub { |
| 575 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 576 | jail: simple_jail(cfg, "input_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 577 | }) |
| 578 | } |
| 579 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 580 | fn create_balloon_device(cfg: &Config, tube: Tube) -> DeviceResult { |
| 581 | let dev = virtio::Balloon::new(virtio::base_features(cfg.protected_vm), tube) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 582 | .context("failed to create balloon")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 583 | |
| 584 | Ok(VirtioDeviceStub { |
| 585 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 586 | jail: simple_jail(cfg, "balloon_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 587 | }) |
| 588 | } |
| 589 | |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 590 | /// Generic method for creating a network device. `create_device` is a closure that takes the virtio |
| 591 | /// features and number of queue pairs as parameters, and is responsible for creating the device |
| 592 | /// itself. |
| 593 | fn create_net_device<F, T>(cfg: &Config, policy: &str, create_device: F) -> DeviceResult |
| 594 | where |
| 595 | F: Fn(u64, u16) -> Result<T>, |
| 596 | T: VirtioDevice + 'static, |
| 597 | { |
Xiong Zhang | 773c707 | 2020-03-20 10:39:55 +0800 | [diff] [blame] | 598 | let mut vq_pairs = cfg.net_vq_pairs.unwrap_or(1); |
| 599 | let vcpu_count = cfg.vcpu_count.unwrap_or(1); |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 600 | if vcpu_count < vq_pairs as usize { |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 601 | warn!("the number of net vq pairs must not exceed the vcpu count, falling back to single queue mode"); |
Xiong Zhang | 773c707 | 2020-03-20 10:39:55 +0800 | [diff] [blame] | 602 | vq_pairs = 1; |
| 603 | } |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 604 | let features = virtio::base_features(cfg.protected_vm); |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 605 | |
| 606 | let dev = create_device(features, vq_pairs)?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 607 | |
| 608 | Ok(VirtioDeviceStub { |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 609 | dev: Box::new(dev) as Box<dyn VirtioDevice>, |
| 610 | jail: simple_jail(cfg, policy)?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 611 | }) |
| 612 | } |
| 613 | |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 614 | /// Returns a network device created from a new TAP interface configured with `host_ip`, `netmask`, |
| 615 | /// and `mac_address`. |
| 616 | fn create_net_device_from_config( |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 617 | cfg: &Config, |
| 618 | host_ip: Ipv4Addr, |
| 619 | netmask: Ipv4Addr, |
| 620 | mac_address: MacAddress, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 621 | ) -> DeviceResult { |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 622 | let policy = if cfg.vhost_net { |
Matt Delco | 45caf91 | 2019-11-13 08:11:09 -0800 | [diff] [blame] | 623 | "vhost_net_device" |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 624 | } else { |
Matt Delco | 45caf91 | 2019-11-13 08:11:09 -0800 | [diff] [blame] | 625 | "net_device" |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 626 | }; |
| 627 | |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 628 | if cfg.vhost_net { |
| 629 | create_net_device(cfg, policy, |features, _vq_pairs| { |
| 630 | virtio::vhost::Net::<Tap, vhost::Net<Tap>>::new( |
| 631 | &cfg.vhost_net_device_path, |
| 632 | features, |
| 633 | host_ip, |
| 634 | netmask, |
| 635 | mac_address, |
| 636 | ) |
| 637 | .context("failed to set up vhost networking") |
| 638 | }) |
| 639 | } else { |
| 640 | create_net_device(cfg, policy, |features, vq_pairs| { |
| 641 | virtio::Net::<Tap>::new(features, host_ip, netmask, mac_address, vq_pairs) |
| 642 | .context("failed to create virtio network device") |
| 643 | }) |
| 644 | } |
| 645 | } |
| 646 | |
| 647 | /// Returns a network device from a file descriptor to a configured TAP interface. |
| 648 | fn create_tap_net_device_from_fd(cfg: &Config, tap_fd: RawDescriptor) -> DeviceResult { |
| 649 | create_net_device(cfg, "net_device", |features, vq_pairs| { |
| 650 | // Safe because we ensure that we get a unique handle to the fd. |
| 651 | let tap = unsafe { |
| 652 | Tap::from_raw_descriptor( |
| 653 | validate_raw_descriptor(tap_fd).context("failed to validate tap descriptor")?, |
| 654 | ) |
| 655 | .context("failed to create tap device")? |
| 656 | }; |
| 657 | |
| 658 | virtio::Net::from(features, tap, vq_pairs).context("failed to create tap net device") |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 659 | }) |
| 660 | } |
| 661 | |
Alexandre Courbot | 993aa7f | 2021-12-09 14:51:29 +0900 | [diff] [blame] | 662 | /// Returns a network device created by opening the persistent, configured TAP interface `tap_name`. |
| 663 | fn create_tap_net_device_from_name(cfg: &Config, tap_name: &[u8]) -> DeviceResult { |
| 664 | create_net_device(cfg, "net_device", |features, vq_pairs| { |
| 665 | virtio::Net::<Tap>::new_from_name(features, tap_name, vq_pairs) |
| 666 | .context("failed to create configured virtio network device") |
| 667 | }) |
| 668 | } |
| 669 | |
Keiichi Watanabe | 6068658 | 2021-03-12 04:53:51 +0900 | [diff] [blame] | 670 | fn create_vhost_user_net_device(cfg: &Config, opt: &VhostUserOption) -> DeviceResult { |
| 671 | let dev = VhostUserNet::new(virtio::base_features(cfg.protected_vm), &opt.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 672 | .context("failed to set up vhost-user net device")?; |
Keiichi Watanabe | 6068658 | 2021-03-12 04:53:51 +0900 | [diff] [blame] | 673 | |
| 674 | Ok(VirtioDeviceStub { |
| 675 | dev: Box::new(dev), |
| 676 | // no sandbox here because virtqueue handling is exported to a different process. |
| 677 | jail: None, |
| 678 | }) |
| 679 | } |
| 680 | |
Chirantan Ekbote | 84091e5 | 2021-09-10 18:43:17 +0900 | [diff] [blame] | 681 | fn create_vhost_user_vsock_device(cfg: &Config, opt: &VhostUserOption) -> DeviceResult { |
| 682 | let dev = VhostUserVsock::new(virtio::base_features(cfg.protected_vm), &opt.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 683 | .context("failed to set up vhost-user vsock device")?; |
Chirantan Ekbote | 84091e5 | 2021-09-10 18:43:17 +0900 | [diff] [blame] | 684 | |
| 685 | Ok(VirtioDeviceStub { |
| 686 | dev: Box::new(dev), |
| 687 | // no sandbox here because virtqueue handling is exported to a different process. |
| 688 | jail: None, |
| 689 | }) |
| 690 | } |
| 691 | |
Chirantan Ekbote | 2ee9dcd | 2021-05-26 18:21:44 +0900 | [diff] [blame] | 692 | fn create_vhost_user_wl_device(cfg: &Config, opt: &VhostUserWlOption) -> DeviceResult { |
| 693 | // The crosvm wl device expects us to connect the tube before it will accept a vhost-user |
| 694 | // connection. |
| 695 | let dev = VhostUserWl::new(virtio::base_features(cfg.protected_vm), &opt.socket) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 696 | .context("failed to set up vhost-user wl device")?; |
Chirantan Ekbote | 2ee9dcd | 2021-05-26 18:21:44 +0900 | [diff] [blame] | 697 | |
| 698 | Ok(VirtioDeviceStub { |
| 699 | dev: Box::new(dev), |
| 700 | // no sandbox here because virtqueue handling is exported to a different process. |
| 701 | jail: None, |
| 702 | }) |
| 703 | } |
| 704 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 705 | #[cfg(feature = "gpu")] |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 706 | fn create_vhost_user_gpu_device( |
| 707 | cfg: &Config, |
| 708 | opt: &VhostUserOption, |
| 709 | host_tube: Tube, |
| 710 | device_tube: Tube, |
| 711 | ) -> DeviceResult { |
| 712 | // The crosvm gpu device expects us to connect the tube before it will accept a vhost-user |
| 713 | // connection. |
| 714 | let dev = VhostUserGpu::new( |
| 715 | virtio::base_features(cfg.protected_vm), |
| 716 | &opt.socket, |
| 717 | host_tube, |
| 718 | device_tube, |
| 719 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 720 | .context("failed to set up vhost-user gpu device")?; |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 721 | |
| 722 | Ok(VirtioDeviceStub { |
| 723 | dev: Box::new(dev), |
| 724 | // no sandbox here because virtqueue handling is exported to a different process. |
| 725 | jail: None, |
| 726 | }) |
| 727 | } |
| 728 | |
Alexandre Courbot | 22740d8 | 2021-12-15 17:06:27 +0900 | [diff] [blame] | 729 | /// Mirror-mount all the directories in `dirs` into `jail` on a best-effort basis. |
| 730 | /// |
| 731 | /// This function will not return an error if any of the directories in `dirs` is missing. |
| 732 | #[cfg(any(feature = "gpu", feature = "video-decoder", feature = "video-encoder"))] |
| 733 | fn jail_mount_bind_if_exists<P: AsRef<std::ffi::OsStr>>( |
| 734 | jail: &mut Minijail, |
| 735 | dirs: &[P], |
| 736 | ) -> Result<()> { |
| 737 | for dir in dirs { |
| 738 | let dir_path = Path::new(dir); |
| 739 | if dir_path.exists() { |
| 740 | jail.mount_bind(dir_path, dir_path, false)?; |
| 741 | } |
| 742 | } |
| 743 | |
| 744 | Ok(()) |
| 745 | } |
| 746 | |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 747 | #[cfg(feature = "gpu")] |
Chia-I Wu | fffb569 | 2021-12-01 13:25:35 -0800 | [diff] [blame] | 748 | fn gpu_jail(cfg: &Config, policy: &str) -> Result<Option<Minijail>> { |
| 749 | match simple_jail(cfg, policy)? { |
| 750 | Some(mut jail) => { |
| 751 | // Create a tmpfs in the device's root directory so that we can bind mount the |
| 752 | // dri directory into it. The size=67108864 is size=64*1024*1024 or size=64MB. |
| 753 | jail.mount_with_data( |
| 754 | Path::new("none"), |
| 755 | Path::new("/"), |
| 756 | "tmpfs", |
| 757 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC) as usize, |
| 758 | "size=67108864", |
| 759 | )?; |
| 760 | |
| 761 | // Device nodes required for DRM. |
| 762 | let sys_dev_char_path = Path::new("/sys/dev/char"); |
| 763 | jail.mount_bind(sys_dev_char_path, sys_dev_char_path, false)?; |
| 764 | let sys_devices_path = Path::new("/sys/devices"); |
| 765 | jail.mount_bind(sys_devices_path, sys_devices_path, false)?; |
| 766 | |
| 767 | let drm_dri_path = Path::new("/dev/dri"); |
| 768 | if drm_dri_path.exists() { |
| 769 | jail.mount_bind(drm_dri_path, drm_dri_path, false)?; |
| 770 | } |
| 771 | |
| 772 | // If the ARM specific devices exist on the host, bind mount them in. |
| 773 | let mali0_path = Path::new("/dev/mali0"); |
| 774 | if mali0_path.exists() { |
| 775 | jail.mount_bind(mali0_path, mali0_path, true)?; |
| 776 | } |
| 777 | |
| 778 | let pvr_sync_path = Path::new("/dev/pvr_sync"); |
| 779 | if pvr_sync_path.exists() { |
| 780 | jail.mount_bind(pvr_sync_path, pvr_sync_path, true)?; |
| 781 | } |
| 782 | |
| 783 | // If the udmabuf driver exists on the host, bind mount it in. |
| 784 | let udmabuf_path = Path::new("/dev/udmabuf"); |
| 785 | if udmabuf_path.exists() { |
| 786 | jail.mount_bind(udmabuf_path, udmabuf_path, true)?; |
| 787 | } |
| 788 | |
| 789 | // Libraries that are required when mesa drivers are dynamically loaded. |
Alexandre Courbot | 22740d8 | 2021-12-15 17:06:27 +0900 | [diff] [blame] | 790 | jail_mount_bind_if_exists( |
| 791 | &mut jail, |
| 792 | &[ |
| 793 | "/usr/lib", |
| 794 | "/usr/lib64", |
| 795 | "/lib", |
| 796 | "/lib64", |
| 797 | "/usr/share/glvnd", |
| 798 | "/usr/share/vulkan", |
| 799 | ], |
| 800 | )?; |
Chia-I Wu | fffb569 | 2021-12-01 13:25:35 -0800 | [diff] [blame] | 801 | |
| 802 | // pvr driver requires read access to /proc/self/task/*/comm. |
| 803 | let proc_path = Path::new("/proc"); |
| 804 | jail.mount( |
| 805 | proc_path, |
| 806 | proc_path, |
| 807 | "proc", |
| 808 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC | libc::MS_RDONLY) as usize, |
| 809 | )?; |
| 810 | |
| 811 | // To enable perfetto tracing, we need to give access to the perfetto service IPC |
| 812 | // endpoints. |
| 813 | let perfetto_path = Path::new("/run/perfetto"); |
| 814 | if perfetto_path.exists() { |
| 815 | jail.mount_bind(perfetto_path, perfetto_path, true)?; |
| 816 | } |
| 817 | |
| 818 | Ok(Some(jail)) |
| 819 | } |
| 820 | None => Ok(None), |
| 821 | } |
| 822 | } |
| 823 | |
| 824 | #[cfg(feature = "gpu")] |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 825 | fn create_gpu_device( |
| 826 | cfg: &Config, |
Michael Hoyle | 685316f | 2020-09-16 15:29:20 -0700 | [diff] [blame] | 827 | exit_evt: &Event, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 828 | gpu_device_tube: Tube, |
| 829 | resource_bridges: Vec<Tube>, |
Ryo Hashimoto | 0b788de | 2019-12-10 17:14:13 +0900 | [diff] [blame] | 830 | wayland_socket_path: Option<&PathBuf>, |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 831 | x_display: Option<String>, |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 832 | render_server_fd: Option<SafeDescriptor>, |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 833 | event_devices: Vec<EventDevice>, |
Lingfeng Yang | 5572c8d | 2020-05-05 08:40:36 -0700 | [diff] [blame] | 834 | map_request: Arc<Mutex<Option<ExternalMapping>>>, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 835 | ) -> DeviceResult { |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 836 | let mut display_backends = vec![ |
| 837 | virtio::DisplayBackend::X(x_display), |
Jason Macnak | 60eb1fb | 2020-01-09 14:36:29 -0800 | [diff] [blame] | 838 | virtio::DisplayBackend::Stub, |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 839 | ]; |
| 840 | |
Gurchetan Singh | 1bbbf1c | 2021-05-19 15:05:56 -0700 | [diff] [blame] | 841 | let wayland_socket_dirs = cfg |
| 842 | .wayland_socket_paths |
| 843 | .iter() |
| 844 | .map(|(_name, path)| path.parent()) |
| 845 | .collect::<Option<Vec<_>>>() |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 846 | .ok_or_else(|| anyhow!("wayland socket path has no parent or file name"))?; |
Gurchetan Singh | 1bbbf1c | 2021-05-19 15:05:56 -0700 | [diff] [blame] | 847 | |
Ryo Hashimoto | 0b788de | 2019-12-10 17:14:13 +0900 | [diff] [blame] | 848 | if let Some(socket_path) = wayland_socket_path { |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 849 | display_backends.insert( |
| 850 | 0, |
Gurchetan Singh | 1bbbf1c | 2021-05-19 15:05:56 -0700 | [diff] [blame] | 851 | virtio::DisplayBackend::Wayland(Some(socket_path.to_owned())), |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 852 | ); |
| 853 | } |
| 854 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 855 | let dev = virtio::Gpu::new( |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 856 | exit_evt.try_clone().context("failed to clone event")?, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 857 | Some(gpu_device_tube), |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 858 | resource_bridges, |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 859 | display_backends, |
Jason Macnak | cc7070b | 2019-11-06 14:48:12 -0800 | [diff] [blame] | 860 | cfg.gpu_parameters.as_ref().unwrap(), |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 861 | render_server_fd, |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 862 | event_devices, |
Lingfeng Yang | 5572c8d | 2020-05-05 08:40:36 -0700 | [diff] [blame] | 863 | map_request, |
| 864 | cfg.sandbox, |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 865 | virtio::base_features(cfg.protected_vm), |
Gurchetan Singh | 781d975 | 2021-02-15 17:45:22 -0800 | [diff] [blame] | 866 | cfg.wayland_socket_paths.clone(), |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 867 | ); |
| 868 | |
Chia-I Wu | fffb569 | 2021-12-01 13:25:35 -0800 | [diff] [blame] | 869 | let jail = match gpu_jail(cfg, "gpu_device")? { |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 870 | Some(mut jail) => { |
John Bates | b220eac | 2020-09-14 17:03:02 -0700 | [diff] [blame] | 871 | // Prepare GPU shader disk cache directory. |
| 872 | if let Some(cache_dir) = cfg |
| 873 | .gpu_parameters |
| 874 | .as_ref() |
| 875 | .and_then(|params| params.cache_path.as_ref()) |
| 876 | { |
| 877 | if cfg!(any(target_arch = "arm", target_arch = "aarch64")) && cfg.sandbox { |
| 878 | warn!("shader caching not yet supported on ARM with sandbox enabled"); |
| 879 | env::set_var("MESA_GLSL_CACHE_DISABLE", "true"); |
| 880 | } else { |
John Bates | 0405973 | 2020-10-01 15:58:55 -0700 | [diff] [blame] | 881 | env::set_var("MESA_GLSL_CACHE_DISABLE", "false"); |
John Bates | b220eac | 2020-09-14 17:03:02 -0700 | [diff] [blame] | 882 | env::set_var("MESA_GLSL_CACHE_DIR", cache_dir); |
| 883 | if let Some(cache_size) = cfg |
| 884 | .gpu_parameters |
| 885 | .as_ref() |
| 886 | .and_then(|params| params.cache_size.as_ref()) |
| 887 | { |
| 888 | env::set_var("MESA_GLSL_CACHE_MAX_SIZE", cache_size); |
| 889 | } |
| 890 | let shadercache_path = Path::new(cache_dir); |
| 891 | jail.mount_bind(shadercache_path, shadercache_path, true)?; |
| 892 | } |
| 893 | } |
| 894 | |
Gurchetan Singh | 1bbbf1c | 2021-05-19 15:05:56 -0700 | [diff] [blame] | 895 | // Bind mount the wayland socket's directory into jail's root. This is necessary since |
| 896 | // each new wayland context must open() the socket. If the wayland socket is ever |
| 897 | // destroyed and remade in the same host directory, new connections will be possible |
| 898 | // without restarting the wayland device. |
| 899 | for dir in &wayland_socket_dirs { |
| 900 | jail.mount_bind(dir, dir, true)?; |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 901 | } |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 902 | |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 903 | add_current_user_to_jail(&mut jail)?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 904 | |
| 905 | Some(jail) |
| 906 | } |
| 907 | None => None, |
| 908 | }; |
| 909 | |
| 910 | Ok(VirtioDeviceStub { |
| 911 | dev: Box::new(dev), |
| 912 | jail, |
| 913 | }) |
| 914 | } |
| 915 | |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 916 | #[cfg(feature = "gpu")] |
| 917 | fn start_gpu_render_server( |
| 918 | cfg: &Config, |
| 919 | render_server_parameters: &GpuRenderServerParameters, |
| 920 | ) -> Result<SafeDescriptor> { |
| 921 | let (server_socket, client_socket) = |
| 922 | UnixSeqpacket::pair().context("failed to create render server socket")?; |
| 923 | |
| 924 | let jail = match gpu_jail(cfg, "gpu_render_server")? { |
| 925 | Some(mut jail) => { |
| 926 | // TODO(olv) bind mount and enable shader cache |
| 927 | |
Chia-I Wu | b86f7f6 | 2021-12-13 12:10:22 -0800 | [diff] [blame] | 928 | // bind mount /dev/log for syslog |
| 929 | let log_path = Path::new("/dev/log"); |
| 930 | if log_path.exists() { |
| 931 | jail.mount_bind(log_path, log_path, true)?; |
| 932 | } |
| 933 | |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 934 | // Run as root in the jail to keep capabilities after execve, which is needed for |
| 935 | // mounting to work. All capabilities will be dropped afterwards. |
| 936 | add_current_user_as_root_to_jail(&mut jail)?; |
| 937 | |
| 938 | jail |
| 939 | } |
| 940 | None => Minijail::new().context("failed to create jail")?, |
| 941 | }; |
| 942 | |
| 943 | let inheritable_fds = [ |
| 944 | server_socket.as_raw_descriptor(), |
| 945 | libc::STDOUT_FILENO, |
| 946 | libc::STDERR_FILENO, |
| 947 | ]; |
| 948 | |
| 949 | let cmd = &render_server_parameters.path; |
| 950 | let cmd_str = cmd |
| 951 | .to_str() |
| 952 | .ok_or_else(|| anyhow!("invalid render server path"))?; |
| 953 | let fd_str = server_socket.as_raw_descriptor().to_string(); |
| 954 | let args = [cmd_str, "--socket-fd", &fd_str]; |
| 955 | |
| 956 | jail.run(cmd, &inheritable_fds, &args) |
| 957 | .context("failed to start gpu render server")?; |
| 958 | |
| 959 | Ok(SafeDescriptor::from(client_socket)) |
| 960 | } |
| 961 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 962 | fn create_wayland_device( |
| 963 | cfg: &Config, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 964 | control_tube: Tube, |
| 965 | resource_bridge: Option<Tube>, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 966 | ) -> DeviceResult { |
Ryo Hashimoto | 0b788de | 2019-12-10 17:14:13 +0900 | [diff] [blame] | 967 | let wayland_socket_dirs = cfg |
| 968 | .wayland_socket_paths |
| 969 | .iter() |
| 970 | .map(|(_name, path)| path.parent()) |
| 971 | .collect::<Option<Vec<_>>>() |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 972 | .ok_or_else(|| anyhow!("wayland socket path has no parent or file name"))?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 973 | |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 974 | let features = virtio::base_features(cfg.protected_vm); |
Will Deacon | 81d5adb | 2020-10-06 18:37:48 +0100 | [diff] [blame] | 975 | let dev = virtio::Wl::new( |
| 976 | features, |
| 977 | cfg.wayland_socket_paths.clone(), |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 978 | control_tube, |
Will Deacon | 81d5adb | 2020-10-06 18:37:48 +0100 | [diff] [blame] | 979 | resource_bridge, |
| 980 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 981 | .context("failed to create wayland device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 982 | |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 983 | let jail = match simple_jail(cfg, "wl_device")? { |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 984 | Some(mut jail) => { |
| 985 | // Create a tmpfs in the device's root directory so that we can bind mount the wayland |
| 986 | // socket directory into it. The size=67108864 is size=64*1024*1024 or size=64MB. |
| 987 | jail.mount_with_data( |
| 988 | Path::new("none"), |
| 989 | Path::new("/"), |
| 990 | "tmpfs", |
| 991 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC) as usize, |
| 992 | "size=67108864", |
David Tolnay | fd0971d | 2019-03-04 17:15:57 -0800 | [diff] [blame] | 993 | )?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 994 | |
| 995 | // Bind mount the wayland socket's directory into jail's root. This is necessary since |
| 996 | // each new wayland context must open() the socket. If the wayland socket is ever |
| 997 | // destroyed and remade in the same host directory, new connections will be possible |
| 998 | // without restarting the wayland device. |
Ryo Hashimoto | 0b788de | 2019-12-10 17:14:13 +0900 | [diff] [blame] | 999 | for dir in &wayland_socket_dirs { |
| 1000 | jail.mount_bind(dir, dir, true)?; |
| 1001 | } |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 1002 | add_current_user_to_jail(&mut jail)?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1003 | |
| 1004 | Some(jail) |
| 1005 | } |
| 1006 | None => None, |
| 1007 | }; |
| 1008 | |
| 1009 | Ok(VirtioDeviceStub { |
| 1010 | dev: Box::new(dev), |
| 1011 | jail, |
| 1012 | }) |
| 1013 | } |
| 1014 | |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1015 | #[cfg(any(feature = "video-decoder", feature = "video-encoder"))] |
| 1016 | fn create_video_device( |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1017 | backend: VideoBackendType, |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1018 | cfg: &Config, |
| 1019 | typ: devices::virtio::VideoDeviceType, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1020 | resource_bridge: Tube, |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1021 | ) -> DeviceResult { |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1022 | let jail = match simple_jail(cfg, "video_device")? { |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1023 | Some(mut jail) => { |
| 1024 | match typ { |
Alexandre Courbot | 8230abf | 2021-06-26 22:49:26 +0900 | [diff] [blame] | 1025 | #[cfg(feature = "video-decoder")] |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 1026 | devices::virtio::VideoDeviceType::Decoder => add_current_user_to_jail(&mut jail)?, |
Alexandre Courbot | 8230abf | 2021-06-26 22:49:26 +0900 | [diff] [blame] | 1027 | #[cfg(feature = "video-encoder")] |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 1028 | devices::virtio::VideoDeviceType::Encoder => add_current_user_to_jail(&mut jail)?, |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1029 | }; |
| 1030 | |
| 1031 | // Create a tmpfs in the device's root directory so that we can bind mount files. |
| 1032 | jail.mount_with_data( |
| 1033 | Path::new("none"), |
| 1034 | Path::new("/"), |
| 1035 | "tmpfs", |
| 1036 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC) as usize, |
| 1037 | "size=67108864", |
| 1038 | )?; |
| 1039 | |
Alexandre Courbot | c02960d | 2021-07-11 23:06:30 +0900 | [diff] [blame] | 1040 | #[cfg(feature = "libvda")] |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1041 | // Render node for libvda. |
Alexandre Courbot | 54cf834 | 2021-12-20 18:10:08 +0900 | [diff] [blame] | 1042 | if backend == VideoBackendType::Libvda || backend == VideoBackendType::LibvdaVd { |
Chih-Yu Huang | d2c2bd1 | 2021-12-06 14:09:59 +0900 | [diff] [blame] | 1043 | // follow the implementation at: |
| 1044 | // https://source.corp.google.com/chromeos_public/src/platform/minigbm/cros_gralloc/cros_gralloc_driver.cc;l=90;bpv=0;cl=c06cc9cccb3cf3c7f9d2aec706c27c34cd6162a0 |
| 1045 | const DRM_NUM_NODES: u32 = 63; |
| 1046 | const DRM_RENDER_NODE_START: u32 = 128; |
| 1047 | for offset in 0..DRM_NUM_NODES { |
| 1048 | let path_str = format!("/dev/dri/renderD{}", DRM_RENDER_NODE_START + offset); |
| 1049 | let dev_dri_path = Path::new(&path_str); |
| 1050 | if !dev_dri_path.exists() { |
| 1051 | break; |
| 1052 | } |
| 1053 | jail.mount_bind(dev_dri_path, dev_dri_path, false)?; |
| 1054 | } |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1055 | } |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1056 | |
David Stevens | e341d0a | 2020-10-08 18:02:32 +0900 | [diff] [blame] | 1057 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
| 1058 | { |
| 1059 | // Device nodes used by libdrm through minigbm in libvda on AMD devices. |
| 1060 | let sys_dev_char_path = Path::new("/sys/dev/char"); |
| 1061 | jail.mount_bind(sys_dev_char_path, sys_dev_char_path, false)?; |
| 1062 | let sys_devices_path = Path::new("/sys/devices"); |
| 1063 | jail.mount_bind(sys_devices_path, sys_devices_path, false)?; |
| 1064 | |
| 1065 | // Required for loading dri libraries loaded by minigbm on AMD devices. |
Alexandre Courbot | 22740d8 | 2021-12-15 17:06:27 +0900 | [diff] [blame] | 1066 | jail_mount_bind_if_exists(&mut jail, &["/usr/lib64"])?; |
David Stevens | e341d0a | 2020-10-08 18:02:32 +0900 | [diff] [blame] | 1067 | } |
| 1068 | |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1069 | // Device nodes required by libchrome which establishes Mojo connection in libvda. |
| 1070 | let dev_urandom_path = Path::new("/dev/urandom"); |
| 1071 | jail.mount_bind(dev_urandom_path, dev_urandom_path, false)?; |
| 1072 | let system_bus_socket_path = Path::new("/run/dbus/system_bus_socket"); |
| 1073 | jail.mount_bind(system_bus_socket_path, system_bus_socket_path, true)?; |
| 1074 | |
| 1075 | Some(jail) |
| 1076 | } |
| 1077 | None => None, |
| 1078 | }; |
| 1079 | |
| 1080 | Ok(VirtioDeviceStub { |
| 1081 | dev: Box::new(devices::virtio::VideoDevice::new( |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 1082 | virtio::base_features(cfg.protected_vm), |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1083 | typ, |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1084 | backend, |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1085 | Some(resource_bridge), |
| 1086 | )), |
| 1087 | jail, |
| 1088 | }) |
| 1089 | } |
| 1090 | |
| 1091 | #[cfg(any(feature = "video-decoder", feature = "video-encoder"))] |
| 1092 | fn register_video_device( |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1093 | backend: VideoBackendType, |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1094 | devs: &mut Vec<VirtioDeviceStub>, |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1095 | video_tube: Tube, |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1096 | cfg: &Config, |
| 1097 | typ: devices::virtio::VideoDeviceType, |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1098 | ) -> Result<()> { |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1099 | devs.push(create_video_device(backend, cfg, typ, video_tube)?); |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1100 | Ok(()) |
| 1101 | } |
| 1102 | |
Chirantan Ekbote | 3e8d52b | 2021-09-10 18:27:16 +0900 | [diff] [blame] | 1103 | fn create_vhost_vsock_device(cfg: &Config, cid: u64) -> DeviceResult { |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 1104 | let features = virtio::base_features(cfg.protected_vm); |
Christian Blichmann | 50f9591 | 2021-11-05 16:59:39 +0100 | [diff] [blame] | 1105 | |
| 1106 | let device_file = match cfg |
| 1107 | .vhost_vsock_device |
| 1108 | .as_ref() |
| 1109 | .unwrap_or(&VhostVsockDeviceParameter::default()) |
| 1110 | { |
| 1111 | VhostVsockDeviceParameter::Fd(fd) => { |
| 1112 | let fd = validate_raw_descriptor(*fd) |
| 1113 | .context("failed to validate fd for virtual socker device")?; |
| 1114 | // Safe because the `fd` is actually owned by this process and |
| 1115 | // we have a unique handle to it. |
| 1116 | unsafe { File::from_raw_fd(fd) } |
| 1117 | } |
| 1118 | VhostVsockDeviceParameter::Path(path) => OpenOptions::new() |
| 1119 | .read(true) |
| 1120 | .write(true) |
| 1121 | .custom_flags(libc::O_CLOEXEC | libc::O_NONBLOCK) |
| 1122 | .open(path) |
| 1123 | .context("failed to open virtual socket device")?, |
| 1124 | }; |
| 1125 | |
| 1126 | let dev = virtio::vhost::Vsock::new(device_file, features, cid) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1127 | .context("failed to set up virtual socket device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1128 | |
| 1129 | Ok(VirtioDeviceStub { |
| 1130 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1131 | jail: simple_jail(cfg, "vhost_vsock_device")?, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1132 | }) |
| 1133 | } |
| 1134 | |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1135 | fn create_fs_device( |
| 1136 | cfg: &Config, |
| 1137 | uid_map: &str, |
| 1138 | gid_map: &str, |
| 1139 | src: &Path, |
| 1140 | tag: &str, |
| 1141 | fs_cfg: virtio::fs::passthrough::Config, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1142 | device_tube: Tube, |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1143 | ) -> DeviceResult { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1144 | let max_open_files = |
| 1145 | base::get_max_open_files().context("failed to get max number of open files")?; |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 1146 | let j = if cfg.sandbox { |
| 1147 | let seccomp_policy = cfg.seccomp_policy_dir.join("fs_device"); |
| 1148 | let config = SandboxConfig { |
| 1149 | limit_caps: false, |
| 1150 | uid_map: Some(uid_map), |
| 1151 | gid_map: Some(gid_map), |
| 1152 | log_failures: cfg.seccomp_log_failures, |
| 1153 | seccomp_policy: &seccomp_policy, |
| 1154 | }; |
Chirantan Ekbote | 34d45e5 | 2020-04-20 18:15:02 +0900 | [diff] [blame] | 1155 | let mut jail = create_base_minijail(src, Some(max_open_files), Some(&config))?; |
| 1156 | // We want bind mounts from the parent namespaces to propagate into the fs device's |
| 1157 | // namespace. |
| 1158 | jail.set_remount_mode(libc::MS_SLAVE); |
| 1159 | |
| 1160 | jail |
Matt Delco | c24ad78 | 2020-02-14 13:24:36 -0800 | [diff] [blame] | 1161 | } else { |
| 1162 | create_base_minijail(src, Some(max_open_files), None)? |
| 1163 | }; |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1164 | |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 1165 | let features = virtio::base_features(cfg.protected_vm); |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1166 | // TODO(chirantan): Use more than one worker once the kernel driver has been fixed to not panic |
| 1167 | // when num_queues > 1. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1168 | let dev = virtio::fs::Fs::new(features, tag, 1, fs_cfg, device_tube) |
| 1169 | .context("failed to create fs device")?; |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1170 | |
| 1171 | Ok(VirtioDeviceStub { |
| 1172 | dev: Box::new(dev), |
| 1173 | jail: Some(j), |
| 1174 | }) |
| 1175 | } |
| 1176 | |
Chirantan Ekbote | c6b73e3 | 2020-02-20 15:53:06 +0900 | [diff] [blame] | 1177 | fn create_9p_device( |
| 1178 | cfg: &Config, |
| 1179 | uid_map: &str, |
| 1180 | gid_map: &str, |
| 1181 | src: &Path, |
| 1182 | tag: &str, |
Chirantan Ekbote | 75ba875 | 2020-10-27 18:33:02 +0900 | [diff] [blame] | 1183 | mut p9_cfg: p9::Config, |
Chirantan Ekbote | c6b73e3 | 2020-02-20 15:53:06 +0900 | [diff] [blame] | 1184 | ) -> DeviceResult { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1185 | let max_open_files = |
| 1186 | base::get_max_open_files().context("failed to get max number of open files")?; |
Chirantan Ekbote | c6b73e3 | 2020-02-20 15:53:06 +0900 | [diff] [blame] | 1187 | let (jail, root) = if cfg.sandbox { |
| 1188 | let seccomp_policy = cfg.seccomp_policy_dir.join("9p_device"); |
| 1189 | let config = SandboxConfig { |
| 1190 | limit_caps: false, |
| 1191 | uid_map: Some(uid_map), |
| 1192 | gid_map: Some(gid_map), |
| 1193 | log_failures: cfg.seccomp_log_failures, |
| 1194 | seccomp_policy: &seccomp_policy, |
| 1195 | }; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1196 | |
Chirantan Ekbote | c6b73e3 | 2020-02-20 15:53:06 +0900 | [diff] [blame] | 1197 | let mut jail = create_base_minijail(src, Some(max_open_files), Some(&config))?; |
| 1198 | // We want bind mounts from the parent namespaces to propagate into the 9p server's |
| 1199 | // namespace. |
| 1200 | jail.set_remount_mode(libc::MS_SLAVE); |
Chirantan Ekbote | 055de38 | 2020-01-24 12:16:58 +0900 | [diff] [blame] | 1201 | |
Chirantan Ekbote | c6b73e3 | 2020-02-20 15:53:06 +0900 | [diff] [blame] | 1202 | // The shared directory becomes the root of the device's file system. |
| 1203 | let root = Path::new("/"); |
| 1204 | (Some(jail), root) |
| 1205 | } else { |
| 1206 | // There's no mount namespace so we tell the server to treat the source directory as the |
| 1207 | // root. |
| 1208 | (None, src) |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1209 | }; |
| 1210 | |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 1211 | let features = virtio::base_features(cfg.protected_vm); |
Chirantan Ekbote | 75ba875 | 2020-10-27 18:33:02 +0900 | [diff] [blame] | 1212 | p9_cfg.root = root.into(); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1213 | let dev = virtio::P9::new(features, tag, p9_cfg).context("failed to create 9p device")?; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1214 | |
| 1215 | Ok(VirtioDeviceStub { |
| 1216 | dev: Box::new(dev), |
| 1217 | jail, |
| 1218 | }) |
| 1219 | } |
| 1220 | |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1221 | fn create_pmem_device( |
| 1222 | cfg: &Config, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 1223 | vm: &mut impl Vm, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1224 | resources: &mut SystemAllocator, |
| 1225 | disk: &DiskOption, |
| 1226 | index: usize, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1227 | pmem_device_tube: Tube, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1228 | ) -> DeviceResult { |
Junichi Uekawa | 7bea39f | 2021-07-16 14:05:06 +0900 | [diff] [blame] | 1229 | let fd = open_file(&disk.path, disk.read_only, false /*O_DIRECT*/) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1230 | .with_context(|| format!("failed to load disk image {}", disk.path.display()))?; |
Daniel Verkamp | 3eeaf6a | 2021-08-30 15:29:44 -0700 | [diff] [blame] | 1231 | |
| 1232 | let (disk_size, arena_size) = { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1233 | let metadata = std::fs::metadata(&disk.path).with_context(|| { |
| 1234 | format!("failed to get disk image {} metadata", disk.path.display()) |
| 1235 | })?; |
Stephen Barber | dc7c07b | 2019-12-20 12:43:35 -0800 | [diff] [blame] | 1236 | let disk_len = metadata.len(); |
| 1237 | // Linux requires pmem region sizes to be 2 MiB aligned. Linux will fill any partial page |
| 1238 | // at the end of an mmap'd file and won't write back beyond the actual file length, but if |
| 1239 | // we just align the size of the file to 2 MiB then access beyond the last page of the |
| 1240 | // mapped file will generate SIGBUS. So use a memory mapping arena that will provide |
| 1241 | // padding up to 2 MiB. |
| 1242 | let alignment = 2 * 1024 * 1024; |
| 1243 | let align_adjust = if disk_len % alignment != 0 { |
| 1244 | alignment - (disk_len % alignment) |
| 1245 | } else { |
| 1246 | 0 |
| 1247 | }; |
Daniel Verkamp | 3eeaf6a | 2021-08-30 15:29:44 -0700 | [diff] [blame] | 1248 | ( |
| 1249 | disk_len, |
| 1250 | disk_len |
| 1251 | .checked_add(align_adjust) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1252 | .ok_or_else(|| anyhow!("pmem device image too big"))?, |
Daniel Verkamp | 3eeaf6a | 2021-08-30 15:29:44 -0700 | [diff] [blame] | 1253 | ) |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1254 | }; |
| 1255 | |
| 1256 | let protection = { |
| 1257 | if disk.read_only { |
| 1258 | Protection::read() |
| 1259 | } else { |
| 1260 | Protection::read_write() |
| 1261 | } |
| 1262 | }; |
| 1263 | |
Stephen Barber | dc7c07b | 2019-12-20 12:43:35 -0800 | [diff] [blame] | 1264 | let arena = { |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1265 | // Conversion from u64 to usize may fail on 32bit system. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1266 | let arena_size = usize::try_from(arena_size).context("pmem device image too big")?; |
| 1267 | let disk_size = usize::try_from(disk_size).context("pmem device image too big")?; |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1268 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1269 | let mut arena = |
| 1270 | MemoryMappingArena::new(arena_size).context("failed to reserve pmem memory")?; |
Stephen Barber | dc7c07b | 2019-12-20 12:43:35 -0800 | [diff] [blame] | 1271 | arena |
Daniel Verkamp | 3eeaf6a | 2021-08-30 15:29:44 -0700 | [diff] [blame] | 1272 | .add_fd_offset_protection(0, disk_size, &fd, 0, protection) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1273 | .context("failed to reserve pmem memory")?; |
Daniel Verkamp | 3eeaf6a | 2021-08-30 15:29:44 -0700 | [diff] [blame] | 1274 | |
| 1275 | // If the disk is not a multiple of the page size, the OS will fill the remaining part |
| 1276 | // of the page with zeroes. However, the anonymous mapping added below must start on a |
| 1277 | // page boundary, so round up the size before calculating the offset of the anon region. |
| 1278 | let disk_size = round_up_to_page_size(disk_size); |
| 1279 | |
| 1280 | if arena_size > disk_size { |
| 1281 | // Add an anonymous region with the same protection as the disk mapping if the arena |
| 1282 | // size was aligned. |
| 1283 | arena |
| 1284 | .add_anon_protection(disk_size, arena_size - disk_size, protection) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1285 | .context("failed to reserve pmem padding")?; |
Daniel Verkamp | 3eeaf6a | 2021-08-30 15:29:44 -0700 | [diff] [blame] | 1286 | } |
Stephen Barber | dc7c07b | 2019-12-20 12:43:35 -0800 | [diff] [blame] | 1287 | arena |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1288 | }; |
| 1289 | |
| 1290 | let mapping_address = resources |
Xiong Zhang | 383b3b5 | 2019-10-30 14:59:26 +0800 | [diff] [blame] | 1291 | .mmio_allocator(MmioType::High) |
Daniel Verkamp | 57e4f54 | 2021-10-28 09:56:40 -0700 | [diff] [blame] | 1292 | .reverse_allocate_with_align( |
Stephen Barber | dc7c07b | 2019-12-20 12:43:35 -0800 | [diff] [blame] | 1293 | arena_size, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1294 | Alloc::PmemDevice(index), |
| 1295 | format!("pmem_disk_image_{}", index), |
| 1296 | // Linux kernel requires pmem namespaces to be 128 MiB aligned. |
| 1297 | 128 * 1024 * 1024, /* 128 MiB */ |
| 1298 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1299 | .context("failed to allocate memory for pmem device")?; |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1300 | |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1301 | let slot = vm |
Gurchetan Singh | 173fe62 | 2020-05-21 18:05:06 -0700 | [diff] [blame] | 1302 | .add_memory_region( |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1303 | GuestAddress(mapping_address), |
Gurchetan Singh | 173fe62 | 2020-05-21 18:05:06 -0700 | [diff] [blame] | 1304 | Box::new(arena), |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1305 | /* read_only = */ disk.read_only, |
| 1306 | /* log_dirty_pages = */ false, |
| 1307 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1308 | .context("failed to add pmem device memory")?; |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1309 | |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1310 | let dev = virtio::Pmem::new( |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 1311 | virtio::base_features(cfg.protected_vm), |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1312 | fd, |
| 1313 | GuestAddress(mapping_address), |
| 1314 | slot, |
| 1315 | arena_size, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1316 | Some(pmem_device_tube), |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1317 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1318 | .context("failed to create pmem device")?; |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1319 | |
| 1320 | Ok(VirtioDeviceStub { |
| 1321 | dev: Box::new(dev) as Box<dyn VirtioDevice>, |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1322 | jail: simple_jail(cfg, "pmem_device")?, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1323 | }) |
| 1324 | } |
| 1325 | |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1326 | fn create_iommu_device( |
| 1327 | cfg: &Config, |
Zide Chen | 71435c1 | 2021-03-03 15:02:02 -0800 | [diff] [blame] | 1328 | phys_max_addr: u64, |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1329 | endpoints: BTreeMap<u32, Arc<Mutex<VfioContainer>>>, |
| 1330 | ) -> DeviceResult { |
Zide Chen | 71435c1 | 2021-03-03 15:02:02 -0800 | [diff] [blame] | 1331 | let dev = virtio::Iommu::new( |
| 1332 | virtio::base_features(cfg.protected_vm), |
| 1333 | endpoints, |
| 1334 | phys_max_addr, |
| 1335 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1336 | .context("failed to create IOMMU device")?; |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1337 | |
| 1338 | Ok(VirtioDeviceStub { |
| 1339 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1340 | jail: simple_jail(cfg, "iommu_device")?, |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1341 | }) |
| 1342 | } |
| 1343 | |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 1344 | fn create_console_device(cfg: &Config, param: &SerialParameters) -> DeviceResult { |
Michael Hoyle | cd23bc2 | 2020-10-20 22:12:20 -0700 | [diff] [blame] | 1345 | let mut keep_rds = Vec::new(); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1346 | let evt = Event::new().context("failed to create event")?; |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 1347 | let dev = param |
Michael Hoyle | cd23bc2 | 2020-10-20 22:12:20 -0700 | [diff] [blame] | 1348 | .create_serial_device::<Console>(cfg.protected_vm, &evt, &mut keep_rds) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1349 | .context("failed to create console device")?; |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 1350 | |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1351 | let jail = match simple_jail(cfg, "serial")? { |
Nicholas Verne | 71e73d8 | 2020-07-08 17:19:55 +1000 | [diff] [blame] | 1352 | Some(mut jail) => { |
| 1353 | // Create a tmpfs in the device's root directory so that we can bind mount the |
| 1354 | // log socket directory into it. |
| 1355 | // The size=67108864 is size=64*1024*1024 or size=64MB. |
| 1356 | jail.mount_with_data( |
| 1357 | Path::new("none"), |
| 1358 | Path::new("/"), |
| 1359 | "tmpfs", |
| 1360 | (libc::MS_NODEV | libc::MS_NOEXEC | libc::MS_NOSUID) as usize, |
| 1361 | "size=67108864", |
| 1362 | )?; |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 1363 | add_current_user_to_jail(&mut jail)?; |
Nicholas Verne | 71e73d8 | 2020-07-08 17:19:55 +1000 | [diff] [blame] | 1364 | let res = param.add_bind_mounts(&mut jail); |
| 1365 | if res.is_err() { |
| 1366 | error!("failed to add bind mounts for console device"); |
| 1367 | } |
| 1368 | Some(jail) |
| 1369 | } |
| 1370 | None => None, |
| 1371 | }; |
| 1372 | |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 1373 | Ok(VirtioDeviceStub { |
| 1374 | dev: Box::new(dev), |
Nicholas Verne | 71e73d8 | 2020-07-08 17:19:55 +1000 | [diff] [blame] | 1375 | jail, // TODO(dverkamp): use a separate policy for console? |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 1376 | }) |
| 1377 | } |
| 1378 | |
Jorge E. Moreira | d4562d0 | 2021-06-28 16:21:12 -0700 | [diff] [blame] | 1379 | #[cfg(feature = "audio")] |
| 1380 | fn create_sound_device(path: &Path, cfg: &Config) -> DeviceResult { |
| 1381 | let dev = virtio::new_sound(path, virtio::base_features(cfg.protected_vm)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1382 | .context("failed to create sound device")?; |
Jorge E. Moreira | d4562d0 | 2021-06-28 16:21:12 -0700 | [diff] [blame] | 1383 | |
| 1384 | Ok(VirtioDeviceStub { |
| 1385 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1386 | jail: simple_jail(cfg, "vios_audio_device")?, |
Jorge E. Moreira | d4562d0 | 2021-06-28 16:21:12 -0700 | [diff] [blame] | 1387 | }) |
| 1388 | } |
| 1389 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1390 | // gpu_device_tube is not used when GPU support is disabled. |
Dmitry Torokhov | ee42b8c | 2019-05-27 11:14:20 -0700 | [diff] [blame] | 1391 | #[cfg_attr(not(feature = "gpu"), allow(unused_variables))] |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1392 | fn create_virtio_devices( |
| 1393 | cfg: &Config, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 1394 | vm: &mut impl Vm, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1395 | resources: &mut SystemAllocator, |
Michael Hoyle | 685316f | 2020-09-16 15:29:20 -0700 | [diff] [blame] | 1396 | _exit_evt: &Event, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1397 | wayland_device_tube: Tube, |
| 1398 | gpu_device_tube: Tube, |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 1399 | vhost_user_gpu_tubes: Vec<(Tube, Tube)>, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1400 | balloon_device_tube: Tube, |
| 1401 | disk_device_tubes: &mut Vec<Tube>, |
| 1402 | pmem_device_tubes: &mut Vec<Tube>, |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 1403 | map_request: Arc<Mutex<Option<ExternalMapping>>>, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1404 | fs_device_tubes: &mut Vec<Tube>, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1405 | ) -> DeviceResult<Vec<VirtioDeviceStub>> { |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 1406 | let mut devs = Vec::new(); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 1407 | |
Daniel Verkamp | a7b6a1c | 2020-03-09 13:16:46 -0700 | [diff] [blame] | 1408 | for (_, param) in cfg |
| 1409 | .serial_parameters |
| 1410 | .iter() |
| 1411 | .filter(|(_k, v)| v.hardware == SerialHardware::VirtioConsole) |
| 1412 | { |
| 1413 | let dev = create_console_device(cfg, param)?; |
| 1414 | devs.push(dev); |
| 1415 | } |
| 1416 | |
Zach Reizner | 8fb5211 | 2017-12-13 16:04:39 -0800 | [diff] [blame] | 1417 | for disk in &cfg.disks { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1418 | let disk_device_tube = disk_device_tubes.remove(0); |
| 1419 | devs.push(create_block_device(cfg, disk, disk_device_tube)?); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 1420 | } |
| 1421 | |
Keiichi Watanabe | f3a37f4 | 2021-01-21 15:41:11 +0900 | [diff] [blame] | 1422 | for blk in &cfg.vhost_user_blk { |
| 1423 | devs.push(create_vhost_user_block_device(cfg, blk)?); |
| 1424 | } |
| 1425 | |
Federico 'Morg' Pareschi | 70fc7de | 2021-04-08 15:43:13 +0900 | [diff] [blame] | 1426 | for console in &cfg.vhost_user_console { |
| 1427 | devs.push(create_vhost_user_console_device(cfg, console)?); |
| 1428 | } |
| 1429 | |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1430 | for (index, pmem_disk) in cfg.pmem_devices.iter().enumerate() { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1431 | let pmem_device_tube = pmem_device_tubes.remove(0); |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1432 | devs.push(create_pmem_device( |
| 1433 | cfg, |
| 1434 | vm, |
| 1435 | resources, |
| 1436 | pmem_disk, |
| 1437 | index, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1438 | pmem_device_tube, |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 1439 | )?); |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1440 | } |
| 1441 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1442 | devs.push(create_rng_device(cfg)?); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 1443 | |
Woody Chow | 737ff12 | 2021-03-22 17:49:57 +0900 | [diff] [blame] | 1444 | #[cfg(feature = "audio_cras")] |
| 1445 | { |
Chih-Yang Hsia | 41dc04f | 2021-12-08 16:04:23 +0800 | [diff] [blame] | 1446 | for cras_snd in &cfg.cras_snds { |
Woody Chow | 0b2b606 | 2021-09-03 15:40:02 +0900 | [diff] [blame] | 1447 | devs.push(create_cras_snd_device(cfg, cras_snd.clone())?); |
Woody Chow | 737ff12 | 2021-03-22 17:49:57 +0900 | [diff] [blame] | 1448 | } |
| 1449 | } |
| 1450 | |
David Tolnay | de6b29a | 2018-12-20 11:49:46 -0800 | [diff] [blame] | 1451 | #[cfg(feature = "tpm")] |
| 1452 | { |
David Tolnay | 43f8e21 | 2019-02-13 17:28:16 -0800 | [diff] [blame] | 1453 | if cfg.software_tpm { |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1454 | devs.push(create_tpm_device(cfg)?); |
David Tolnay | 43f8e21 | 2019-02-13 17:28:16 -0800 | [diff] [blame] | 1455 | } |
David Tolnay | de6b29a | 2018-12-20 11:49:46 -0800 | [diff] [blame] | 1456 | } |
| 1457 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1458 | for (idx, single_touch_spec) in cfg.virtio_single_touch.iter().enumerate() { |
| 1459 | devs.push(create_single_touch_device( |
| 1460 | cfg, |
| 1461 | single_touch_spec, |
| 1462 | idx as u32, |
| 1463 | )?); |
Jorge E. Moreira | 99d3f08 | 2019-03-07 10:59:54 -0800 | [diff] [blame] | 1464 | } |
| 1465 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1466 | for (idx, multi_touch_spec) in cfg.virtio_multi_touch.iter().enumerate() { |
| 1467 | devs.push(create_multi_touch_device( |
| 1468 | cfg, |
| 1469 | multi_touch_spec, |
| 1470 | idx as u32, |
| 1471 | )?); |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 1472 | } |
| 1473 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1474 | for (idx, trackpad_spec) in cfg.virtio_trackpad.iter().enumerate() { |
| 1475 | devs.push(create_trackpad_device(cfg, trackpad_spec, idx as u32)?); |
Jorge E. Moreira | dffec50 | 2019-01-14 18:44:49 -0800 | [diff] [blame] | 1476 | } |
| 1477 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1478 | for (idx, mouse_socket) in cfg.virtio_mice.iter().enumerate() { |
| 1479 | devs.push(create_mouse_device(cfg, mouse_socket, idx as u32)?); |
Jorge E. Moreira | dffec50 | 2019-01-14 18:44:49 -0800 | [diff] [blame] | 1480 | } |
| 1481 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1482 | for (idx, keyboard_socket) in cfg.virtio_keyboard.iter().enumerate() { |
| 1483 | devs.push(create_keyboard_device(cfg, keyboard_socket, idx as u32)?); |
Jorge E. Moreira | dffec50 | 2019-01-14 18:44:49 -0800 | [diff] [blame] | 1484 | } |
| 1485 | |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1486 | for (idx, switches_socket) in cfg.virtio_switches.iter().enumerate() { |
| 1487 | devs.push(create_switches_device(cfg, switches_socket, idx as u32)?); |
Daniel Norman | 5e23df7 | 2021-03-11 10:11:02 -0800 | [diff] [blame] | 1488 | } |
| 1489 | |
Jianxun Zhang | 8f4d768 | 2019-02-21 12:55:31 -0800 | [diff] [blame] | 1490 | for dev_path in &cfg.virtio_input_evdevs { |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1491 | devs.push(create_vinput_device(cfg, dev_path)?); |
Jorge E. Moreira | dffec50 | 2019-01-14 18:44:49 -0800 | [diff] [blame] | 1492 | } |
| 1493 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1494 | devs.push(create_balloon_device(cfg, balloon_device_tube)?); |
Dylan Reid | 295ccac | 2017-11-06 14:06:24 -0800 | [diff] [blame] | 1495 | |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 1496 | // We checked above that if the IP is defined, then the netmask is, too. |
Jianxun Zhang | 8f4d768 | 2019-02-21 12:55:31 -0800 | [diff] [blame] | 1497 | for tap_fd in &cfg.tap_fd { |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 1498 | devs.push(create_tap_net_device_from_fd(cfg, *tap_fd)?); |
Jorge E. Moreira | b795280 | 2019-02-12 16:43:05 -0800 | [diff] [blame] | 1499 | } |
| 1500 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1501 | if let (Some(host_ip), Some(netmask), Some(mac_address)) = |
| 1502 | (cfg.host_ip, cfg.netmask, cfg.mac_address) |
| 1503 | { |
Keiichi Watanabe | 6068658 | 2021-03-12 04:53:51 +0900 | [diff] [blame] | 1504 | if !cfg.vhost_user_net.is_empty() { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1505 | bail!("vhost-user-net cannot be used with any of --host_ip, --netmask or --mac"); |
Keiichi Watanabe | 6068658 | 2021-03-12 04:53:51 +0900 | [diff] [blame] | 1506 | } |
Alexandre Courbot | 911773a | 2021-12-10 14:31:10 +0900 | [diff] [blame] | 1507 | devs.push(create_net_device_from_config( |
| 1508 | cfg, |
| 1509 | host_ip, |
| 1510 | netmask, |
| 1511 | mac_address, |
| 1512 | )?); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 1513 | } |
| 1514 | |
Alexandre Courbot | 993aa7f | 2021-12-09 14:51:29 +0900 | [diff] [blame] | 1515 | for tap_name in &cfg.tap_name { |
| 1516 | devs.push(create_tap_net_device_from_name(cfg, tap_name.as_bytes())?); |
| 1517 | } |
| 1518 | |
Keiichi Watanabe | 6068658 | 2021-03-12 04:53:51 +0900 | [diff] [blame] | 1519 | for net in &cfg.vhost_user_net { |
| 1520 | devs.push(create_vhost_user_net_device(cfg, net)?); |
| 1521 | } |
| 1522 | |
Chirantan Ekbote | 84091e5 | 2021-09-10 18:43:17 +0900 | [diff] [blame] | 1523 | for vsock in &cfg.vhost_user_vsock { |
| 1524 | devs.push(create_vhost_user_vsock_device(cfg, vsock)?); |
| 1525 | } |
| 1526 | |
Chirantan Ekbote | 2ee9dcd | 2021-05-26 18:21:44 +0900 | [diff] [blame] | 1527 | for opt in &cfg.vhost_user_wl { |
| 1528 | devs.push(create_vhost_user_wl_device(cfg, opt)?); |
| 1529 | } |
| 1530 | |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 1531 | #[cfg(feature = "gpu")] |
| 1532 | for (opt, (host_tube, device_tube)) in cfg.vhost_user_gpu.iter().zip(vhost_user_gpu_tubes) { |
| 1533 | devs.push(create_vhost_user_gpu_device( |
| 1534 | cfg, |
| 1535 | opt, |
| 1536 | host_tube, |
| 1537 | device_tube, |
| 1538 | )?); |
| 1539 | } |
| 1540 | |
David Tolnay | fa70171 | 2019-02-13 16:42:54 -0800 | [diff] [blame] | 1541 | #[cfg_attr(not(feature = "gpu"), allow(unused_mut))] |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1542 | let mut resource_bridges = Vec::<Tube>::new(); |
Chirantan Ekbote | dd11d43 | 2019-06-11 21:50:46 +0900 | [diff] [blame] | 1543 | |
Ryo Hashimoto | 0b788de | 2019-12-10 17:14:13 +0900 | [diff] [blame] | 1544 | if !cfg.wayland_socket_paths.is_empty() { |
Chirantan Ekbote | dd11d43 | 2019-06-11 21:50:46 +0900 | [diff] [blame] | 1545 | #[cfg_attr(not(feature = "gpu"), allow(unused_mut))] |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1546 | let mut wl_resource_bridge = None::<Tube>; |
Chirantan Ekbote | dd11d43 | 2019-06-11 21:50:46 +0900 | [diff] [blame] | 1547 | |
| 1548 | #[cfg(feature = "gpu")] |
| 1549 | { |
Jason Macnak | cc7070b | 2019-11-06 14:48:12 -0800 | [diff] [blame] | 1550 | if cfg.gpu_parameters.is_some() { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1551 | let (wl_socket, gpu_socket) = Tube::pair().context("failed to create tube")?; |
Chirantan Ekbote | dd11d43 | 2019-06-11 21:50:46 +0900 | [diff] [blame] | 1552 | resource_bridges.push(gpu_socket); |
| 1553 | wl_resource_bridge = Some(wl_socket); |
| 1554 | } |
| 1555 | } |
| 1556 | |
| 1557 | devs.push(create_wayland_device( |
| 1558 | cfg, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1559 | wayland_device_tube, |
Chirantan Ekbote | dd11d43 | 2019-06-11 21:50:46 +0900 | [diff] [blame] | 1560 | wl_resource_bridge, |
| 1561 | )?); |
| 1562 | } |
David Tolnay | fa70171 | 2019-02-13 16:42:54 -0800 | [diff] [blame] | 1563 | |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1564 | #[cfg(feature = "video-decoder")] |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1565 | let video_dec_cfg = if let Some(backend) = cfg.video_dec { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1566 | let (video_tube, gpu_tube) = Tube::pair().context("failed to create tube")?; |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1567 | resource_bridges.push(gpu_tube); |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1568 | Some((video_tube, backend)) |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1569 | } else { |
| 1570 | None |
| 1571 | }; |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1572 | |
| 1573 | #[cfg(feature = "video-encoder")] |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1574 | let video_enc_cfg = if let Some(backend) = cfg.video_enc { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1575 | let (video_tube, gpu_tube) = Tube::pair().context("failed to create tube")?; |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1576 | resource_bridges.push(gpu_tube); |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1577 | Some((video_tube, backend)) |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1578 | } else { |
| 1579 | None |
| 1580 | }; |
Keiichi Watanabe | 57df6a0 | 2019-12-06 22:24:40 +0900 | [diff] [blame] | 1581 | |
Zach Reizner | 3a8100a | 2017-09-13 19:15:43 -0700 | [diff] [blame] | 1582 | #[cfg(feature = "gpu")] |
| 1583 | { |
Noah Gold | dc7f52b | 2020-02-01 13:01:58 -0800 | [diff] [blame] | 1584 | if let Some(gpu_parameters) = &cfg.gpu_parameters { |
Jason Macnak | d659a0d | 2021-03-15 15:33:01 -0700 | [diff] [blame] | 1585 | let mut gpu_display_w = DEFAULT_DISPLAY_WIDTH; |
| 1586 | let mut gpu_display_h = DEFAULT_DISPLAY_HEIGHT; |
| 1587 | if !gpu_parameters.displays.is_empty() { |
| 1588 | gpu_display_w = gpu_parameters.displays[0].width; |
| 1589 | gpu_display_h = gpu_parameters.displays[0].height; |
| 1590 | } |
| 1591 | |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1592 | let mut event_devices = Vec::new(); |
| 1593 | if cfg.display_window_mouse { |
| 1594 | let (event_device_socket, virtio_dev_socket) = |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1595 | UnixStream::pair().context("failed to create socket")?; |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 1596 | let (multi_touch_width, multi_touch_height) = cfg |
| 1597 | .virtio_multi_touch |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1598 | .first() |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 1599 | .as_ref() |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 1600 | .map(|multi_touch_spec| multi_touch_spec.get_size()) |
Jason Macnak | d659a0d | 2021-03-15 15:33:01 -0700 | [diff] [blame] | 1601 | .unwrap_or((gpu_display_w, gpu_display_h)); |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 1602 | let dev = virtio::new_multi_touch( |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1603 | // u32::MAX is the least likely to collide with the indices generated above for |
| 1604 | // the multi_touch options, which begin at 0. |
| 1605 | u32::MAX, |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 1606 | virtio_dev_socket, |
Tristan Muntsinger | 486cffc | 2020-09-29 22:05:41 +0000 | [diff] [blame] | 1607 | multi_touch_width, |
| 1608 | multi_touch_height, |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 1609 | virtio::base_features(cfg.protected_vm), |
Kaiyi Li | bccb4eb | 2020-02-06 17:53:11 -0800 | [diff] [blame] | 1610 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1611 | .context("failed to set up mouse device")?; |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1612 | devs.push(VirtioDeviceStub { |
| 1613 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1614 | jail: simple_jail(cfg, "input_device")?, |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1615 | }); |
| 1616 | event_devices.push(EventDevice::touchscreen(event_device_socket)); |
| 1617 | } |
| 1618 | if cfg.display_window_keyboard { |
| 1619 | let (event_device_socket, virtio_dev_socket) = |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1620 | UnixStream::pair().context("failed to create socket")?; |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 1621 | let dev = virtio::new_keyboard( |
Jorge E. Moreira | 6635ca4 | 2021-04-28 13:11:41 -0700 | [diff] [blame] | 1622 | // u32::MAX is the least likely to collide with the indices generated above for |
| 1623 | // the multi_touch options, which begin at 0. |
| 1624 | u32::MAX, |
Noah Gold | d4ca29b | 2020-10-27 12:21:52 -0700 | [diff] [blame] | 1625 | virtio_dev_socket, |
| 1626 | virtio::base_features(cfg.protected_vm), |
| 1627 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1628 | .context("failed to set up keyboard device")?; |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1629 | devs.push(VirtioDeviceStub { |
| 1630 | dev: Box::new(dev), |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1631 | jail: simple_jail(cfg, "input_device")?, |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1632 | }); |
| 1633 | event_devices.push(EventDevice::keyboard(event_device_socket)); |
| 1634 | } |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 1635 | |
| 1636 | let mut render_server_fd = None; |
| 1637 | if let Some(ref render_server_parameters) = gpu_parameters.render_server { |
| 1638 | render_server_fd = Some(start_gpu_render_server(cfg, render_server_parameters)?); |
| 1639 | } |
| 1640 | |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 1641 | devs.push(create_gpu_device( |
| 1642 | cfg, |
| 1643 | _exit_evt, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1644 | gpu_device_tube, |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 1645 | resource_bridges, |
Ryo Hashimoto | 0b788de | 2019-12-10 17:14:13 +0900 | [diff] [blame] | 1646 | // Use the unnamed socket for GPU display screens. |
| 1647 | cfg.wayland_socket_paths.get(""), |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 1648 | cfg.x_display.clone(), |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 1649 | render_server_fd, |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1650 | event_devices, |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 1651 | map_request, |
Zach Reizner | 0f2cfb0 | 2019-06-19 17:46:03 -0700 | [diff] [blame] | 1652 | )?); |
Zach Reizner | 3a8100a | 2017-09-13 19:15:43 -0700 | [diff] [blame] | 1653 | } |
| 1654 | } |
| 1655 | |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1656 | #[cfg(feature = "video-decoder")] |
| 1657 | { |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1658 | if let Some((video_dec_tube, video_dec_backend)) = video_dec_cfg { |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1659 | register_video_device( |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1660 | video_dec_backend, |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1661 | &mut devs, |
| 1662 | video_dec_tube, |
| 1663 | cfg, |
| 1664 | devices::virtio::VideoDeviceType::Decoder, |
| 1665 | )?; |
| 1666 | } |
| 1667 | } |
| 1668 | |
| 1669 | #[cfg(feature = "video-encoder")] |
| 1670 | { |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1671 | if let Some((video_enc_tube, video_enc_backend)) = video_enc_cfg { |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1672 | register_video_device( |
Alexandre Courbot | b42b3e5 | 2021-07-09 23:38:57 +0900 | [diff] [blame] | 1673 | video_enc_backend, |
Daniel Verkamp | ffb5912 | 2021-03-18 14:06:15 -0700 | [diff] [blame] | 1674 | &mut devs, |
| 1675 | video_enc_tube, |
| 1676 | cfg, |
| 1677 | devices::virtio::VideoDeviceType::Encoder, |
| 1678 | )?; |
| 1679 | } |
| 1680 | } |
| 1681 | |
Zach Reizner | aa57566 | 2018-08-15 10:46:32 -0700 | [diff] [blame] | 1682 | if let Some(cid) = cfg.cid { |
Chirantan Ekbote | 3e8d52b | 2021-09-10 18:27:16 +0900 | [diff] [blame] | 1683 | devs.push(create_vhost_vsock_device(cfg, cid)?); |
Zach Reizner | aa57566 | 2018-08-15 10:46:32 -0700 | [diff] [blame] | 1684 | } |
| 1685 | |
Woody Chow | 5890b70 | 2021-02-12 14:57:02 +0900 | [diff] [blame] | 1686 | for vhost_user_fs in &cfg.vhost_user_fs { |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1687 | devs.push(create_vhost_user_fs_device(cfg, vhost_user_fs)?); |
Woody Chow | 5890b70 | 2021-02-12 14:57:02 +0900 | [diff] [blame] | 1688 | } |
| 1689 | |
Woody Chow | 1b16db1 | 2021-04-02 16:59:59 +0900 | [diff] [blame] | 1690 | #[cfg(feature = "audio")] |
| 1691 | for vhost_user_snd in &cfg.vhost_user_snd { |
| 1692 | devs.push(create_vhost_user_snd_device(cfg, vhost_user_snd)?); |
| 1693 | } |
| 1694 | |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1695 | for shared_dir in &cfg.shared_dirs { |
| 1696 | let SharedDir { |
| 1697 | src, |
| 1698 | tag, |
| 1699 | kind, |
| 1700 | uid_map, |
| 1701 | gid_map, |
Chirantan Ekbote | 75ba875 | 2020-10-27 18:33:02 +0900 | [diff] [blame] | 1702 | fs_cfg, |
| 1703 | p9_cfg, |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1704 | } = shared_dir; |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1705 | |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1706 | let dev = match kind { |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 1707 | SharedDirKind::FS => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1708 | let device_tube = fs_device_tubes.remove(0); |
| 1709 | create_fs_device(cfg, uid_map, gid_map, src, tag, fs_cfg.clone(), device_tube)? |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 1710 | } |
Chirantan Ekbote | 75ba875 | 2020-10-27 18:33:02 +0900 | [diff] [blame] | 1711 | SharedDirKind::P9 => create_9p_device(cfg, uid_map, gid_map, src, tag, p9_cfg.clone())?, |
Chirantan Ekbote | bd4723b | 2019-07-17 10:50:30 +0900 | [diff] [blame] | 1712 | }; |
| 1713 | devs.push(dev); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1714 | } |
| 1715 | |
JaeMan Park | eb9cc53 | 2021-07-02 15:02:59 +0900 | [diff] [blame] | 1716 | if let Some(vhost_user_mac80211_hwsim) = &cfg.vhost_user_mac80211_hwsim { |
| 1717 | devs.push(create_vhost_user_mac80211_hwsim_device( |
| 1718 | cfg, |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1719 | vhost_user_mac80211_hwsim, |
JaeMan Park | eb9cc53 | 2021-07-02 15:02:59 +0900 | [diff] [blame] | 1720 | )?); |
| 1721 | } |
| 1722 | |
Jorge E. Moreira | d4562d0 | 2021-06-28 16:21:12 -0700 | [diff] [blame] | 1723 | #[cfg(feature = "audio")] |
| 1724 | if let Some(path) = &cfg.sound { |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1725 | devs.push(create_sound_device(path, cfg)?); |
Jorge E. Moreira | d4562d0 | 2021-06-28 16:21:12 -0700 | [diff] [blame] | 1726 | } |
| 1727 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1728 | Ok(devs) |
| 1729 | } |
| 1730 | |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1731 | fn create_vfio_device( |
| 1732 | cfg: &Config, |
| 1733 | vm: &impl Vm, |
| 1734 | resources: &mut SystemAllocator, |
| 1735 | control_tubes: &mut Vec<TaggedControlTube>, |
| 1736 | vfio_path: &Path, |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 1737 | bus_num: Option<u8>, |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1738 | endpoints: &mut BTreeMap<u32, Arc<Mutex<VfioContainer>>>, |
| 1739 | iommu_enabled: bool, |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1740 | ) -> DeviceResult<(Box<VfioPciDevice>, Option<Minijail>)> { |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1741 | let vfio_container = VfioCommonSetup::vfio_get_container(vfio_path, iommu_enabled) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1742 | .context("failed to get vfio container")?; |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1743 | |
| 1744 | // create MSI, MSI-X, and Mem request sockets for each vfio device |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1745 | let (vfio_host_tube_msi, vfio_device_tube_msi) = |
| 1746 | Tube::pair().context("failed to create tube")?; |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1747 | control_tubes.push(TaggedControlTube::VmIrq(vfio_host_tube_msi)); |
| 1748 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1749 | let (vfio_host_tube_msix, vfio_device_tube_msix) = |
| 1750 | Tube::pair().context("failed to create tube")?; |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1751 | control_tubes.push(TaggedControlTube::VmIrq(vfio_host_tube_msix)); |
| 1752 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1753 | let (vfio_host_tube_mem, vfio_device_tube_mem) = |
| 1754 | Tube::pair().context("failed to create tube")?; |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1755 | control_tubes.push(TaggedControlTube::VmMemory(vfio_host_tube_mem)); |
| 1756 | |
Keiichi Watanabe | 7b80554 | 2021-09-03 02:13:51 +0900 | [diff] [blame] | 1757 | let vfio_device = |
| 1758 | VfioDevice::new_passthrough(&vfio_path, vm, vfio_container.clone(), iommu_enabled) |
| 1759 | .context("failed to create vfio device")?; |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1760 | let mut vfio_pci_device = Box::new(VfioPciDevice::new( |
| 1761 | vfio_device, |
Xiong Zhang | e19ab75 | 2021-05-20 18:18:46 +0800 | [diff] [blame] | 1762 | bus_num, |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1763 | vfio_device_tube_msi, |
| 1764 | vfio_device_tube_msix, |
| 1765 | vfio_device_tube_mem, |
| 1766 | )); |
| 1767 | // early reservation for pass-through PCI devices. |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1768 | let endpoint_addr = vfio_pci_device.allocate_address(resources); |
| 1769 | if endpoint_addr.is_err() { |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1770 | warn!( |
| 1771 | "address reservation failed for vfio {}", |
| 1772 | vfio_pci_device.debug_label() |
| 1773 | ); |
| 1774 | } |
| 1775 | |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1776 | if iommu_enabled { |
| 1777 | endpoints.insert(endpoint_addr.unwrap().to_u32(), vfio_container); |
| 1778 | } |
| 1779 | |
Xiong Zhang | 10f1505 | 2021-04-08 17:23:33 +0800 | [diff] [blame] | 1780 | Ok((vfio_pci_device, simple_jail(cfg, "vfio_device")?)) |
| 1781 | } |
| 1782 | |
Tomasz Nowicki | 344eb14 | 2021-09-22 05:51:58 +0000 | [diff] [blame] | 1783 | fn create_vfio_platform_device( |
| 1784 | cfg: &Config, |
| 1785 | vm: &impl Vm, |
| 1786 | _resources: &mut SystemAllocator, |
| 1787 | control_tubes: &mut Vec<TaggedControlTube>, |
| 1788 | vfio_path: &Path, |
| 1789 | _endpoints: &mut BTreeMap<u32, Arc<Mutex<VfioContainer>>>, |
| 1790 | iommu_enabled: bool, |
| 1791 | ) -> DeviceResult<(VfioPlatformDevice, Option<Minijail>)> { |
| 1792 | let vfio_container = VfioCommonSetup::vfio_get_container(vfio_path, iommu_enabled) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1793 | .context("Failed to create vfio device")?; |
Tomasz Nowicki | 344eb14 | 2021-09-22 05:51:58 +0000 | [diff] [blame] | 1794 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1795 | let (vfio_host_tube_mem, vfio_device_tube_mem) = |
| 1796 | Tube::pair().context("failed to create tube")?; |
Tomasz Nowicki | 344eb14 | 2021-09-22 05:51:58 +0000 | [diff] [blame] | 1797 | control_tubes.push(TaggedControlTube::VmMemory(vfio_host_tube_mem)); |
| 1798 | |
Keiichi Watanabe | 7b80554 | 2021-09-03 02:13:51 +0900 | [diff] [blame] | 1799 | let vfio_device = VfioDevice::new_passthrough(&vfio_path, vm, vfio_container, iommu_enabled) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1800 | .context("Failed to create vfio device")?; |
Tomasz Nowicki | 344eb14 | 2021-09-22 05:51:58 +0000 | [diff] [blame] | 1801 | let vfio_plat_dev = VfioPlatformDevice::new(vfio_device, vfio_device_tube_mem); |
| 1802 | |
| 1803 | Ok((vfio_plat_dev, simple_jail(cfg, "vfio_platform_device")?)) |
| 1804 | } |
| 1805 | |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1806 | fn create_devices( |
Trent Begin | 17ccaad | 2019-04-17 13:51:25 -0600 | [diff] [blame] | 1807 | cfg: &Config, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 1808 | vm: &mut impl Vm, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1809 | resources: &mut SystemAllocator, |
Michael Hoyle | 685316f | 2020-09-16 15:29:20 -0700 | [diff] [blame] | 1810 | exit_evt: &Event, |
Zide Chen | 71435c1 | 2021-03-03 15:02:02 -0800 | [diff] [blame] | 1811 | phys_max_addr: u64, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1812 | control_tubes: &mut Vec<TaggedControlTube>, |
| 1813 | wayland_device_tube: Tube, |
| 1814 | gpu_device_tube: Tube, |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 1815 | vhost_user_gpu_tubes: Vec<(Tube, Tube)>, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1816 | balloon_device_tube: Tube, |
| 1817 | disk_device_tubes: &mut Vec<Tube>, |
| 1818 | pmem_device_tubes: &mut Vec<Tube>, |
| 1819 | fs_device_tubes: &mut Vec<Tube>, |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 1820 | #[cfg(feature = "usb")] usb_provider: HostBackendDeviceProvider, |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 1821 | map_request: Arc<Mutex<Option<ExternalMapping>>>, |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1822 | ) -> DeviceResult<Vec<(Box<dyn BusDeviceObj>, Option<Minijail>)>> { |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1823 | let stubs = create_virtio_devices( |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1824 | cfg, |
Jakub Staron | a3411ea | 2019-04-24 10:55:25 -0700 | [diff] [blame] | 1825 | vm, |
| 1826 | resources, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1827 | exit_evt, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1828 | wayland_device_tube, |
| 1829 | gpu_device_tube, |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 1830 | vhost_user_gpu_tubes, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1831 | balloon_device_tube, |
| 1832 | disk_device_tubes, |
| 1833 | pmem_device_tubes, |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 1834 | map_request, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1835 | fs_device_tubes, |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1836 | )?; |
| 1837 | |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1838 | let mut devices = Vec::new(); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1839 | |
| 1840 | for stub in stubs { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1841 | let (msi_host_tube, msi_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 1842 | control_tubes.push(TaggedControlTube::VmIrq(msi_host_tube)); |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 1843 | let dev = VirtioPciDevice::new(vm.get_memory().clone(), stub.dev, msi_device_tube) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1844 | .context("failed to create virtio pci dev")?; |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1845 | let dev = Box::new(dev) as Box<dyn BusDeviceObj>; |
| 1846 | devices.push((dev, stub.jail)); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1847 | } |
| 1848 | |
Andrew Scull | 1590e6f | 2020-03-18 18:00:47 +0000 | [diff] [blame] | 1849 | #[cfg(feature = "audio")] |
Judy Hsiao | d5c1e96 | 2020-02-04 12:30:01 +0800 | [diff] [blame] | 1850 | for ac97_param in &cfg.ac97_parameters { |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 1851 | let dev = Ac97Dev::try_new(vm.get_memory().clone(), ac97_param.clone()) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1852 | .context("failed to create ac97 device")?; |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 1853 | let jail = simple_jail(cfg, dev.minijail_policy())?; |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1854 | devices.push((Box::new(dev), jail)); |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1855 | } |
Andrew Scull | 1590e6f | 2020-03-18 18:00:47 +0000 | [diff] [blame] | 1856 | |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 1857 | #[cfg(feature = "usb")] |
| 1858 | { |
| 1859 | // Create xhci controller. |
| 1860 | let usb_controller = Box::new(XhciController::new(vm.get_memory().clone(), usb_provider)); |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1861 | devices.push((usb_controller, simple_jail(cfg, "xhci")?)); |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 1862 | } |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1863 | |
Zide Chen | 5deee48 | 2021-04-19 11:06:01 -0700 | [diff] [blame] | 1864 | if !cfg.vfio.is_empty() { |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1865 | let mut iommu_attached_endpoints: BTreeMap<u32, Arc<Mutex<VfioContainer>>> = |
| 1866 | BTreeMap::new(); |
| 1867 | |
Tomasz Nowicki | 71aca79 | 2021-06-09 18:53:49 +0000 | [diff] [blame] | 1868 | for vfio_dev in cfg |
| 1869 | .vfio |
| 1870 | .iter() |
| 1871 | .filter(|dev| dev.get_type() == VfioType::Pci) |
| 1872 | { |
| 1873 | let vfio_path = &vfio_dev.vfio_path; |
Zide Chen | 5deee48 | 2021-04-19 11:06:01 -0700 | [diff] [blame] | 1874 | let (vfio_pci_device, jail) = create_vfio_device( |
| 1875 | cfg, |
| 1876 | vm, |
| 1877 | resources, |
| 1878 | control_tubes, |
| 1879 | vfio_path.as_path(), |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 1880 | None, |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1881 | &mut iommu_attached_endpoints, |
Tomasz Nowicki | 71aca79 | 2021-06-09 18:53:49 +0000 | [diff] [blame] | 1882 | vfio_dev.iommu_enabled(), |
Zide Chen | 5deee48 | 2021-04-19 11:06:01 -0700 | [diff] [blame] | 1883 | )?; |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1884 | |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1885 | devices.push((vfio_pci_device, jail)); |
Zide Chen | 5deee48 | 2021-04-19 11:06:01 -0700 | [diff] [blame] | 1886 | } |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1887 | |
Tomasz Nowicki | 344eb14 | 2021-09-22 05:51:58 +0000 | [diff] [blame] | 1888 | for vfio_dev in cfg |
| 1889 | .vfio |
| 1890 | .iter() |
| 1891 | .filter(|dev| dev.get_type() == VfioType::Platform) |
| 1892 | { |
| 1893 | let vfio_path = &vfio_dev.vfio_path; |
| 1894 | let (vfio_plat_dev, jail) = create_vfio_platform_device( |
| 1895 | cfg, |
| 1896 | vm, |
| 1897 | resources, |
| 1898 | control_tubes, |
| 1899 | vfio_path.as_path(), |
| 1900 | &mut iommu_attached_endpoints, |
| 1901 | false, // Virtio IOMMU is not supported yet |
| 1902 | )?; |
| 1903 | |
| 1904 | devices.push((Box::new(vfio_plat_dev), jail)); |
| 1905 | } |
| 1906 | |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1907 | if !iommu_attached_endpoints.is_empty() { |
Zide Chen | 71435c1 | 2021-03-03 15:02:02 -0800 | [diff] [blame] | 1908 | let iommu_dev = create_iommu_device(cfg, phys_max_addr, iommu_attached_endpoints)?; |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1909 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1910 | let (msi_host_tube, msi_device_tube) = Tube::pair().context("failed to create tube")?; |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1911 | control_tubes.push(TaggedControlTube::VmIrq(msi_host_tube)); |
Peter Fang | ad3b24e | 2021-06-21 00:43:29 -0700 | [diff] [blame] | 1912 | let mut dev = |
| 1913 | VirtioPciDevice::new(vm.get_memory().clone(), iommu_dev.dev, msi_device_tube) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1914 | .context("failed to create virtio pci dev")?; |
Peter Fang | ad3b24e | 2021-06-21 00:43:29 -0700 | [diff] [blame] | 1915 | // early reservation for viommu. |
| 1916 | dev.allocate_address(resources) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1917 | .context("failed to allocate resources early for virtio pci dev")?; |
Peter Fang | ad3b24e | 2021-06-21 00:43:29 -0700 | [diff] [blame] | 1918 | let dev = Box::new(dev); |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1919 | devices.push((dev, iommu_dev.jail)); |
Zide Chen | dfc4b88 | 2021-03-10 16:35:37 -0800 | [diff] [blame] | 1920 | } |
Xiong Zhang | 17b0daf | 2019-04-23 17:14:50 +0800 | [diff] [blame] | 1921 | } |
| 1922 | |
Mattias Nissler | de2c640 | 2021-10-21 12:05:29 +0000 | [diff] [blame] | 1923 | for params in &cfg.stub_pci_devices { |
| 1924 | // Stub devices don't need jailing since they don't do anything. |
| 1925 | devices.push((Box::new(StubPciDevice::new(params)), None)); |
| 1926 | } |
| 1927 | |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 1928 | Ok(devices) |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1929 | } |
| 1930 | |
| 1931 | #[derive(Copy, Clone)] |
Chirantan Ekbote | 1a2683b | 2019-11-26 16:28:23 +0900 | [diff] [blame] | 1932 | #[cfg_attr(not(feature = "tpm"), allow(dead_code))] |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 1933 | struct Ids { |
| 1934 | uid: uid_t, |
| 1935 | gid: gid_t, |
| 1936 | } |
| 1937 | |
David Tolnay | 48c4829 | 2019-03-01 16:54:25 -0800 | [diff] [blame] | 1938 | // Set the uid/gid for the jailed process and give a basic id map. This is |
| 1939 | // required for bind mounts to work. |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 1940 | fn add_current_user_to_jail(jail: &mut Minijail) -> Result<Ids> { |
| 1941 | let crosvm_uid = geteuid(); |
| 1942 | let crosvm_gid = getegid(); |
David Tolnay | 48c4829 | 2019-03-01 16:54:25 -0800 | [diff] [blame] | 1943 | |
David Tolnay | 48c4829 | 2019-03-01 16:54:25 -0800 | [diff] [blame] | 1944 | jail.uidmap(&format!("{0} {0} 1", crosvm_uid)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1945 | .context("error setting UID map")?; |
David Tolnay | 48c4829 | 2019-03-01 16:54:25 -0800 | [diff] [blame] | 1946 | jail.gidmap(&format!("{0} {0} 1", crosvm_gid)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1947 | .context("error setting GID map")?; |
David Tolnay | 48c4829 | 2019-03-01 16:54:25 -0800 | [diff] [blame] | 1948 | |
Chirantan Ekbote | e1663ee | 2021-09-03 18:31:25 +0900 | [diff] [blame] | 1949 | if crosvm_uid != 0 { |
| 1950 | jail.change_uid(crosvm_uid); |
| 1951 | } |
| 1952 | if crosvm_gid != 0 { |
| 1953 | jail.change_gid(crosvm_gid); |
| 1954 | } |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 1955 | |
David Tolnay | 41a6f84 | 2019-03-01 16:18:44 -0800 | [diff] [blame] | 1956 | Ok(Ids { |
| 1957 | uid: crosvm_uid, |
| 1958 | gid: crosvm_gid, |
| 1959 | }) |
David Tolnay | 48c4829 | 2019-03-01 16:54:25 -0800 | [diff] [blame] | 1960 | } |
| 1961 | |
Chia-I Wu | 16fb659 | 2021-11-10 11:45:32 -0800 | [diff] [blame] | 1962 | fn add_current_user_as_root_to_jail(jail: &mut Minijail) -> Result<Ids> { |
| 1963 | let crosvm_uid = geteuid(); |
| 1964 | let crosvm_gid = getegid(); |
| 1965 | jail.uidmap(&format!("0 {0} 1", crosvm_uid)) |
| 1966 | .context("error setting UID map")?; |
| 1967 | jail.gidmap(&format!("0 {0} 1", crosvm_gid)) |
| 1968 | .context("error setting GID map")?; |
| 1969 | |
| 1970 | Ok(Ids { |
| 1971 | uid: crosvm_uid, |
| 1972 | gid: crosvm_gid, |
| 1973 | }) |
| 1974 | } |
| 1975 | |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1976 | trait IntoUnixStream { |
| 1977 | fn into_unix_stream(self) -> Result<UnixStream>; |
| 1978 | } |
| 1979 | |
| 1980 | impl<'a> IntoUnixStream for &'a Path { |
| 1981 | fn into_unix_stream(self) -> Result<UnixStream> { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1982 | if let Some(fd) = safe_descriptor_from_path(self).context("failed to open event device")? { |
Andrew Walbran | bc55e30 | 2021-07-13 17:35:10 +0100 | [diff] [blame] | 1983 | Ok(fd.into()) |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1984 | } else { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 1985 | UnixStream::connect(self).context("failed to open event device") |
Zach Reizner | 65b98f1 | 2019-11-22 17:34:58 -0800 | [diff] [blame] | 1986 | } |
| 1987 | } |
| 1988 | } |
| 1989 | impl<'a> IntoUnixStream for &'a PathBuf { |
| 1990 | fn into_unix_stream(self) -> Result<UnixStream> { |
| 1991 | self.as_path().into_unix_stream() |
| 1992 | } |
| 1993 | } |
| 1994 | |
| 1995 | impl IntoUnixStream for UnixStream { |
| 1996 | fn into_unix_stream(self) -> Result<UnixStream> { |
| 1997 | Ok(self) |
Jorge E. Moreira | dffec50 | 2019-01-14 18:44:49 -0800 | [diff] [blame] | 1998 | } |
| 1999 | } |
| 2000 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2001 | fn setup_vcpu_signal_handler<T: Vcpu>(use_hypervisor_signals: bool) -> Result<()> { |
| 2002 | if use_hypervisor_signals { |
Matt Delco | 84cf9c0 | 2019-10-07 22:38:13 -0700 | [diff] [blame] | 2003 | unsafe { |
Allen Webb | 44c728c | 2021-03-23 15:22:41 -0500 | [diff] [blame] | 2004 | extern "C" fn handle_signal(_: c_int) {} |
Matt Delco | 84cf9c0 | 2019-10-07 22:38:13 -0700 | [diff] [blame] | 2005 | // Our signal handler does nothing and is trivially async signal safe. |
| 2006 | register_rt_signal_handler(SIGRTMIN() + 0, handle_signal) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2007 | .context("error registering signal handler")?; |
Matt Delco | 84cf9c0 | 2019-10-07 22:38:13 -0700 | [diff] [blame] | 2008 | } |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2009 | block_signal(SIGRTMIN() + 0).context("failed to block signal")?; |
Matt Delco | 84cf9c0 | 2019-10-07 22:38:13 -0700 | [diff] [blame] | 2010 | } else { |
| 2011 | unsafe { |
Allen Webb | 44c728c | 2021-03-23 15:22:41 -0500 | [diff] [blame] | 2012 | extern "C" fn handle_signal<T: Vcpu>(_: c_int) { |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2013 | T::set_local_immediate_exit(true); |
Matt Delco | 84cf9c0 | 2019-10-07 22:38:13 -0700 | [diff] [blame] | 2014 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2015 | register_rt_signal_handler(SIGRTMIN() + 0, handle_signal::<T>) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2016 | .context("error registering signal handler")?; |
Matt Delco | 84cf9c0 | 2019-10-07 22:38:13 -0700 | [diff] [blame] | 2017 | } |
Mark Ryan | 6ed5aea | 2018-04-20 13:52:35 +0100 | [diff] [blame] | 2018 | } |
Mark Ryan | 6ed5aea | 2018-04-20 13:52:35 +0100 | [diff] [blame] | 2019 | Ok(()) |
| 2020 | } |
| 2021 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2022 | // Sets up a vcpu and converts it into a runnable vcpu. |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2023 | fn runnable_vcpu<V>( |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2024 | cpu_id: usize, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2025 | kvm_vcpu_id: usize, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2026 | vcpu: Option<V>, |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 2027 | vm: impl VmArch, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2028 | irq_chip: &mut dyn IrqChipArch, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2029 | vcpu_count: usize, |
Kansho Nishida | ab205af | 2020-08-13 18:17:50 +0900 | [diff] [blame] | 2030 | run_rt: bool, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2031 | vcpu_affinity: Vec<usize>, |
Suleiman Souhlal | 015c3c1 | 2020-10-07 14:15:41 +0900 | [diff] [blame] | 2032 | no_smt: bool, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2033 | has_bios: bool, |
| 2034 | use_hypervisor_signals: bool, |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 2035 | enable_per_vm_core_scheduling: bool, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2036 | host_cpu_topology: bool, |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2037 | ) -> Result<(V, VcpuRunHandle)> |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2038 | where |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2039 | V: VcpuArch, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2040 | { |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 2041 | let mut vcpu = match vcpu { |
| 2042 | Some(v) => v, |
| 2043 | None => { |
| 2044 | // If vcpu is None, it means this arch/hypervisor requires create_vcpu to be called from |
| 2045 | // the vcpu thread. |
| 2046 | match vm |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2047 | .create_vcpu(kvm_vcpu_id) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2048 | .context("failed to create vcpu")? |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 2049 | .downcast::<V>() |
| 2050 | { |
| 2051 | Ok(v) => *v, |
| 2052 | Err(_) => panic!("VM created wrong type of VCPU"), |
| 2053 | } |
| 2054 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2055 | }; |
Dylan Reid | bb30b2f | 2019-10-22 18:30:36 +0300 | [diff] [blame] | 2056 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2057 | irq_chip |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 2058 | .add_vcpu(cpu_id, &vcpu) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2059 | .context("failed to add vcpu to irq chip")?; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2060 | |
Daniel Verkamp | caf9ced | 2020-09-29 15:35:02 -0700 | [diff] [blame] | 2061 | if !vcpu_affinity.is_empty() { |
| 2062 | if let Err(e) = set_cpu_affinity(vcpu_affinity) { |
| 2063 | error!("Failed to set CPU affinity: {}", e); |
| 2064 | } |
| 2065 | } |
| 2066 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2067 | Arch::configure_vcpu( |
| 2068 | vm.get_memory(), |
| 2069 | vm.get_hypervisor(), |
| 2070 | irq_chip, |
| 2071 | &mut vcpu, |
| 2072 | cpu_id, |
| 2073 | vcpu_count, |
| 2074 | has_bios, |
Suleiman Souhlal | 015c3c1 | 2020-10-07 14:15:41 +0900 | [diff] [blame] | 2075 | no_smt, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2076 | host_cpu_topology, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2077 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2078 | .context("failed to configure vcpu")?; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2079 | |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 2080 | if !enable_per_vm_core_scheduling { |
| 2081 | // Do per-vCPU core scheduling by setting a unique cookie to each vCPU. |
| 2082 | if let Err(e) = enable_core_scheduling() { |
| 2083 | error!("Failed to enable core scheduling: {}", e); |
| 2084 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2085 | } |
| 2086 | |
Kansho Nishida | ab205af | 2020-08-13 18:17:50 +0900 | [diff] [blame] | 2087 | if run_rt { |
| 2088 | const DEFAULT_VCPU_RT_LEVEL: u16 = 6; |
| 2089 | if let Err(e) = set_rt_prio_limit(u64::from(DEFAULT_VCPU_RT_LEVEL)) |
| 2090 | .and_then(|_| set_rt_round_robin(i32::from(DEFAULT_VCPU_RT_LEVEL))) |
| 2091 | { |
| 2092 | warn!("Failed to set vcpu to real time: {}", e); |
| 2093 | } |
| 2094 | } |
| 2095 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2096 | if use_hypervisor_signals { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2097 | let mut v = get_blocked_signals().context("failed to retrieve signal mask for vcpu")?; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2098 | v.retain(|&x| x != SIGRTMIN() + 0); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2099 | vcpu.set_signal_mask(&v) |
| 2100 | .context("failed to set the signal mask for vcpu")?; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2101 | } |
| 2102 | |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2103 | let vcpu_run_handle = vcpu |
| 2104 | .take_run_handle(Some(SIGRTMIN() + 0)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2105 | .context("failed to set thread id for vcpu")?; |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2106 | |
| 2107 | Ok((vcpu, vcpu_run_handle)) |
Dylan Reid | bb30b2f | 2019-10-22 18:30:36 +0300 | [diff] [blame] | 2108 | } |
| 2109 | |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2110 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 2111 | fn handle_debug_msg<V>( |
| 2112 | cpu_id: usize, |
| 2113 | vcpu: &V, |
| 2114 | guest_mem: &GuestMemory, |
| 2115 | d: VcpuDebug, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2116 | reply_tube: &mpsc::Sender<VcpuDebugStatusMessage>, |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2117 | ) -> Result<()> |
| 2118 | where |
| 2119 | V: VcpuArch + 'static, |
| 2120 | { |
| 2121 | match d { |
| 2122 | VcpuDebug::ReadRegs => { |
| 2123 | let msg = VcpuDebugStatusMessage { |
| 2124 | cpu: cpu_id as usize, |
| 2125 | msg: VcpuDebugStatus::RegValues( |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2126 | Arch::debug_read_registers(vcpu as &V) |
| 2127 | .context("failed to handle a gdb ReadRegs command")?, |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2128 | ), |
| 2129 | }; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2130 | reply_tube |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2131 | .send(msg) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2132 | .context("failed to send a debug status to GDB thread") |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2133 | } |
| 2134 | VcpuDebug::WriteRegs(regs) => { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2135 | Arch::debug_write_registers(vcpu as &V, ®s) |
| 2136 | .context("failed to handle a gdb WriteRegs command")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2137 | reply_tube |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2138 | .send(VcpuDebugStatusMessage { |
| 2139 | cpu: cpu_id as usize, |
| 2140 | msg: VcpuDebugStatus::CommandComplete, |
| 2141 | }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2142 | .context("failed to send a debug status to GDB thread") |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2143 | } |
| 2144 | VcpuDebug::ReadMem(vaddr, len) => { |
| 2145 | let msg = VcpuDebugStatusMessage { |
| 2146 | cpu: cpu_id as usize, |
| 2147 | msg: VcpuDebugStatus::MemoryRegion( |
| 2148 | Arch::debug_read_memory(vcpu as &V, guest_mem, vaddr, len) |
| 2149 | .unwrap_or(Vec::new()), |
| 2150 | ), |
| 2151 | }; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2152 | reply_tube |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2153 | .send(msg) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2154 | .context("failed to send a debug status to GDB thread") |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2155 | } |
| 2156 | VcpuDebug::WriteMem(vaddr, buf) => { |
| 2157 | Arch::debug_write_memory(vcpu as &V, guest_mem, vaddr, &buf) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2158 | .context("failed to handle a gdb WriteMem command")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2159 | reply_tube |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2160 | .send(VcpuDebugStatusMessage { |
| 2161 | cpu: cpu_id as usize, |
| 2162 | msg: VcpuDebugStatus::CommandComplete, |
| 2163 | }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2164 | .context("failed to send a debug status to GDB thread") |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2165 | } |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2166 | VcpuDebug::EnableSinglestep => { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2167 | Arch::debug_enable_singlestep(vcpu as &V) |
| 2168 | .context("failed to handle a gdb EnableSingleStep command")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2169 | reply_tube |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2170 | .send(VcpuDebugStatusMessage { |
| 2171 | cpu: cpu_id as usize, |
| 2172 | msg: VcpuDebugStatus::CommandComplete, |
| 2173 | }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2174 | .context("failed to send a debug status to GDB thread") |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2175 | } |
| 2176 | VcpuDebug::SetHwBreakPoint(addrs) => { |
| 2177 | Arch::debug_set_hw_breakpoints(vcpu as &V, &addrs) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2178 | .context("failed to handle a gdb SetHwBreakPoint command")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2179 | reply_tube |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2180 | .send(VcpuDebugStatusMessage { |
| 2181 | cpu: cpu_id as usize, |
| 2182 | msg: VcpuDebugStatus::CommandComplete, |
| 2183 | }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2184 | .context("failed to send a debug status to GDB thread") |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2185 | } |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2186 | } |
| 2187 | } |
| 2188 | |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2189 | fn run_vcpu<V>( |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2190 | cpu_id: usize, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2191 | kvm_vcpu_id: usize, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2192 | vcpu: Option<V>, |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 2193 | vm: impl VmArch + 'static, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2194 | mut irq_chip: Box<dyn IrqChipArch + 'static>, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2195 | vcpu_count: usize, |
Kansho Nishida | ab205af | 2020-08-13 18:17:50 +0900 | [diff] [blame] | 2196 | run_rt: bool, |
Daniel Verkamp | 107edb3 | 2019-04-05 09:58:48 -0700 | [diff] [blame] | 2197 | vcpu_affinity: Vec<usize>, |
Suleiman Souhlal | 63630e8 | 2021-02-18 11:53:11 +0900 | [diff] [blame] | 2198 | delay_rt: bool, |
Suleiman Souhlal | 015c3c1 | 2020-10-07 14:15:41 +0900 | [diff] [blame] | 2199 | no_smt: bool, |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 2200 | start_barrier: Arc<Barrier>, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2201 | has_bios: bool, |
Colin Downs-Razouk | 11bed5e | 2021-11-02 09:33:14 -0700 | [diff] [blame] | 2202 | mut io_bus: devices::Bus, |
| 2203 | mut mmio_bus: devices::Bus, |
Michael Hoyle | 685316f | 2020-09-16 15:29:20 -0700 | [diff] [blame] | 2204 | exit_evt: Event, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2205 | requires_pvclock_ctrl: bool, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2206 | from_main_tube: mpsc::Receiver<VcpuControl>, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2207 | use_hypervisor_signals: bool, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2208 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] to_gdb_tube: Option< |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2209 | mpsc::Sender<VcpuDebugStatusMessage>, |
| 2210 | >, |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 2211 | enable_per_vm_core_scheduling: bool, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2212 | host_cpu_topology: bool, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2213 | ) -> Result<JoinHandle<()>> |
| 2214 | where |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2215 | V: VcpuArch + 'static, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2216 | { |
Zach Reizner | 8fb5211 | 2017-12-13 16:04:39 -0800 | [diff] [blame] | 2217 | thread::Builder::new() |
| 2218 | .name(format!("crosvm_vcpu{}", cpu_id)) |
| 2219 | .spawn(move || { |
Zach Reizner | 9588531 | 2020-01-29 18:06:01 -0800 | [diff] [blame] | 2220 | // The VCPU thread must trigger the `exit_evt` in all paths, and a `ScopedEvent`'s Drop |
| 2221 | // implementation accomplishes that. |
| 2222 | let _scoped_exit_evt = ScopedEvent::from(exit_evt); |
| 2223 | |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2224 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 2225 | let guest_mem = vm.get_memory().clone(); |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2226 | let runnable_vcpu = runnable_vcpu( |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2227 | cpu_id, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2228 | kvm_vcpu_id, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2229 | vcpu, |
| 2230 | vm, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2231 | irq_chip.as_mut(), |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2232 | vcpu_count, |
Suleiman Souhlal | 63630e8 | 2021-02-18 11:53:11 +0900 | [diff] [blame] | 2233 | run_rt && !delay_rt, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2234 | vcpu_affinity, |
Suleiman Souhlal | 015c3c1 | 2020-10-07 14:15:41 +0900 | [diff] [blame] | 2235 | no_smt, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2236 | has_bios, |
| 2237 | use_hypervisor_signals, |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 2238 | enable_per_vm_core_scheduling, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2239 | host_cpu_topology, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2240 | ); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 2241 | |
Zach Reizner | 8fb5211 | 2017-12-13 16:04:39 -0800 | [diff] [blame] | 2242 | start_barrier.wait(); |
Mark Ryan | 6ed5aea | 2018-04-20 13:52:35 +0100 | [diff] [blame] | 2243 | |
Zach Reizner | 2c770e6 | 2020-09-30 16:49:59 -0700 | [diff] [blame] | 2244 | let (vcpu, vcpu_run_handle) = match runnable_vcpu { |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2245 | Ok(v) => v, |
| 2246 | Err(e) => { |
Maciek Swiech | c301122 | 2021-11-24 21:01:04 +0000 | [diff] [blame] | 2247 | error!("failed to start vcpu {}: {:#}", cpu_id, e); |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2248 | return; |
| 2249 | } |
| 2250 | }; |
Mark Ryan | 6ed5aea | 2018-04-20 13:52:35 +0100 | [diff] [blame] | 2251 | |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2252 | let mut run_mode = VmRunMode::Running; |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2253 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2254 | if to_gdb_tube.is_some() { |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2255 | // Wait until a GDB client attaches |
| 2256 | run_mode = VmRunMode::Breakpoint; |
| 2257 | } |
| 2258 | |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2259 | let mut interrupted_by_signal = false; |
| 2260 | |
Colin Downs-Razouk | 11bed5e | 2021-11-02 09:33:14 -0700 | [diff] [blame] | 2261 | mmio_bus.set_access_id(cpu_id); |
| 2262 | io_bus.set_access_id(cpu_id); |
| 2263 | |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2264 | 'vcpu_loop: loop { |
| 2265 | // Start by checking for messages to process and the run state of the CPU. |
| 2266 | // An extra check here for Running so there isn't a need to call recv unless a |
| 2267 | // message is likely to be ready because a signal was sent. |
| 2268 | if interrupted_by_signal || run_mode != VmRunMode::Running { |
| 2269 | 'state_loop: loop { |
| 2270 | // Tries to get a pending message without blocking first. |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2271 | let msg = match from_main_tube.try_recv() { |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2272 | Ok(m) => m, |
| 2273 | Err(mpsc::TryRecvError::Empty) if run_mode == VmRunMode::Running => { |
| 2274 | // If the VM is running and no message is pending, the state won't |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2275 | // change. |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2276 | break 'state_loop; |
| 2277 | } |
| 2278 | Err(mpsc::TryRecvError::Empty) => { |
| 2279 | // If the VM is not running, wait until a message is ready. |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2280 | match from_main_tube.recv() { |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2281 | Ok(m) => m, |
| 2282 | Err(mpsc::RecvError) => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2283 | error!("Failed to read from main tube in vcpu"); |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2284 | break 'vcpu_loop; |
| 2285 | } |
| 2286 | } |
| 2287 | } |
| 2288 | Err(mpsc::TryRecvError::Disconnected) => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2289 | error!("Failed to read from main tube in vcpu"); |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2290 | break 'vcpu_loop; |
| 2291 | } |
| 2292 | }; |
| 2293 | |
| 2294 | // Collect all pending messages. |
| 2295 | let mut messages = vec![msg]; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2296 | messages.append(&mut from_main_tube.try_iter().collect()); |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2297 | |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2298 | for msg in messages { |
| 2299 | match msg { |
| 2300 | VcpuControl::RunState(new_mode) => { |
| 2301 | run_mode = new_mode; |
| 2302 | match run_mode { |
| 2303 | VmRunMode::Running => break 'state_loop, |
| 2304 | VmRunMode::Suspending => { |
| 2305 | // On KVM implementations that use a paravirtualized |
| 2306 | // clock (e.g. x86), a flag must be set to indicate to |
| 2307 | // the guest kernel that a vCPU was suspended. The guest |
| 2308 | // kernel will use this flag to prevent the soft lockup |
| 2309 | // detection from triggering when this vCPU resumes, |
| 2310 | // which could happen days later in realtime. |
| 2311 | if requires_pvclock_ctrl { |
| 2312 | if let Err(e) = vcpu.pvclock_ctrl() { |
| 2313 | error!( |
| 2314 | "failed to tell hypervisor vcpu {} is suspending: {}", |
| 2315 | cpu_id, e |
| 2316 | ); |
| 2317 | } |
| 2318 | } |
| 2319 | } |
| 2320 | VmRunMode::Breakpoint => {} |
| 2321 | VmRunMode::Exiting => break 'vcpu_loop, |
| 2322 | } |
| 2323 | } |
| 2324 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 2325 | VcpuControl::Debug(d) => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2326 | match &to_gdb_tube { |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2327 | Some(ref ch) => { |
| 2328 | if let Err(e) = handle_debug_msg( |
Daniel Verkamp | 166d1dd | 2021-08-19 17:05:29 -0700 | [diff] [blame] | 2329 | cpu_id, &vcpu, &guest_mem, d, ch, |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2330 | ) { |
| 2331 | error!("Failed to handle gdb message: {}", e); |
| 2332 | } |
| 2333 | }, |
| 2334 | None => { |
| 2335 | error!("VcpuControl::Debug received while GDB feature is disabled: {:?}", d); |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2336 | } |
| 2337 | } |
| 2338 | } |
Suleiman Souhlal | 2ac78b9 | 2021-02-01 12:33:26 +0900 | [diff] [blame] | 2339 | VcpuControl::MakeRT => { |
| 2340 | if run_rt && delay_rt { |
| 2341 | info!("Making vcpu {} RT\n", cpu_id); |
| 2342 | const DEFAULT_VCPU_RT_LEVEL: u16 = 6; |
| 2343 | if let Err(e) = set_rt_prio_limit( |
| 2344 | u64::from(DEFAULT_VCPU_RT_LEVEL)) |
| 2345 | .and_then(|_| |
| 2346 | set_rt_round_robin( |
| 2347 | i32::from(DEFAULT_VCPU_RT_LEVEL) |
| 2348 | )) |
| 2349 | { |
| 2350 | warn!("Failed to set vcpu to real time: {}", e); |
| 2351 | } |
| 2352 | } |
| 2353 | } |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 2354 | } |
| 2355 | } |
| 2356 | } |
| 2357 | } |
| 2358 | |
| 2359 | interrupted_by_signal = false; |
| 2360 | |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2361 | // Vcpus may have run a HLT instruction, which puts them into a state other than |
| 2362 | // VcpuRunState::Runnable. In that case, this call to wait_until_runnable blocks |
| 2363 | // until either the irqchip receives an interrupt for this vcpu, or until the main |
| 2364 | // thread kicks this vcpu as a result of some VmControl operation. In most IrqChip |
| 2365 | // implementations HLT instructions do not make it to crosvm, and thus this is a |
| 2366 | // no-op that always returns VcpuRunState::Runnable. |
| 2367 | match irq_chip.wait_until_runnable(&vcpu) { |
| 2368 | Ok(VcpuRunState::Runnable) => {} |
| 2369 | Ok(VcpuRunState::Interrupted) => interrupted_by_signal = true, |
| 2370 | Err(e) => error!( |
| 2371 | "error waiting for vcpu {} to become runnable: {}", |
| 2372 | cpu_id, e |
| 2373 | ), |
| 2374 | } |
| 2375 | |
| 2376 | if !interrupted_by_signal { |
| 2377 | match vcpu.run(&vcpu_run_handle) { |
| 2378 | Ok(VcpuExit::IoIn { port, mut size }) => { |
| 2379 | let mut data = [0; 8]; |
| 2380 | if size > data.len() { |
Dmitry Torokhov | a041068 | 2021-08-01 10:40:50 -0700 | [diff] [blame] | 2381 | error!("unsupported IoIn size of {} bytes at port {:#x}", size, port); |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2382 | size = data.len(); |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2383 | } |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2384 | io_bus.read(port as u64, &mut data[..size]); |
| 2385 | if let Err(e) = vcpu.set_data(&data[..size]) { |
Dmitry Torokhov | a041068 | 2021-08-01 10:40:50 -0700 | [diff] [blame] | 2386 | error!("failed to set return data for IoIn at port {:#x}: {}", port, e); |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2387 | } |
Keiichi Watanabe | 23f9471 | 2020-10-22 17:43:06 +0900 | [diff] [blame] | 2388 | } |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2389 | Ok(VcpuExit::IoOut { |
| 2390 | port, |
| 2391 | mut size, |
| 2392 | data, |
| 2393 | }) => { |
| 2394 | if size > data.len() { |
Dmitry Torokhov | a041068 | 2021-08-01 10:40:50 -0700 | [diff] [blame] | 2395 | error!("unsupported IoOut size of {} bytes at port {:#x}", size, port); |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2396 | size = data.len(); |
| 2397 | } |
| 2398 | io_bus.write(port as u64, &data[..size]); |
| 2399 | } |
| 2400 | Ok(VcpuExit::MmioRead { address, size }) => { |
| 2401 | let mut data = [0; 8]; |
| 2402 | mmio_bus.read(address, &mut data[..size]); |
| 2403 | // Setting data for mmio can not fail. |
| 2404 | let _ = vcpu.set_data(&data[..size]); |
| 2405 | } |
| 2406 | Ok(VcpuExit::MmioWrite { |
| 2407 | address, |
| 2408 | size, |
| 2409 | data, |
| 2410 | }) => { |
| 2411 | mmio_bus.write(address, &data[..size]); |
| 2412 | } |
| 2413 | Ok(VcpuExit::IoapicEoi { vector }) => { |
| 2414 | if let Err(e) = irq_chip.broadcast_eoi(vector) { |
| 2415 | error!( |
| 2416 | "failed to broadcast eoi {} on vcpu {}: {}", |
| 2417 | vector, cpu_id, e |
| 2418 | ); |
| 2419 | } |
| 2420 | } |
| 2421 | Ok(VcpuExit::IrqWindowOpen) => {} |
Leo Lai | 558460f | 2021-07-23 05:32:27 +0000 | [diff] [blame] | 2422 | Ok(VcpuExit::Hlt) => irq_chip.halted(cpu_id), |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2423 | Ok(VcpuExit::Shutdown) => break, |
| 2424 | Ok(VcpuExit::FailEntry { |
| 2425 | hardware_entry_failure_reason, |
| 2426 | }) => { |
| 2427 | error!("vcpu hw run failure: {:#x}", hardware_entry_failure_reason); |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2428 | break; |
| 2429 | } |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2430 | Ok(VcpuExit::SystemEvent(_, _)) => break, |
| 2431 | Ok(VcpuExit::Debug { .. }) => { |
| 2432 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 2433 | { |
| 2434 | let msg = VcpuDebugStatusMessage { |
| 2435 | cpu: cpu_id as usize, |
| 2436 | msg: VcpuDebugStatus::HitBreakPoint, |
| 2437 | }; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2438 | if let Some(ref ch) = to_gdb_tube { |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2439 | if let Err(e) = ch.send(msg) { |
| 2440 | error!("failed to notify breakpoint to GDB thread: {}", e); |
| 2441 | break; |
| 2442 | } |
| 2443 | } |
| 2444 | run_mode = VmRunMode::Breakpoint; |
| 2445 | } |
| 2446 | } |
| 2447 | Ok(r) => warn!("unexpected vcpu exit: {:?}", r), |
| 2448 | Err(e) => match e.errno() { |
| 2449 | libc::EINTR => interrupted_by_signal = true, |
| 2450 | libc::EAGAIN => {} |
| 2451 | _ => { |
| 2452 | error!("vcpu hit unknown error: {}", e); |
| 2453 | break; |
| 2454 | } |
| 2455 | }, |
| 2456 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2457 | } |
| 2458 | |
| 2459 | if interrupted_by_signal { |
| 2460 | if use_hypervisor_signals { |
| 2461 | // Try to clear the signal that we use to kick VCPU if it is pending before |
| 2462 | // attempting to handle pause requests. |
| 2463 | if let Err(e) = clear_signal(SIGRTMIN() + 0) { |
| 2464 | error!("failed to clear pending signal: {}", e); |
| 2465 | break; |
| 2466 | } |
| 2467 | } else { |
| 2468 | vcpu.set_immediate_exit(false); |
| 2469 | } |
David Tolnay | 8f3a232 | 2018-11-30 17:11:35 -0800 | [diff] [blame] | 2470 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2471 | |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 2472 | if let Err(e) = irq_chip.inject_interrupts(&vcpu) { |
| 2473 | error!("failed to inject interrupts for vcpu {}: {}", cpu_id, e); |
| 2474 | } |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 2475 | } |
David Tolnay | 2bac1e7 | 2018-12-12 14:33:42 -0800 | [diff] [blame] | 2476 | }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2477 | .context("failed to spawn VCPU thread") |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 2478 | } |
| 2479 | |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2480 | fn setup_vm_components(cfg: &Config) -> Result<VmComponents> { |
David Tolnay | 2b089fc | 2019-03-04 15:33:22 -0800 | [diff] [blame] | 2481 | let initrd_image = if let Some(initrd_path) = &cfg.initrd_path { |
Andrew Walbran | bc55e30 | 2021-07-13 17:35:10 +0100 | [diff] [blame] | 2482 | Some( |
Junichi Uekawa | 7bea39f | 2021-07-16 14:05:06 +0900 | [diff] [blame] | 2483 | open_file( |
| 2484 | initrd_path, |
| 2485 | true, /*read_only*/ |
| 2486 | false, /*O_DIRECT*/ |
| 2487 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2488 | .with_context(|| format!("failed to open initrd {}", initrd_path.display()))?, |
Andrew Walbran | bc55e30 | 2021-07-13 17:35:10 +0100 | [diff] [blame] | 2489 | ) |
Daniel Verkamp | e403f5c | 2018-12-11 16:29:26 -0800 | [diff] [blame] | 2490 | } else { |
| 2491 | None |
| 2492 | }; |
| 2493 | |
Cody Schuffelen | 6d1ab50 | 2019-05-21 12:12:38 -0700 | [diff] [blame] | 2494 | let vm_image = match cfg.executable_path { |
Andrew Walbran | bc55e30 | 2021-07-13 17:35:10 +0100 | [diff] [blame] | 2495 | Some(Executable::Kernel(ref kernel_path)) => VmImage::Kernel( |
Junichi Uekawa | 7bea39f | 2021-07-16 14:05:06 +0900 | [diff] [blame] | 2496 | open_file( |
| 2497 | kernel_path, |
| 2498 | true, /*read_only*/ |
| 2499 | false, /*O_DIRECT*/ |
| 2500 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2501 | .with_context(|| format!("failed to open kernel image {}", kernel_path.display()))?, |
Andrew Walbran | bc55e30 | 2021-07-13 17:35:10 +0100 | [diff] [blame] | 2502 | ), |
| 2503 | Some(Executable::Bios(ref bios_path)) => VmImage::Bios( |
Junichi Uekawa | 7bea39f | 2021-07-16 14:05:06 +0900 | [diff] [blame] | 2504 | open_file(bios_path, true /*read_only*/, false /*O_DIRECT*/) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2505 | .with_context(|| format!("failed to open bios {}", bios_path.display()))?, |
Andrew Walbran | bc55e30 | 2021-07-13 17:35:10 +0100 | [diff] [blame] | 2506 | ), |
Cody Schuffelen | 6d1ab50 | 2019-05-21 12:12:38 -0700 | [diff] [blame] | 2507 | _ => panic!("Did not receive a bios or kernel, should be impossible."), |
| 2508 | }; |
| 2509 | |
Will Deacon | c48e783 | 2021-07-30 19:03:06 +0100 | [diff] [blame] | 2510 | let swiotlb = if let Some(size) = cfg.swiotlb { |
| 2511 | Some( |
| 2512 | size.checked_mul(1024 * 1024) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2513 | .ok_or_else(|| anyhow!("requested swiotlb size too large"))?, |
Will Deacon | c48e783 | 2021-07-30 19:03:06 +0100 | [diff] [blame] | 2514 | ) |
| 2515 | } else { |
| 2516 | match cfg.protected_vm { |
Andrew Walbran | 0bbbb68 | 2021-12-13 13:42:07 +0000 | [diff] [blame^] | 2517 | ProtectionType::Protected | ProtectionType::ProtectedWithoutFirmware => { |
| 2518 | Some(64 * 1024 * 1024) |
| 2519 | } |
Will Deacon | c48e783 | 2021-07-30 19:03:06 +0100 | [diff] [blame] | 2520 | ProtectionType::Unprotected => None, |
| 2521 | } |
| 2522 | }; |
| 2523 | |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2524 | Ok(VmComponents { |
Daniel Verkamp | 6a84706 | 2019-11-26 13:16:35 -0800 | [diff] [blame] | 2525 | memory_size: cfg |
| 2526 | .memory |
| 2527 | .unwrap_or(256) |
| 2528 | .checked_mul(1024 * 1024) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2529 | .ok_or_else(|| anyhow!("requested memory size too large"))?, |
Will Deacon | c48e783 | 2021-07-30 19:03:06 +0100 | [diff] [blame] | 2530 | swiotlb, |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 2531 | vcpu_count: cfg.vcpu_count.unwrap_or(1), |
Daniel Verkamp | 107edb3 | 2019-04-05 09:58:48 -0700 | [diff] [blame] | 2532 | vcpu_affinity: cfg.vcpu_affinity.clone(), |
Daniel Verkamp | 8a72afc | 2021-03-15 17:55:52 -0700 | [diff] [blame] | 2533 | cpu_clusters: cfg.cpu_clusters.clone(), |
| 2534 | cpu_capacity: cfg.cpu_capacity.clone(), |
Suleiman Souhlal | 015c3c1 | 2020-10-07 14:15:41 +0900 | [diff] [blame] | 2535 | no_smt: cfg.no_smt, |
Sergey Senozhatsky | 1e369c5 | 2021-04-13 20:23:51 +0900 | [diff] [blame] | 2536 | hugepages: cfg.hugepages, |
Cody Schuffelen | 6d1ab50 | 2019-05-21 12:12:38 -0700 | [diff] [blame] | 2537 | vm_image, |
Tristan Muntsinger | 4133b01 | 2018-12-21 16:01:56 -0800 | [diff] [blame] | 2538 | android_fstab: cfg |
| 2539 | .android_fstab |
| 2540 | .as_ref() |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2541 | .map(|x| { |
| 2542 | File::open(x) |
| 2543 | .with_context(|| format!("failed to open android fstab file {}", x.display())) |
| 2544 | }) |
Tristan Muntsinger | 4133b01 | 2018-12-21 16:01:56 -0800 | [diff] [blame] | 2545 | .map_or(Ok(None), |v| v.map(Some))?, |
Kansho Nishida | 282115b | 2019-12-18 13:13:14 +0900 | [diff] [blame] | 2546 | pstore: cfg.pstore.clone(), |
Daniel Verkamp | e403f5c | 2018-12-11 16:29:26 -0800 | [diff] [blame] | 2547 | initrd_image, |
Daniel Verkamp | aac2813 | 2018-10-15 14:58:48 -0700 | [diff] [blame] | 2548 | extra_kernel_params: cfg.params.clone(), |
Tomasz Jeznach | 4264464 | 2020-05-20 23:27:59 -0700 | [diff] [blame] | 2549 | acpi_sdts: cfg |
| 2550 | .acpi_tables |
| 2551 | .iter() |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2552 | .map(|path| { |
| 2553 | SDT::from_file(path) |
| 2554 | .with_context(|| format!("failed to open ACPI file {}", path.display())) |
| 2555 | }) |
Tomasz Jeznach | 4264464 | 2020-05-20 23:27:59 -0700 | [diff] [blame] | 2556 | .collect::<Result<Vec<SDT>>>()?, |
Kansho Nishida | ab205af | 2020-08-13 18:17:50 +0900 | [diff] [blame] | 2557 | rt_cpus: cfg.rt_cpus.clone(), |
Suleiman Souhlal | 63630e8 | 2021-02-18 11:53:11 +0900 | [diff] [blame] | 2558 | delay_rt: cfg.delay_rt, |
Will Deacon | 7d2b8ac | 2020-10-06 18:51:12 +0100 | [diff] [blame] | 2559 | protected_vm: cfg.protected_vm, |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 2560 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2561 | gdb: None, |
Tomasz Jeznach | ccb2694 | 2021-03-30 22:44:11 -0700 | [diff] [blame] | 2562 | dmi_path: cfg.dmi_path.clone(), |
Tomasz Jeznach | d93c29f | 2021-04-12 11:00:24 -0700 | [diff] [blame] | 2563 | no_legacy: cfg.no_legacy, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2564 | host_cpu_topology: cfg.host_cpu_topology, |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2565 | }) |
| 2566 | } |
| 2567 | |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 2568 | pub enum ExitState { |
| 2569 | Reset, |
| 2570 | Stop, |
| 2571 | } |
| 2572 | |
| 2573 | pub fn run_config(cfg: Config) -> Result<ExitState> { |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2574 | let components = setup_vm_components(&cfg)?; |
| 2575 | |
| 2576 | let guest_mem_layout = |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2577 | Arch::guest_memory_layout(&components).context("failed to create guest memory layout")?; |
| 2578 | let guest_mem = GuestMemory::new(&guest_mem_layout).context("failed to create guest memory")?; |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2579 | let mut mem_policy = MemoryPolicy::empty(); |
| 2580 | if components.hugepages { |
| 2581 | mem_policy |= MemoryPolicy::USE_HUGEPAGES; |
| 2582 | } |
Quentin Perret | 2620380 | 2021-12-02 09:48:43 +0000 | [diff] [blame] | 2583 | guest_mem.set_memory_policy(mem_policy); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2584 | let kvm = Kvm::new_with_path(&cfg.kvm_device_path).context("failed to create kvm")?; |
Andrew Walbran | 00f1c9f | 2021-12-10 17:13:08 +0000 | [diff] [blame] | 2585 | let vm = KvmVm::new(&kvm, guest_mem, components.protected_vm).context("failed to create vm")?; |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2586 | let vm_clone = vm.try_clone().context("failed to clone vm")?; |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2587 | |
| 2588 | enum KvmIrqChip { |
| 2589 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
| 2590 | Split(KvmSplitIrqChip), |
| 2591 | Kernel(KvmKernelIrqChip), |
| 2592 | } |
| 2593 | |
| 2594 | impl KvmIrqChip { |
| 2595 | fn as_mut(&mut self) -> &mut dyn IrqChipArch { |
| 2596 | match self { |
| 2597 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
| 2598 | KvmIrqChip::Split(i) => i, |
| 2599 | KvmIrqChip::Kernel(i) => i, |
| 2600 | } |
| 2601 | } |
| 2602 | } |
| 2603 | |
| 2604 | let ioapic_host_tube; |
| 2605 | let mut irq_chip = if cfg.split_irqchip { |
| 2606 | #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))] |
| 2607 | unimplemented!("KVM split irqchip mode only supported on x86 processors"); |
| 2608 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
| 2609 | { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2610 | let (host_tube, ioapic_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2611 | ioapic_host_tube = Some(host_tube); |
| 2612 | KvmIrqChip::Split( |
| 2613 | KvmSplitIrqChip::new( |
| 2614 | vm_clone, |
| 2615 | components.vcpu_count, |
| 2616 | ioapic_device_tube, |
| 2617 | Some(120), |
| 2618 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2619 | .context("failed to create IRQ chip")?, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2620 | ) |
| 2621 | } |
| 2622 | } else { |
| 2623 | ioapic_host_tube = None; |
| 2624 | KvmIrqChip::Kernel( |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2625 | KvmKernelIrqChip::new(vm_clone, components.vcpu_count) |
| 2626 | .context("failed to create IRQ chip")?, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2627 | ) |
| 2628 | }; |
| 2629 | |
| 2630 | run_vm::<KvmVcpu, KvmVm>(cfg, components, vm, irq_chip.as_mut(), ioapic_host_tube) |
| 2631 | } |
| 2632 | |
| 2633 | fn run_vm<Vcpu, V>( |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2634 | cfg: Config, |
| 2635 | #[allow(unused_mut)] mut components: VmComponents, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2636 | mut vm: V, |
| 2637 | irq_chip: &mut dyn IrqChipArch, |
| 2638 | ioapic_host_tube: Option<Tube>, |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 2639 | ) -> Result<ExitState> |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2640 | where |
| 2641 | Vcpu: VcpuArch + 'static, |
| 2642 | V: VmArch + 'static, |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2643 | { |
| 2644 | if cfg.sandbox { |
| 2645 | // Printing something to the syslog before entering minijail so that libc's syslogger has a |
| 2646 | // chance to open files necessary for its operation, like `/etc/localtime`. After jailing, |
| 2647 | // access to those files will not be possible. |
| 2648 | info!("crosvm entering multiprocess mode"); |
| 2649 | } |
| 2650 | |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 2651 | #[cfg(feature = "usb")] |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2652 | let (usb_control_tube, usb_provider) = |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2653 | HostBackendDeviceProvider::new().context("failed to create usb provider")?; |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 2654 | |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2655 | // Masking signals is inherently dangerous, since this can persist across clones/execs. Do this |
| 2656 | // before any jailed devices have been spawned, so that we can catch any of them that fail very |
| 2657 | // quickly. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2658 | let sigchld_fd = SignalFd::new(libc::SIGCHLD).context("failed to create signalfd")?; |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 2659 | |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 2660 | let control_server_socket = match &cfg.socket_path { |
| 2661 | Some(path) => Some(UnlinkUnixSeqpacketListener( |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2662 | UnixSeqpacketListener::bind(path).context("failed to create control server")?, |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 2663 | )), |
| 2664 | None => None, |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 2665 | }; |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 2666 | |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2667 | let mut control_tubes = Vec::new(); |
| 2668 | |
| 2669 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 2670 | if let Some(port) = cfg.gdb { |
| 2671 | // GDB needs a control socket to interrupt vcpus. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2672 | let (gdb_host_tube, gdb_control_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2673 | control_tubes.push(TaggedControlTube::Vm(gdb_host_tube)); |
| 2674 | components.gdb = Some((port, gdb_control_tube)); |
| 2675 | } |
| 2676 | |
Chirantan Ekbote | 2ee9dcd | 2021-05-26 18:21:44 +0900 | [diff] [blame] | 2677 | for wl_cfg in &cfg.vhost_user_wl { |
| 2678 | let wayland_host_tube = UnixSeqpacket::connect(&wl_cfg.vm_tube) |
| 2679 | .map(Tube::new) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2680 | .context("failed to connect to wayland tube")?; |
Chirantan Ekbote | 2ee9dcd | 2021-05-26 18:21:44 +0900 | [diff] [blame] | 2681 | control_tubes.push(TaggedControlTube::VmMemory(wayland_host_tube)); |
| 2682 | } |
| 2683 | |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 2684 | let mut vhost_user_gpu_tubes = Vec::with_capacity(cfg.vhost_user_gpu.len()); |
| 2685 | for _ in 0..cfg.vhost_user_gpu.len() { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2686 | let (host_tube, device_tube) = Tube::pair().context("failed to create tube")?; |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 2687 | vhost_user_gpu_tubes.push(( |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2688 | host_tube.try_clone().context("failed to clone tube")?, |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 2689 | device_tube, |
| 2690 | )); |
| 2691 | control_tubes.push(TaggedControlTube::VmMemory(host_tube)); |
| 2692 | } |
| 2693 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2694 | let (wayland_host_tube, wayland_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2695 | control_tubes.push(TaggedControlTube::VmMemory(wayland_host_tube)); |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 2696 | // Balloon gets a special socket so balloon requests can be forwarded from the main process. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2697 | let (balloon_host_tube, balloon_device_tube) = Tube::pair().context("failed to create tube")?; |
Hikaru Nishida | af3f3bb | 2021-05-21 12:03:54 +0900 | [diff] [blame] | 2698 | // Set recv timeout to avoid deadlock on sending BalloonControlCommand before guest is ready. |
| 2699 | balloon_host_tube |
| 2700 | .set_recv_timeout(Some(Duration::from_millis(100))) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2701 | .context("failed to create tube")?; |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 2702 | |
Daniel Verkamp | 92f73d7 | 2018-12-04 13:17:46 -0800 | [diff] [blame] | 2703 | // Create one control socket per disk. |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2704 | let mut disk_device_tubes = Vec::new(); |
| 2705 | let mut disk_host_tubes = Vec::new(); |
Daniel Verkamp | 92f73d7 | 2018-12-04 13:17:46 -0800 | [diff] [blame] | 2706 | let disk_count = cfg.disks.len(); |
| 2707 | for _ in 0..disk_count { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2708 | let (disk_host_tub, disk_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2709 | disk_host_tubes.push(disk_host_tub); |
| 2710 | disk_device_tubes.push(disk_device_tube); |
Daniel Verkamp | 92f73d7 | 2018-12-04 13:17:46 -0800 | [diff] [blame] | 2711 | } |
| 2712 | |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2713 | let mut pmem_device_tubes = Vec::new(); |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 2714 | let pmem_count = cfg.pmem_devices.len(); |
| 2715 | for _ in 0..pmem_count { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2716 | let (pmem_host_tube, pmem_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2717 | pmem_device_tubes.push(pmem_device_tube); |
| 2718 | control_tubes.push(TaggedControlTube::VmMsync(pmem_host_tube)); |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 2719 | } |
| 2720 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2721 | let (gpu_host_tube, gpu_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2722 | control_tubes.push(TaggedControlTube::VmMemory(gpu_host_tube)); |
Gurchetan Singh | 96beafc | 2019-05-15 09:46:52 -0700 | [diff] [blame] | 2723 | |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2724 | if let Some(ioapic_host_tube) = ioapic_host_tube { |
| 2725 | control_tubes.push(TaggedControlTube::VmIrq(ioapic_host_tube)); |
| 2726 | } |
Zhuocheng Ding | f2e90bf | 2019-12-02 15:50:20 +0800 | [diff] [blame] | 2727 | |
Chuanxiao Dong | bbb32af | 2020-04-27 16:37:10 +0800 | [diff] [blame] | 2728 | let battery = if cfg.battery_type.is_some() { |
Daniel Verkamp | cfe4946 | 2021-08-19 17:11:05 -0700 | [diff] [blame] | 2729 | #[cfg_attr(not(feature = "power-monitor-powerd"), allow(clippy::manual_map))] |
Alex Lau | f408c73 | 2020-11-10 18:24:04 +0900 | [diff] [blame] | 2730 | let jail = match simple_jail(&cfg, "battery")? { |
Daniel Verkamp | cfe4946 | 2021-08-19 17:11:05 -0700 | [diff] [blame] | 2731 | #[cfg_attr(not(feature = "power-monitor-powerd"), allow(unused_mut))] |
Alex Lau | f408c73 | 2020-11-10 18:24:04 +0900 | [diff] [blame] | 2732 | Some(mut jail) => { |
| 2733 | // Setup a bind mount to the system D-Bus socket if the powerd monitor is used. |
| 2734 | #[cfg(feature = "power-monitor-powerd")] |
| 2735 | { |
Fergus Dall | 5120051 | 2021-08-19 12:54:26 +1000 | [diff] [blame] | 2736 | add_current_user_to_jail(&mut jail)?; |
Alex Lau | f408c73 | 2020-11-10 18:24:04 +0900 | [diff] [blame] | 2737 | |
| 2738 | // Create a tmpfs in the device's root directory so that we can bind mount files. |
| 2739 | jail.mount_with_data( |
| 2740 | Path::new("none"), |
| 2741 | Path::new("/"), |
| 2742 | "tmpfs", |
| 2743 | (libc::MS_NOSUID | libc::MS_NODEV | libc::MS_NOEXEC) as usize, |
| 2744 | "size=67108864", |
| 2745 | )?; |
| 2746 | |
| 2747 | let system_bus_socket_path = Path::new("/run/dbus/system_bus_socket"); |
| 2748 | jail.mount_bind(system_bus_socket_path, system_bus_socket_path, true)?; |
| 2749 | } |
| 2750 | Some(jail) |
| 2751 | } |
| 2752 | None => None, |
| 2753 | }; |
| 2754 | (&cfg.battery_type, jail) |
Chuanxiao Dong | bbb32af | 2020-04-27 16:37:10 +0800 | [diff] [blame] | 2755 | } else { |
| 2756 | (&cfg.battery_type, None) |
| 2757 | }; |
| 2758 | |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 2759 | let map_request: Arc<Mutex<Option<ExternalMapping>>> = Arc::new(Mutex::new(None)); |
| 2760 | |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 2761 | let fs_count = cfg |
| 2762 | .shared_dirs |
| 2763 | .iter() |
| 2764 | .filter(|sd| sd.kind == SharedDirKind::FS) |
| 2765 | .count(); |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2766 | let mut fs_device_tubes = Vec::with_capacity(fs_count); |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 2767 | for _ in 0..fs_count { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2768 | let (fs_host_tube, fs_device_tube) = Tube::pair().context("failed to create tube")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2769 | control_tubes.push(TaggedControlTube::Fs(fs_host_tube)); |
| 2770 | fs_device_tubes.push(fs_device_tube); |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 2771 | } |
| 2772 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2773 | let exit_evt = Event::new().context("failed to create event")?; |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 2774 | let reset_evt = Event::new().context("failed to create event")?; |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2775 | let mut sys_allocator = Arch::create_system_allocator(vm.get_memory()); |
Ryo Hashimoto | 8f9dc1d | 2021-08-18 19:07:29 +0900 | [diff] [blame] | 2776 | |
| 2777 | // Allocate the ramoops region first. AArch64::build_vm() assumes this. |
| 2778 | let ramoops_region = match &components.pstore { |
| 2779 | Some(pstore) => Some( |
Dennis Kempin | 65740a6 | 2021-10-18 16:46:57 -0700 | [diff] [blame] | 2780 | arch::pstore::create_memory_region(&mut vm, &mut sys_allocator, pstore) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2781 | .context("failed to allocate pstore region")?, |
Ryo Hashimoto | 8f9dc1d | 2021-08-18 19:07:29 +0900 | [diff] [blame] | 2782 | ), |
| 2783 | None => None, |
| 2784 | }; |
| 2785 | |
Zide Chen | 71435c1 | 2021-03-03 15:02:02 -0800 | [diff] [blame] | 2786 | let phys_max_addr = Arch::get_phys_max_addr(); |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 2787 | let mut devices = create_devices( |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2788 | &cfg, |
| 2789 | &mut vm, |
| 2790 | &mut sys_allocator, |
| 2791 | &exit_evt, |
Zide Chen | 71435c1 | 2021-03-03 15:02:02 -0800 | [diff] [blame] | 2792 | phys_max_addr, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2793 | &mut control_tubes, |
| 2794 | wayland_device_tube, |
| 2795 | gpu_device_tube, |
Chirantan Ekbote | 44292f5 | 2021-06-25 18:31:41 +0900 | [diff] [blame] | 2796 | vhost_user_gpu_tubes, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2797 | balloon_device_tube, |
| 2798 | &mut disk_device_tubes, |
| 2799 | &mut pmem_device_tubes, |
| 2800 | &mut fs_device_tubes, |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 2801 | #[cfg(feature = "usb")] |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2802 | usb_provider, |
| 2803 | Arc::clone(&map_request), |
| 2804 | )?; |
| 2805 | |
Peter Fang | c2bba08 | 2021-04-19 18:40:24 -0700 | [diff] [blame] | 2806 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 2807 | for device in devices |
| 2808 | .iter_mut() |
| 2809 | .filter_map(|(dev, _)| dev.as_pci_device_mut()) |
| 2810 | { |
Peter Fang | c2bba08 | 2021-04-19 18:40:24 -0700 | [diff] [blame] | 2811 | let sdts = device |
| 2812 | .generate_acpi(components.acpi_sdts) |
| 2813 | .or_else(|| { |
| 2814 | error!("ACPI table generation error"); |
| 2815 | None |
| 2816 | }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2817 | .ok_or_else(|| anyhow!("failed to generate ACPI table"))?; |
Peter Fang | c2bba08 | 2021-04-19 18:40:24 -0700 | [diff] [blame] | 2818 | components.acpi_sdts = sdts; |
| 2819 | } |
| 2820 | |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2821 | // KVM_CREATE_VCPU uses apic id for x86 and uses cpu id for others. |
| 2822 | let mut kvm_vcpu_ids = Vec::new(); |
| 2823 | |
Kuo-Hsin Yang | 6139da6 | 2021-04-14 16:55:24 +0800 | [diff] [blame] | 2824 | #[cfg_attr(not(feature = "direct"), allow(unused_mut))] |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2825 | let mut linux = Arch::build_vm::<V, Vcpu>( |
Trent Begin | 17ccaad | 2019-04-17 13:51:25 -0600 | [diff] [blame] | 2826 | components, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2827 | &exit_evt, |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 2828 | &reset_evt, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2829 | &mut sys_allocator, |
Trent Begin | 17ccaad | 2019-04-17 13:51:25 -0600 | [diff] [blame] | 2830 | &cfg.serial_parameters, |
Matt Delco | 45caf91 | 2019-11-13 08:11:09 -0800 | [diff] [blame] | 2831 | simple_jail(&cfg, "serial")?, |
Chuanxiao Dong | bbb32af | 2020-04-27 16:37:10 +0800 | [diff] [blame] | 2832 | battery, |
Zach Reizner | a90649a | 2021-03-31 12:56:08 -0700 | [diff] [blame] | 2833 | vm, |
Ryo Hashimoto | 8f9dc1d | 2021-08-18 19:07:29 +0900 | [diff] [blame] | 2834 | ramoops_region, |
Tomasz Nowicki | ab86d52 | 2021-09-22 05:50:46 +0000 | [diff] [blame] | 2835 | devices, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2836 | irq_chip, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2837 | &mut kvm_vcpu_ids, |
Trent Begin | 17ccaad | 2019-04-17 13:51:25 -0600 | [diff] [blame] | 2838 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2839 | .context("the architecture failed to build the vm")?; |
Lepton Wu | 6089388 | 2018-11-21 11:06:18 -0800 | [diff] [blame] | 2840 | |
Daniel Verkamp | 1286b48 | 2021-11-30 15:14:16 -0800 | [diff] [blame] | 2841 | #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] |
| 2842 | { |
| 2843 | // Create Pcie Root Port |
| 2844 | let pcie_root_port = Arc::new(Mutex::new(PcieRootPort::new())); |
| 2845 | let (msi_host_tube, msi_device_tube) = Tube::pair().context("failed to create tube")?; |
| 2846 | control_tubes.push(TaggedControlTube::VmIrq(msi_host_tube)); |
| 2847 | let sec_bus = (1..255) |
| 2848 | .find(|&bus_num| sys_allocator.pci_bus_empty(bus_num)) |
| 2849 | .context("failed to find empty bus for Pci hotplug")?; |
| 2850 | let pci_bridge = Box::new(PciBridge::new( |
| 2851 | pcie_root_port.clone(), |
| 2852 | msi_device_tube, |
| 2853 | 0, |
| 2854 | sec_bus, |
| 2855 | )); |
| 2856 | Arch::register_pci_device(&mut linux, pci_bridge, None, &mut sys_allocator) |
| 2857 | .context("Failed to configure pci bridge device")?; |
| 2858 | linux.hotplug_bus.push(pcie_root_port); |
| 2859 | } |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 2860 | |
Tomasz Jeznach | 3ce7476 | 2021-02-26 01:01:53 -0800 | [diff] [blame] | 2861 | #[cfg(feature = "direct")] |
| 2862 | if let Some(pmio) = &cfg.direct_pmio { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2863 | let direct_io = Arc::new( |
| 2864 | devices::DirectIo::new(&pmio.path, false).context("failed to open direct io device")?, |
| 2865 | ); |
Tomasz Jeznach | 3ce7476 | 2021-02-26 01:01:53 -0800 | [diff] [blame] | 2866 | for range in pmio.ranges.iter() { |
| 2867 | linux |
| 2868 | .io_bus |
Junichi Uekawa | b180f9c | 2021-12-07 09:21:36 +0900 | [diff] [blame] | 2869 | .insert_sync(direct_io.clone(), range.base, range.len) |
Tomasz Jeznach | 3ce7476 | 2021-02-26 01:01:53 -0800 | [diff] [blame] | 2870 | .unwrap(); |
| 2871 | } |
| 2872 | }; |
| 2873 | |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2874 | #[cfg(feature = "direct")] |
Tomasz Jeznach | 9e6c633 | 2021-05-27 21:49:14 -0700 | [diff] [blame] | 2875 | if let Some(mmio) = &cfg.direct_mmio { |
Xiong Zhang | 46471a0 | 2021-11-12 00:34:42 +0800 | [diff] [blame] | 2876 | let direct_mmio = Arc::new( |
Junichi Uekawa | b180f9c | 2021-12-07 09:21:36 +0900 | [diff] [blame] | 2877 | devices::DirectMmio::new(&mmio.path, false, &mmio.ranges) |
Xiong Zhang | 46471a0 | 2021-11-12 00:34:42 +0800 | [diff] [blame] | 2878 | .context("failed to open direct mmio device")?, |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2879 | ); |
Xiong Zhang | 46471a0 | 2021-11-12 00:34:42 +0800 | [diff] [blame] | 2880 | |
Tomasz Jeznach | 9e6c633 | 2021-05-27 21:49:14 -0700 | [diff] [blame] | 2881 | for range in mmio.ranges.iter() { |
| 2882 | linux |
| 2883 | .mmio_bus |
Junichi Uekawa | b180f9c | 2021-12-07 09:21:36 +0900 | [diff] [blame] | 2884 | .insert_sync(direct_mmio.clone(), range.base, range.len) |
Tomasz Jeznach | 9e6c633 | 2021-05-27 21:49:14 -0700 | [diff] [blame] | 2885 | .unwrap(); |
| 2886 | } |
| 2887 | }; |
| 2888 | |
| 2889 | #[cfg(feature = "direct")] |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2890 | let mut irqs = Vec::new(); |
| 2891 | |
| 2892 | #[cfg(feature = "direct")] |
| 2893 | for irq in &cfg.direct_level_irq { |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2894 | if !sys_allocator.reserve_irq(*irq) { |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2895 | warn!("irq {} already reserved.", irq); |
| 2896 | } |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2897 | let trigger = Event::new().context("failed to create event")?; |
| 2898 | let resample = Event::new().context("failed to create event")?; |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2899 | linux |
| 2900 | .irq_chip |
| 2901 | .register_irq_event(*irq, &trigger, Some(&resample)) |
| 2902 | .unwrap(); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2903 | let direct_irq = devices::DirectIrq::new(trigger, Some(resample)) |
| 2904 | .context("failed to enable interrupt forwarding")?; |
| 2905 | direct_irq |
| 2906 | .irq_enable(*irq) |
| 2907 | .context("failed to enable interrupt forwarding")?; |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2908 | irqs.push(direct_irq); |
| 2909 | } |
| 2910 | |
| 2911 | #[cfg(feature = "direct")] |
| 2912 | for irq in &cfg.direct_edge_irq { |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2913 | if !sys_allocator.reserve_irq(*irq) { |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2914 | warn!("irq {} already reserved.", irq); |
| 2915 | } |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2916 | let trigger = Event::new().context("failed to create event")?; |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2917 | linux |
| 2918 | .irq_chip |
| 2919 | .register_irq_event(*irq, &trigger, None) |
| 2920 | .unwrap(); |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2921 | let direct_irq = devices::DirectIrq::new(trigger, None) |
| 2922 | .context("failed to enable interrupt forwarding")?; |
| 2923 | direct_irq |
| 2924 | .irq_enable(*irq) |
| 2925 | .context("failed to enable interrupt forwarding")?; |
Tomasz Jeznach | 7271f75 | 2021-03-04 01:44:06 -0800 | [diff] [blame] | 2926 | irqs.push(direct_irq); |
| 2927 | } |
| 2928 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2929 | let gralloc = RutabagaGralloc::new().context("failed to create gralloc")?; |
Daniel Verkamp | 92f73d7 | 2018-12-04 13:17:46 -0800 | [diff] [blame] | 2930 | run_control( |
| 2931 | linux, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2932 | sys_allocator, |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 2933 | control_server_socket, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2934 | control_tubes, |
| 2935 | balloon_host_tube, |
| 2936 | &disk_host_tubes, |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 2937 | #[cfg(feature = "usb")] |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 2938 | usb_control_tube, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 2939 | exit_evt, |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 2940 | reset_evt, |
Daniel Verkamp | 92f73d7 | 2018-12-04 13:17:46 -0800 | [diff] [blame] | 2941 | sigchld_fd, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 2942 | cfg.sandbox, |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 2943 | Arc::clone(&map_request), |
Gurchetan Singh | 293913c | 2020-12-09 10:44:13 -0800 | [diff] [blame] | 2944 | gralloc, |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 2945 | cfg.per_vm_core_scheduling, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 2946 | cfg.host_cpu_topology, |
| 2947 | kvm_vcpu_ids, |
Daniel Verkamp | 92f73d7 | 2018-12-04 13:17:46 -0800 | [diff] [blame] | 2948 | ) |
Dylan Reid | 0ed91ab | 2018-05-31 15:42:18 -0700 | [diff] [blame] | 2949 | } |
| 2950 | |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 2951 | fn get_hp_bus<V: VmArch, Vcpu: VcpuArch>( |
| 2952 | linux: &RunnableLinuxVm<V, Vcpu>, |
| 2953 | host_addr: PciAddress, |
| 2954 | ) -> Result<(Arc<Mutex<dyn HotPlugBus>>, u8)> { |
| 2955 | for hp_bus in linux.hotplug_bus.iter() { |
| 2956 | if let Some(number) = hp_bus.lock().is_match(host_addr) { |
| 2957 | return Ok((hp_bus.clone(), number)); |
| 2958 | } |
| 2959 | } |
| 2960 | Err(anyhow!("Failed to find a suitable hotplug bus")) |
| 2961 | } |
| 2962 | |
Xiong Zhang | 8c9fe3e | 2021-04-12 15:07:17 +0800 | [diff] [blame] | 2963 | #[allow(dead_code)] |
| 2964 | fn add_vfio_device<V: VmArch, Vcpu: VcpuArch>( |
| 2965 | linux: &mut RunnableLinuxVm<V, Vcpu>, |
| 2966 | sys_allocator: &mut SystemAllocator, |
| 2967 | cfg: &Config, |
| 2968 | control_tubes: &mut Vec<TaggedControlTube>, |
| 2969 | vfio_path: &Path, |
| 2970 | ) -> Result<()> { |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 2971 | let host_os_str = vfio_path |
| 2972 | .file_name() |
| 2973 | .ok_or_else(|| anyhow!("failed to parse or find vfio path"))?; |
| 2974 | let host_str = host_os_str |
| 2975 | .to_str() |
| 2976 | .ok_or_else(|| anyhow!("failed to parse or find vfio path"))?; |
| 2977 | let host_addr = PciAddress::from_string(host_str); |
| 2978 | |
| 2979 | let (hp_bus, bus_num) = get_hp_bus(linux, host_addr)?; |
| 2980 | |
Xiong Zhang | 8c9fe3e | 2021-04-12 15:07:17 +0800 | [diff] [blame] | 2981 | let mut endpoints: BTreeMap<u32, Arc<Mutex<VfioContainer>>> = BTreeMap::new(); |
| 2982 | let (vfio_pci_device, jail) = create_vfio_device( |
| 2983 | cfg, |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 2984 | &linux.vm, |
Xiong Zhang | 8c9fe3e | 2021-04-12 15:07:17 +0800 | [diff] [blame] | 2985 | sys_allocator, |
| 2986 | control_tubes, |
| 2987 | vfio_path, |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 2988 | Some(bus_num), |
Xiong Zhang | 8c9fe3e | 2021-04-12 15:07:17 +0800 | [diff] [blame] | 2989 | &mut endpoints, |
| 2990 | false, |
| 2991 | )?; |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 2992 | |
| 2993 | let pci_address = Arch::register_pci_device(linux, vfio_pci_device, jail, sys_allocator) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2994 | .context("Failed to configure pci hotplug device")?; |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 2995 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 2996 | let host_os_str = vfio_path |
| 2997 | .file_name() |
| 2998 | .ok_or_else(|| anyhow!("failed to parse or find vfio path"))?; |
| 2999 | let host_str = host_os_str |
| 3000 | .to_str() |
| 3001 | .ok_or_else(|| anyhow!("failed to parse or find vfio path"))?; |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 3002 | let host_addr = PciAddress::from_string(host_str); |
| 3003 | let host_key = HostHotPlugKey::Vfio { host_addr }; |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 3004 | let mut hp_bus = hp_bus.lock(); |
| 3005 | hp_bus.add_hotplug_device(host_key, pci_address); |
| 3006 | hp_bus.hot_plug(pci_address); |
| 3007 | Ok(()) |
Xiong Zhang | 8c9fe3e | 2021-04-12 15:07:17 +0800 | [diff] [blame] | 3008 | } |
| 3009 | |
| 3010 | #[allow(dead_code)] |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 3011 | fn remove_vfio_device<V: VmArch, Vcpu: VcpuArch>( |
| 3012 | linux: &RunnableLinuxVm<V, Vcpu>, |
Xiong Zhang | 2d45b91 | 2021-05-13 16:22:25 +0800 | [diff] [blame] | 3013 | sys_allocator: &mut SystemAllocator, |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 3014 | vfio_path: &Path, |
| 3015 | ) -> Result<()> { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3016 | let host_os_str = vfio_path |
| 3017 | .file_name() |
| 3018 | .ok_or_else(|| anyhow!("failed to parse or find vfio path"))?; |
| 3019 | let host_str = host_os_str |
| 3020 | .to_str() |
| 3021 | .ok_or_else(|| anyhow!("failed to parse or find vfio path"))?; |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 3022 | let host_addr = PciAddress::from_string(host_str); |
| 3023 | let host_key = HostHotPlugKey::Vfio { host_addr }; |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 3024 | for hp_bus in linux.hotplug_bus.iter() { |
| 3025 | let mut hp_bus_lock = hp_bus.lock(); |
| 3026 | if let Some(pci_addr) = hp_bus_lock.get_hotplug_device(host_key) { |
| 3027 | hp_bus_lock.hot_unplug(pci_addr); |
Xiong Zhang | 2d45b91 | 2021-05-13 16:22:25 +0800 | [diff] [blame] | 3028 | sys_allocator.release_pci(pci_addr.bus, pci_addr.dev, pci_addr.func); |
Xiong Zhang | f82f2dc | 2021-05-21 16:54:12 +0800 | [diff] [blame] | 3029 | return Ok(()); |
| 3030 | } |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 3031 | } |
| 3032 | |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3033 | Err(anyhow!("HotPlugBus hasn't been implemented")) |
Xiong Zhang | 9fadc3f | 2021-06-07 14:16:45 +0800 | [diff] [blame] | 3034 | } |
Xiong Zhang | 8c9fe3e | 2021-04-12 15:07:17 +0800 | [diff] [blame] | 3035 | |
Daniel Verkamp | 2940980 | 2021-02-24 14:46:19 -0800 | [diff] [blame] | 3036 | /// Signals all running VCPUs to vmexit, sends VcpuControl message to each VCPU tube, and tells |
| 3037 | /// `irq_chip` to stop blocking halted VCPUs. The channel message is set first because both the |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 3038 | /// signal and the irq_chip kick could cause the VCPU thread to continue through the VCPU run |
| 3039 | /// loop. |
| 3040 | fn kick_all_vcpus( |
| 3041 | vcpu_handles: &[(JoinHandle<()>, mpsc::Sender<vm_control::VcpuControl>)], |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3042 | irq_chip: &dyn IrqChip, |
Daniel Verkamp | 2940980 | 2021-02-24 14:46:19 -0800 | [diff] [blame] | 3043 | message: VcpuControl, |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 3044 | ) { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3045 | for (handle, tube) in vcpu_handles { |
Daniel Verkamp | 2940980 | 2021-02-24 14:46:19 -0800 | [diff] [blame] | 3046 | if let Err(e) = tube.send(message.clone()) { |
| 3047 | error!("failed to send VcpuControl: {}", e); |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 3048 | } |
| 3049 | let _ = handle.kill(SIGRTMIN() + 0); |
| 3050 | } |
| 3051 | irq_chip.kick_halted_vcpus(); |
| 3052 | } |
| 3053 | |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3054 | fn run_control<V: VmArch + 'static, Vcpu: VcpuArch + 'static>( |
| 3055 | mut linux: RunnableLinuxVm<V, Vcpu>, |
| 3056 | mut sys_allocator: SystemAllocator, |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3057 | control_server_socket: Option<UnlinkUnixSeqpacketListener>, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3058 | mut control_tubes: Vec<TaggedControlTube>, |
| 3059 | balloon_host_tube: Tube, |
| 3060 | disk_host_tubes: &[Tube], |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 3061 | #[cfg(feature = "usb")] usb_control_tube: Tube, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3062 | exit_evt: Event, |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3063 | reset_evt: Event, |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 3064 | sigchld_fd: SignalFd, |
Lepton Wu | 20333e4 | 2019-03-14 10:48:03 -0700 | [diff] [blame] | 3065 | sandbox: bool, |
Lingfeng Yang | d6ac1ab | 2020-01-31 13:55:35 -0800 | [diff] [blame] | 3066 | map_request: Arc<Mutex<Option<ExternalMapping>>>, |
Gurchetan Singh | 293913c | 2020-12-09 10:44:13 -0800 | [diff] [blame] | 3067 | mut gralloc: RutabagaGralloc, |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 3068 | enable_per_vm_core_scheduling: bool, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 3069 | host_cpu_topology: bool, |
| 3070 | kvm_vcpu_ids: Vec<usize>, |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3071 | ) -> Result<ExitState> { |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3072 | #[derive(PollToken)] |
| 3073 | enum Token { |
| 3074 | Exit, |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3075 | Reset, |
Chuanxiao Dong | 546f01c | 2020-02-12 21:58:47 +0800 | [diff] [blame] | 3076 | Suspend, |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3077 | ChildSignal, |
Colin Downs-Razouk | bd53276 | 2020-09-08 15:49:35 -0700 | [diff] [blame] | 3078 | IrqFd { index: IrqEventIndex }, |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3079 | VmControlServer, |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3080 | VmControl { index: usize }, |
| 3081 | } |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3082 | |
Zach Reizner | 19ad1f3 | 2019-12-12 18:58:50 -0800 | [diff] [blame] | 3083 | stdin() |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3084 | .set_raw_mode() |
| 3085 | .expect("failed to set terminal raw mode"); |
| 3086 | |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3087 | let wait_ctx = WaitContext::build_with(&[ |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3088 | (&exit_evt, Token::Exit), |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3089 | (&reset_evt, Token::Reset), |
Chuanxiao Dong | 546f01c | 2020-02-12 21:58:47 +0800 | [diff] [blame] | 3090 | (&linux.suspend_evt, Token::Suspend), |
Zach Reizner | b2110be | 2019-07-23 15:55:03 -0700 | [diff] [blame] | 3091 | (&sigchld_fd, Token::ChildSignal), |
| 3092 | ]) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3093 | .context("failed to add descriptor to wait context")?; |
Zach Reizner | b2110be | 2019-07-23 15:55:03 -0700 | [diff] [blame] | 3094 | |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3095 | if let Some(socket_server) = &control_server_socket { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3096 | wait_ctx |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3097 | .add(socket_server, Token::VmControlServer) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3098 | .context("failed to add descriptor to wait context")?; |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3099 | } |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3100 | for (index, socket) in control_tubes.iter().enumerate() { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3101 | wait_ctx |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 3102 | .add(socket.as_ref(), Token::VmControl { index }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3103 | .context("failed to add descriptor to wait context")?; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3104 | } |
| 3105 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3106 | let events = linux |
| 3107 | .irq_chip |
| 3108 | .irq_event_tokens() |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3109 | .context("failed to add descriptor to wait context")?; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3110 | |
Colin Downs-Razouk | bd53276 | 2020-09-08 15:49:35 -0700 | [diff] [blame] | 3111 | for (index, _gsi, evt) in events { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3112 | wait_ctx |
Colin Downs-Razouk | bd53276 | 2020-09-08 15:49:35 -0700 | [diff] [blame] | 3113 | .add(&evt, Token::IrqFd { index }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3114 | .context("failed to add descriptor to wait context")?; |
Zhuocheng Ding | b9f4c9b | 2019-12-02 15:50:28 +0800 | [diff] [blame] | 3115 | } |
| 3116 | |
Lepton Wu | 20333e4 | 2019-03-14 10:48:03 -0700 | [diff] [blame] | 3117 | if sandbox { |
| 3118 | // Before starting VCPUs, in case we started with some capabilities, drop them all. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3119 | drop_capabilities().context("failed to drop process capabilities")?; |
Lepton Wu | 20333e4 | 2019-03-14 10:48:03 -0700 | [diff] [blame] | 3120 | } |
Dmitry Torokhov | 7100607 | 2019-03-06 10:56:51 -0800 | [diff] [blame] | 3121 | |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3122 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 3123 | // Create a channel for GDB thread. |
| 3124 | let (to_gdb_channel, from_vcpu_channel) = if linux.gdb.is_some() { |
| 3125 | let (s, r) = mpsc::channel(); |
| 3126 | (Some(s), Some(r)) |
| 3127 | } else { |
| 3128 | (None, None) |
| 3129 | }; |
| 3130 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3131 | let mut vcpu_handles = Vec::with_capacity(linux.vcpu_count); |
| 3132 | let vcpu_thread_barrier = Arc::new(Barrier::new(linux.vcpu_count + 1)); |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3133 | let use_hypervisor_signals = !linux |
| 3134 | .vm |
| 3135 | .get_hypervisor() |
| 3136 | .check_capability(&HypervisorCap::ImmediateExit); |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 3137 | setup_vcpu_signal_handler::<Vcpu>(use_hypervisor_signals)?; |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3138 | |
Zach Reizner | 304e731 | 2020-09-29 16:00:24 -0700 | [diff] [blame] | 3139 | let vcpus: Vec<Option<_>> = match linux.vcpus.take() { |
Andrew Walbran | 9cfdbd9 | 2021-01-11 17:40:34 +0000 | [diff] [blame] | 3140 | Some(vec) => vec.into_iter().map(Some).collect(), |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3141 | None => iter::repeat_with(|| None).take(linux.vcpu_count).collect(), |
| 3142 | }; |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 3143 | // Enable core scheduling before creating vCPUs so that the cookie will be |
| 3144 | // shared by all vCPU threads. |
| 3145 | // TODO(b/199312402): Avoid enabling core scheduling for the crosvm process |
| 3146 | // itself for even better performance. Only vCPUs need the feature. |
| 3147 | if enable_per_vm_core_scheduling { |
| 3148 | if let Err(e) = enable_core_scheduling() { |
| 3149 | error!("Failed to enable core scheduling: {}", e); |
| 3150 | } |
| 3151 | } |
Daniel Verkamp | 94c3527 | 2019-09-12 13:31:30 -0700 | [diff] [blame] | 3152 | for (cpu_id, vcpu) in vcpus.into_iter().enumerate() { |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 3153 | let (to_vcpu_channel, from_main_channel) = mpsc::channel(); |
Daniel Verkamp | c677fb4 | 2020-09-08 13:47:49 -0700 | [diff] [blame] | 3154 | let vcpu_affinity = match linux.vcpu_affinity.clone() { |
| 3155 | Some(VcpuAffinity::Global(v)) => v, |
| 3156 | Some(VcpuAffinity::PerVcpu(mut m)) => m.remove(&cpu_id).unwrap_or_default(), |
| 3157 | None => Default::default(), |
| 3158 | }; |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 3159 | let handle = run_vcpu( |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3160 | cpu_id, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 3161 | kvm_vcpu_ids[cpu_id], |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 3162 | vcpu, |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3163 | linux.vm.try_clone().context("failed to clone vm")?, |
| 3164 | linux |
| 3165 | .irq_chip |
| 3166 | .try_box_clone() |
| 3167 | .context("failed to clone irqchip")?, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3168 | linux.vcpu_count, |
Kansho Nishida | ab205af | 2020-08-13 18:17:50 +0900 | [diff] [blame] | 3169 | linux.rt_cpus.contains(&cpu_id), |
Daniel Verkamp | c677fb4 | 2020-09-08 13:47:49 -0700 | [diff] [blame] | 3170 | vcpu_affinity, |
Suleiman Souhlal | 63630e8 | 2021-02-18 11:53:11 +0900 | [diff] [blame] | 3171 | linux.delay_rt, |
Suleiman Souhlal | 015c3c1 | 2020-10-07 14:15:41 +0900 | [diff] [blame] | 3172 | linux.no_smt, |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 3173 | vcpu_thread_barrier.clone(), |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3174 | linux.has_bios, |
Colin Downs-Razouk | 11bed5e | 2021-11-02 09:33:14 -0700 | [diff] [blame] | 3175 | (*linux.io_bus).clone(), |
| 3176 | (*linux.mmio_bus).clone(), |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3177 | exit_evt.try_clone().context("failed to clone event")?, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3178 | linux.vm.check_capability(VmCap::PvClockSuspend), |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 3179 | from_main_channel, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3180 | use_hypervisor_signals, |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3181 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 3182 | to_gdb_channel.clone(), |
Yusuke Sato | 31e136a | 2021-08-18 11:51:38 -0700 | [diff] [blame] | 3183 | enable_per_vm_core_scheduling, |
ZhaoLiu | 2aaf7ad | 2021-10-10 18:22:29 +0800 | [diff] [blame] | 3184 | host_cpu_topology, |
Zach Reizner | 55a9e50 | 2018-10-03 10:22:32 -0700 | [diff] [blame] | 3185 | )?; |
Dylan Reid | b049266 | 2019-05-17 14:50:13 -0700 | [diff] [blame] | 3186 | vcpu_handles.push((handle, to_vcpu_channel)); |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 3187 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3188 | |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3189 | #[cfg(all(target_arch = "x86_64", feature = "gdb"))] |
| 3190 | // Spawn GDB thread. |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3191 | if let Some((gdb_port_num, gdb_control_tube)) = linux.gdb.take() { |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3192 | let to_vcpu_channels = vcpu_handles |
| 3193 | .iter() |
| 3194 | .map(|(_handle, channel)| channel.clone()) |
| 3195 | .collect(); |
| 3196 | let target = GdbStub::new( |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3197 | gdb_control_tube, |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3198 | to_vcpu_channels, |
| 3199 | from_vcpu_channel.unwrap(), // Must succeed to unwrap() |
| 3200 | ); |
| 3201 | thread::Builder::new() |
| 3202 | .name("gdb".to_owned()) |
| 3203 | .spawn(move || gdb_thread(target, gdb_port_num)) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3204 | .context("failed to spawn GDB thread")?; |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3205 | }; |
| 3206 | |
Dylan Reid | 059a188 | 2018-07-23 17:58:09 -0700 | [diff] [blame] | 3207 | vcpu_thread_barrier.wait(); |
| 3208 | |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3209 | let mut exit_state = ExitState::Stop; |
Charles William Dick | 5404501 | 2021-07-27 19:11:53 +0900 | [diff] [blame] | 3210 | let mut balloon_stats_id: u64 = 0; |
| 3211 | |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3212 | 'wait: loop { |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3213 | let events = { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3214 | match wait_ctx.wait() { |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3215 | Ok(v) => v, |
| 3216 | Err(e) => { |
David Tolnay | b4bd00f | 2019-02-12 17:51:26 -0800 | [diff] [blame] | 3217 | error!("failed to poll: {}", e); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3218 | break; |
| 3219 | } |
| 3220 | } |
| 3221 | }; |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3222 | |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3223 | if let Err(e) = linux.irq_chip.process_delayed_irq_events() { |
| 3224 | warn!("can't deliver delayed irqs: {}", e); |
| 3225 | } |
Zhuocheng Ding | b9f4c9b | 2019-12-02 15:50:28 +0800 | [diff] [blame] | 3226 | |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3227 | let mut vm_control_indices_to_remove = Vec::new(); |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3228 | for event in events.iter().filter(|e| e.is_readable) { |
| 3229 | match event.token { |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3230 | Token::Exit => { |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3231 | info!("vcpu requested shutdown"); |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3232 | break 'wait; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3233 | } |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3234 | Token::Reset => { |
| 3235 | info!("vcpu requested reset"); |
| 3236 | exit_state = ExitState::Reset; |
| 3237 | break 'wait; |
| 3238 | } |
Chuanxiao Dong | 546f01c | 2020-02-12 21:58:47 +0800 | [diff] [blame] | 3239 | Token::Suspend => { |
| 3240 | info!("VM requested suspend"); |
| 3241 | linux.suspend_evt.read().unwrap(); |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3242 | kick_all_vcpus( |
| 3243 | &vcpu_handles, |
| 3244 | linux.irq_chip.as_irq_chip(), |
Daniel Verkamp | 2940980 | 2021-02-24 14:46:19 -0800 | [diff] [blame] | 3245 | VcpuControl::RunState(VmRunMode::Suspending), |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3246 | ); |
Chuanxiao Dong | 546f01c | 2020-02-12 21:58:47 +0800 | [diff] [blame] | 3247 | } |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3248 | Token::ChildSignal => { |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3249 | // Print all available siginfo structs, then exit the loop. |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3250 | while let Some(siginfo) = |
| 3251 | sigchld_fd.read().context("failed to create signalfd")? |
| 3252 | { |
Zach Reizner | 3ba0098 | 2019-01-23 19:04:43 -0800 | [diff] [blame] | 3253 | let pid = siginfo.ssi_pid; |
| 3254 | let pid_label = match linux.pid_debug_label_map.get(&pid) { |
| 3255 | Some(label) => format!("{} (pid {})", label, pid), |
| 3256 | None => format!("pid {}", pid), |
| 3257 | }; |
David Tolnay | f503276 | 2018-12-03 10:46:45 -0800 | [diff] [blame] | 3258 | error!( |
| 3259 | "child {} died: signo {}, status {}, code {}", |
Zach Reizner | 3ba0098 | 2019-01-23 19:04:43 -0800 | [diff] [blame] | 3260 | pid_label, siginfo.ssi_signo, siginfo.ssi_status, siginfo.ssi_code |
David Tolnay | f503276 | 2018-12-03 10:46:45 -0800 | [diff] [blame] | 3261 | ); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3262 | } |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3263 | break 'wait; |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3264 | } |
Colin Downs-Razouk | bd53276 | 2020-09-08 15:49:35 -0700 | [diff] [blame] | 3265 | Token::IrqFd { index } => { |
| 3266 | if let Err(e) = linux.irq_chip.service_irq_event(index) { |
| 3267 | error!("failed to signal irq {}: {}", index, e); |
Zhuocheng Ding | b9f4c9b | 2019-12-02 15:50:28 +0800 | [diff] [blame] | 3268 | } |
| 3269 | } |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3270 | Token::VmControlServer => { |
| 3271 | if let Some(socket_server) = &control_server_socket { |
| 3272 | match socket_server.accept() { |
| 3273 | Ok(socket) => { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3274 | wait_ctx |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3275 | .add( |
| 3276 | &socket, |
| 3277 | Token::VmControl { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3278 | index: control_tubes.len(), |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3279 | }, |
| 3280 | ) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3281 | .context("failed to add descriptor to wait context")?; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3282 | control_tubes.push(TaggedControlTube::Vm(Tube::new(socket))); |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3283 | } |
| 3284 | Err(e) => error!("failed to accept socket: {}", e), |
| 3285 | } |
| 3286 | } |
| 3287 | } |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3288 | Token::VmControl { index } => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3289 | if let Some(socket) = control_tubes.get(index) { |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3290 | match socket { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3291 | TaggedControlTube::Vm(tube) => match tube.recv::<VmRequest>() { |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3292 | Ok(request) => { |
| 3293 | let mut run_mode_opt = None; |
| 3294 | let response = request.execute( |
| 3295 | &mut run_mode_opt, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3296 | &balloon_host_tube, |
Charles William Dick | 5404501 | 2021-07-27 19:11:53 +0900 | [diff] [blame] | 3297 | &mut balloon_stats_id, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3298 | disk_host_tubes, |
Daniel Verkamp | f1439d4 | 2021-05-21 13:55:10 -0700 | [diff] [blame] | 3299 | #[cfg(feature = "usb")] |
| 3300 | Some(&usb_control_tube), |
| 3301 | #[cfg(not(feature = "usb"))] |
| 3302 | None, |
Chuanxiao Dong | 256be3a | 2020-04-27 16:39:33 +0800 | [diff] [blame] | 3303 | &mut linux.bat_control, |
Suleiman Souhlal | 2ac78b9 | 2021-02-01 12:33:26 +0900 | [diff] [blame] | 3304 | &vcpu_handles, |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3305 | ); |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3306 | if let Err(e) = tube.send(&response) { |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3307 | error!("failed to send VmResponse: {}", e); |
| 3308 | } |
| 3309 | if let Some(run_mode) = run_mode_opt { |
| 3310 | info!("control socket changed run mode to {}", run_mode); |
| 3311 | match run_mode { |
| 3312 | VmRunMode::Exiting => { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3313 | break 'wait; |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3314 | } |
Keiichi Watanabe | c5262e9 | 2020-10-21 15:57:33 +0900 | [diff] [blame] | 3315 | other => { |
Chuanxiao Dong | 2bbe85c | 2020-11-12 17:18:07 +0800 | [diff] [blame] | 3316 | if other == VmRunMode::Running { |
Daniel Verkamp | da4e8a9 | 2021-07-21 13:49:02 -0700 | [diff] [blame] | 3317 | for dev in &linux.resume_notify_devices { |
| 3318 | dev.lock().resume_imminent(); |
| 3319 | } |
Chuanxiao Dong | 546f01c | 2020-02-12 21:58:47 +0800 | [diff] [blame] | 3320 | } |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 3321 | kick_all_vcpus( |
| 3322 | &vcpu_handles, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3323 | linux.irq_chip.as_irq_chip(), |
Daniel Verkamp | 2940980 | 2021-02-24 14:46:19 -0800 | [diff] [blame] | 3324 | VcpuControl::RunState(other), |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 3325 | ); |
Zach Reizner | 6a8fdd9 | 2019-01-16 14:38:41 -0800 | [diff] [blame] | 3326 | } |
| 3327 | } |
| 3328 | } |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3329 | } |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3330 | Err(e) => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3331 | if let TubeError::Disconnected = e { |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3332 | vm_control_indices_to_remove.push(index); |
| 3333 | } else { |
| 3334 | error!("failed to recv VmRequest: {}", e); |
| 3335 | } |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3336 | } |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3337 | }, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3338 | TaggedControlTube::VmMemory(tube) => { |
| 3339 | match tube.recv::<VmMemoryRequest>() { |
| 3340 | Ok(request) => { |
| 3341 | let response = request.execute( |
| 3342 | &mut linux.vm, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3343 | &mut sys_allocator, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3344 | Arc::clone(&map_request), |
| 3345 | &mut gralloc, |
| 3346 | ); |
| 3347 | if let Err(e) = tube.send(&response) { |
| 3348 | error!("failed to send VmMemoryControlResponse: {}", e); |
| 3349 | } |
| 3350 | } |
| 3351 | Err(e) => { |
| 3352 | if let TubeError::Disconnected = e { |
| 3353 | vm_control_indices_to_remove.push(index); |
| 3354 | } else { |
| 3355 | error!("failed to recv VmMemoryControlRequest: {}", e); |
| 3356 | } |
Jakub Staron | d99cd0a | 2019-04-11 14:09:39 -0700 | [diff] [blame] | 3357 | } |
| 3358 | } |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3359 | } |
| 3360 | TaggedControlTube::VmIrq(tube) => match tube.recv::<VmIrqRequest>() { |
Xiong Zhang | 2515b75 | 2019-09-19 10:29:02 +0800 | [diff] [blame] | 3361 | Ok(request) => { |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3362 | let response = { |
| 3363 | let irq_chip = &mut linux.irq_chip; |
| 3364 | request.execute( |
| 3365 | |setup| match setup { |
| 3366 | IrqSetup::Event(irq, ev) => { |
Colin Downs-Razouk | bd53276 | 2020-09-08 15:49:35 -0700 | [diff] [blame] | 3367 | if let Some(event_index) = irq_chip |
| 3368 | .register_irq_event(irq, ev, None)? |
| 3369 | { |
| 3370 | match wait_ctx.add( |
| 3371 | ev, |
| 3372 | Token::IrqFd { |
| 3373 | index: event_index |
| 3374 | }, |
| 3375 | ) { |
| 3376 | Err(e) => { |
| 3377 | warn!("failed to add IrqFd to poll context: {}", e); |
| 3378 | Err(e) |
| 3379 | }, |
| 3380 | Ok(_) => { |
| 3381 | Ok(()) |
| 3382 | } |
| 3383 | } |
| 3384 | } else { |
| 3385 | Ok(()) |
| 3386 | } |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3387 | } |
| 3388 | IrqSetup::Route(route) => irq_chip.route_irq(route), |
| 3389 | }, |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3390 | &mut sys_allocator, |
Steven Richman | f32d0b4 | 2020-06-20 21:45:32 -0700 | [diff] [blame] | 3391 | ) |
| 3392 | }; |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3393 | if let Err(e) = tube.send(&response) { |
Xiong Zhang | 2515b75 | 2019-09-19 10:29:02 +0800 | [diff] [blame] | 3394 | error!("failed to send VmIrqResponse: {}", e); |
| 3395 | } |
| 3396 | } |
| 3397 | Err(e) => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3398 | if let TubeError::Disconnected = e { |
Xiong Zhang | 2515b75 | 2019-09-19 10:29:02 +0800 | [diff] [blame] | 3399 | vm_control_indices_to_remove.push(index); |
| 3400 | } else { |
| 3401 | error!("failed to recv VmIrqRequest: {}", e); |
| 3402 | } |
| 3403 | } |
| 3404 | }, |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3405 | TaggedControlTube::VmMsync(tube) => { |
| 3406 | match tube.recv::<VmMsyncRequest>() { |
| 3407 | Ok(request) => { |
| 3408 | let response = request.execute(&mut linux.vm); |
| 3409 | if let Err(e) = tube.send(&response) { |
| 3410 | error!("failed to send VmMsyncResponse: {}", e); |
| 3411 | } |
| 3412 | } |
| 3413 | Err(e) => { |
| 3414 | if let TubeError::Disconnected = e { |
| 3415 | vm_control_indices_to_remove.push(index); |
| 3416 | } else { |
| 3417 | error!("failed to recv VmMsyncRequest: {}", e); |
| 3418 | } |
Daniel Verkamp | e1980a9 | 2020-02-07 11:00:55 -0800 | [diff] [blame] | 3419 | } |
| 3420 | } |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3421 | } |
| 3422 | TaggedControlTube::Fs(tube) => match tube.recv::<FsMappingRequest>() { |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 3423 | Ok(request) => { |
| 3424 | let response = |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3425 | request.execute(&mut linux.vm, &mut sys_allocator); |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3426 | if let Err(e) = tube.send(&response) { |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 3427 | error!("failed to send VmResponse: {}", e); |
| 3428 | } |
| 3429 | } |
| 3430 | Err(e) => { |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3431 | if let TubeError::Disconnected = e { |
Keiichi Watanabe | eefe7fb | 2020-11-17 17:58:35 +0900 | [diff] [blame] | 3432 | vm_control_indices_to_remove.push(index); |
| 3433 | } else { |
| 3434 | error!("failed to recv VmResponse: {}", e); |
| 3435 | } |
| 3436 | } |
| 3437 | }, |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3438 | } |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3439 | } |
| 3440 | } |
Zach Reizner | 5bed0d2 | 2018-03-28 02:31:11 -0700 | [diff] [blame] | 3441 | } |
| 3442 | } |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3443 | |
Vikram Auradkar | ede68c7 | 2021-07-01 14:33:54 -0700 | [diff] [blame] | 3444 | // It's possible more data is readable and buffered while the socket is hungup, |
| 3445 | // so don't delete the tube from the poll context until we're sure all the |
| 3446 | // data is read. |
| 3447 | // Below case covers a condition where we have received a hungup event and the tube is not |
| 3448 | // readable. |
| 3449 | // In case of readable tube, once all data is read, any attempt to read more data on hungup |
| 3450 | // tube should fail. On such failure, we get Disconnected error and index gets added to |
| 3451 | // vm_control_indices_to_remove by the time we reach here. |
| 3452 | for event in events.iter().filter(|e| e.is_hungup && !e.is_readable) { |
| 3453 | if let Token::VmControl { index } = event.token { |
| 3454 | vm_control_indices_to_remove.push(index); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3455 | } |
| 3456 | } |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3457 | |
| 3458 | // Sort in reverse so the highest indexes are removed first. This removal algorithm |
Zide Chen | 8958407 | 2019-11-14 10:33:51 -0800 | [diff] [blame] | 3459 | // preserves correct indexes as each element is removed. |
Daniel Verkamp | 8c2f000 | 2020-08-31 15:13:35 -0700 | [diff] [blame] | 3460 | vm_control_indices_to_remove.sort_unstable_by_key(|&k| Reverse(k)); |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3461 | vm_control_indices_to_remove.dedup(); |
| 3462 | for index in vm_control_indices_to_remove { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3463 | // Delete the socket from the `wait_ctx` synchronously. Otherwise, the kernel will do |
| 3464 | // this automatically when the FD inserted into the `wait_ctx` is closed after this |
Zide Chen | 8958407 | 2019-11-14 10:33:51 -0800 | [diff] [blame] | 3465 | // if-block, but this removal can be deferred unpredictably. In some instances where the |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3466 | // system is under heavy load, we can even get events returned by `wait_ctx` for an FD |
Zide Chen | 8958407 | 2019-11-14 10:33:51 -0800 | [diff] [blame] | 3467 | // that has already been closed. Because the token associated with that spurious event |
| 3468 | // now belongs to a different socket, the control loop will start to interact with |
| 3469 | // sockets that might not be ready to use. This can cause incorrect hangup detection or |
| 3470 | // blocking on a socket that will never be ready. See also: crbug.com/1019986 |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3471 | if let Some(socket) = control_tubes.get(index) { |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3472 | wait_ctx |
| 3473 | .delete(socket) |
| 3474 | .context("failed to remove descriptor from wait context")?; |
Zide Chen | 8958407 | 2019-11-14 10:33:51 -0800 | [diff] [blame] | 3475 | } |
| 3476 | |
| 3477 | // This line implicitly drops the socket at `index` when it gets returned by |
| 3478 | // `swap_remove`. After this line, the socket at `index` is not the one from |
| 3479 | // `vm_control_indices_to_remove`. Because of this socket's change in index, we need to |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3480 | // use `wait_ctx.modify` to change the associated index in its `Token::VmControl`. |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3481 | control_tubes.swap_remove(index); |
| 3482 | if let Some(tube) = control_tubes.get(index) { |
Michael Hoyle | e392c46 | 2020-10-07 03:29:24 -0700 | [diff] [blame] | 3483 | wait_ctx |
Zach Reizner | d49bcdb | 2021-01-07 08:30:28 -0800 | [diff] [blame] | 3484 | .modify(tube, EventType::Read, Token::VmControl { index }) |
Daniel Verkamp | 6b29858 | 2021-08-16 15:37:11 -0700 | [diff] [blame] | 3485 | .context("failed to add descriptor to wait context")?; |
Zach Reizner | a60744b | 2019-02-13 17:33:32 -0800 | [diff] [blame] | 3486 | } |
| 3487 | } |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3488 | } |
| 3489 | |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3490 | kick_all_vcpus( |
| 3491 | &vcpu_handles, |
| 3492 | linux.irq_chip.as_irq_chip(), |
Daniel Verkamp | 2940980 | 2021-02-24 14:46:19 -0800 | [diff] [blame] | 3493 | VcpuControl::RunState(VmRunMode::Exiting), |
Zach Reizner | dc74848 | 2021-04-14 13:59:30 -0700 | [diff] [blame] | 3494 | ); |
Steven Richman | 11dc671 | 2020-09-02 15:39:14 -0700 | [diff] [blame] | 3495 | for (handle, _) in vcpu_handles { |
| 3496 | if let Err(e) = handle.join() { |
| 3497 | error!("failed to join vcpu thread: {:?}", e); |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3498 | } |
| 3499 | } |
| 3500 | |
Daniel Verkamp | 94c3527 | 2019-09-12 13:31:30 -0700 | [diff] [blame] | 3501 | // Explicitly drop the VM structure here to allow the devices to clean up before the |
| 3502 | // control sockets are closed when this function exits. |
| 3503 | mem::drop(linux); |
| 3504 | |
Zach Reizner | 19ad1f3 | 2019-12-12 18:58:50 -0800 | [diff] [blame] | 3505 | stdin() |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3506 | .set_canon_mode() |
| 3507 | .expect("failed to restore canonical mode for terminal"); |
| 3508 | |
Dmitry Torokhov | f75699f | 2021-12-03 11:19:13 -0800 | [diff] [blame] | 3509 | Ok(exit_state) |
Zach Reizner | 39aa26b | 2017-12-12 18:03:23 -0800 | [diff] [blame] | 3510 | } |