uhyve 0.8.0

A specialized hypervisor for Hermit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Serial output functionality
use std::{
	fs::{File, OpenOptions},
	io::{self, Write},
	sync::{Arc, Mutex},
};

use crate::{HypervisorResult, params};

/// The destination of the kernels serial output.
#[derive(Clone, Debug, Default)]
pub enum Destination {
	/// Same IO as the Uhyve process.
	#[default]
	StdIo,
	/// Redirect output to a file.
	File(Arc<Mutex<File>>),
	/// Redirect output to a buffer.
	Buffer(Arc<Mutex<Vec<u8>>>),
	/// Ignore all serial output.
	None,
}

/// Handles serial output functionality.
#[derive(Debug, Clone)]
pub(crate) struct UhyveSerial {
	pub(crate) destination: Destination,
}
impl UhyveSerial {
	pub fn from_params(params: &params::Output) -> HypervisorResult<Self> {
		Ok(Self {
			destination: match params {
				params::Output::None => Destination::None,
				params::Output::StdIo => Destination::StdIo,
				params::Output::Buffer => {
					Destination::Buffer(Arc::new(Mutex::new(Vec::with_capacity(8096))))
				}
				params::Output::File(path) => {
					let f = OpenOptions::new()
						.read(false)
						.write(true)
						.create_new(true)
						.open(path)
						.map_err(|e| {
							error!("Cant create kernel output file: {e}");
							e
						})?;
					Destination::File(Arc::new(Mutex::new(f)))
				}
			},
		})
	}

	/// Output a utf8 buffer to the configured output destination.
	pub fn output(&self, buf: &[u8]) -> io::Result<()> {
		match &self.destination {
			Destination::StdIo => io::stdout().write_all(buf),
			Destination::None => Ok(()),
			Destination::Buffer(b) => {
				b.lock().unwrap().extend_from_slice(buf);
				Ok(())
			}
			Destination::File(f) => f.lock().unwrap().write_all(buf),
		}
	}
}