refactor: systemcall inspired by linux design

Author: Andreas Wessing

src/arch/x86_64/kernel/pc_keyboard.rs

@@ -1,10 +1,11 @@
 use alloc::collections::VecDeque;
-use core::num::NonZero;
+use core::num::NonZeroU8;
 
 use hermit_sync::{InterruptTicketMutex, Lazy};
 use x86_64::instructions::port::Port;
 
 use crate::kernel::interrupts;
+use crate::synch::semaphore::Semaphore;
 
 const PS2_DATA_PORT: u16 = 0x60;
 const PS2_CMD_PORT: u16 = 0x64;
@@ -13,10 +14,13 @@ const PS2_CMD_WRITE_CNFG: u8 = 0x60;
 const PS2_CMD_DISABLE_KEYBOARD: u8 = 0xad;
 const PS2_CMD_DISABLE_MOUSE: u8 = 0xa7;
 const PS2_CMD_ENABLE_KEYBOARD: u8 = 0xae;
+#[allow(dead_code)]
+const PS2_CMD_ENABLE_MOUSE: u8 = 0xa8;
 const PS2_CNFG_ENABLE_KEYBOARD_INTERRUPT: u8 = 0x01;
 const PS2_BUFFER_FULL: u8 = 0x01;
 
 const BUFFER_SIZE: usize = 256;
+static KEYBOARD_SEMAPHORE: Semaphore = Semaphore::new(0);
 
 struct Ps2;
 impl Ps2 {
@@ -37,26 +41,34 @@ impl Ps2 {
 	}
 }
 
-static KEYBOARD_BUFFER: Lazy<InterruptTicketMutex<VecDeque<u8>>> =
+static KEYBOARD_BUFFER: Lazy<InterruptTicketMutex<VecDeque<NonZeroU8>>> =
 	Lazy::new(|| InterruptTicketMutex::new(VecDeque::with_capacity(BUFFER_SIZE)));
 
 fn keyboard_handler() {
 	let scancode = Ps2::read_data();
-	let mut buffer = KEYBOARD_BUFFER.lock();
-
-	// Don't allow the buffer to grow infinitely, pop the oldest scancode if the buffer is full.
-	if buffer.len() >= BUFFER_SIZE {
-		buffer.pop_front();
+	if let Some(valid_scancode) = NonZeroU8::new(scancode) {
+		let mut sem = true;
+		{
+			let mut buffer = KEYBOARD_BUFFER.lock();
+
+			// Pop the oldest scancode if the buffer is full.
+			if buffer.len() >= BUFFER_SIZE {
+				buffer.pop_front();
+				sem = false;
+			}
+			buffer.push_back(valid_scancode);
+		}
+		if sem {
+			KEYBOARD_SEMAPHORE.release();
+		}
 	}
-
-	buffer.push_back(scancode);
 }
 
 pub(crate) fn get_keyboard_handler() -> (u8, fn()) {
 	Ps2::write_cmd(PS2_CMD_DISABLE_KEYBOARD);
 	Ps2::write_cmd(PS2_CMD_DISABLE_MOUSE);
 
-	// Ensure an empty buffer to guard against stuck data
+	// Ensure an empty buffer to guard against stuck/garbage data
 	while (Ps2::read_status() & PS2_BUFFER_FULL) != 0 {
 		let _ = Ps2::read_data();
 	}
@@ -79,7 +91,27 @@ pub(crate) fn get_keyboard_handler() -> (u8, fn()) {
 	(1, keyboard_handler)
 }
 
-/// Pops a scancode from the keyboard buffer, returning None if the buffer is empty.
-pub fn pop_scancode() -> Option<NonZero<u8>> {
-	KEYBOARD_BUFFER.lock().pop_front()
+/// 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

@@ -1,4 +1,5 @@
 use crate::arch::mm::paging::{BasePageSize, PageSize};
+use crate::errno::Errno;
 
 /// Returns the base page size, in bytes, of the current system.
 #[hermit_macro::system]
@@ -10,6 +11,18 @@ pub extern "C" fn sys_getpagesize() -> i32 {
 #[cfg(all(target_arch = "x86_64", feature = "pc-keyboard"))]
 #[hermit_macro::system]
 #[unsafe(no_mangle)]
-pub extern "C" fn sys_read_keyboard() -> u8 {
-	crate::kernel::pc_keyboard::pop_scancode().unwrap_or(0)
+pub unsafe extern "C" fn sys_read_keyboard(buffer: *mut u8, size: usize, nonblock: bool) -> isize {
+	if buffer.is_null() {
+		return -(Errno::Fault as isize);
+	}
+	if size == 0 {
+		return 0;
+	}
+	let buffer_slice: &mut [u8] = unsafe { core::slice::from_raw_parts_mut(buffer, size) };
+	let result = crate::kernel::pc_keyboard::pop_scancodes(buffer_slice, nonblock);
+	if result == 0 && nonblock {
+		-(Errno::Again as isize)
+	} else {
+		result as isize
+	}
 }