scheduler: Refactor

The scheduler needed some love for a long time now.

Author: sysheap

kernel/src/debugging/mod.rs

@@ -1,8 +1,4 @@
-use crate::{
-    info,
-    klibc::sizes::MiB,
-    processes::{process_table, scheduler::get_current_process},
-};
+use crate::{info, klibc::sizes::MiB, processes::scheduler};
 
 pub mod backtrace;
 mod eh_frame_parser;
@@ -24,16 +20,14 @@ pub fn dump_current_state() {
         used_heap_pages, total_heap_pages
     );
 
-    process_table::THE.lock().dump();
-
-    let current_process = get_current_process();
-    if let Some(process) = current_process {
-        let process = process.lock();
+    scheduler::THE.with_lock(|s| {
+        s.dump();
+        let current_process = s.get_current_process().lock();
         info!(
             "Current Process: PID={} NAME={} STATE={:?}",
-            process.get_pid(),
-            process.get_name(),
-            process.get_state()
+            current_process.get_pid(),
+            current_process.get_name(),
+            current_process.get_state()
         );
-    }
+    });
 }

kernel/src/interrupts/trap.rs

@@ -7,18 +7,17 @@ use crate::{
     memory::linker_information::LinkerInformation,
     processes::{
         process::ProcessState,
-        scheduler::{self, get_current_process, schedule},
+        scheduler::{self},
     },
     syscalls::{self},
     warn,
 };
-use alloc::string::ToString;
 use common::syscalls::trap_frame::{Register, TrapFrame};
 use core::panic;
 
 #[no_mangle]
 extern "C" fn handle_timer_interrupt() {
-    scheduler::schedule();
+    scheduler::THE.lock().schedule();
 }
 
 #[no_mangle]
@@ -35,7 +34,7 @@ fn handle_external_interrupt() {
     plic::complete_interrupt(plic_interrupt);
 
     match input {
-        3 => crate::processes::scheduler::send_ctrl_c(),
+        3 => scheduler::THE.lock().send_ctrl_c(),
         4 => crate::debugging::dump_current_state(),
         _ => STDIN_BUFFER.lock().push(input),
     }
@@ -53,11 +52,11 @@ fn handle_syscall(sepc: usize, trap_frame: &mut TrapFrame) {
         cpu::write_sepc(sepc + 4); // Skip the ecall instruction
     }
     // 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() == ProcessState::Waiting
-    {
-        schedule();
-    }
+    scheduler::THE.with_lock(|mut s| {
+        if s.get_current_process().lock().get_state() == ProcessState::Waiting {
+            s.schedule();
+        }
+    });
 }
 
 fn warn_on_stackoverflow(cause: InterruptCause, stval: usize) {
@@ -77,27 +76,19 @@ fn handle_unhandled_exception(
     sepc: usize,
     trap_frame: &mut TrapFrame,
 ) {
-    let current_process = get_current_process();
-    let mut is_userspace_address = "NO ACTIVE PROCESS".to_string();
-    let mut process_name = is_userspace_address.clone();
-    if let Some(current_process) = current_process {
-        let current_process = current_process.lock();
-        is_userspace_address = format!(
-            "{}",
-            current_process.get_page_table().is_userspace_address(sepc)
-        );
-        process_name = current_process.get_name().to_string();
-    }
-    panic!(
+    let message= scheduler::THE.lock().get_current_process().with_lock(|p| {
+        format!(
             "Unhandled exception!\nName: {}\nException code: {}\nstval: 0x{:x}\nsepc: 0x{:x}\nFrom Userspace: {}\nProcess name: {}\nTrap Frame: {:?}",
             cause.get_reason(),
             cause.get_exception_code(),
             stval,
             sepc,
-            is_userspace_address,
-            process_name,
+            p.get_page_table().is_userspace_address(sepc),
+            p.get_name(),
             trap_frame
-        );
+        )
+    });
+    panic!("{}", message);
 }
 
 #[no_mangle]

kernel/src/io/stdin_buf.rs

@@ -2,7 +2,7 @@ use crate::{
     cpu,
     processes::{
         process::{Pid, ProcessState},
-        process_table, timer,
+        scheduler, timer,
     },
 };
 use alloc::collections::{BTreeSet, VecDeque};
@@ -29,9 +29,9 @@ impl StdinBuffer {
 
     pub fn push(&mut self, byte: u8) {
         let notified = !self.wakeup_queue.is_empty();
-        process_table::THE.with_lock(|pt| {
+        scheduler::THE.with_lock(|s| {
             for pid in &self.wakeup_queue {
-                if let Some(process) = pt.get_process(*pid) {
+                if let Some(process) = s.get_process(*pid) {
                     process.with_lock(|mut p| {
                         p.set_state(ProcessState::Runnable);
                         p.set_syscall_return_code(byte as usize);

kernel/src/main.rs

@@ -118,7 +118,7 @@ extern "C" fn kernel_init(hart_id: usize, device_tree_pointer: *const ()) {
 
     plic::init_uart_interrupt();
 
-    scheduler::initialize();
+    scheduler::init();
 
     let mut pci_devices = enumerate_devices(&pci_information);
 

kernel/src/memory/page_tables.rs

@@ -163,6 +163,13 @@ impl RootPageTableHolder {
         }
     }
 
+    pub const fn invalid() -> Self {
+        Self {
+            root_table: null_mut(),
+            already_mapped: Vec::new(),
+        }
+    }
+
     fn table(&self) -> &PageTable {
         // SAFETY: It is always allocated
         unsafe { &*self.root_table }

kernel/src/panic.rs

@@ -10,8 +10,6 @@ static PANIC_COUNTER: AtomicU8 = AtomicU8::new(0);
 #[cfg(not(miri))]
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    use crate::processes::scheduler::disarm_current_process;
-
     unsafe {
         crate::cpu::disable_global_interrupts();
     }
@@ -22,7 +20,6 @@ fn panic(info: &PanicInfo) -> ! {
     // output some data
     unsafe {
         QEMU_UART.disarm();
-        disarm_current_process();
     }
 
     println!("");

kernel/src/processes/mod.rs

@@ -1,4 +1,4 @@
-pub mod loader;
+mod loader;
 pub mod process;
 pub mod process_table;
 pub mod scheduler;

kernel/src/processes/process.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use alloc::{
     collections::{BTreeMap, BTreeSet},
-    string::String,
+    string::{String, ToString},
     vec::Vec,
 };
 use common::{
@@ -21,6 +21,8 @@ use core::{
 
 pub type Pid = u64;
 
+pub const NEVER_PID: Pid = 0;
+
 const FREE_MMAP_START_ADDRESS: usize = 0x2000000000;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -30,6 +32,8 @@ pub enum ProcessState {
 }
 
 fn get_next_pid() -> Pid {
+    // PIDs will start from 1
+    // 0 is reserved for the never process which will be never scheduled
     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");
@@ -76,6 +80,23 @@ impl Debug for Process {
 }
 
 impl Process {
+    pub fn never() -> Self {
+        Self {
+            name: "never".to_string(),
+            pid: NEVER_PID,
+            register_state: TrapFrame::zero(),
+            page_table: RootPageTableHolder::invalid(),
+            program_counter: 0,
+            allocated_pages: Vec::new(),
+            state: ProcessState::Waiting,
+            free_mmap_address: FREE_MMAP_START_ADDRESS,
+            next_free_descriptor: 0,
+            open_udp_sockets: BTreeMap::new(),
+            in_kernel_mode: false,
+            notify_on_die: BTreeSet::new(),
+        }
+    }
+
     pub fn get_notifies_on_die(&self) -> impl Iterator<Item = &Pid> {
         self.notify_on_die.iter()
     }

kernel/src/processes/process_table.rs

@@ -3,9 +3,7 @@ use common::mutex::Mutex;
 
 use crate::{debug, info};
 
-use super::process::{Pid, Process, ProcessState};
-
-pub static THE: Mutex<ProcessTable> = Mutex::new(ProcessTable::new());
+use super::process::{Pid, Process, ProcessState, NEVER_PID};
 
 pub type ProcessRef = Arc<Mutex<Process>>;
 
@@ -14,10 +12,12 @@ pub struct ProcessTable {
 }
 
 impl ProcessTable {
-    const fn new() -> Self {
-        Self {
+    pub fn new() -> Self {
+        let mut self_ = Self {
             processes: BTreeMap::new(),
-        }
+        };
+        self_.add_process(Process::never());
+        self_
     }
 
     pub fn add_process(&mut self, process: Process) {
@@ -26,13 +26,18 @@ impl ProcessTable {
     }
 
     pub fn is_empty(&self) -> bool {
-        self.processes.is_empty()
+        // If only the never process is left
+        // we know the process table is empty
+        self.processes.len() == 1
     }
 
-    pub fn get_highest_pid_without_yash(&self) -> Option<Pid> {
+    pub fn get_highest_pid_without(&self, process_names: &[&str]) -> Option<Pid> {
         self.processes
             .iter()
-            .filter(|(_, p)| p.lock().get_name() != "yash")
+            .filter(|(_, p)| {
+                let p = p.lock();
+                !process_names.iter().any(|n| p.get_name() == *n) && p.get_pid() != NEVER_PID
+            })
             .max_by_key(|(pid, _)| *pid)
             .map(|(pid, _)| *pid)
     }
@@ -50,6 +55,10 @@ impl ProcessTable {
     }
 
     pub fn kill(&mut self, pid: Pid) {
+        assert!(
+            pid != NEVER_PID,
+            "We are not allowed to kill the never process"
+        );
         debug!("Removing pid={pid} from process table");
         if let Some(process) = self.processes.remove(&pid) {
             assert_eq!(
@@ -93,8 +102,11 @@ impl ProcessTable {
         self.processes.get(&pid)
     }
 
-    pub fn does_pid_exist(&self, pid: Pid) -> bool {
-        self.processes.contains_key(&pid)
+    pub fn get_dummy_process(&self) -> ProcessRef {
+        self.processes
+            .get(&NEVER_PID)
+            .expect("The dummy process must always exist")
+            .clone()
     }
 
     pub fn wake_process_up(&self, pid: Pid) {