mikros/kernel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: mikros:4548d9540ea16e76110b8c8b564fad5cf9bfa8e2
Branches Tags
mikros:master
..
compare: mikros:fb58d2c7c4de8f1ba32eb8e7c09523639109d5b2
Branches Tags
mikros:master

2 Commits
4548d9540e ... fb58d2c7c4

Author SHA1 Message Date
pjht
fb58d2c7c4
Format 2024-11-08 14:13:27 -06:00
pjht
50e7b7236e
Make clear_exited_pid work on running processes 2024-11-08 14:13:13 -06:00
2 changed files with 105 additions and 92 deletions
Show Stats Expand all files Collapse all files

166
src/interrupts.rs
View File

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

31
src/tasking.rs
View File

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