diff --git a/emulation/soc/betrusted-soc.repl b/emulation/soc/betrusted-soc.repl index 4f81049e1..44cba9fb4 100644 --- a/emulation/soc/betrusted-soc.repl +++ b/emulation/soc/betrusted-soc.repl @@ -7,24 +7,28 @@ cpu: CPU.VexRiscv @ sysbus // Platform Peripherals // Unrecognized peripheral: reboot +timer0: Timers.LiteX_Timer_32 @ sysbus 0xf0001000 + frequency: 100000000 + -> cpu @ 1000 + // Unrecognized peripheral: crg // Unrecognized peripheral: gpio -uart: UART.LiteX_UART @ sysbus 0xf0004000 +uart: UART.LiteX_UART @ sysbus 0xf0005000 -> cpu @ 1002 -console: UART.LiteX_UART @ sysbus 0xf0006000 +console: UART.LiteX_UART @ sysbus 0xf0007000 -> cpu @ 1003 -app_uart: UART.LiteX_UART @ sysbus 0xf0008000 +app_uart: UART.LiteX_UART @ sysbus 0xf0009000 -> cpu @ 1004 // Unrecognized peripheral: info // Unrecognized peripheral: sram_ext -memlcd: Video.BetrustedLCD @ sysbus 0xf000b000 +memlcd: Video.BetrustedLCD @ sysbus 0xf000c000 // Unrecognized peripheral: com @@ -36,7 +40,7 @@ memlcd: Video.BetrustedLCD @ sysbus 0xf000b000 // Unrecognized peripheral: messible2 -ticktimer: Timers.TickTimer @ sysbus 0xf0011000 +ticktimer: Timers.TickTimer @ sysbus 0xf0012000 -> cpu @ 1008 // Unrecognized peripheral: susres @@ -45,7 +49,7 @@ ticktimer: Timers.TickTimer @ sysbus 0xf0011000 // Unrecognized peripheral: spinor -keyboard: Input.BetrustedKbd @ sysbus 0xf0015000 +keyboard: Input.BetrustedKbd @ sysbus 0xf0016000 -> cpu @ 1011 // Unrecognized peripheral: keyinject @@ -56,10 +60,10 @@ keyboard: Input.BetrustedKbd @ sysbus 0xf0015000 // Unrecognized peripheral: audio -trng_kernel: Miscellaneous.BetrustedRNGKernel @ sysbus 0xf001a000 +trng_kernel: Miscellaneous.BetrustedRNGKernel @ sysbus 0xf001b000 -> cpu @ 1013 -trng_server: Miscellaneous.BetrustedRNGServer @ sysbus 0xf001b000 +trng_server: Miscellaneous.BetrustedRNGServer @ sysbus 0xf001c000 -> cpu @ 1014 // Unrecognized peripheral: trng @@ -74,11 +78,9 @@ trng_server: Miscellaneous.BetrustedRNGServer @ sysbus 0xf001b000 // Unrecognized peripheral: d11ctime -// Unrecognized peripheral: identifier_mem +// Unrecognized peripheral: wfi -timer0: Timers.LiteX_Timer_32 @ sysbus 0xf0023000 - frequency: 100000000 - -> cpu @ 1000 +// Unrecognized peripheral: identifier_mem // Physical base addresses of memory regions diff --git a/emulation/xous-release.resc b/emulation/xous-release.resc index 99b7ec216..478d7b2ee 100644 --- a/emulation/xous-release.resc +++ b/emulation/xous-release.resc @@ -27,9 +27,6 @@ showAnalyzer memlcd sysbus Tag <0xB0000000, 0xB0006000> "Framebuffer" -# Silence COM messages -sysbus SilenceRange <0xF000C000, 0xF000CFFF> - # Silence WDT sysbus SilenceRange <0xF001F000, 0xF001FFFF> diff --git a/kernel/.cargo/config b/kernel/.cargo/config index ad2f9e83e..6ad13b533 100644 --- a/kernel/.cargo/config +++ b/kernel/.cargo/config @@ -19,4 +19,4 @@ rustflags = [ ] [build] -target = "riscv32imac-unknown-none-elf" +#target = "riscv32imac-unknown-none-elf" diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 10eadef75..2ad0e0fd4 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -26,7 +26,7 @@ print-panics = [] report-memory = ["stats_alloc"] wrap-print = [] # default = ["print-panics", "debug-print", "wrap-print"] -default = ["print-panics", "gdbserver"] +default = ["print-panics", "gdbserver", "debug-print", "wrap-print"] [target.'cfg(any(windows, unix))'.dependencies] crossbeam-channel = "0.5" diff --git a/kernel/src/arch/riscv/irq.rs b/kernel/src/arch/riscv/irq.rs index 38db3841f..b9d83aaf1 100644 --- a/kernel/src/arch/riscv/irq.rs +++ b/kernel/src/arch/riscv/irq.rs @@ -44,10 +44,9 @@ pub unsafe fn set_isr_return_pair(pid: PID, tid: TID) { PREVIOUS_PAIR = Some((pid, tid)); } -// #[allow(dead_code)] -// pub unsafe fn take_isr_return_pair() -> Option<(PID, TID)> { -// PREVIOUS_PAIR.take() -// } +pub unsafe fn take_isr_return_pair() -> Option<(PID, TID)> { + PREVIOUS_PAIR.take() +} /// Trap entry point rust (_start_trap_rust) /// @@ -104,7 +103,15 @@ pub extern "C" fn trap_handler( // println!("Syscall Result: {:?}", response); ArchProcess::with_current_mut(|p| { let thread = p.current_thread(); - unsafe { _xous_syscall_return_result(&response, thread) }; + // If we're resuming a process that was previously sleeping, restore the + // thread context. Otherwise, keep the thread context the same and pass + // the return values in 8 argument registers. + if response == xous_kernel::Result::ResumeProcess { + crate::arch::syscall::resume(current_pid().get() == 1, thread); + } else { + // println!("Returning to address {:08x}", thread.sepc); + unsafe { _xous_syscall_return_result(&response, thread) }; + } }); } diff --git a/kernel/src/debug.rs b/kernel/src/debug.rs index ca10f5f58..d0fca1e6a 100644 --- a/kernel/src/debug.rs +++ b/kernel/src/debug.rs @@ -305,7 +305,7 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) { #[cfg(feature = "gdbserver")] unsafe { - use crate::debug::gdb_server::{GDB_STATE, XousDebugState}; + use crate::debug::gdb_server::{XousDebugState, GDB_STATE}; use gdbstub::state_machine::GdbStubStateMachine; use gdbstub::{DisconnectReason, GdbStubError}; if let Some(XousDebugState { @@ -438,6 +438,22 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) { Err(e) => println!("Unable to start GDB server: {}", e), } } + b's' => { + println!(">>>>>>>>>>>>>>>>>>>>>>>>>>>> Suspenidng PID 3"); + crate::services::SystemServices::with_mut(|system_services| { + system_services + .suspend_process(xous_kernel::PID::new(3).unwrap()) + .unwrap(); + }); + } + b'c' => { + println!(">>>>>>>>>>>>>>>>>>>>>>>>>>>> Continuing (Resuming) PID 3"); + crate::services::SystemServices::with_mut(|system_services| { + system_services + .continue_process(xous_kernel::PID::new(3).unwrap()) + .unwrap(); + }); + } b'h' => { println!("Xous Kernel Debug"); println!("key | command"); @@ -447,6 +463,8 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) { println!(" m | print MMU page tables of all processes"); println!(" p | print all processes and threads"); println!(" r | report RAM usage of all processes"); + println!(" s | Suspend PID 3"); + println!(" c | Continue PID 3"); } _ => {} } diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 82f165861..4f37f7f2d 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -559,6 +559,23 @@ impl SystemServices { Ok(()) } + pub fn runnable(&self, pid: PID, tid: Option) -> Result { + let process = self.get_process(pid)?; + if let Some(tid) = tid { + Ok(match process.state { + ProcessState::Running(x) if x & (1 << tid) == 0 => true, + ProcessState::Ready(x) if x & (1 << tid) == 0 => true, + ProcessState::Sleeping => true, + _ => false, + }) + } else { + Ok(match process.state { + ProcessState::Running(_) | ProcessState::Ready(_) | ProcessState::Sleeping => true, + _ => false, + }) + } + } + /// Mark the specified context as ready to run. If the thread is Sleeping, mark /// it as Ready. pub fn ready_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> { @@ -572,6 +589,7 @@ impl SystemServices { } ProcessState::Ready(x) if x & (1 << tid) == 0 => ProcessState::Ready(x | (1 << tid)), ProcessState::Sleeping => ProcessState::Ready(1 << tid), + ProcessState::Debug(x) if x & (1 << tid) == 0 => ProcessState::Debug(x | (1 << tid)), other => panic!( "PID {} was not in a state to wake thread {}: {:?}", pid, tid, other @@ -1954,6 +1972,54 @@ impl SystemServices { Ok(parent_pid) } + pub fn suspend_process(&mut self, pid: PID) -> Result<(), xous_kernel::Error> { + let (process_state, parent_pid) = { + let process = self.get_process_mut(pid)?; + (process.state, process.ppid) + }; + let new_process_state = match process_state { + ProcessState::Allocated => ProcessState::Allocated, + ProcessState::Free => ProcessState::Free, + ProcessState::Setup(thread_init) => ProcessState::Setup(thread_init), + ProcessState::Ready(tids) => ProcessState::Debug(tids), + ProcessState::Sleeping => ProcessState::Debug(0), + ProcessState::Debug(tids) => ProcessState::Debug(tids), + ProcessState::Running(tids) => { + // Switch to the parent process when we return. + let current_tid = arch::process::current_tid(); + + let parent_process = self.get_process_mut(parent_pid).unwrap(); + parent_process.activate().unwrap(); + let mut p = crate::arch::process::Process::current(); + // FIXME: What happens if this fails? We're currently in the new process + // but without a context to switch to. + p.set_thread(parent_process.previous_thread).unwrap(); + parent_process.current_thread = parent_process.previous_thread; + + // Ensure we don't switch back to the same process. + unsafe { crate::arch::irq::take_isr_return_pair() }; + ProcessState::Ready(tids | 1 << current_tid) + } + }; + self.get_process_mut(pid).unwrap().state = new_process_state; + Ok(()) + } + + pub fn continue_process(&mut self, pid: PID) -> Result<(), xous_kernel::Error> { + let process = self.get_process_mut(pid)?; + process.state = match process.state { + ProcessState::Allocated => ProcessState::Allocated, + ProcessState::Free => ProcessState::Free, + ProcessState::Setup(thread_init) => ProcessState::Setup(thread_init), + ProcessState::Ready(tids) => ProcessState::Ready(tids), + ProcessState::Sleeping => ProcessState::Sleeping, + ProcessState::Debug(0) => ProcessState::Sleeping, + ProcessState::Debug(tids) => ProcessState::Ready(tids), + ProcessState::Running(tids) => ProcessState::Running(tids), + }; + Ok(()) + } + /// Calls the provided function with the current inner process state. pub fn shutdown(&mut self) -> Result<(), xous_kernel::Error> { // Destroy all servers. This will cause all queued messages to be lost. diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 3835dc07f..239efde92 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -145,116 +145,117 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes // If the server has an available thread to receive the message, // transfer it right away. - if let Some(server_tid) = ss - .server_from_sidx_mut(sidx) - .expect("server couldn't be located") - .take_available_thread() - { - // klog!( - // "there are threads available in PID {} to handle this message -- marking as Ready", - // server_pid - // ); - let sender_idx = if message.is_blocking() { - ss.remember_server_message(sidx, pid, thread, &message, client_address) - .map_err(|e| { - klog!("error remembering server message: {:?}", e); - ss.server_from_sidx_mut(sidx) - .expect("server couldn't be located") - .return_available_thread(server_tid); - e - })? - } else { - 0 - }; - let sender = SenderID::new(sidx, sender_idx, Some(pid)); - klog!( - "server connection data: sidx: {}, idx: {}, server pid: {}", - sidx, - sender_idx, - server_pid - ); - let envelope = MessageEnvelope { - sender: sender.into(), - body: message, - }; - - // Mark the server's context as "Ready". If this fails, return the context - // to the blocking list. - ss.ready_thread(server_pid, server_tid).map_err(|e| { - ss.server_from_sidx_mut(sidx) - .expect("server couldn't be located") - .return_available_thread(server_tid); - e - })?; - - if blocking && cfg!(baremetal) { - klog!("Activating Server context and switching away from Client"); - ss.activate_process_thread(thread, server_pid, server_tid, false) - .map(|_| Ok(xous_kernel::Result::Message(envelope))) - .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) - } else if blocking && !cfg!(baremetal) { - klog!("Blocking client, since it sent a blocking message"); - ss.switch_from_thread(pid, thread)?; - ss.switch_to_thread(server_pid, Some(server_tid))?; - ss.set_thread_result( - server_pid, - server_tid, - xous_kernel::Result::Message(envelope), - ) - .map(|_| xous_kernel::Result::BlockedProcess) - } else if cfg!(baremetal) { - klog!("Setting the return value of the Server ({}:{}) to {:?} and returning to Client", - server_pid, server_tid, envelope); - ss.set_thread_result( - server_pid, - server_tid, - xous_kernel::Result::Message(envelope), - ) - .map(|_| xous_kernel::Result::Ok) - } else { + if ss.runnable(server_pid, None).unwrap() { + let server = ss + .server_from_sidx_mut(sidx) + .expect("server couldn't be located"); + if let Some(server_tid) = server.take_available_thread() { + // klog!( + // "there are threads available in PID {} to handle this message -- marking as Ready", + // server_pid + // ); + let sender_idx = if message.is_blocking() { + ss.remember_server_message(sidx, pid, thread, &message, client_address) + .map_err(|e| { + klog!("error remembering server message: {:?}", e); + ss.server_from_sidx_mut(sidx) + .expect("server couldn't be located") + .return_available_thread(server_tid); + e + })? + } else { + 0 + }; + let sender = SenderID::new(sidx, sender_idx, Some(pid)); klog!( - "setting the return value of the Server to {:?} and returning to Client", - envelope + "server connection data: sidx: {}, idx: {}, server pid: {}", + sidx, + sender_idx, + server_pid ); - // "Switch to" the server PID when not running on bare metal. This ensures - // that it's "Running". - ss.switch_to_thread(server_pid, Some(server_tid))?; - ss.set_thread_result( - server_pid, - server_tid, - xous_kernel::Result::Message(envelope), - ) - .map(|_| xous_kernel::Result::Ok) + let envelope = MessageEnvelope { + sender: sender.into(), + body: message, + }; + + // Mark the server's context as "Ready". If this fails, return the context + // to the blocking list. + ss.ready_thread(server_pid, server_tid).map_err(|e| { + ss.server_from_sidx_mut(sidx) + .expect("server couldn't be located") + .return_available_thread(server_tid); + e + })?; + + // --- NOTE: Returning this value // + return if blocking && cfg!(baremetal) { + klog!("Activating Server context and switching away from Client"); + ss.activate_process_thread(thread, server_pid, server_tid, false) + .map(|_| Ok(xous_kernel::Result::Message(envelope))) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) + } else if blocking && !cfg!(baremetal) { + klog!("Blocking client, since it sent a blocking message"); + ss.switch_from_thread(pid, thread)?; + ss.switch_to_thread(server_pid, Some(server_tid))?; + ss.set_thread_result( + server_pid, + server_tid, + xous_kernel::Result::Message(envelope), + ) + .map(|_| xous_kernel::Result::BlockedProcess) + } else if cfg!(baremetal) { + klog!("Setting the return value of the Server ({}:{}) to {:?} and returning to Client", + server_pid, server_tid, envelope); + ss.set_thread_result( + server_pid, + server_tid, + xous_kernel::Result::Message(envelope), + ) + .map(|_| xous_kernel::Result::Ok) + } else { + klog!( + "setting the return value of the Server to {:?} and returning to Client", + envelope + ); + // "Switch to" the server PID when not running on bare metal. This ensures + // that it's "Running". + ss.switch_to_thread(server_pid, Some(server_tid))?; + ss.set_thread_result( + server_pid, + server_tid, + xous_kernel::Result::Message(envelope), + ) + .map(|_| xous_kernel::Result::Ok) + }; + } + } + klog!( + "no threads available in PID {} to handle this message, so queueing", + server_pid + ); + // Add this message to the queue. If the queue is full, this + // returns an error. + let _queue_idx = ss.queue_server_message(sidx, pid, thread, message, client_address)?; + klog!("queued into index {:x}", _queue_idx); + + // Park this context if it's blocking. This is roughly + // equivalent to a "Yield". + if blocking { + if cfg!(baremetal) { + // println!("Returning to parent"); + let process = ss.get_process(pid).expect("Can't get current process"); + let ppid = process.ppid; + unsafe { SWITCHTO_CALLER = None }; + ss.activate_process_thread(thread, ppid, 0, false) + .map(|_| Ok(xous_kernel::Result::ResumeProcess)) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) + } else { + ss.switch_from_thread(pid, thread)?; + Ok(xous_kernel::Result::BlockedProcess) } } else { - klog!( - "no threads available in PID {} to handle this message, so queueing", - server_pid - ); - // Add this message to the queue. If the queue is full, this - // returns an error. - let _queue_idx = ss.queue_server_message(sidx, pid, thread, message, client_address)?; - klog!("queued into index {:x}", _queue_idx); - - // Park this context if it's blocking. This is roughly - // equivalent to a "Yield". - if blocking { - if cfg!(baremetal) { - // println!("Returning to parent"); - let process = ss.get_process(pid).expect("Can't get current process"); - let ppid = process.ppid; - unsafe { SWITCHTO_CALLER = None }; - ss.activate_process_thread(thread, ppid, 0, false) - .map(|_| Ok(xous_kernel::Result::ResumeProcess)) - .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) - } else { - ss.switch_from_thread(pid, thread)?; - Ok(xous_kernel::Result::BlockedProcess) - } - } else { - // println!("Returning to Client with Ok result"); - Ok(xous_kernel::Result::Ok) - } + // println!("Returning to Client with Ok result"); + Ok(xous_kernel::Result::Ok) } }) }