use alloc::string::String;
use alloc::vec;
use alloc::{
sync::{Arc, Weak},
vec::Vec,
};
use crate::fs::stdio::{Stdin, Stdout};
use crate::mm::page_table::get_translated_refmut;
use crate::trap::context::Riscv64RegAlias;
use crate::{
fs::File,
mm::{
KERNEL_SPACE,
address::{PAGE_SIZE_SV39, PhysicalPageNumber, VirtualAddress, VirtualPageNumber},
memory_set::{MemorySet, TRAMPOLINE},
},
trap::{context::TrapCtx, handler::trap_handler},
utils::safety::SyncRefCell,
};
use super::{
context::TaskCtx,
pid::{PidAllocator, PidHandler},
stack::KernelStack,
};
pub const TRAP_CONTEXT: usize = TRAMPOLINE - PAGE_SIZE_SV39;
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ProcessStatus {
Create,
Ready,
Running,
Wait,
Stopped,
}
pub type FdTable = Vec<Option<Arc<dyn File + Send + Sync>>>;
pub trait FdTableClone {
fn fd_clone(&self) -> Self;
}
impl FdTableClone for FdTable {
fn fd_clone(&self) -> Self {
let mut new_table = Vec::new();
for file in self.iter() {
new_table.push(if let Some(file) = file {
Some(Arc::clone(file))
} else {
None
});
}
new_table
}
}
pub struct ProcessControlBlock {
pub pid: PidHandler,
pub kernel_stack: KernelStack,
pub status: ProcessStatus,
pub ctx: TaskCtx,
pub memory_set: MemorySet,
pub trap_ctx_ppn: PhysicalPageNumber,
pub base_size: usize,
pub parent: Option<Weak<SyncRefCell<ProcessControlBlock>>>,
pub children: Vec<Arc<SyncRefCell<ProcessControlBlock>>>,
pub exit_code: i32,
pub fd_table: FdTable,
}
impl ProcessControlBlock {
pub fn get_trap_cx(&self) -> &'static mut TrapCtx {
self.trap_ctx_ppn.get_mut()
}
pub fn get_user_token(&mut self) -> usize {
let t = self.memory_set.token();
t
}
pub fn get_status(&self) -> ProcessStatus {
self.status
}
pub fn get_pid(&self) -> usize {
self.pid.0
}
pub fn new(app_data: &[u8]) -> Self {
let (memory_set, user_sp, entry) = MemorySet::from_elf_app(app_data);
let trap_ctx_ppn = PhysicalPageNumber::from(
&memory_set
.translate(VirtualPageNumber::from(VirtualAddress::from(TRAP_CONTEXT)))
.unwrap(),
);
let pid = PidAllocator::alloc_pid();
let kernel_stack = KernelStack::new(&pid);
let kernel_stack_top = kernel_stack.top();
let pcb = Self {
pid,
kernel_stack,
status: ProcessStatus::Ready,
ctx: TaskCtx::goto_trap_return(kernel_stack_top),
memory_set,
trap_ctx_ppn,
base_size: user_sp,
parent: None,
children: Vec::new(),
exit_code: 0,
fd_table: vec![
Some(Arc::new(Stdin)),
Some(Arc::new(Stdout)),
Some(Arc::new(Stdout)),
],
};
let ctx = pcb.get_trap_cx();
*ctx = TrapCtx::init_app_context(
entry,
user_sp,
KERNEL_SPACE.ref_cell.borrow_mut().token(),
kernel_stack_top,
trap_handler as usize,
);
pcb
}
pub fn alloc_fd(&mut self) -> usize {
for (fd, file) in self.fd_table.iter().enumerate() {
if file.is_none() {
return fd;
}
}
self.fd_table.push(None);
self.fd_table.len() - 1
}
}
impl SyncRefCell<ProcessControlBlock> {
pub fn fork(
self: &Arc<SyncRefCell<ProcessControlBlock>>,
) -> Arc<SyncRefCell<ProcessControlBlock>> {
let mut parent = self.inner_borrow_mut();
let memory_set = MemorySet::from_existed_user(&parent.memory_set);
let trap_ctx_ppn = PhysicalPageNumber::from(
&memory_set
.translate(VirtualPageNumber::from(VirtualAddress::from(TRAP_CONTEXT)))
.unwrap(),
);
let pid = PidAllocator::alloc_pid();
let kernel_stack = KernelStack::new(&pid);
let kernel_stack_top = kernel_stack.top();
let child = Arc::new(SyncRefCell::new(ProcessControlBlock {
pid,
kernel_stack,
status: ProcessStatus::Ready,
ctx: TaskCtx::goto_trap_return(kernel_stack_top),
memory_set,
trap_ctx_ppn,
base_size: parent.base_size,
parent: Some(Arc::downgrade(self)),
children: Vec::new(),
exit_code: 0,
fd_table: parent.fd_table.fd_clone(),
}));
parent.children.push(child.clone());
let ctx = child.inner_borrow().get_trap_cx();
ctx.kernel_virt_sp = kernel_stack_top;
child
}
pub fn exec(self: &Arc<SyncRefCell<ProcessControlBlock>>, app_data: &[u8], args: Vec<String>) {
let (memory_set, mut user_sp, entry) = MemorySet::from_elf_app(app_data);
let trap_ctx_ppn = PhysicalPageNumber::from(
&memory_set
.translate(VirtualPageNumber::from(VirtualAddress::from(TRAP_CONTEXT)))
.unwrap(),
);
for i in (0..args.len()).rev() {
user_sp -= 1;
*get_translated_refmut(memory_set.token(), user_sp as *mut u8) = 0;
for byte in args[i].bytes().rev() {
user_sp -= 1;
*get_translated_refmut(memory_set.token(), user_sp as *mut u8) = byte;
}
}
let argv_start = user_sp;
let argc = args.len();
user_sp -= user_sp % core::mem::size_of::<usize>();
let mut pcb = self.inner_borrow_mut();
pcb.memory_set = memory_set;
pcb.trap_ctx_ppn = trap_ctx_ppn;
let ctx = pcb.get_trap_cx();
*ctx = TrapCtx::init_app_context(
entry,
user_sp,
KERNEL_SPACE.ref_cell.borrow_mut().token(),
pcb.kernel_stack.top(),
trap_handler as usize,
);
*ctx.a(1) = argc as usize;
*ctx.a(2) = argv_start;
}
}