Refactor process_list and name it process_table

Author: sysheap

common/src/mutex.rs

@@ -24,6 +24,11 @@ impl<T> Mutex<T> {
         }
     }
 
+    pub fn with_lock<'a, R>(&'a self, f: impl FnOnce(MutexGuard<'a, T>) -> R) -> R {
+        let lock = self.lock();
+        f(lock)
+    }
+
     pub fn lock(&self) -> MutexGuard<T> {
         if self.disarmed.load(Ordering::SeqCst) {
             return MutexGuard { mutex: self };

kernel/src/cpu.rs

@@ -65,6 +65,12 @@ pub fn wait_for_interrupt() {
 const SIE_STIE: usize = 5;
 const SSTATUS_SPP: usize = 8;
 
+pub fn is_timer_enabled() -> bool {
+    let sie: usize;
+    unsafe { asm!("csrr {}, sie", out(reg) sie) }
+    (sie & (1 << SIE_STIE)) > 0
+}
+
 pub fn disable_timer_interrupt() {
     unsafe {
         asm!("

kernel/src/debugging/mod.rs

@@ -1,7 +1,7 @@
 use crate::{
     info,
     klibc::sizes::MiB,
-    processes::{process_list, scheduler::get_current_process},
+    processes::{process_table, scheduler::get_current_process},
 };
 
 pub mod backtrace;
@@ -24,7 +24,7 @@ pub fn dump_current_state() {
         used_heap_pages, total_heap_pages
     );
 
-    process_list::dump();
+    process_table::THE.lock().dump();
 
     let current_process = get_current_process();
     if let Some(process) = current_process {

kernel/src/io/stdin_buf.rs

@@ -1,4 +1,10 @@
-use crate::processes::{process::Pid, process_list};
+use crate::{
+    cpu,
+    processes::{
+        process::{Pid, ProcessState},
+        process_table, timer,
+    },
+};
 use alloc::collections::{BTreeSet, VecDeque};
 use common::mutex::Mutex;
 
@@ -22,14 +28,24 @@ impl StdinBuffer {
     }
 
     pub fn push(&mut self, byte: u8) {
-        let mut notified = false;
-        for pid in &self.wakeup_queue {
-            if process_list::notify_input(*pid, byte) {
-                notified = true;
+        let notified = !self.wakeup_queue.is_empty();
+        process_table::THE.with_lock(|pt| {
+            for pid in &self.wakeup_queue {
+                if let Some(process) = pt.get_process(*pid) {
+                    process.with_lock(|mut p| {
+                        p.set_state(ProcessState::Runnable);
+                        p.set_syscall_return_code(byte as usize);
+                    })
+                }
             }
-        }
+        });
         self.wakeup_queue.clear();
         if notified {
+            if !cpu::is_timer_enabled() {
+                // Enable timer because we were sleeping and waiting
+                // for input
+                timer::set_timer(0);
+            }
             return;
         }
         self.data.push_back(byte);

kernel/src/processes/mod.rs

@@ -1,5 +1,5 @@
 pub mod loader;
 pub mod process;
-pub mod process_list;
+pub mod process_table;
 pub mod scheduler;
 pub mod timer;

kernel/src/processes/process.rs

@@ -3,10 +3,7 @@ use crate::{
     klibc::elf::ElfFile,
     memory::{page::PinnedHeapPages, page_tables::RootPageTableHolder, PAGE_SIZE},
     net::sockets::SharedAssignedSocket,
-    processes::{
-        loader::{self, LoadedElf},
-        process_list,
-    },
+    processes::loader::{self, LoadedElf},
 };
 use alloc::{
     collections::{BTreeMap, BTreeSet},
@@ -33,7 +30,7 @@ pub enum ProcessState {
 }
 
 fn get_next_pid() -> Pid {
-    static PID_COUNTER: AtomicU64 = AtomicU64::new(0);
+    static PID_COUNTER: AtomicU64 = AtomicU64::new(1);
     let next_pid = PID_COUNTER.fetch_add(1, Ordering::Relaxed);
     assert_ne!(next_pid, u64::MAX, "We ran out of process pids");
     next_pid
@@ -79,6 +76,10 @@ impl Debug for Process {
 }
 
 impl Process {
+    pub fn get_notifies_on_die(&self) -> impl Iterator<Item = &Pid> {
+        self.notify_on_die.iter()
+    }
+
     pub fn mmap_pages(&mut self, number_of_pages: usize) -> *mut u8 {
         let pages = PinnedHeapPages::new(number_of_pages);
         self.page_table.map_userspace(
@@ -196,9 +197,6 @@ 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

@@ -0,0 +1,110 @@
+use alloc::{collections::BTreeMap, sync::Arc};
+use common::mutex::Mutex;
+
+use crate::{debug, info};
+
+use super::process::{Pid, Process, ProcessState};
+
+pub static THE: Mutex<ProcessTable> = Mutex::new(ProcessTable::new());
+
+pub type ProcessRef = Arc<Mutex<Process>>;
+
+pub struct ProcessTable {
+    processes: BTreeMap<Pid, ProcessRef>,
+}
+
+impl ProcessTable {
+    const fn new() -> Self {
+        Self {
+            processes: BTreeMap::new(),
+        }
+    }
+
+    pub fn add_process(&mut self, process: Process) {
+        self.processes
+            .insert(process.get_pid(), Arc::new(Mutex::new(process)));
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.processes.is_empty()
+    }
+
+    pub fn get_highest_pid_without_yash(&self) -> Option<Pid> {
+        self.processes
+            .iter()
+            .filter(|(_, p)| p.lock().get_name() != "yash")
+            .max_by_key(|(pid, _)| *pid)
+            .map(|(pid, _)| *pid)
+    }
+
+    pub fn dump(&self) {
+        for (pid, process) in &self.processes {
+            let process = process.lock();
+            info!(
+                "PID={} NAME={} STATE={:?}",
+                *pid,
+                process.get_name(),
+                process.get_state()
+            );
+        }
+    }
+
+    pub fn kill(&mut self, pid: Pid) {
+        debug!("Removing pid={pid} from process table");
+        if let Some(process) = self.processes.remove(&pid) {
+            assert_eq!(
+                Arc::strong_count(&process),
+                1,
+                "There should no more than one process handles be active"
+            );
+            for pid in process.lock().get_notifies_on_die() {
+                self.wake_process_up(*pid);
+            }
+        }
+    }
+
+    pub fn next_runnable(&self, old_pid: Pid) -> Option<ProcessRef> {
+        let mut next_iter = self
+            .processes
+            .range(old_pid..)
+            .skip(1)
+            .filter_map(Self::filter_map_runnable_processes);
+
+        if let Some(next_process) = next_iter.next() {
+            Some(next_process.clone())
+        } else {
+            self.processes
+                .iter()
+                .filter_map(Self::filter_map_runnable_processes)
+                .next()
+                .cloned()
+        }
+    }
+
+    fn filter_map_runnable_processes<'a>((_, p): (&Pid, &'a ProcessRef)) -> Option<&'a ProcessRef> {
+        if p.lock().get_state() == ProcessState::Runnable {
+            Some(p)
+        } else {
+            None
+        }
+    }
+
+    pub fn get_process(&self, pid: Pid) -> Option<&ProcessRef> {
+        self.processes.get(&pid)
+    }
+
+    pub fn does_pid_exist(&self, pid: Pid) -> bool {
+        self.processes.contains_key(&pid)
+    }
+
+    pub fn wake_process_up(&self, pid: Pid) {
+        debug!("Waking process up with pid={pid}");
+        let mut process = self.processes.get(&pid).expect("Process must exist").lock();
+        assert_eq!(
+            process.get_state(),
+            ProcessState::Waiting,
+            "Process must be in waiting state to be woken up"
+        );
+        process.set_state(ProcessState::Runnable);
+    }
+}