add support of virtio console according to the VirtIO standard

During runtime the kernel checks, if a virtio console device is
available, initialize this device and use it to print kernel
messages.

A device support at the early stage of the boot process is currently
not possible.

Author: stlankes

Cargo.toml

@@ -69,6 +69,7 @@ trace = []
 udp = ["smoltcp", "smoltcp/socket-udp"]
 vga = []
 vsock = ["pci"]
+console = []
 
 [lints.rust]
 rust_2018_idioms = "warn"

src/arch/aarch64/kernel/mmio.rs

@@ -7,6 +7,9 @@ use virtio::mmio::{DeviceRegisters, DeviceRegistersVolatileFieldAccess};
 use volatile::VolatileRef;
 
 use crate::arch::aarch64::mm::paging::{self, PageSize};
+#[cfg(feature = "console")]
+use crate::drivers::console::VirtioConsoleDriver;
+#[cfg(any(feature = "tcp", feature = "udp"))]
 use crate::drivers::net::virtio::VirtioNetDriver;
 use crate::drivers::virtio::transport::mmio::{self as mmio_virtio, VirtioDriver};
 use crate::init_cell::InitCell;
@@ -17,13 +20,26 @@ pub(crate) static MMIO_DRIVERS: InitCell<Vec<MmioDriver>> = InitCell::new(Vec::n
 pub(crate) enum MmioDriver {
 	#[cfg(any(feature = "tcp", feature = "udp"))]
 	VirtioNet(InterruptTicketMutex<VirtioNetDriver>),
+	#[cfg(feature = "console")]
+	VirtioConsole(InterruptTicketMutex<VirtioConsoleDriver>),
 }
 
 impl MmioDriver {
 	#[cfg(any(feature = "tcp", feature = "udp"))]
 	fn get_network_driver(&self) -> Option<&InterruptTicketMutex<VirtioNetDriver>> {
 		match self {
 			Self::VirtioNet(drv) => Some(drv),
+			#[cfg(feature = "console")]
+			_ => None,
+		}
+	}
+
+	#[cfg(feature = "console")]
+	fn get_console_driver(&self) -> Option<&InterruptTicketMutex<VirtioConsoleDriver>> {
+		match self {
+			Self::VirtioConsole(drv) => Some(drv),
+			#[cfg(any(feature = "tcp", feature = "udp"))]
+			_ => None,
 		}
 	}
 }
@@ -40,6 +56,14 @@ pub(crate) fn get_network_driver() -> Option<&'static InterruptTicketMutex<Virti
 		.find_map(|drv| drv.get_network_driver())
 }
 
+#[cfg(feature = "console")]
+pub(crate) fn get_console_driver() -> Option<&'static InterruptTicketMutex<VirtioConsoleDriver>> {
+	MMIO_DRIVERS
+		.get()?
+		.iter()
+		.find_map(|drv| drv.get_console_driver())
+}
+
 pub fn init_drivers() {
 	without_interrupts(|| {
 		if let Some(fdt) = crate::env::fdt() {
@@ -96,16 +120,30 @@ pub fn init_drivers() {
 							// Verify the device-ID to find the network card
 							let id = mmio.as_ptr().device_id().read();
 
-							#[cfg(any(feature = "tcp", feature = "udp"))]
-							if id == virtio::Id::Net {
-								trace!("Found network card at {mmio:p}, irq: {irq}");
-								if let Ok(VirtioDriver::Network(drv)) =
-									mmio_virtio::init_device(mmio, irq.try_into().unwrap())
-								{
-									register_driver(MmioDriver::VirtioNet(
-										hermit_sync::InterruptTicketMutex::new(drv),
-									));
+							match id {
+								#[cfg(any(feature = "tcp", feature = "udp"))]
+								virtio::Id::Net => {
+									trace!("Found network card at {mmio:p}, irq: {irq}");
+									if let Ok(VirtioDriver::Network(drv)) =
+										mmio_virtio::init_device(mmio, irq.try_into().unwrap())
+									{
+										register_driver(MmioDriver::VirtioNet(
+											hermit_sync::InterruptTicketMutex::new(drv),
+										));
+									}
+								}
+								#[cfg(feature = "console")]
+								virtio::Id::Console => {
+									info!("Found console at {mmio:p}, irq: {irq}");
+									if let Ok(VirtioDriver::Console(drv)) =
+										mmio_virtio::init_device(mmio, irq.try_into().unwrap())
+									{
+										register_driver(MmioDriver::VirtioConsole(
+											hermit_sync::InterruptTicketMutex::new(*drv),
+										));
+									}
 								}
+								_ => {}
 							}
 						}
 					}
@@ -117,4 +155,15 @@ pub fn init_drivers() {
 	});
 
 	MMIO_DRIVERS.finalize();
+
+	#[cfg(feature = "console")]
+	{
+		if get_console_driver().is_some() {
+			info!("Switch to virtio console");
+			crate::console::CONSOLE
+				.lock()
+				.inner
+				.switch_to_virtio_console();
+		}
+	}
 }

src/arch/aarch64/kernel/mod.rs

@@ -1,6 +1,9 @@
 pub mod core_local;
 pub mod interrupts;
-#[cfg(all(not(feature = "pci"), any(feature = "tcp", feature = "udp")))]
+#[cfg(all(
+	not(feature = "pci"),
+	any(feature = "tcp", feature = "udp", feature = "console")
+))]
 pub mod mmio;
 #[cfg(feature = "pci")]
 pub mod pci;
@@ -39,10 +42,7 @@ impl Console {
 		let base = env::boot_info()
 			.hardware_info
 			.serial_port_base
-			.map(|uartport| uartport.get())
-			.unwrap_or_default()
-			.try_into()
-			.unwrap();
+			.map(|uartport| uartport.get());
 
 		let serial_port = SerialPort::new(base);
 
@@ -63,6 +63,11 @@ impl Console {
 		true
 	}
 
+	#[cfg(all(not(feature = "pci"), feature = "console"))]
+	pub fn switch_to_virtio_console(&mut self) {
+		self.serial_port.switch_to_virtio_console();
+	}
+
 	pub fn register_waker(&mut self, _waker: &Waker) {}
 }
 

src/arch/aarch64/kernel/serial.rs

@@ -1,31 +1,48 @@
 use core::arch::asm;
 
+#[cfg(all(not(feature = "pci"), feature = "console"))]
+use crate::kernel::mmio::get_console_driver;
 use crate::syscalls::interfaces::serial_buf_hypercall;
 
 enum SerialInner {
+	None,
 	Uart(u32),
 	Uhyve,
+	#[cfg(all(not(feature = "pci"), feature = "console"))]
+	Virtio,
 }
 
 pub struct SerialPort {
 	inner: SerialInner,
 }
 
 impl SerialPort {
-	pub fn new(port_address: u32) -> Self {
+	pub fn new(port_address: Option<u64>) -> Self {
 		if crate::env::is_uhyve() {
 			Self {
 				inner: SerialInner::Uhyve,
 			}
+		} else if let Some(port_address) = port_address {
+			Self {
+				inner: SerialInner::Uart(port_address.try_into().unwrap()),
+			}
 		} else {
 			Self {
-				inner: SerialInner::Uart(port_address),
+				inner: SerialInner::None,
 			}
 		}
 	}
 
+	#[cfg(all(not(feature = "pci"), feature = "console"))]
+	pub fn switch_to_virtio_console(&mut self) {
+		self.inner = SerialInner::Virtio;
+	}
+
 	pub fn write_buf(&mut self, buf: &[u8]) {
 		match &mut self.inner {
+			SerialInner::None => {
+				// No serial port configured, do nothing.
+			}
 			SerialInner::Uhyve => {
 				serial_buf_hypercall(buf);
 			}
@@ -54,6 +71,12 @@ impl SerialPort {
 					}
 				}
 			}
+			#[cfg(all(not(feature = "pci"), feature = "console"))]
+			SerialInner::Virtio => {
+				if let Some(console_driver) = get_console_driver() {
+					let _ = console_driver.lock().write(buf);
+				}
+			}
 		}
 	}
 

src/arch/x86_64/kernel/mod.rs

@@ -79,6 +79,11 @@ impl Console {
 	pub fn register_waker(&mut self, waker: &Waker) {
 		self.serial_port.register_waker(waker);
 	}
+
+	#[cfg(all(feature = "pci", feature = "console"))]
+	pub fn switch_to_virtio_console(&mut self) {
+		self.serial_port.switch_to_virtio_console();
+	}
 }
 
 impl Default for Console {

src/arch/x86_64/kernel/serial.rs

@@ -4,6 +4,8 @@ use core::task::Waker;
 use crate::arch::x86_64::kernel::apic;
 use crate::arch::x86_64::kernel::core_local::increment_irq_counter;
 use crate::arch::x86_64::kernel::interrupts::{self, IDT};
+#[cfg(all(feature = "pci", feature = "console"))]
+use crate::drivers::pci::get_console_driver;
 use crate::executor::WakerRegistration;
 use crate::syscalls::interfaces::serial_buf_hypercall;
 
@@ -12,6 +14,8 @@ const SERIAL_IRQ: u8 = 36;
 enum SerialInner {
 	Uart(uart_16550::SerialPort),
 	Uhyve,
+	#[cfg(all(feature = "console", feature = "pci"))]
+	Virtio,
 }
 
 pub struct SerialPort {
@@ -71,8 +75,19 @@ impl SerialPort {
 					s.send(data);
 				}
 			}
+			#[cfg(all(feature = "console", feature = "pci"))]
+			SerialInner::Virtio => {
+				if let Some(console_driver) = get_console_driver() {
+					let _ = console_driver.lock().write(buf);
+				}
+			}
 		}
 	}
+
+	#[cfg(all(feature = "pci", feature = "console"))]
+	pub fn switch_to_virtio_console(&mut self) {
+		self.inner = SerialInner::Virtio;
+	}
 }
 
 extern "x86-interrupt" fn serial_interrupt(_stack_frame: crate::interrupts::ExceptionStackFrame) {

src/config.rs

@@ -7,7 +7,8 @@ pub(crate) const USER_STACK_SIZE: usize = 0x0010_0000;
 #[cfg(any(
 	all(any(feature = "tcp", feature = "udp"), not(feature = "rtl8139")),
 	feature = "fuse",
-	feature = "vsock"
+	feature = "vsock",
+	feature = "console"
 ))]
 pub(crate) const VIRTIO_MAX_QUEUE_SIZE: u16 = if cfg!(feature = "pci") { 2048 } else { 1024 };
 
@@ -17,3 +18,6 @@ pub(crate) const DEFAULT_KEEP_ALIVE_INTERVAL: u64 = 75000;
 
 #[cfg(feature = "vsock")]
 pub(crate) const VSOCK_PACKET_SIZE: u32 = 8192;
+
+#[cfg(feature = "console")]
+pub(crate) const CONSOLE_PACKET_SIZE: u32 = 1024;

src/drivers/console/mmio.rs

@@ -0,0 +1,65 @@
+//! A module containing a virtio console driver.
+//!
+//! The module contains ...
+
+use virtio::console::Config;
+use virtio::mmio::{DeviceRegisters, DeviceRegistersVolatileFieldAccess};
+use volatile::VolatileRef;
+
+use crate::drivers::InterruptLine;
+use crate::drivers::console::{ConsoleDevCfg, RxQueue, TxQueue, VirtioConsoleDriver};
+use crate::drivers::virtio::error::VirtioError;
+use crate::drivers::virtio::transport::mmio::{ComCfg, IsrStatus, NotifCfg};
+
+// Backend-dependent interface for Virtio console driver
+impl VirtioConsoleDriver {
+	pub fn new(
+		dev_id: u16,
+		mut registers: VolatileRef<'static, DeviceRegisters>,
+		irq: InterruptLine,
+	) -> Result<VirtioConsoleDriver, VirtioError> {
+		let dev_cfg_raw: &'static Config = unsafe {
+			&*registers
+				.borrow_mut()
+				.as_mut_ptr()
+				.config()
+				.as_raw_ptr()
+				.cast::<Config>()
+				.as_ptr()
+		};
+		let dev_cfg_raw = VolatileRef::from_ref(dev_cfg_raw);
+		let dev_cfg = ConsoleDevCfg {
+			raw: dev_cfg_raw,
+			dev_id,
+			features: virtio::console::F::empty(),
+		};
+		let isr_stat = IsrStatus::new(registers.borrow_mut());
+		let notif_cfg = NotifCfg::new(registers.borrow_mut());
+
+		Ok(VirtioConsoleDriver {
+			dev_cfg,
+			com_cfg: ComCfg::new(registers, 1),
+			isr_stat,
+			notif_cfg,
+			irq,
+			recv_vq: RxQueue::new(),
+			send_vq: TxQueue::new(),
+		})
+	}
+
+	/// Initializes virtio console device by mapping configuration layout to
+	/// respective structs (configuration structs are:
+	///
+	/// Returns a driver instance of
+	/// [VirtioConsoleDriver](structs.virtionetdriver.html) or an [VirtioError](enums.virtioerror.html).
+	pub fn init(
+		dev_id: u16,
+		registers: VolatileRef<'static, DeviceRegisters>,
+		irq: InterruptLine,
+	) -> Result<VirtioConsoleDriver, VirtioError> {
+		let mut drv = VirtioConsoleDriver::new(dev_id, registers, irq)?;
+		drv.init_dev()
+			.map_err(|error_code| VirtioError::ConsoleDriver(error_code))?;
+		Ok(drv)
+	}
+}