processes: Let bet waken up by subcomponents

Don't store the reason why a process is sleeping. Let the process be
waken up by the timer or input on the keyboard.

Author: sysheap

kernel/src/cpu.rs

@@ -2,8 +2,6 @@ use core::arch::asm;
 
 use common::syscalls::trap_frame::TrapFrame;
 
-use crate::assert::assert_unreachable;
-
 pub fn write_sscratch_register(value: *const TrapFrame) {
     unsafe {
         asm!("csrw sscratch, {}", in(reg) value);
@@ -64,18 +62,6 @@ pub fn wait_for_interrupt() {
     }
 }
 
-pub fn sret_to_kernel() -> ! {
-    unsafe {
-        asm!(
-            "
-                csrs sstatus, {}
-                sret
-            ", in(reg) (1<<8)
-        )
-    }
-    assert_unreachable();
-}
-
 const SIE_STIE: usize = 5;
 const SSTATUS_SPP: usize = 8;
 

kernel/src/interrupts/trap.rs

@@ -5,7 +5,10 @@ use crate::{
     interrupts::plic::{self, InterruptSource},
     io::{stdin_buf::STDIN_BUFFER, uart},
     memory::linker_information::LinkerInformation,
-    processes::scheduler::{self, get_current_process, schedule},
+    processes::{
+        process::ProcessState,
+        scheduler::{self, get_current_process, schedule},
+    },
     syscalls::{self},
     warn,
 };
@@ -51,7 +54,7 @@ fn handle_syscall(sepc: usize, trap_frame: &mut TrapFrame) {
     }
     // In case our current process was set to waiting state we need to reschedule
     if let Some(process) = get_current_process()
-        && process.lock().get_state().is_waiting()
+        && process.lock().get_state() == ProcessState::Waiting
     {
         schedule();
     }

kernel/src/io/stdin_buf.rs

@@ -1,23 +1,35 @@
-use crate::processes::process_list;
-use alloc::collections::VecDeque;
+use crate::processes::{process::Pid, process_list};
+use alloc::collections::{BTreeSet, VecDeque};
 use common::mutex::Mutex;
 
 pub static STDIN_BUFFER: Mutex<StdinBuffer> = Mutex::new(StdinBuffer::new());
 
 pub struct StdinBuffer {
     data: VecDeque<u8>,
+    wakeup_queue: BTreeSet<Pid>,
 }
 
 impl StdinBuffer {
     const fn new() -> Self {
         StdinBuffer {
             data: VecDeque::new(),
+            wakeup_queue: BTreeSet::new(),
         }
     }
 
+    pub fn register_wakeup(&mut self, pid: Pid) {
+        self.wakeup_queue.insert(pid);
+    }
+
     pub fn push(&mut self, byte: u8) {
-        if process_list::notify_input(byte) {
-            // We already delivered the byte to the processes waiting for it
+        let mut notified = false;
+        for pid in &self.wakeup_queue {
+            if process_list::notify_input(*pid, byte) {
+                notified = true;
+            }
+        }
+        self.wakeup_queue.clear();
+        if notified {
             return;
         }
         self.data.push_back(byte);

kernel/src/processes/process.rs

@@ -3,9 +3,16 @@ use crate::{
     klibc::elf::ElfFile,
     memory::{page::PinnedHeapPages, page_tables::RootPageTableHolder, PAGE_SIZE},
     net::sockets::SharedAssignedSocket,
-    processes::loader::{self, LoadedElf},
+    processes::{
+        loader::{self, LoadedElf},
+        process_list,
+    },
+};
+use alloc::{
+    collections::{BTreeMap, BTreeSet},
+    string::String,
+    vec::Vec,
 };
-use alloc::{collections::BTreeMap, string::String, vec::Vec};
 use common::{
     net::UDPDescriptor,
     syscalls::trap_frame::{Register, TrapFrame},
@@ -22,17 +29,7 @@ const FREE_MMAP_START_ADDRESS: usize = 0x2000000000;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProcessState {
     Runnable,
-    WaitingFor(Pid),
-    WaitingForInput,
-}
-
-impl ProcessState {
-    pub fn is_waiting(&self) -> bool {
-        matches!(
-            self,
-            ProcessState::WaitingFor(_) | ProcessState::WaitingForInput
-        )
-    }
+    Waiting,
 }
 
 fn get_next_pid() -> Pid {
@@ -54,6 +51,7 @@ pub struct Process {
     next_free_descriptor: u64,
     open_udp_sockets: BTreeMap<UDPDescriptor, SharedAssignedSocket>,
     in_kernel_mode: bool,
+    notify_on_die: BTreeSet<Pid>,
 }
 
 impl Debug for Process {
@@ -96,6 +94,10 @@ impl Process {
         ptr
     }
 
+    pub fn add_notify_on_die(&mut self, pid: Pid) {
+        self.notify_on_die.insert(pid);
+    }
+
     pub fn get_register_state(&self) -> &TrapFrame {
         &self.register_state
     }
@@ -168,6 +170,7 @@ impl Process {
             next_free_descriptor: 0,
             open_udp_sockets: BTreeMap::new(),
             in_kernel_mode: false,
+            notify_on_die: BTreeSet::new(),
         }
     }
 
@@ -193,6 +196,9 @@ impl Process {
 
 impl Drop for Process {
     fn drop(&mut self) {
+        for pid in &self.notify_on_die {
+            process_list::wake_up(*pid);
+        }
         debug!(
             "Drop process (PID: {}) (Allocated pages: {:?})",
             self.pid, self.allocated_pages

kernel/src/processes/process_list.rs

@@ -53,7 +53,6 @@ pub fn kill(pid: Pid) {
         );
         // Drop process lock
         drop(processes);
-        notify_died(pid);
     }
 }
 
@@ -87,26 +86,33 @@ pub fn does_pid_exits(pid: Pid) -> bool {
         .any(|process| process.lock().get_pid() == pid)
 }
 
-pub fn notify_died(pid: Pid) {
-    let processes = PROCESSES.lock();
-    for process in processes.iter() {
-        if process.lock().get_state() == ProcessState::WaitingFor(pid) {
-            process.lock().set_state(ProcessState::Runnable);
-        }
+pub fn get_process(pid: Pid) -> Option<Arc<Mutex<Process>>> {
+    PROCESSES
+        .lock()
+        .iter()
+        .find(|process| process.lock().get_pid() == pid)
+        .cloned()
+}
+
+pub fn wake_up(pid: Pid) {
+    let mut processes = PROCESSES.lock();
+    let process = processes.iter_mut().find(|p| p.lock().get_pid() == pid);
+
+    if let Some(process) = process {
+        process.lock().set_state(ProcessState::Runnable);
     }
 }
 
-pub fn notify_input(byte: u8) -> bool {
+pub fn notify_input(pid: Pid, byte: u8) -> bool {
     let processes = PROCESSES.lock();
     let mut notified = false;
-    for process in processes.iter() {
+    if let Some(process) = processes.iter().find(|p| p.lock().get_pid() == pid) {
         let mut process = process.lock();
-        if process.get_state() == ProcessState::WaitingForInput {
-            process.set_state(ProcessState::Runnable);
-            process.set_syscall_return_code(byte as usize);
-            notified = true;
-        }
+        process.set_state(ProcessState::Runnable);
+        process.set_syscall_return_code(byte as usize);
+        notified = true;
     }
+
     if notified {
         // Let's schedule a new process which can process the input
         timer::set_timer(0);

kernel/src/processes/scheduler.rs

@@ -4,13 +4,14 @@ use super::{
 };
 use crate::{
     autogenerated::userspace_programs::{INIT, PROGRAMS},
-    cpu::{self, sret_to_kernel},
+    cpu::{self},
     debug, info,
     interrupts::{read_trap_frame, set_sscratch_to_kernel_trap_frame, write_trap_frame},
+    io::stdin_buf::STDIN_BUFFER,
     klibc::elf::ElfFile,
     memory::page_tables::{activate_page_table, KERNEL_PAGE_TABLES},
     processes::{
-        process_list::{self, notify_died},
+        process_list::{self},
         timer,
     },
     test::qemu_exit,
@@ -52,17 +53,20 @@ pub fn schedule() {
     let addr = cpu::wfi_loop as *const () as usize;
     debug!("setting sepc={addr:#x}");
     cpu::write_sepc(addr);
+    cpu::set_ret_to_kernel_mode(true);
     set_sscratch_to_kernel_trap_frame();
-    sret_to_kernel()
 }
 
 pub fn kill_current_process() {
-    debug!("Killing current process");
     let current_process = CURRENT_PROCESS.lock().take();
     if let Some(current_process) = current_process {
+        assert_eq!(
+            Arc::strong_count(&current_process),
+            1,
+            "We should have the last handle of this process"
+        );
         activate_page_table(&KERNEL_PAGE_TABLES);
-        notify_died(current_process.lock().get_pid());
-        debug!("{:?}", current_process);
+        debug!("Killing {:?}", *current_process.lock());
     }
     schedule();
 }
@@ -77,8 +81,12 @@ pub fn let_current_process_wait_for(pid: Pid) -> bool {
         .expect("There should be a process.");
 
     let mut current_process = current_process.lock();
-    current_process.set_state(ProcessState::WaitingFor(pid));
+    current_process.set_state(ProcessState::Waiting);
     current_process.set_syscall_return_code(0);
+
+    let wait_for = process_list::get_process(pid).expect("This process must exist");
+    wait_for.lock().add_notify_on_die(current_process.get_pid());
+
     true
 }
 
@@ -89,7 +97,10 @@ pub fn let_current_process_wait_for_input() {
         .expect("There should be a process.");
 
     let mut current_process = current_process.lock();
-    current_process.set_state(ProcessState::WaitingForInput);
+    STDIN_BUFFER
+        .lock()
+        .register_wakeup(current_process.get_pid());
+    current_process.set_state(ProcessState::Waiting);
 }
 
 pub fn send_ctrl_c() {