Syscalls

.gitignore

@@ -4,7 +4,9 @@
 *.hdd
 *.img
 *.txt
+*.od
 
 /target
+.vscode
 
 .DS_Store

kernel/limage_config.toml

@@ -29,7 +29,7 @@ base_args = [
 
     # Graphics
     "-vga", "std",
-
+"-serial", "stdio",
     # Debugging traces
     # USB
     # "-trace", "usb*",
@@ -44,7 +44,7 @@ base_args = [
 
 [modes]
 terminal = { args = ["-nographic"] }
-gui = { args = [] }
+gui = { args = ["-serial", "stdio"] }
 gdb-terminal = { args = ["-nographic", "-s", "-S"] }
 gdb-gui = { args = ["-s", "-S"] }
 
@@ -54,6 +54,5 @@ success_exit_code = 33
 no_reboot = true
 extra_args = [
     "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04",
-    "-serial", "stdio",
     "-display", "none"
 ]

kernel/src/constants/processes.rs

@@ -1,8 +1,6 @@
 //! Process related constants
 
 // Binaries used for tests
-pub const PRINT_EXIT: &[u8] = include_bytes!("../processes/test_binaries/print_exit");
-
 pub const FORK_SIMPLE: &[u8] = include_bytes!("../processes/test_binaries/fork_simple");
 
 pub const TEST_SIMPLE_PROCESS: &[u8] =
@@ -14,6 +12,8 @@ pub const TEST_PRINT_EXIT: &[u8] = include_bytes!("../processes/test_binaries/te
 
 pub const TEST_WAIT: &[u8] = include_bytes!("../processes/test_binaries/test_wait");
 
+pub const TEST_SLEEP: &[u8] = include_bytes!("../processes/test_binaries/sleep");
+
 pub const TEST_FORK_COW: &[u8] = include_bytes!("../processes/test_binaries/test_fork_cow");
 
 pub const TEST_MMAP_ANON_SHARED: &[u8] =

kernel/src/constants/syscalls.rs

@@ -2,12 +2,37 @@
 
 pub const SYSCALL_EXIT: u32 = 60;
 pub const SYSCALL_NANOSLEEP: u32 = 35;
-pub const SYSCALL_PRINT: u32 = 3;
+
+pub const SYSCALL_PRINT: u32 = 1003;
+
+pub const SYSCALL_READ: u32 = 0;
+pub const SYSCALL_WRITE: u32 = 1;
+pub const SYSCALL_OPEN: u32 = 2;
+pub const SYSCALL_CLOSE: u32 = 3;
+
+pub const SYSCALL_ACCESS: u32 = 21;
+
+pub const SYSCALL_SCHED_YIELD: u32 = 24;
+
+pub const SYSCALL_CREAT: u32 = 85;
+
+pub const SYSCALL_FUTEX: u32 = 202;
+pub const SYSCALL_OPENAT: u32 = 257;
+
+pub const SYSCALL_GETRANDOM: u32 = 318;
+
 pub const SYSCALL_MMAP: u32 = 4;
 pub const SYSCALL_MPROTECT: u32 = 10;
 pub const SYSCALL_MUNMAP: u32 = 11;
 pub const SYSCALL_FORK: u32 = 5;
 pub const SYSCALL_WAIT: u32 = 6;
+pub const SYSCALL_EXECVE: u32 = 59;
+
+pub const SYSCALL_GETUID: u32 = 102;
+pub const SYSCALL_GETEUID: u32 = 107;
+pub const SYSCALL_GETGID: u32 = 104;
+pub const SYSCALL_GETEGID: u32 = 108;
+pub const SYSCALL_ARCH_PRCTL: u32 = 158;
 
 // Mmap
 pub const START_MMAP_ADDRESS: u64 = 0x0900_0000_0000;

kernel/src/devices/ps2_dev/keyboard.rs

@@ -5,7 +5,7 @@
 
 use crate::{
     devices::ps2_dev::controller,
-    events::{futures::sync::BlockMutex, schedule_kernel},
+    events::{futures::sync::BlockMutex, schedule_kernel, yield_now},
     interrupts::idt::without_interrupts,
     serial_println,
 };
@@ -19,6 +19,7 @@ use lazy_static::lazy_static;
 use pc_keyboard::{
     layouts, DecodedKey, Error, HandleControl, KeyCode, KeyState, Keyboard, Modifiers, ScancodeSet2,
 };
+use ps2::flags::ControllerStatusFlags;
 use spin::Mutex;
 
 /// Maximum number of keyboard events to store in the buffer
@@ -258,6 +259,25 @@ pub fn keyboard_handler() {
     });
 }
 
+pub async fn flush_buffer() {
+    loop {
+        if let Ok(mut kb) = KEYBOARD.try_lock() {
+            // got the lock, clear it
+            kb.clear_buffer();
+            controller::with_controller(|ctrl| {
+                while ctrl
+                    .read_status()
+                    .contains(ControllerStatusFlags::OUTPUT_FULL)
+                {
+                    let _ = ctrl.read_data();
+                }
+            });
+            return;
+        }
+        yield_now().await;
+    }
+}
+
 impl Stream for KeyboardStream {
     type Item = KeyboardEvent;
 

kernel/src/events/event.rs

@@ -24,6 +24,10 @@ impl Event {
             completed: AtomicBool::new(false),
         }
     }
+
+    pub fn id(&self) -> u64 {
+        self.eid.0
+    }
 }
 
 impl ArcWake for Event {

kernel/src/events/event_runner.rs

@@ -46,7 +46,6 @@ impl EventRunner {
                 if !self.have_unblocked_events() {
                     break;
                 }
-
                 self.current_event = self.next_event();
 
                 let event = self
@@ -66,6 +65,7 @@ impl EventRunner {
 
                     // Executes the event
                     let ready: bool = future_guard.as_mut().poll(&mut context) != Poll::Pending;
+                    interrupts::disable();
 
                     drop(future_guard);
 
@@ -84,6 +84,8 @@ impl EventRunner {
                         // Event is ready, go ahead and remove it
                         event.completed.swap(true, Ordering::Relaxed);
                         self.pending_events.write().remove(&event.eid.0);
+
+                        crate::debug!("Event {} done", event.eid.0);
                     }
                 }
 
@@ -92,6 +94,8 @@ impl EventRunner {
                 // Explicitly re-enable interrupts once the current event is unmarked
                 // Helps with run_process_ring3(), which shouldn't be pre-empted
                 // TODO can maybe refactor and safely remove
+
+                // TODO do a lil work-stealing
                 interrupts::enable();
             }
 
@@ -100,8 +104,6 @@ impl EventRunner {
                 self.awake_next_sleeper();
             }
 
-            // TODO do a lil work-stealing
-
             // Sleep until next interrupt
             interrupts::enable_and_hlt();
         }
@@ -259,6 +261,12 @@ impl EventRunner {
         self.current_event.as_ref().map(|e| {
             let system_ticks = nanos_to_ticks(nanos);
 
+            crate::debug!(
+                "Sleeping @ {}, to be awoken @ {}",
+                self.system_clock,
+                self.system_clock + system_ticks
+            );
+
             let sleep = Sleep::new(self.system_clock + system_ticks, (*e).clone());
             self.sleeping_events.push(sleep.clone());
             self.blocked_events.write().insert(e.eid.0);
@@ -305,6 +313,15 @@ impl EventRunner {
         }
     }
 
+    /// Blocks the current event until awoken
+    ///
+    /// # Returns
+    /// * `Option<Block>` - A Block future that can be awaited on (if there is an event to block)
+    #[allow(dead_code)]
+    pub fn block_current_event(&mut self) -> Option<Sleep> {
+        todo!();
+    }
+
     /// # Returns
     /// * `bool` - true if there are blocked events on this runner
     fn have_blocked_events(&self) -> bool {

kernel/src/events/tasks/yield_task.rs

@@ -23,12 +23,11 @@ impl Default for Yield {
 impl Future for Yield {
     type Output = ();
 
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
         if self.yielded {
             Poll::Ready(())
         } else {
             self.yielded = true;
-            cx.waker().wake_by_ref();
             Poll::Pending
         }
     }

kernel/src/filesys/ext2/filesystem.rs

@@ -322,10 +322,11 @@ impl Ext2 {
 
         let size = node.size() as usize;
         let mut buffer = vec![0; size];
-        node.read_at(pos as u64, &mut buffer)
+        let s = node
+            .read_at(pos as u64, &mut buffer)
             .await
             .map_err(FilesystemError::NodeError)?;
-
+        buffer.resize(s, 0);
         Ok(buffer)
     }
 

kernel/src/filesys/ext2/node.rs

@@ -495,6 +495,7 @@ impl Node {
 
     async fn read_raw_at(&self, offset: u64, buffer: &mut [u8]) -> NodeResult<usize> {
         let size = self.size();
+
         if offset >= size {
             return Ok(0);
         }

kernel/src/filesys/ext2/structures.rs

@@ -317,7 +317,7 @@ mod tests {
     #[test_case]
     async fn test_superblock_block_size() {
         let mut sb = Superblock::default();
-
+        // sb.block_size_shift = 0; // 1024 bytes
         assert_eq!(sb.block_size(), 1024);
 
         sb.block_size_shift = 1; // 2048 bytes