device_virtio_console/
lib.rs

1// Copyright 2020 The ChromiumOS Authors
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! Virtio console device.
6
7pub mod control;
8pub mod device;
9pub mod input;
10pub mod output;
11pub mod port;
12pub mod worker;
13
14mod sys;
15
16use std::collections::BTreeMap;
17
18use anyhow::Context;
19#[cfg(any(target_os = "android", target_os = "linux"))]
20use base::info;
21use base::Event;
22use base::RawDescriptor;
23use hypervisor::ProtectionType;
24use snapshot::AnySnapshot;
25use vm_memory::GuestMemory;
26
27#[cfg(any(target_os = "android", target_os = "linux"))]
28pub mod vhost_user;
29
30use devices::serial::sys::InStreamType;
31use devices::virtio::DeviceType;
32use devices::virtio::Interrupt;
33use devices::virtio::Queue;
34use devices::virtio::VirtioDevice;
35use devices::PciAddress;
36use devices::SerialParameters;
37#[cfg(any(target_os = "android", target_os = "linux"))]
38use devices::SerialType;
39use devices::VirtioDeviceArgs;
40use devices::VirtioDeviceModule;
41
42use crate::device::ConsoleDevice;
43use crate::device::ConsoleSnapshot;
44use crate::port::ConsolePort;
45
46const QUEUE_SIZE: u16 = 256;
47
48/// Virtio console device.
49pub struct Console {
50    console: ConsoleDevice,
51    max_queue_sizes: Vec<u16>,
52    pci_address: Option<PciAddress>,
53}
54
55impl Console {
56    fn new(
57        protection_type: ProtectionType,
58        input: Option<InStreamType>,
59        output: Option<Box<dyn std::io::Write + Send>>,
60        keep_rds: Vec<RawDescriptor>,
61        pci_address: Option<PciAddress>,
62        max_queue_sizes: Option<Vec<u16>>,
63    ) -> Console {
64        let port = ConsolePort::new(input, output, None, keep_rds);
65        let console = ConsoleDevice::new_single_port(protection_type, port);
66        let max_queue_sizes =
67            max_queue_sizes.unwrap_or_else(|| vec![QUEUE_SIZE; console.max_queues()]);
68
69        // TODO: Move these checks into cmdline validation or something so it is more user
70        // friendly when it fails.
71        assert_eq!(max_queue_sizes.len(), console.max_queues());
72        for qs in &max_queue_sizes {
73            assert!(qs.is_power_of_two());
74        }
75
76        Console {
77            console,
78            max_queue_sizes,
79            pci_address,
80        }
81    }
82}
83
84impl VirtioDevice for Console {
85    fn keep_rds(&self) -> Vec<RawDescriptor> {
86        self.console.keep_rds()
87    }
88
89    fn features(&self) -> u64 {
90        self.console.features()
91    }
92
93    fn device_type(&self) -> DeviceType {
94        DeviceType::Console
95    }
96
97    fn queue_max_sizes(&self) -> &[u16] {
98        &self.max_queue_sizes
99    }
100
101    fn read_config(&self, offset: u64, data: &mut [u8]) {
102        self.console.read_config(offset, data);
103    }
104
105    fn on_device_sandboxed(&mut self) {
106        self.console.start_input_threads();
107    }
108
109    fn activate(
110        &mut self,
111        _mem: GuestMemory,
112        _interrupt: Interrupt,
113        queues: BTreeMap<usize, Queue>,
114    ) -> anyhow::Result<()> {
115        for (idx, queue) in queues.into_iter() {
116            self.console.start_queue(idx, queue)?
117        }
118        Ok(())
119    }
120
121    fn pci_address(&self) -> Option<PciAddress> {
122        self.pci_address
123    }
124
125    fn reset(&mut self) -> anyhow::Result<()> {
126        self.console.reset()
127    }
128
129    fn virtio_sleep(&mut self) -> anyhow::Result<Option<BTreeMap<usize, Queue>>> {
130        // Stop and collect all the queues.
131        let mut queues = BTreeMap::new();
132        for idx in 0..self.console.max_queues() {
133            if let Some(queue) = self
134                .console
135                .stop_queue(idx)
136                .with_context(|| format!("failed to stop queue {idx}"))?
137            {
138                queues.insert(idx, queue);
139            }
140        }
141
142        if !queues.is_empty() {
143            Ok(Some(queues))
144        } else {
145            Ok(None)
146        }
147    }
148
149    fn virtio_wake(
150        &mut self,
151        queues_state: Option<(GuestMemory, Interrupt, BTreeMap<usize, Queue>)>,
152    ) -> anyhow::Result<()> {
153        if let Some((_mem, _interrupt, queues)) = queues_state {
154            for (idx, queue) in queues.into_iter() {
155                self.console.start_queue(idx, queue)?;
156            }
157        }
158        Ok(())
159    }
160
161    fn virtio_snapshot(&mut self) -> anyhow::Result<AnySnapshot> {
162        let snap = self.console.snapshot()?;
163        AnySnapshot::to_any(snap).context("failed to snapshot virtio console")
164    }
165
166    fn virtio_restore(&mut self, data: AnySnapshot) -> anyhow::Result<()> {
167        let snap: ConsoleSnapshot =
168            AnySnapshot::from_any(data).context("failed to deserialize virtio console")?;
169        self.console.restore(&snap)
170    }
171}
172
173#[derive(serde::Serialize, serde::Deserialize)]
174pub struct VirtioConsoleModule(pub SerialParameters);
175
176impl VirtioDeviceModule for VirtioConsoleModule {
177    fn sort_name(&self) -> &'static str {
178        "console"
179    }
180
181    fn create(&self, args: &mut VirtioDeviceArgs<'_>) -> anyhow::Result<Box<dyn VirtioDevice>> {
182        let mut keep_rds = Vec::new();
183        let evt = Event::new().context("failed to create event")?;
184        Ok(Box::new(
185            self.0
186                .create_serial_device::<Console>(args.protection_type, &evt, &mut keep_rds)
187                .context("failed to create console device")?,
188        ))
189    }
190
191    #[cfg(any(target_os = "android", target_os = "linux"))]
192    fn create_jail(
193        &self,
194        jail_config: Option<&jail::JailConfig>,
195    ) -> anyhow::Result<Option<minijail::Minijail>> {
196        let Some(jail_config) = jail_config else {
197            return Ok(None);
198        };
199        create_jail(
200            &self.0,
201            jail_config,
202            &devices::virtio::VirtioDeviceType::Regular.seccomp_policy_file("serial"),
203        )
204    }
205}
206
207#[cfg(any(target_os = "android", target_os = "linux"))]
208pub fn create_jail(
209    params: &SerialParameters,
210    jail_config: &jail::JailConfig,
211    policy: &str,
212) -> anyhow::Result<Option<minijail::Minijail>> {
213    let mut config = jail::SandboxConfig::new(jail_config, policy);
214    config.bind_mounts = true;
215    let mut jail = jail::create_sandbox_minijail(
216        &jail_config.pivot_root,
217        jail::MAX_OPEN_FILES_DEFAULT,
218        &config,
219    )?;
220    if let Some(path) = &params.path {
221        if let SerialType::SystemSerialType = params.type_ {
222            if let Some(parent) = path.as_path().parent() {
223                if parent.exists() {
224                    info!("Bind mounting dir {}", parent.display());
225                    jail.mount_bind(parent, parent, true)
226                        .context("failed to add bind mounts for console device")?;
227                }
228            }
229        }
230    }
231    Ok(Some(jail))
232}
233
234#[cfg(test)]
235mod tests {
236    #[cfg(windows)]
237    use base::windows::named_pipes;
238    use devices::suspendable_virtio_tests;
239    use tempfile::tempfile;
240
241    use super::*;
242
243    struct ConsoleContext {
244        #[cfg(windows)]
245        #[allow(dead_code)]
246        input_pipe_client: named_pipes::PipeConnection,
247    }
248
249    fn modify_device(_context: &mut ConsoleContext, b: &mut Console) {
250        let input_buffer = b.console.ports[0].clone_input_buffer();
251        input_buffer.lock().push_back(0);
252    }
253
254    #[cfg(any(target_os = "android", target_os = "linux"))]
255    fn create_device() -> (ConsoleContext, Console) {
256        let input = Box::new(tempfile().unwrap());
257        let output = Box::new(tempfile().unwrap());
258
259        let console = Console::new(
260            hypervisor::ProtectionType::Unprotected,
261            Some(input),
262            Some(output),
263            Vec::new(),
264            None,
265            None,
266        );
267
268        let context = ConsoleContext {};
269        (context, console)
270    }
271
272    #[cfg(windows)]
273    fn create_device() -> (ConsoleContext, Console) {
274        let (input_pipe_server, input_pipe_client) = named_pipes::pair(
275            &named_pipes::FramingMode::Byte,
276            &named_pipes::BlockingMode::NoWait,
277            0,
278        )
279        .unwrap();
280
281        let input = Box::new(input_pipe_server);
282        let output = Box::new(tempfile().unwrap());
283
284        let console = Console::new(
285            hypervisor::ProtectionType::Unprotected,
286            Some(input),
287            Some(output),
288            Vec::new(),
289            None,
290            None,
291        );
292
293        let context = ConsoleContext { input_pipe_client };
294
295        (context, console)
296    }
297
298    suspendable_virtio_tests!(console, create_device, 2, modify_device);
299
300    #[test]
301    fn test_inactive_sleep_resume() {
302        let (_ctx, mut device) = create_device();
303
304        let input_buffer = device.console.ports[0].clone_input_buffer();
305
306        // Initialize the device, starting the input thread, but don't activate any queues.
307        device.on_device_sandboxed();
308
309        // No queues were started, so `virtio_sleep()` should return `None`.
310        let sleep_result = device.virtio_sleep().expect("failed to sleep");
311        assert!(sleep_result.is_none());
312
313        // Inject some input data.
314        input_buffer.lock().extend(b"Hello".iter());
315
316        // Ensure snapshot does not fail and contains the buffered input data.
317        let snapshot = device.virtio_snapshot().expect("failed to snapshot");
318        let snapshot: ConsoleSnapshot =
319            AnySnapshot::from_any(snapshot).expect("failed to deserialize snapshot");
320
321        assert_eq!(snapshot.ports[0].input_buffer, b"Hello");
322
323        // Wake up the device, which should start the input thread again.
324        device.virtio_wake(None).expect("failed to wake");
325    }
326}