diff --git a/kernel/src/debug.rs b/kernel/src/debug.rs index ca5963fa6..6df5f977e 100644 --- a/kernel/src/debug.rs +++ b/kernel/src/debug.rs @@ -83,7 +83,7 @@ impl Uart { } #[cfg(all(not(test), feature = "debug-print"))] -pub fn irq(_irq_number: usize, _arg: usize) { +pub fn irq(_irq_number: usize, _arg: *mut usize) { println!( "Interrupt {}: Key pressed: {}", _irq_number, diff --git a/kernel/src/main.rs b/kernel/src/main.rs index d0ddfffd9..8b1e1ccb8 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -17,9 +17,9 @@ mod args; mod irq; mod macros; mod mem; +mod server; mod services; mod syscall; -mod server; use mem::MemoryManagerHandle; use services::SystemServicesHandle; @@ -110,12 +110,8 @@ pub extern "C" fn main() { println!("KMAIN: Supervisor mode started..."); debug::SUPERVISOR_UART.enable_rx(); println!("Claiming IRQ 3 via syscall..."); - xous::rsyscall(xous::SysCall::ClaimInterrupt( - 3, - debug::irq as *mut usize, - 0 as *mut usize, - )) - .expect("Couldn't claim interrupt 3"); + xous::claim_interrupt(3, debug::irq, 0 as *mut usize) + .expect("Couldn't claim interrupt 3"); print!("}} "); } @@ -128,6 +124,26 @@ pub extern "C" fn main() { } } + let child_pids = { + let system_services = SystemServicesHandle::get(); + let mut child_count = 0; + for process in system_services.processes { + if process.ppid == 1 { + child_count += 1; + } + } + + let mut child_pids = [0; child_count]; + let mut idx = 0; + for (process_idx, process) in system_services.processes.enumerate() { + if process.ppid == 1 { + child_pids[idx] = process_idx; + idx += 1; + } + } + child_pids + }; + let mut pid = None; loop { arch::irq::disable_all_irqs(); @@ -137,8 +153,7 @@ pub extern "C" fn main() { match pid { Some(pid) => { println!("Attempting to switch to PID {}", pid); - xous::rsyscall(xous::SysCall::SwitchTo(pid, 0)) - .expect("couldn't switch to pid"); + xous::rsyscall(xous::SysCall::SwitchTo(pid, 0)).expect("couldn't switch to pid"); () } None => { diff --git a/kernel/src/services.rs b/kernel/src/services.rs index dfb73bf98..7a2e14671 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -169,7 +169,9 @@ static mut SYSTEM_SERVICES: SystemServices = SystemServices { ppid: 0, mapping: arch::mem::DEFAULT_MEMORY_MAPPING, }; MAX_PROCESS_COUNT], - servers: filled_array![None; 32], // Note we can't use MAX_SERVER_COUNT here because of how Rust's tokenization works + // Note we can't use MAX_SERVER_COUNT here because of how Rust's + // macro tokenization works + servers: filled_array![None; 32], syscall_stack: [(0, 0), (0, 0), (0, 0)], syscall_depth: 0, }; @@ -185,9 +187,9 @@ impl core::fmt::Debug for Process { } impl SystemServices { - /// Create a new "System Services" object based on the arguments from the kernel. - /// These arguments decide where the memory spaces are located, as well as where - /// the stack and program counter should initially go. + /// Create a new "System Services" object based on the arguments from the + /// kernel. These arguments decide where the memory spaces are located, as + /// well as where the stack and program counter should initially go. pub fn init(&mut self, base: *const u32, args: &KernelArguments) { // Look through the kernel arguments and create a new process for each. let init_offsets = { @@ -200,9 +202,9 @@ impl SystemServices { unsafe { slice::from_raw_parts(base as *const InitialProcess, init_count) } }; - // Copy over the initial process list. The pid is encoded in the SATP value - // from the bootloader. For each process, translate it from a raw KernelArguments - // value to a SystemServices Process value. + // Copy over the initial process list. The pid is encoded in the SATP + // value from the bootloader. For each process, translate it from a raw + // KernelArguments value to a SystemServices Process value. for init in init_offsets.iter() { let pid = (init.satp >> 22) & ((1 << 9) - 1); let ref mut process = self.processes[(pid - 1) as usize]; @@ -293,8 +295,8 @@ impl SystemServices { irq_no: usize, arg: *mut usize, ) -> Result<(), xous::Error> { - // Get the current process (which was just interrupted) and mark - // it as "ready to run". + // Get the current process (which was just interrupted) and mark it as + // "ready to run". { let current_pid = self.current_pid(); let mut current = self @@ -308,7 +310,8 @@ impl SystemServices { current.state = ProcessState::Ready; } - // Get the new process, and ensure that it is in a state where it's fit to run. + // Get the new process, and ensure that it is in a state where it's fit + // to run. let mut process = self.get_process_mut(pid)?; match process.state { ProcessState::Ready | ProcessState::Running | ProcessState::Sleeping => (), @@ -336,8 +339,8 @@ impl SystemServices { Ok(()) } - /// Resume the given process, picking up exactly where it left off. - /// If the process is in the Setup state, set it up and then resume. + /// Resume the given process, picking up exactly where it left off. If the + /// process is in the Setup state, set it up and then resume. pub fn resume_pid( &mut self, pid: PID, @@ -383,7 +386,8 @@ impl SystemServices { } new.state = ProcessState::Running; - // Mark the previous process as ready to run, since we just switched away + // Mark the previous process as ready to run, since we just switched + // away { // println!( // "Marking previous process {} as {:?}", @@ -405,8 +409,8 @@ impl SystemServices { Ok(()) } - /// Allocate a new server ID for this process and return the address. - /// If the server table is full, return an error. + /// Allocate a new server ID for this process and return the address. If the + /// server table is full, return an error. pub fn create_server(&mut self, name: usize) -> Result { println!("Looking through server list for free server"); println!("Server entries are {} bytes long", mem::size_of::()); @@ -431,8 +435,8 @@ impl SystemServices { Err(xous::Error::OutOfMemory) } - /// Allocate a new server ID for this process and return the address. - /// If the server table is full, return an error. + /// Allocate a new server ID for this process and return the address. If the + /// server table is full, return an error. pub fn connect_to_server(&mut self, sid: SID) -> Result { // Check to see if we've already connected to this server. // While doing this, find a free slot in case we haven't @@ -440,7 +444,8 @@ impl SystemServices { let mut slot_idx = None; let mut process = ProcessHandle::get(); - // Look through the connection map for (1) a free slot, and (2) an existing connection + // Look through the connection map for (1) a free slot, and (2) an + // existing connection for (idx, server_idx) in process.inner.connection_map.iter().enumerate() { // If we find an empty slot, use it if *server_idx == 0 { @@ -502,19 +507,18 @@ impl SystemServices { } } -/// How many people have checked out the handle object. -/// This should be replaced by an AtomicUsize when we get -/// multicore support. -/// For now, we can get away with this since the memory manager -/// should only be accessed in an IRQ context. +/// How many people have checked out the handle object. This should be replaced +/// by an AtomicUsize when we get multicore support. For now, we can get away +/// with this since the memory manager should only be accessed in an IRQ +/// context. static mut SS_HANDLE_COUNT: usize = 0; pub struct SystemServicesHandle<'a> { manager: &'a mut SystemServices, } -/// Wraps the MemoryManager in a safe mutex. Because of this, accesses -/// to the Memory Manager should only be made during interrupt contexts. +/// Wraps the MemoryManager in a safe mutex. Because of this, accesses to the +/// Memory Manager should only be made during interrupt contexts. impl<'a> SystemServicesHandle<'a> { /// Get the singleton memory manager. pub fn get() -> SystemServicesHandle<'a> {