src/interrupts.rs

@@ -9,12 +9,7 @@ use crate::{
 use alloc::{boxed::Box, vec::Vec};
 use az::WrappingCast;
 use cast::{u64, usize};
-use core::{
-    arch::{asm, naked_asm},
-    ffi::CStr,
-    fmt::Write,
-    ptr, slice,
-};
+use core::{arch::{asm, naked_asm}, ffi::CStr, fmt::Write, ptr, slice};
 use hashbrown::HashMap;
 use pic8259::ChainedPics;
 use saturating_cast::SaturatingCast;
@@ -132,83 +127,89 @@ impl Drop for EoiGuard {
 }
 
 pub fn send_ipc_to(pid: usize, buffer: Box<[u8], &'static ASpaceMutex>, len: usize) {
-    //#[expect(
-    //    clippy::unwrap_used,
-    //    reason = "The min call guarantees that the value is in the range of a u32 before the cast"
-    //)]
-    //let trunc_len: u32 = usize::min(len, 4096).try_into().unwrap();
-    //#[expect(
-    //    clippy::arithmetic_side_effects,
-    //    reason = "Can't underflow, as x % 4 < 4 no matter the x"
-    //)]
-    //let padding = if (trunc_len % 4) != 0 { 4 - (trunc_len % 4) } else { 0 };
-    //#[expect(
-    //    clippy::arithmetic_side_effects,
-    //    reason = "Can't overflow, as padding is no more than 4 and trunc_len is no more than 4096."
-    //)]
-    //let padded_len = trunc_len + padding;
-    //#[expect(
-    //    clippy::arithmetic_side_effects,
-    //    reason = "Can't overflow, as padded_len is no more than 4096 and 4096+24 < u32::MAX"
-    //)]
-    //let total_len = padded_len + 8 + (4 * 4);
-    //SECOND_PORT.write_u32s(&[
-    //    0x3,                                            // SPB type
-    //    total_len,                                      // Total block length
-    //    len.saturating_cast::<u32>().saturating_add(8), // Packet length
-    //]);
-    //SECOND_PORT.write_bytes(&pid.to_ne_bytes());
-    //#[expect(
-    //    clippy::indexing_slicing,
-    //    reason = "The truncated length is always <= the buffer's length"
-    //)]
-    //SECOND_PORT.write_bytes(&buffer[0..usize(trunc_len)]);
-    //for _ in 0..padding {
-    //    SECOND_PORT.write_bytes(&[0]);
-    //}
-    //SECOND_PORT.write_u32s(&[
-    //    total_len, // Total block length
-    //]);
-    //assert!(len <= buffer.len());
-    if TASKING.message_queue_mut(pid, |_| ()).is_ok() {
-        let buf_num_pages = buffer.len() / 4096;
-        let buffer = Box::into_raw(buffer);
-        let buf_start_page =
-            Page::from_start_address(VirtAddr::new(u64(buffer.expose_provenance()))).unwrap();
-        let dest_buffer = TASKING
-            .address_space_mut(pid, |aspace| {
-                // This is None only if the destiniation is the current process. If so,
-                // no remapping is necessary so just return the old buffer.
-                let Some(aspace) = aspace else {
-                    return buffer;
-                };
-                let page = ACTIVE_SPACE
-                    .lock()
-                    .move_mappings_free(buf_start_page, buf_num_pages, aspace)
-                    .unwrap();
-                ptr::slice_from_raw_parts_mut::<u8>(page.start_address().as_mut_ptr(), buffer.len())
-            })
-            .unwrap();
-        #[expect(
-            clippy::unwrap_used,
-            reason = "The PID is known valid due to using it in message_queue_mut in the if-let condition"
-        )]
-        let new_buffer_key = TASKING.proc_data_buffers_mut(pid, |x| x.insert(dest_buffer)).unwrap();
-        #[expect(
-            clippy::unwrap_used,
-            reason = "The option was already checked at the start of the if-let"
-        )]
-        TASKING.message_queue_mut(pid, |x| x.push((new_buffer_key, len))).unwrap();
-        #[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, SleepReason::WaitingForIPC).unwrap();
-    } else {
-        println!("irq 1 msg: Bad PID ({})", pid);
-    }
+        //#[expect(
+        //    clippy::unwrap_used,
+        //    reason = "The min call guarantees that the value is in the range of a u32 before the cast"
+        //)]
+        //let trunc_len: u32 = usize::min(len, 4096).try_into().unwrap();
+        //#[expect(
+        //    clippy::arithmetic_side_effects,
+        //    reason = "Can't underflow, as x % 4 < 4 no matter the x"
+        //)]
+        //let padding = if (trunc_len % 4) != 0 { 4 - (trunc_len % 4) } else { 0 };
+        //#[expect(
+        //    clippy::arithmetic_side_effects,
+        //    reason = "Can't overflow, as padding is no more than 4 and trunc_len is no more than 4096."
+        //)]
+        //let padded_len = trunc_len + padding;
+        //#[expect(
+        //    clippy::arithmetic_side_effects,
+        //    reason = "Can't overflow, as padded_len is no more than 4096 and 4096+24 < u32::MAX"
+        //)]
+        //let total_len = padded_len + 8 + (4 * 4);
+        //SECOND_PORT.write_u32s(&[
+        //    0x3,                                            // SPB type
+        //    total_len,                                      // Total block length
+        //    len.saturating_cast::<u32>().saturating_add(8), // Packet length
+        //]);
+        //SECOND_PORT.write_bytes(&pid.to_ne_bytes());
+        //#[expect(
+        //    clippy::indexing_slicing,
+        //    reason = "The truncated length is always <= the buffer's length"
+        //)]
+        //SECOND_PORT.write_bytes(&buffer[0..usize(trunc_len)]);
+        //for _ in 0..padding {
+        //    SECOND_PORT.write_bytes(&[0]);
+        //}
+        //SECOND_PORT.write_u32s(&[
+        //    total_len, // Total block length
+        //]);
+        //assert!(len <= buffer.len());
+        if TASKING.message_queue_mut(pid, |_| ()).is_ok() {
+            let buf_num_pages = buffer.len() / 4096;
+            let buffer = Box::into_raw(buffer);
+            let buf_start_page =
+                Page::from_start_address(VirtAddr::new(u64(buffer.expose_provenance()))).unwrap();
+            let dest_buffer = TASKING
+                .address_space_mut(pid, |aspace| {
+                    // This is None only if the destiniation is the current process. If so,
+                    // no remapping is necessary so just return the old buffer.
+                    let Some(aspace) = aspace else {
+                        return buffer;
+                    };
+                    let page = ACTIVE_SPACE
+                        .lock()
+                        .move_mappings_free(buf_start_page, buf_num_pages, aspace)
+                        .unwrap();
+                    ptr::slice_from_raw_parts_mut::<u8>(
+                        page.start_address().as_mut_ptr(),
+                        buffer.len(),
+                    )
+                })
+                .unwrap();
+            #[expect(
+                clippy::unwrap_used,
+                reason = "The PID is known valid due to using it in message_queue_mut in the if-let condition"
+            )]
+            let new_buffer_key =
+                TASKING.proc_data_buffers_mut(pid, |x| x.insert(dest_buffer)).unwrap();
+            #[expect(
+                clippy::unwrap_used,
+                reason = "The option was already checked at the start of the if-let"
+            )]
+            TASKING.message_queue_mut(pid, |x| x.push((new_buffer_key, len))).unwrap();
+            #[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, SleepReason::WaitingForIPC).unwrap();
+        } else {
+            println!("irq 1 msg: Bad PID ({})", pid);
+        }
+
 }
 
+
 #[expect(clippy::needless_pass_by_value, reason = "Signature dictated by external crate")]
 fn irq_handler(_stack_frame: InterruptStackFrame, index: u8, _error_code: Option<u64>) {
     #[expect(
@@ -309,8 +310,7 @@ fn get_buffer(id: u64) -> Option<Box<[u8], &'static ASpaceMutex>> {
     })
 }
 
-pub static REGISTERD_PIDS: Lazy<RwLock<HashMap<u64, u64>>> =
-    Lazy::new(|| RwLock::new(HashMap::new()));
+pub static REGISTERD_PIDS: Lazy<RwLock<HashMap<u64, u64>>> = Lazy::new(|| RwLock::new(HashMap::new()));
 
 static INITRD_BUF: Lazy<&'static [u8]> = Lazy::new(|| {
     #[warn(clippy::expect_used, reason = "FIXME")]

src/tasking.rs

@@ -1,13 +1,9 @@
 use crate::{
-    gdt,
-    interrupts::{send_ipc_to, REGISTERD_PIDS},
-    println, qemu_exit,
-    virtual_memory::{ASpaceMutex, AddressSpace, PagingError, ACTIVE_SPACE, KERNEL_SPACE},
+    gdt, interrupts::{send_ipc_to, REGISTERD_PIDS}, println, qemu_exit, virtual_memory::{ASpaceMutex, AddressSpace, PagingError, ACTIVE_SPACE, KERNEL_SPACE}
 };
 use alloc::{
     borrow::ToOwned, boxed::Box, collections::VecDeque, ffi::CString, string::ToString, vec::Vec,
 };
-use cast::{u64, usize};
 use core::{
     alloc::Layout,
     arch::naked_asm,
@@ -23,6 +19,7 @@ use x86_64::{
     structures::paging::{Page, PageTableFlags},
     VirtAddr,
 };
+use cast::{u64, usize};
 
 #[naked]
 extern "C" fn switch_to_asm(current_stack: *mut *mut usize, next_stack: *mut usize) {
@@ -221,22 +218,14 @@ impl Tasking {
             buffer[19..21].copy_from_slice(&8u16.to_le_bytes());
             buffer[21..23].copy_from_slice(&6u16.to_le_bytes());
             len = 23;
-            len += unsigned_varint::encode::u64(
-                u64(pid),
-                (&mut buffer[len..len + 10]).try_into().unwrap(),
-            )
-            .len();
+            len += unsigned_varint::encode::u64(u64(pid), (&mut buffer[len..len+10]).try_into().unwrap()).len();
             if let Some(current_pid) = *(self.current_pid.read()) {
                 buffer[len] = 1;
-                len += 1;
-                len += unsigned_varint::encode::u64(
-                    u64(current_pid),
-                    (&mut buffer[len..len + 10]).try_into().unwrap(),
-                )
-                .len();
+                len+=1;
+                len += unsigned_varint::encode::u64(u64(current_pid), (&mut buffer[len..len+10]).try_into().unwrap()).len();
             } else {
                 buffer[len] = 0;
-                len += 1;
+                len+=1;
             }
             send_ipc_to(usize(proc_man_pid), buffer, len);
         } else {
@@ -363,14 +352,12 @@ impl Tasking {
         }
     }
 
+
     pub fn clear_exited_pid(&self, pid: usize) -> Result<(), ()> {
-        if self.current_pid() == Some(pid) {
-            return Err(());
-        }
         let mut processes = self.processes.write();
         let process = processes.get(pid).ok_or(())?;
-        if process.sleeping.read().is_none() {
-            self.ready_to_run.lock().retain(|e| *e != pid);
+        if *process.sleeping.read() != Some(SleepReason::Exited) {
+            return Err(());
         }
         self.freeable_kstacks.lock().push(processes.remove(pid).kernel_stack);
         Ok(())