feat: add PS/2 keyboard interrupt driver

Cargo.toml

@@ -216,6 +216,15 @@ virtio-vsock = ["virtio"]
 ## This is only useful on PCs (x86-64).
 vga = []
 
+## Enables the PS/2 keyboard driver.
+## 
+## This feature initializes the PS/2 keyboard controller and installs a keyboard interrupt handler. 
+## It also provides a system call to receive the last scancode from the internal keyboard buffer. 
+## Note that this is not a complete keyboard driver and not needed for serial input/output.
+## It allows receiving scancodes from the PS/2 keyboard that can be used to port applications.
+## This is only useful on PCs (x86-64). 
+pc-keyboard = []   
+
 #! ### Performance Features
 
 ## Disables putting the CPU to sleep.

src/arch/x86_64/kernel/interrupts.rs

@@ -157,7 +157,16 @@ pub(crate) fn install() {
 	IRQ_NAMES.lock().insert(7, "FPU");
 }
 
-pub(crate) fn install_handlers(handlers: InterruptHandlerMap) {
+#[allow(unused_mut)]
+pub(crate) fn install_handlers(mut handlers: InterruptHandlerMap) {
+	#[cfg(feature = "pc-keyboard")]
+	{
+		use crate::arch::kernel::pc_keyboard::get_keyboard_handler;
+
+		let (irq, handler) = get_keyboard_handler();
+		handlers.entry(irq).or_default().push_back(handler);
+	}
+
 	IRQ_HANDLERS.set(handlers).unwrap();
 }
 

src/arch/x86_64/kernel/mod.rs

@@ -20,6 +20,8 @@ pub mod interrupts;
 pub mod kernel_stack;
 #[cfg(all(not(feature = "pci"), feature = "virtio"))]
 pub mod mmio;
+#[cfg(feature = "pc-keyboard")]
+pub mod pc_keyboard;
 #[cfg(feature = "pci")]
 pub mod pci;
 pub mod pic;

src/arch/x86_64/kernel/pc_keyboard.rs

@@ -0,0 +1,131 @@
+use alloc::collections::VecDeque;
+use core::num::NonZeroU8;
+
+use hermit_sync::{InterruptTicketMutex, Lazy};
+use x86_64::instructions::port::Port;
+
+use crate::arch::kernel::interrupts;
+use crate::synch::semaphore::Semaphore;
+
+const PS2_DATA_PORT: u16 = 0x60;
+const PS2_CMD_PORT: u16 = 0x64;
+
+#[repr(u8)]
+enum Ps2Command {
+	ReadConfig = 0x20,
+	WriteConfig = 0x60,
+	DisableKeyboard = 0xad,
+	DisableMouse = 0xa7,
+	EnableKeyboard = 0xae,
+	#[allow(dead_code)]
+	EnableMouse = 0xa8,
+	TestFirstPort = 0xab,
+}
+
+const PS2_CNFG_ENABLE_KEYBOARD_INTERRUPT: u8 = 0x01;
+const PS2_BUFFER_FULL: u8 = 0x01;
+
+const MAX_INP_BUFFER_SIZE: usize = 256;
+static KEYBOARD_SEMAPHORE: Semaphore = Semaphore::new(0);
+
+struct Ps2;
+impl Ps2 {
+	pub fn read_status() -> u8 {
+		// SAFETY: Correct port access without safety related side-effects.
+		unsafe { Port::<u8>::new(PS2_CMD_PORT).read() }
+	}
+
+	pub fn write_cmd(cmd: Ps2Command) {
+		// SAFETY: Correct port access without memory safety related side-effects.
+		unsafe { Port::<u8>::new(PS2_CMD_PORT).write(cmd as u8) }
+	}
+
+	pub fn read_data() -> u8 {
+		// SAFETY: Correct port access without safety related side-effects.
+		unsafe { Port::<u8>::new(PS2_DATA_PORT).read() }
+	}
+
+	pub fn write_data(data: u8) {
+		// SAFETY: Correct port access without memory safety related side-effects.
+		unsafe { Port::<u8>::new(PS2_DATA_PORT).write(data) }
+	}
+}
+
+static KEYBOARD_BUFFER: Lazy<InterruptTicketMutex<VecDeque<NonZeroU8>>> =
+	Lazy::new(|| InterruptTicketMutex::new(VecDeque::with_capacity(32)));
+
+fn keyboard_handler() {
+	let scancode = Ps2::read_data();
+	if let Some(valid_scancode) = NonZeroU8::new(scancode) {
+		{
+			let mut buffer = KEYBOARD_BUFFER.lock();
+
+			// Pop the oldest scancode if the buffer is full.
+			if buffer.len() >= MAX_INP_BUFFER_SIZE {
+				buffer.pop_front();
+				buffer.push_back(valid_scancode);
+				return;
+			}
+			buffer.push_back(valid_scancode);
+		}
+		KEYBOARD_SEMAPHORE.release();
+	}
+}
+
+pub(crate) fn get_keyboard_handler() -> (u8, fn()) {
+	Ps2::write_cmd(Ps2Command::DisableKeyboard);
+	Ps2::write_cmd(Ps2Command::DisableMouse);
+
+	// Ensure an empty buffer to guard against stuck/garbage data
+	while (Ps2::read_status() & PS2_BUFFER_FULL) != 0 {
+		let _ = Ps2::read_data();
+	}
+
+	Ps2::write_cmd(Ps2Command::ReadConfig);
+	let mut config = Ps2::read_data();
+
+	config |= PS2_CNFG_ENABLE_KEYBOARD_INTERRUPT;
+
+	Ps2::write_cmd(Ps2Command::WriteConfig);
+	Ps2::write_data(config);
+
+	Ps2::write_cmd(Ps2Command::TestFirstPort);
+
+	if Ps2::read_data() != 0 {
+		error!("PS/2 keyboard test failed");
+	}
+
+	Ps2::write_cmd(Ps2Command::EnableKeyboard);
+
+	// Force the initialization of the keyboard buffer to ensure it is ready before any interrupts occur.
+	Lazy::force(&KEYBOARD_BUFFER);
+
+	interrupts::add_irq_name(1, "PS/2 Keyboard");
+
+	(1, keyboard_handler)
+}
+
+/// Pops scancodes from the keyboard buffer into the provided slice. If `nonblocking` is false, the
+/// function will sleep the current thread until a scancode has been received. Returns the number of scancodes
+/// popped into the slice.
+pub fn pop_scancodes(slice: &mut [u8], nonblocking: bool) -> usize {
+	if slice.is_empty() {
+		return 0;
+	}
+	if nonblocking {
+		if !KEYBOARD_SEMAPHORE.try_acquire() {
+			return 0;
+		}
+	} else {
+		KEYBOARD_SEMAPHORE.acquire(None);
+	}
+	let mut amount: usize = 1;
+	while amount < slice.len() && KEYBOARD_SEMAPHORE.try_acquire() {
+		amount += 1;
+	}
+	let mut buffer = KEYBOARD_BUFFER.lock();
+	for scancode in slice[..amount].iter_mut() {
+		*scancode = buffer.pop_front().unwrap().get();
+	}
+	amount
+}

src/syscalls/system.rs

@@ -6,3 +6,29 @@ use crate::arch::mm::paging::{BasePageSize, PageSize};
 pub extern "C" fn sys_getpagesize() -> i32 {
 	BasePageSize::SIZE.try_into().unwrap()
 }
+
+// Writes the scancodes from the keyboard buffer into the provided buffer.
+// If 'nonblock' is true, it will return immediately if there are no scancodes available,
+// otherwise it will block until at least one scancode is available.
+// Returns the number of bytes written to the buffer,
+// or a negative error code on failure.
+#[cfg(all(target_arch = "x86_64", feature = "pc-keyboard"))]
+#[hermit_macro::system]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn sys_read_keyboard(buffer: *mut u8, size: usize, nonblock: bool) -> isize {
+	if buffer.is_null() {
+		return -(crate::errno::Errno::Fault as isize);
+	}
+	if size == 0 {
+		return 0;
+	}
+	// SAFETY: We have to trust the user input, because we are a unikernel and if the user wants to crash the program
+	// they are free to do so.
+	let buffer_slice: &mut [u8] = unsafe { core::slice::from_raw_parts_mut(buffer, size) };
+	let result = crate::arch::kernel::pc_keyboard::pop_scancodes(buffer_slice, nonblock);
+	if result == 0 && nonblock {
+		-(crate::errno::Errno::Again as isize)
+	} else {
+		result as isize
+	}
+}