Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-06-16 16:53:40 +08:00
parent 651844ba20
commit fb839f3217
8 changed files with 220 additions and 129 deletions

View file

@ -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

View file

@ -27,9 +27,6 @@ showAnalyzer memlcd
sysbus Tag <0xB0000000, 0xB0006000> "Framebuffer"
# Silence COM messages
sysbus SilenceRange <0xF000C000, 0xF000CFFF>
# Silence WDT
sysbus SilenceRange <0xF001F000, 0xF001FFFF>

View file

@ -19,4 +19,4 @@ rustflags = [
]
[build]
target = "riscv32imac-unknown-none-elf"
#target = "riscv32imac-unknown-none-elf"

View file

@ -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"

View file

@ -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) };
}
});
}

View file

@ -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");
}
_ => {}
}

View file

@ -559,6 +559,23 @@ impl SystemServices {
Ok(())
}
pub fn runnable(&self, pid: PID, tid: Option<TID>) -> Result<bool, xous_kernel::Error> {
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.

View file

@ -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)
}
})
}