pub mod pid;
pub use pid::ProcessId;
pub mod pcb;
pub use pcb::{ProcessControlBlock, ProcessState};
pub mod context;
pub use context::{
ProcessContext, PROCESS_CONTEXT_SATP_OFFSET, PROCESS_CONTEXT_SEPC_OFFSET,
PROCESS_CONTEXT_SSTATUS_OFFSET,
};
pub mod scheduler;
pub mod state; pub use scheduler::RoundRobinScheduler;
pub mod elf;
pub mod switch;
pub mod user;
pub mod user_elf;
use crate::println;
use alloc::boxed::Box;
use core::sync::atomic::{AtomicBool, Ordering};
use lazy_static::lazy_static;
use spin::Mutex;
lazy_static! {
pub static ref SCHEDULER: Mutex<RoundRobinScheduler> = Mutex::new(RoundRobinScheduler::new(5));
}
static mut SCHEDULER_STARTED: bool = false;
use crate::memory::{PhysAddr, SimpleFrameAllocator};
static mut FRAME_ALLOCATOR: Option<SimpleFrameAllocator> = None;
static FRAME_ALLOCATOR_BUSY: AtomicBool = AtomicBool::new(false);
lazy_static! {
static ref KERNEL_PAGE_TABLE_PADDR: Mutex<Option<usize>> = Mutex::new(None);
}
pub fn init_frame_allocator_from(kernel_end: usize) {
let memory_end = 0x8000_0000usize + 128 * 1024 * 1024;
let allocator = SimpleFrameAllocator::new(kernel_end, memory_end);
unsafe {
FRAME_ALLOCATOR = Some(allocator);
}
}
pub fn set_kernel_page_table_paddr(paddr: PhysAddr) {
*KERNEL_PAGE_TABLE_PADDR.lock() = Some(paddr.as_usize());
}
pub fn kernel_page_table_paddr() -> Option<PhysAddr> {
let paddr = *KERNEL_PAGE_TABLE_PADDR.lock();
paddr.map(PhysAddr::new)
}
#[allow(static_mut_refs)]
pub fn with_frame_allocator<F, R>(f: F) -> R
where
F: FnOnce(&mut SimpleFrameAllocator) -> R,
{
if FRAME_ALLOCATOR_BUSY.swap(true, Ordering::Acquire) {
panic!("frame allocator reentered — interrupt-in-allocator detected");
}
let result = unsafe { f(FRAME_ALLOCATOR.as_mut().expect("frame allocator not set")) };
FRAME_ALLOCATOR_BUSY.store(false, Ordering::Release);
result
}
extern "C" fn task_trap() -> ! {
crate::serial_println!("[TASK] Kernel task returned unexpectedly — halting");
crate::hlt_loop();
}
fn kernel_sstatus_init() -> usize {
let raw: usize;
unsafe {
core::arch::asm!("csrr {}, sstatus", out(reg) raw);
}
(raw | (1 << 8) | (1 << 5)) & !(1 << 1) }
pub unsafe fn create_kernel_task(
pid: ProcessId,
name: &'static str,
entry: extern "C" fn() -> !,
stack: *mut [u8; 4096],
) -> Box<ProcessControlBlock> {
let mut pcb = ProcessControlBlock::new(pid, name, None);
let ctx = pcb.context_mut();
let stack_ptr = unsafe { (*stack).as_mut_ptr() };
ctx.set_ra(task_trap as *const () as usize);
ctx.set_sp(stack_ptr as usize + 4096);
ctx.set_sepc(entry as usize);
ctx.set_sstatus(kernel_sstatus_init());
ctx.set_satp(riscv::register::satp::read().bits());
Box::new(pcb)
}
pub unsafe fn start_first_task(ctx: *const ProcessContext) {
SCHEDULER_STARTED = true;
riscv::register::sstatus::clear_sie();
unsafe {
core::arch::asm!("csrw sscratch, {}", in(reg) crate::interrupts::trap_stack_top());
}
switch::__start_first_task(ctx);
}
pub fn scheduler_tick(tf: &mut crate::interrupts::TrapFrame) {
let mut sched = SCHEDULER.lock();
if let Some(pcb) = sched.current_mut() {
tf.save_to(pcb.context_mut());
}
sched.tick();
if let Some(pcb) = sched.current() {
tf.load_from(pcb.context());
}
}
pub fn debug_scheduler_state() {
let sched = SCHEDULER.lock();
let stats = sched.stats();
println!(
" [SCHED] current={:?}, ready={}, blocked={}, zombies={}, total={}, is_idle={}",
sched.current().map(|p| (p.name(), p.pid().as_usize())),
stats.ready,
stats.blocked,
stats.zombies,
stats.total,
sched.is_idle(),
);
}
pub fn fork_current(tf: &crate::interrupts::TrapFrame) -> isize {
let (parent_pid, parent_satp) = {
let sched = SCHEDULER.lock();
let current = match sched.current() {
Some(p) => p,
None => return -1isize,
};
(current.pid(), current.context().satp)
};
let child_satp = match with_frame_allocator(|allocator| {
crate::memory::address_space::deep_copy_user_address_space(parent_satp, allocator)
}) {
Ok(satp) => satp,
Err(reason) => {
crate::serial_println!("[FORK] address-space copy failed: {}", reason);
return -1isize;
}
};
let child_pid = ProcessId::new();
let mut child_pcb = ProcessControlBlock::new(child_pid, "child", Some(parent_pid));
{
let child_ctx = child_pcb.context_mut();
child_ctx.x.copy_from_slice(&tf.x[1..]);
child_ctx.x[9] = 0; child_ctx.sepc = tf.sepc.wrapping_add(4);
child_ctx.sstatus = (tf.sstatus | (1 << 5)) & !(1 << 1);
child_ctx.satp = child_satp;
}
let mut sched = SCHEDULER.lock();
if let Some(parent) = sched.current_mut() {
if parent.pid() != parent_pid {
return -1isize;
}
parent.add_child(child_pid);
} else {
return -1isize;
}
if sched.add_process(Box::new(child_pcb)).is_err() {
if let Some(parent) = sched.current_mut() {
parent.remove_child(child_pid);
}
return -1isize;
}
crate::serial_println!(
"[FORK] parent={} child={} satp={:#x}",
parent_pid.as_usize(),
child_pid.as_usize(),
child_satp
);
child_pid.as_usize() as isize
}
pub fn exec_current(path: &str) -> isize {
use crate::fs::vfs::open_file;
let file = match open_file(path) {
Ok(f) => f,
Err(_) => return -1isize,
};
let mut elf_data = alloc::vec![0u8; 65536];
let n = match file.lock().read(&mut elf_data) {
Ok(n) => n,
Err(_) => return -1isize,
};
elf_data.truncate(n);
let elf = match elf::Elf::parse(&elf_data) {
Ok(e) => e,
Err(_) => return -1isize,
};
with_frame_allocator(|allocator| {
let kernel_paddr = match kernel_page_table_paddr() {
Some(paddr) => paddr,
None => return -1isize,
};
let new_addr_space =
match user::create_user_address_space(&elf, &elf_data, allocator, kernel_paddr) {
Ok(a) => a,
Err(_) => return -1isize,
};
let new_satp = {
let ppn = new_addr_space.page_table_paddr().as_usize() >> 12;
(8usize << 60) | ppn
};
let user_stack_top = 0x7FFF_F000usize;
let mut sched = SCHEDULER.lock();
if let Some(pcb) = sched.current_mut() {
let ctx = pcb.context_mut();
ctx.x = [0; 31];
ctx.set_ra(0);
ctx.set_sp(user_stack_top);
ctx.set_sepc(elf.entry);
let raw: usize;
unsafe {
core::arch::asm!("csrr {}, sstatus", out(reg) raw);
}
ctx.set_sstatus((raw | (1 << 5) | (1 << 18)) & !((1 << 8) | (1 << 1)));
ctx.set_satp(new_satp);
}
crate::serial_println!(
"[EXEC] Loaded ELF '{}' entry={:#x} satp={:#x}",
path,
elf.entry,
new_satp
);
0
})
}
pub fn exec_current_into_trap_frame(tf: &mut crate::interrupts::TrapFrame, path: &str) -> isize {
let ret = exec_current(path);
if ret != 0 {
return ret;
}
let sched = SCHEDULER.lock();
if let Some(pcb) = sched.current() {
tf.load_from(pcb.context());
0
} else {
-1
}
}
pub fn exit_current_and_switch(tf: &mut crate::interrupts::TrapFrame, exit_code: i32) -> ! {
let switched = {
let mut sched = SCHEDULER.lock();
let parent_pid = if let Some(pcb) = sched.current_mut() {
pcb.set_exit_code(exit_code);
crate::serial_println!(
"[EXIT] PID={} exit_code={} parent={:?}",
pcb.pid().as_usize(),
exit_code,
pcb.parent_pid()
);
pcb.parent_pid()
} else {
None
};
if let Some(ppid) = parent_pid {
sched.unblock_process(ppid);
}
sched.schedule();
if let Some(pcb) = sched.current() {
tf.load_from(pcb.context());
true
} else {
false
}
};
if !switched {
crate::serial_println!("[EXIT] no runnable process remains; halting");
crate::hlt_loop();
}
let tf_addr = tf as *const _ as usize;
unsafe {
core::arch::asm!(
"mv sp, {tf}",
"j trap_return",
tf = in(reg) tf_addr,
options(noreturn)
);
}
}
pub fn wait_current(tf: &mut crate::interrupts::TrapFrame, exit_code_ptr: usize) -> isize {
let mut sched = SCHEDULER.lock();
let parent_pid = match sched.current() {
Some(p) => p.pid(),
None => return -1,
};
if let Some((child_pid, code)) = sched.find_zombie_child(parent_pid) {
let child_pid_value = child_pid.as_usize();
drop(sched);
if exit_code_ptr != 0
&& crate::syscall::user_ptr::raw_write_value(exit_code_ptr, code).is_err()
{
return -1;
}
let mut sched = SCHEDULER.lock();
sched.remove_zombie(child_pid);
drop(sched);
crate::serial_println!(
"[WAIT] Reaped zombie PID={} exit_code={}",
child_pid_value,
code
);
return child_pid_value as isize;
}
if sched.has_living_children(parent_pid) {
if sched.ready_count() == 0 {
crate::serial_println!(
"[WAIT] PID={} has living children but no runnable handoff task",
parent_pid.as_usize()
);
return crate::errno::EBUSY;
}
tf.sepc = tf.sepc.wrapping_add(4);
if let Some(pcb) = sched.current_mut() {
tf.save_to(pcb.context_mut());
pcb.set_state(ProcessState::Blocked)
.expect("running process can block on wait");
}
let next = sched.pick_next_ready();
if let Some(pcb) = next {
tf.load_from(pcb.context());
}
drop(sched);
let tf_addr = tf as *const _ as usize;
unsafe {
core::arch::asm!(
"mv sp, {tf}",
"j trap_return",
tf = in(reg) tf_addr,
options(noreturn)
);
}
}
-1isize
}