1pub 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
48pub 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 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 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) = ¶ms.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 device.on_device_sandboxed();
308
309 let sleep_result = device.virtio_sleep().expect("failed to sleep");
311 assert!(sleep_result.is_none());
312
313 input_buffer.lock().extend(b"Hello".iter());
315
316 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 device.virtio_wake(None).expect("failed to wake");
325 }
326}