Make new processes start sleeping

src/interrupts.rs

@@ -188,14 +188,11 @@ fn irq_handler(_stack_frame: InterruptStackFrame, index: u8, _error_code: Option
                 clippy::unwrap_used,
                 reason = "The PID is known valid due to using it in message_queue_mut in the if-let condition"
             )]
-            let sleep_status = TASKING.proc_sleeping(pid).unwrap();
-            if sleep_status == Some(SleepReason::WaitingForIPC) {
             #[expect(
                 clippy::unwrap_used,
                 reason = "The PID is known valid due to using it in message_queue_mut in the if-let condition"
             )]
-                TASKING.wake(pid).unwrap();
+            TASKING.wake(pid, SleepReason::WaitingForIPC).unwrap();
-            }
         } else {
             println!("irq 1 msg: Bad PID ({})", pid);
         }
@@ -549,14 +546,11 @@ extern "C" fn syscall_handler() {
                         clippy::unwrap_used,
                         reason = "The PID is known valid due to using it in message_queue_mut in the if-let condition"
                     )]
-                    let sleep_status = TASKING.proc_sleeping(pid).unwrap();
-                    if sleep_status == Some(SleepReason::WaitingForIPC) {
                     #[expect(
                         clippy::unwrap_used,
                         reason = "The PID is known valid due to using it in message_queue_mut in the if-let condition"
                     )]
-                        TASKING.wake(pid).unwrap();
+                    TASKING.wake(pid, SleepReason::WaitingForIPC).unwrap();
-                    }
                     retval = 0;
                 } else {
                     println!("ipc_send: Bad PID ({})", pid);
@@ -752,6 +746,14 @@ extern "C" fn syscall_handler() {
                 retval = 1;
             }
         }
+        24 => {
+            let pid = usize(regs.rcx);
+            if TASKING.wake(pid, SleepReason::NewProcess).is_err() {
+                retval = 1;
+            } else {
+                retval = 0;
+            }
+        }
         _ => (),
     };
     unsafe { SYSCALL_REGS = regs };

src/main.rs

@@ -102,7 +102,7 @@ use physical_memory::PHYSICAL_MEMORY;
 use serial::SECOND_PORT;
 use spin::lazy::Lazy;
 use tar_no_std::TarArchiveRef;
-use tasking::TASKING;
+use tasking::{SleepReason, TASKING};
 use virtual_memory::{ACTIVE_SPACE, KERNEL_SPACE};
 use x86_64::{
     registers::rflags::{self, RFlags},
@@ -290,11 +290,12 @@ pub fn main() {
         clippy::unwrap_used,
         reason = "Argument does not contain a null byte, thus this cannot panic"
     )]
-    TASKING
+    let init_pid = TASKING
         .new_process(
             ptr::with_exposed_provenance(usize(init.ehdr.e_entry)),
             init_addr_space,
             &[&CString::new(b"init").unwrap()],
         )
         .expect("Failed to create init process");
+    TASKING.wake(init_pid, SleepReason::NewProcess).unwrap();
 }

src/tasking.rs

@@ -85,6 +85,7 @@ extern "C" fn task_init() {
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum SleepReason {
     WaitingForIPC,
+    NewProcess,
 }
 
 #[derive(Debug)]
@@ -203,10 +204,10 @@ impl Tasking {
             address_spaces: Mutex::new(Slab::new()),
             data_buffers: Mutex::new(Slab::new()),
             message_queue: Mutex::new(SegQueue::new()),
-            sleeping: RwLock::new(None),
+            sleeping: RwLock::new(Some(SleepReason::NewProcess)),
             arguments: (user_arg_mem.cast(), arguments.len()),
         });
-        self.ready_to_run.lock().push_back(pid);
+        //self.ready_to_run.lock().push_back(pid);
         Ok(pid)
     }
 
@@ -222,17 +223,18 @@ impl Tasking {
     }
 
     pub fn task_yield(&self) {
+        loop {
             self.freeable_kstacks.lock().clear();
             let Some(current_pid) = *self.current_pid.read() else {
                 self.wfi_loop.store(false, Ordering::Relaxed);
-            return;
+                break;
             };
             let next_process_pid = self.ready_to_run.lock().pop_front();
             if let Some(next_process_pid) = next_process_pid {
                 self.wfi_loop.store(false, Ordering::Relaxed);
                 if next_process_pid == self.current_pid().unwrap() {
                     println!("Yielding to currect process! Returning");
-                return;
+                    break;
                 }
                 #[expect(
                     clippy::expect_used,
@@ -264,6 +266,7 @@ impl Tasking {
                 let curr_stack = addr_of_mut!(processes[previous_process].kernel_esp);
                 core::mem::drop(processes);
                 switch_to_asm(curr_stack, kernel_esp);
+                break;
             } else if {
                 #[warn(clippy::indexing_slicing, reason = "FIXME(?)")]
                 let res = self.processes.read()[current_pid].sleeping.read().is_some();
@@ -276,9 +279,10 @@ impl Tasking {
                 self.wfi_loop.store(true, Ordering::Relaxed);
                 x86_64::instructions::interrupts::enable_and_hlt();
                 x86_64::instructions::interrupts::disable();
-            self.task_yield();
             } else {
                 self.wfi_loop.store(false, Ordering::Relaxed);
+                break;
+            }
         }
     }
 
@@ -287,6 +291,7 @@ impl Tasking {
     }
 
     pub fn exit(&self) -> ! {
+        loop {
             let next_process_pid = self.ready_to_run.lock().pop_front();
             if let Some(next_process_pid) = next_process_pid {
                 self.wfi_loop.store(false, Ordering::Relaxed);
@@ -317,7 +322,8 @@ impl Tasking {
                 self.wfi_loop.store(true, Ordering::Relaxed);
                 x86_64::instructions::interrupts::enable_and_hlt();
                 x86_64::instructions::interrupts::disable();
-            self.exit();
+                //self.exit();
+            }
         }
     }
 
@@ -389,11 +395,16 @@ impl Tasking {
         self.task_yield();
     }
 
-    pub fn wake(&self, pid: usize) -> Result<(), InvalidPid> {
+    pub fn wake(&self, pid: usize, reason: SleepReason) -> Result<(), InvalidPid> {
-        *self.processes.read().get(pid).ok_or(InvalidPid)?.sleeping.write() = None;
+        let processes = self.processes.read();
+        let process = processes.get(pid).ok_or(InvalidPid)?;
+        let mut sleeping = process.sleeping.write();
+        if *sleeping == Some(reason) {
             if Some(pid) != self.current_pid() {
                 self.ready_to_run.lock().push_back(pid);
             }
+            *sleeping = None;
+        }
         Ok(())
     }