kernel: support debugging interrupt handlers

SUpport debugging when interrupt handlers go awry, such as when they
blow out their own stack.

Do this by creating a dummy sentinal of 255 for interrupt handlers.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2023-07-16 15:26:15 +08:00
parent 85055052fd
commit cb32b31e18

View file

@ -26,6 +26,11 @@ pub const EXIT_THREAD: usize = 0xff80_3000;
/// This is the address a thread will return to when it finishes handling an exception. /// This is the address a thread will return to when it finishes handling an exception.
pub const RETURN_FROM_EXCEPTION_HANDLER: usize = 0xff80_4000; pub const RETURN_FROM_EXCEPTION_HANDLER: usize = 0xff80_4000;
/// Support processing interrupts, which normally are TID 0. Since
/// the TID is a NonZeroU8, we must pick a value here that can be
/// used throughout the rest of the kernel.
const IRQ_TID_SENTINAL: TID = 255;
// Thread IDs have three possible meaning: // Thread IDs have three possible meaning:
// Logical Thread ID: What the user sees // Logical Thread ID: What the user sees
// Thread Context Index: An index into the thread slice // Thread Context Index: An index into the thread slice
@ -122,6 +127,14 @@ pub struct Process {
pid: PID, pid: PID,
} }
fn fixup_irq(tid: TID) -> TID {
if tid == IRQ_TID_SENTINAL {
0
} else {
tid
}
}
#[repr(C)] #[repr(C)]
#[derive(Copy, Clone, Debug, Default)] #[derive(Copy, Clone, Debug, Default)]
/// Everything required to keep track of a single thread of execution. /// Everything required to keep track of a single thread of execution.
@ -202,40 +215,44 @@ impl Process {
} }
pub fn thread_exists(&self, tid: TID) -> bool { pub fn thread_exists(&self, tid: TID) -> bool {
let tid = fixup_irq(tid);
self.thread(tid).sepc != 0 self.thread(tid).sepc != 0
} }
/// Set the current thread number. /// Set the current thread number.
pub fn set_tid(&mut self, thread: TID) -> Result<(), xous_kernel::Error> { pub fn set_tid(&mut self, tid: TID) -> Result<(), xous_kernel::Error> {
let mut process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
klog!("Switching to thread {}", thread); let tid = fixup_irq(tid);
klog!("Switching to thread {}", tid);
assert!( assert!(
thread <= process.threads.len(), tid <= process.threads.len(),
"attempt to switch to an invalid thread {}", "attempt to switch to an invalid thread {}",
thread tid
); );
process.hardware_thread = thread + 1; process.hardware_thread = tid + 1;
Ok(()) Ok(())
} }
pub fn thread_mut(&mut self, thread: TID) -> &mut Thread { pub fn thread_mut(&mut self, tid: TID) -> &mut Thread {
let process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
let tid = fixup_irq(tid);
assert!( assert!(
thread <= process.threads.len(), tid <= process.threads.len(),
"attempt to retrieve an invalid thread {}", "attempt to retrieve an invalid thread {}",
thread tid
); );
&mut process.threads[thread] &mut process.threads[tid]
} }
pub fn thread(&self, thread: TID) -> &Thread { pub fn thread(&self, tid: TID) -> &Thread {
let process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
let tid = fixup_irq(tid);
assert!( assert!(
thread <= process.threads.len(), tid <= process.threads.len(),
"attempt to retrieve an invalid thread {}", "attempt to retrieve an invalid thread {}",
thread tid
); );
&process.threads[thread] &process.threads[tid]
} }
#[cfg(feature = "gdb-stub")] #[cfg(feature = "gdb-stub")]
@ -246,10 +263,14 @@ impl Process {
let process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
for (idx, thread) in process.threads.iter_mut().enumerate() { for (idx, thread) in process.threads.iter_mut().enumerate() {
// Ignore threads that have no PC, and ignore the ISR thread // Ignore threads that have no PC, and ignore the ISR thread
if thread.sepc == 0 || idx == IRQ_TID { if thread.sepc == 0 {
continue; continue;
} }
op(idx, thread); if idx == IRQ_TID {
op(IRQ_TID_SENTINAL, thread);
} else {
op(idx, thread);
}
} }
} }
@ -282,7 +303,7 @@ impl Process {
pub fn retry_instruction(&mut self, tid: TID) -> Result<(), xous_kernel::Error> { pub fn retry_instruction(&mut self, tid: TID) -> Result<(), xous_kernel::Error> {
let process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
let mut thread = &mut process.threads[tid]; let thread = &mut process.threads[tid];
if thread.sepc >= 4 { if thread.sepc >= 4 {
thread.sepc -= 4; thread.sepc -= 4;
} }
@ -292,7 +313,7 @@ impl Process {
/// Initialize this process thread with the given entrypoint and stack /// Initialize this process thread with the given entrypoint and stack
/// addresses. /// addresses.
pub fn setup_process(pid: PID, thread_init: ThreadInit) -> Result<(), xous_kernel::Error> { pub fn setup_process(pid: PID, thread_init: ThreadInit) -> Result<(), xous_kernel::Error> {
let mut process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
let tid = INITIAL_TID; let tid = INITIAL_TID;
assert_eq!( assert_eq!(
@ -342,7 +363,7 @@ impl Process {
*thread = Default::default(); *thread = Default::default();
} }
let mut thread = &mut process.threads[tid]; let thread = &mut process.threads[tid];
thread.sepc = unsafe { core::mem::transmute::<_, usize>(thread_init.call) }; thread.sepc = unsafe { core::mem::transmute::<_, usize>(thread_init.call) };
thread.registers[1] = thread_init.stack.as_ptr() as usize + thread_init.stack.len(); thread.registers[1] = thread_init.stack.as_ptr() as usize + thread_init.stack.len();
@ -502,7 +523,7 @@ impl Process {
} }
pub fn destroy(pid: PID) -> Result<(), xous_kernel::Error> { pub fn destroy(pid: PID) -> Result<(), xous_kernel::Error> {
let mut process_table = unsafe { &mut PROCESS_TABLE }; let process_table = unsafe { &mut PROCESS_TABLE };
let pid_idx = pid.get() as usize - 1; let pid_idx = pid.get() as usize - 1;
if pid_idx >= process_table.table.len() { if pid_idx >= process_table.table.len() {
panic!("attempted to destroy PID that exceeds table index: {}", pid); panic!("attempted to destroy PID that exceeds table index: {}", pid);
@ -597,7 +618,7 @@ impl core::fmt::Display for Thread {
pub fn set_current_pid(pid: PID) { pub fn set_current_pid(pid: PID) {
let pid_idx = (pid.get() - 1) as usize; let pid_idx = (pid.get() - 1) as usize;
unsafe { unsafe {
let mut pt = &mut PROCESS_TABLE; let pt = &mut PROCESS_TABLE;
match pt.table.get(pid_idx) { match pt.table.get(pid_idx) {
None | Some(false) => panic!("PID {} does not exist", pid), None | Some(false) => panic!("PID {} does not exist", pid),