revise serial device

Moving interface partly to the platform independent part and detect on
supported architectures the virtio interface.

Author: stlankes

src/arch/aarch64/kernel/mmio.rs

@@ -10,7 +10,11 @@ use volatile::VolatileRef;
 use crate::arch::aarch64::kernel::interrupts::GIC;
 use crate::arch::aarch64::mm::paging::{self, PageSize};
 #[cfg(feature = "console")]
+use crate::console::IoDevice;
+#[cfg(feature = "console")]
 use crate::drivers::console::VirtioConsoleDriver;
+#[cfg(feature = "console")]
+use crate::drivers::console::VirtioUART;
 #[cfg(any(feature = "tcp", feature = "udp"))]
 use crate::drivers::net::virtio::VirtioNetDriver;
 use crate::drivers::virtio::transport::mmio::{self as mmio_virtio, VirtioDriver};
@@ -237,8 +241,7 @@ pub fn init_drivers() {
 			info!("Switch to virtio console");
 			crate::console::CONSOLE
 				.lock()
-				.inner
-				.switch_to_virtio_console();
+				.replace_device(IoDevice::Virtio(VirtioUART::new()));
 		}
 	}
 }

src/arch/aarch64/kernel/mod.rs

@@ -18,65 +18,15 @@ pub mod systemtime;
 use alloc::alloc::{Layout, alloc};
 use core::arch::global_asm;
 use core::sync::atomic::{AtomicPtr, AtomicU32, Ordering};
-use core::task::Waker;
 use core::{ptr, str};
 
 use memory_addresses::arch::aarch64::{PhysAddr, VirtAddr};
 
 use crate::arch::aarch64::kernel::core_local::*;
-use crate::arch::aarch64::kernel::serial::SerialPort;
 use crate::arch::aarch64::mm::paging::{BasePageSize, PageSize};
 use crate::config::*;
 use crate::env;
 
-const SERIAL_PORT_BAUDRATE: u32 = 115_200;
-
-pub(crate) struct Console {
-	serial_port: SerialPort,
-}
-
-impl Console {
-	pub fn new() -> Self {
-		CoreLocal::install();
-
-		let base = env::boot_info()
-			.hardware_info
-			.serial_port_base
-			.map(|uartport| uartport.get());
-
-		let serial_port = SerialPort::new(base);
-
-		serial_port.init(SERIAL_PORT_BAUDRATE);
-
-		Self { serial_port }
-	}
-
-	pub fn write(&mut self, buf: &[u8]) {
-		self.serial_port.write_buf(buf);
-	}
-
-	pub fn read(&mut self) -> Option<u8> {
-		None
-	}
-
-	pub fn is_empty(&self) -> bool {
-		true
-	}
-
-	#[cfg(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) {}
-}
-
-impl Default for Console {
-	fn default() -> Self {
-		Self::new()
-	}
-}
-
 #[repr(align(8))]
 pub(crate) struct AlignedAtomicU32(AtomicU32);
 

src/arch/aarch64/kernel/serial.rs

@@ -1,88 +1,52 @@
 use core::arch::asm;
+use core::mem::MaybeUninit;
 
-#[cfg(all(feature = "pci", feature = "console"))]
-use crate::drivers::pci::get_console_driver;
-#[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(feature = "console")]
-	Virtio,
-}
-
-pub struct SerialPort {
-	inner: SerialInner,
+pub(crate) struct SerialDevice {
+	pub addr: u32,
 }
 
-impl SerialPort {
-	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::None,
-			}
-		}
-	}
+impl SerialDevice {
+	pub fn new() -> Self {
+		let base = crate::env::boot_info()
+			.hardware_info
+			.serial_port_base
+			.map(|uartport| uartport.get())
+			.unwrap();
 
-	#[cfg(feature = "console")]
-	pub fn switch_to_virtio_console(&mut self) {
-		self.inner = SerialInner::Virtio;
+		Self { addr: base as u32 }
 	}
 
-	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);
-			}
-			SerialInner::Uart(port_address) => {
-				let port = core::ptr::with_exposed_provenance_mut::<u8>(*port_address as usize);
-				for &byte in buf {
-					// LF newline characters need to be extended to CRLF over a real serial port.
-					if byte == b'\n' {
-						unsafe {
-							asm!(
-								"strb w8, [{port}]",
-								port = in(reg) port,
-								in("x8") b'\r',
-								options(nostack),
-							);
-						}
-					}
-
-					unsafe {
-						asm!(
-							"strb w8, [{port}]",
-							port = in(reg) port,
-							in("x8") byte,
-							options(nostack),
-						);
-					}
+	pub fn write(&self, buf: &[u8]) {
+		let port = core::ptr::with_exposed_provenance_mut::<u8>(self.addr as usize);
+		for &byte in buf {
+			// LF newline characters need to be extended to CRLF over a real serial port.
+			if byte == b'\n' {
+				unsafe {
+					asm!(
+						"strb w8, [{port}]",
+						port = in(reg) port,
+						in("x8") b'\r',
+						options(nostack),
+					);
 				}
 			}
-			#[cfg(feature = "console")]
-			SerialInner::Virtio => {
-				if let Some(console_driver) = get_console_driver() {
-					let _ = console_driver.lock().write(buf);
-				}
+
+			unsafe {
+				asm!(
+					"strb w8, [{port}]",
+					port = in(reg) port,
+					in("x8") byte,
+					options(nostack),
+				);
 			}
 		}
 	}
 
-	pub fn init(&self, _baudrate: u32) {
-		// We don't do anything here (yet).
+	pub fn read(&self, _buf: &mut [MaybeUninit<u8>]) -> crate::io::Result<usize> {
+		Ok(0)
+	}
+
+	pub fn can_read(&self) -> bool {
+		false
 	}
 }

src/arch/mod.rs

@@ -13,6 +13,7 @@ cfg_if::cfg_if! {
 		#[cfg(feature = "pci")]
 		pub(crate) use self::aarch64::kernel::pci;
 		pub(crate) use self::aarch64::kernel::processor;
+		pub(crate) use self::aarch64::kernel::serial::SerialDevice;
 		pub(crate) use self::aarch64::kernel::processor::set_oneshot_timer;
 		pub(crate) use self::aarch64::kernel::scheduler;
 		#[cfg(not(feature = "common-os"))]
@@ -39,6 +40,7 @@ cfg_if::cfg_if! {
 		#[cfg(feature = "pci")]
 		pub(crate) use self::x86_64::kernel::pci;
 		pub(crate) use self::x86_64::kernel::processor;
+		pub(crate) use self::x86_64::kernel::serial::SerialDevice;
 		pub(crate) use self::x86_64::kernel::scheduler;
 		pub(crate) use self::x86_64::kernel::switch;
 		#[cfg(target_os = "none")]
@@ -60,6 +62,7 @@ cfg_if::cfg_if! {
 		#[cfg(feature = "pci")]
 		pub(crate) use self::riscv64::kernel::pci;
 		pub(crate) use self::riscv64::kernel::processor::{self, set_oneshot_timer, wakeup_core};
+		pub(crate) use self::riscv64::kernel::serial::SerialDevice;
 		pub(crate) use self::riscv64::kernel::{
 			boot_processor_init,
 			core_local,

src/arch/riscv64/kernel/devicetree.rs

@@ -1,39 +1,62 @@
 #![allow(dead_code)]
 
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "pci")))]
+#[cfg(all(
+	any(feature = "tcp", feature = "udp", feature = "console"),
+	not(feature = "pci")
+))]
 use core::ptr::NonNull;
 
 use fdt::Fdt;
 use memory_addresses::PhysAddr;
 #[cfg(all(
-	any(feature = "tcp", feature = "udp"),
+	any(feature = "tcp", feature = "udp", feature = "console"),
 	feature = "gem-net",
 	not(feature = "pci")
 ))]
 use memory_addresses::VirtAddr;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "pci")))]
+#[cfg(all(
+	any(feature = "tcp", feature = "udp", feature = "console"),
+	not(feature = "pci")
+))]
 use virtio::mmio::{DeviceRegisters, DeviceRegistersVolatileFieldAccess};
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "pci")))]
+#[cfg(all(
+	any(feature = "tcp", feature = "udp", feature = "console"),
+	not(feature = "pci")
+))]
 use volatile::VolatileRef;
 
 use crate::arch::riscv64::kernel::get_dtb_ptr;
 use crate::arch::riscv64::kernel::interrupts::init_plic;
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "pci")))]
+#[cfg(all(
+	any(feature = "tcp", feature = "udp", feature = "console"),
+	not(feature = "pci")
+))]
 use crate::arch::riscv64::kernel::mmio::MmioDriver;
 use crate::arch::riscv64::mm::paging::{self, PageSize};
+#[cfg(feature = "console")]
+use crate::console::IoDevice;
+#[cfg(feature = "console")]
+use crate::drivers::console::VirtioUART;
+#[cfg(all(feature = "console", not(feature = "pci")))]
+use crate::drivers::mmio::get_console_driver;
 #[cfg(all(
 	any(feature = "tcp", feature = "udp"),
 	feature = "gem-net",
 	not(feature = "pci")
 ))]
 use crate::drivers::net::gem;
+#[cfg(all(feature = "console", feature = "pci"))]
+use crate::drivers::pci::get_console_driver;
 #[cfg(all(
-	any(feature = "tcp", feature = "udp"),
+	any(feature = "tcp", feature = "udp", feature = "console"),
 	not(feature = "pci"),
 	not(feature = "gem-net")
 ))]
 use crate::drivers::virtio::transport::mmio::{self as mmio_virtio, VirtioDriver};
-#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "pci")))]
+#[cfg(all(
+	any(feature = "tcp", feature = "udp", feature = "console"),
+	not(feature = "pci")
+))]
 use crate::kernel::mmio::register_driver;
 
 static mut PLATFORM_MODEL: Model = Model::Unknown;
@@ -172,7 +195,10 @@ pub fn init_drivers() {
 			}
 
 			// Init virtio-mmio
-			#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "pci")))]
+			#[cfg(all(
+				any(feature = "tcp", feature = "udp", feature = "console"),
+				not(feature = "pci")
+			))]
 			if let Some(virtio_node) = fdt.find_compatible(&["virtio,mmio"]) {
 				debug!("Found virtio mmio device");
 				let virtio_region = virtio_node
@@ -218,31 +244,57 @@ 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 {
-					debug!("It's not a network card at {mmio:p}");
-					return;
-				}
-
-				info!("Found network card at {mmio:p}");
-
 				// crate::mm::physicalmem::reserve(
 				// 	PhysAddr::from(current_address.align_down(BasePageSize::SIZE as usize)),
 				// 	BasePageSize::SIZE as usize,
 				// );
 
-				#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "gem-net")))]
-				if let Ok(VirtioDriver::Network(drv)) =
-					mmio_virtio::init_device(mmio, irq.try_into().unwrap())
-				{
-					register_driver(MmioDriver::VirtioNet(hermit_sync::InterruptSpinMutex::new(
-						drv,
-					)));
+				match id {
+					#[cfg(all(any(feature = "tcp", feature = "udp"), not(feature = "gem-net")))]
+					virtio::Id::Net => {
+						debug!("Found virtio network card at {mmio:p}");
+
+						if let Ok(VirtioDriver::Network(drv)) =
+							mmio_virtio::init_device(mmio, irq.try_into().unwrap())
+						{
+							register_driver(MmioDriver::VirtioNet(
+								hermit_sync::InterruptSpinMutex::new(drv),
+							));
+						}
+					}
+					#[cfg(feature = "console")]
+					virtio::Id::Console => {
+						debug!("Found virtio console at {mmio:p}");
+
+						if let Ok(VirtioDriver::Console(drv)) =
+							mmio_virtio::init_device(mmio, irq.try_into().unwrap())
+						{
+							register_driver(MmioDriver::VirtioConsole(
+								hermit_sync::InterruptSpinMutex::new(*drv),
+							));
+						}
+					}
+					_ => {
+						warn!("Found unknown virtio device with ID {id:?} at {mmio:p}");
+					}
 				}
 			}
 		}
 	}
 
-	#[cfg(all(feature = "tcp", not(feature = "pci")))]
+	#[cfg(all(
+		any(feature = "tcp", feature = "udp", feature = "console"),
+		not(feature = "pci")
+	))]
 	super::mmio::MMIO_DRIVERS.finalize();
+
+	#[cfg(feature = "console")]
+	{
+		if get_console_driver().is_some() {
+			info!("Switch to virtio console");
+			crate::console::CONSOLE
+				.lock()
+				.replace_device(IoDevice::Virtio(VirtioUART::new()));
+		}
+	}
 }