kernel: initial gdb-stub reimplementation

Add an initial reimplementation of the gdb-stub using the gdbstub
backing crate.

This supports process enumeration and basic thread investigation.
Processes will pause when the debugger is inspecting them. Memory and
registers can be investigated. Threads can be listed and selected.

It does not yet support breakpoints.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2023-04-06 10:45:42 +08:00
parent e48c108288
commit 13029a76a2
6 changed files with 904 additions and 17 deletions

View file

@ -24,6 +24,8 @@ xous-kernel = { package = "xous", version = "0.9.37", features = [
[target.'cfg(target_arch = "riscv32")'.dependencies]
riscv = { version = "0.5.6", package = "xous-riscv" } # source is in "../imports/riscv-0.5.6"
gdbstub = { version = "0.6.4", optional = true, default-features = false }
gdbstub_arch = { version = "0.2.4", optional = true, default-features = false }
[target.'cfg(target_arch = "arm")'.dependencies]
armv7 = { git = "https://github.com/Foundation-Devices/armv7.git", branch = "update", features = ["critical-section"] }
@ -40,7 +42,7 @@ hosted = ["utralib/hosted"]
renode = ["utralib/renode"]
debug-print = []
gdb-stub = []
gdb-stub = ["gdbstub", "gdbstub_arch"]
print-panics = []
report-memory = ["stats_alloc"]
wrap-print = []

678
kernel/src/debug/gdb.rs Normal file
View file

@ -0,0 +1,678 @@
use gdbstub::common::{Signal, Tid};
use gdbstub::stub::state_machine::GdbStubStateMachine;
use gdbstub::stub::{GdbStubBuilder, GdbStubError, MultiThreadStopReason};
use gdbstub::target;
use gdbstub::target::ext::base::multithread::{MultiThreadBase, MultiThreadResume};
use gdbstub::target::ext::base::single_register_access::{
SingleRegisterAccess, SingleRegisterAccessOps,
};
use gdbstub::target::ext::base::BaseOps;
use gdbstub::target::ext::monitor_cmd::MonitorCmd;
use gdbstub::target::TargetError;
use gdbstub::target::{Target, TargetResult};
use gdbstub_arch::riscv::reg::id::RiscvRegId;
use crate::io::SerialRead;
use crate::platform::precursor::gdbuart::GdbUart;
use core::convert::TryInto;
pub struct XousTarget {
pid: Option<xous_kernel::PID>,
}
pub struct XousDebugState<'a> {
pub target: XousTarget,
pub server: GdbStubStateMachine<'a, XousTarget, crate::platform::precursor::gdbuart::GdbUart>,
}
pub static mut GDB_STATE: Option<XousDebugState> = None;
pub static mut GDB_BUFFER: [u8; 4096] = [0u8; 4096];
fn receive_irq(uart: &mut GdbUart) {
while let Some(c) = uart.getc() {
advance_gdb_or_recreate(Some(c));
}
}
impl XousTarget {
pub fn new() -> XousTarget {
XousTarget { pid: None }
}
}
impl Target for XousTarget {
type Arch = gdbstub_arch::riscv::Riscv32;
type Error = &'static str;
fn base_ops(&mut self) -> BaseOps<Self::Arch, Self::Error> {
BaseOps::MultiThread(self)
}
fn support_breakpoints(
&mut self,
) -> Option<gdbstub::target::ext::breakpoints::BreakpointsOps<Self>> {
Some(self)
}
fn support_monitor_cmd(&mut self) -> Option<target::ext::monitor_cmd::MonitorCmdOps<'_, Self>> {
Some(self)
}
}
impl MultiThreadBase for XousTarget {
fn read_registers(
&mut self,
regs: &mut gdbstub_arch::riscv::reg::RiscvCoreRegs<u32>,
tid: Tid,
) -> TargetResult<(), Self> {
let Some(pid) = self.pid else {
for entry in regs.x.iter_mut() {
*entry = 0;
}
return Ok(());
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
let debugging_pid = pid;
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
let process = crate::arch::process::Process::current();
let thread = process.thread(tid.get());
regs.x[0] = 0;
for (dbg_reg, thr_reg) in regs.x[1..].iter_mut().zip(thread.registers.iter()) {
*dbg_reg = (*thr_reg) as u32;
}
regs.pc = (thread.sepc) as u32;
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
});
Ok(())
}
fn write_registers(
&mut self,
regs: &gdbstub_arch::riscv::reg::RiscvCoreRegs<u32>,
tid: Tid,
) -> TargetResult<(), Self> {
let Some(pid) = self.pid else {
return Ok(())
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
let debugging_pid = pid;
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
let mut process = crate::arch::process::Process::current();
let thread = process.thread_mut(tid.get());
for (thr_reg, dbg_reg) in thread.registers.iter_mut().zip(regs.x[1..].iter()) {
*thr_reg = (*dbg_reg) as usize;
}
thread.sepc = (regs.pc) as usize;
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
});
Ok(())
}
fn read_addrs(
&mut self,
start_addr: u32,
data: &mut [u8],
_tid: Tid, // same address space for each core
) -> TargetResult<(), Self> {
let mut current_addr = start_addr;
let Some(pid) = self.pid else {
for entry in data.iter_mut() { *entry = 0 };
return Ok(());
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
let debugging_pid = pid;
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
data.iter_mut().for_each(|b| {
*b = crate::arch::mem::peek_memory(current_addr as *mut u8).unwrap_or(0xff);
current_addr += 1;
});
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
});
Ok(())
}
fn write_addrs(
&mut self,
start_addr: u32,
data: &[u8],
_tid: Tid, // same address space for each core
) -> TargetResult<(), Self> {
let mut current_addr = start_addr;
let Some(pid) = self.pid else {
return Ok(());
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
let debugging_pid = pid;
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
data.iter().for_each(|b| {
if let Err(_e) = crate::arch::mem::poke_memory(current_addr as *mut u8, *b) {
panic!("couldn't poke memory: {:?}", _e);
// gprintln!("Error writing to {:08x}: {:?}", current_addr, e);
}
current_addr += 1;
});
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
});
Ok(())
}
fn list_active_threads(
&mut self,
register_thread: &mut dyn FnMut(Tid),
) -> Result<(), Self::Error> {
let Some(pid) = self.pid else {
// Register a fake thread
register_thread(Tid::new(1).unwrap());
return Ok(());
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
let debugging_pid = pid;
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
crate::arch::process::Process::current().for_each_thread_mut(|tid, _thr| {
register_thread(Tid::new(tid).unwrap());
});
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
});
Ok(())
}
fn support_single_register_access(&mut self) -> Option<SingleRegisterAccessOps<'_, Tid, Self>> {
Some(self)
}
fn support_resume(
&mut self,
) -> Option<target::ext::base::multithread::MultiThreadResumeOps<'_, Self>> {
Some(self)
}
}
impl SingleRegisterAccess<Tid> for XousTarget {
fn read_register(
&mut self,
tid: Tid,
reg_id: RiscvRegId<u32>,
buf: &mut [u8],
) -> TargetResult<usize, Self> {
// For the case of no PID, fake a value
let Some(pid) = self.pid else {
buf.copy_from_slice(&0u32.to_le_bytes());
return Ok(buf.len());
};
let reg_id = match reg_id {
RiscvRegId::Gpr(0) => {
buf.copy_from_slice(&0u32.to_le_bytes());
return Ok(buf.len());
}
RiscvRegId::Gpr(x) => x as usize - 1,
RiscvRegId::Pc => 32,
_ => {
return Err(TargetError::Fatal("register out of range"));
}
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
let debugging_pid = pid;
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
let process = crate::arch::process::Process::current();
let thread = process.thread(tid.get());
let reg = if reg_id == 32 {
&thread.sepc
} else {
match thread.registers.get(reg_id) {
Some(val) => val,
None => return Err(TargetError::Fatal("register out of range")),
}
};
buf.copy_from_slice(&reg.to_le_bytes());
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
Ok(buf.len())
})
}
fn write_register(
&mut self,
tid: Tid,
reg_id: RiscvRegId<u32>,
val: &[u8],
) -> TargetResult<(), Self> {
let Some(pid) = self.pid else {
return Ok(())
};
let w = u32::from_le_bytes(
val.try_into()
.map_err(|_| TargetError::Fatal("invalid data"))?,
);
let reg_id = match reg_id {
RiscvRegId::Gpr(0) => {
return Ok(());
}
RiscvRegId::Gpr(x) => x as usize - 1,
RiscvRegId::Pc => 32,
_ => {
return Err(TargetError::Fatal("register out of range"));
}
};
crate::services::SystemServices::with(|system_services| {
let current_pid = system_services.current_pid();
// Actiavte the debugging process and iterate through it,
// noting down each active thread.
let debugging_pid = pid;
system_services
.get_process(debugging_pid)
.unwrap()
.activate()
.unwrap();
let mut process = crate::arch::process::Process::current();
let thread = process.thread_mut(tid.get());
let reg = if reg_id == 32 {
&mut thread.sepc
} else {
match thread.registers.get_mut(reg_id) {
Some(val) => val,
None => return Err(TargetError::Fatal("register out of range")),
}
};
*reg = w as usize;
// Restore the previous PID
system_services
.get_process(current_pid)
.unwrap()
.activate()
.unwrap();
Ok(())
})
}
}
impl MultiThreadResume for XousTarget {
fn resume(&mut self) -> Result<(), Self::Error> {
println!("Resuming process {:?}", self.pid);
// unsafe { HALTED = false };
// match default_resume_action {
// ResumeAction::Step | ResumeAction::StepWithSignal(_) => {
// return Err("single-stepping not supported")
// }
// _ => (),
// }
if let Some(pid) = self.pid {
crate::services::SystemServices::with_mut(|system_services| {
system_services.resume_process_from_debug(pid).unwrap()
});
}
Ok(())
}
fn clear_resume_actions(&mut self) -> Result<(), Self::Error> {
println!("Clearing resume actions");
Ok(())
}
fn set_resume_action_continue(
&mut self,
tid: Tid,
signal: Option<Signal>,
) -> Result<(), Self::Error> {
println!(
"Setting resume action continue on process {:?} thread {:?} with signal: {:?}",
self.pid, tid, signal
);
// match action {
// ResumeAction::Step | ResumeAction::StepWithSignal(_) => {
// Err("single-stepping resume action not supported")
// }
// ResumeAction::Continue | ResumeAction::ContinueWithSignal(_) => Ok(()),
// }
Ok(())
}
}
impl target::ext::breakpoints::Breakpoints for XousTarget {
#[inline(always)]
fn support_sw_breakpoint(
&mut self,
) -> Option<target::ext::breakpoints::SwBreakpointOps<'_, Self>> {
Some(self)
}
}
impl target::ext::breakpoints::SwBreakpoint for XousTarget {
#[inline(never)]
fn add_sw_breakpoint(&mut self, _addr: u32, _kind: usize) -> TargetResult<bool, Self> {
println!(
"GDB asked us to add a software breakpoint at {:08x} of kind {:?}",
_addr, _kind
);
Ok(true)
}
#[inline(never)]
fn remove_sw_breakpoint(&mut self, _addr: u32, _kind: usize) -> TargetResult<bool, Self> {
println!(
"GDB asked us to remove a software breakpoint at {:08x} of kind {:?}",
_addr, _kind
);
Ok(true)
}
}
impl MonitorCmd for XousTarget {
fn handle_monitor_cmd(
&mut self,
cmd: &[u8],
mut out: target::ext::monitor_cmd::ConsoleOutput<'_>,
) -> Result<(), Self::Error> {
let Ok(cmd) = core::str::from_utf8(cmd) else {
gdbstub::outputln!(out, "command must be valid UTF-8");
return Ok(());
};
if cmd.starts_with("pr") {
if let Some(pid_str) = cmd.split_ascii_whitespace().nth(1) {
// Parse the new PID. If it isn't a valid string, then this will be None
let new_pid =
xous_kernel::PID::new(u8::from_str_radix(pid_str, 10).unwrap_or_default());
if let Some(previous_pid) = self.pid {
crate::services::SystemServices::with_mut(|system_services| {
system_services
.resume_process_from_debug(previous_pid)
.unwrap()
});
}
// Disallow debugging the kernel. Sad times.
if new_pid.map(|v| v.get() == 1).unwrap_or(false) {
gdbstub::outputln!(out, "Kernel cannot debug itself");
self.pid = None;
return Ok(());
}
self.pid = new_pid;
if let Some(new_pid) = self.pid {
gdbstub::outputln!(out, "Now debugging PID {}", new_pid);
crate::services::SystemServices::with_mut(|system_services| {
system_services.pause_process_for_debug(new_pid).unwrap()
});
} else {
gdbstub::outputln!(out, "No process is selected for debugging");
}
return Ok(());
}
gdbstub::outputln!(out, "Available processes:");
crate::services::SystemServices::with(|system_services| {
for process in &system_services.processes {
if !process.free() {
gdbstub::outputln!(
out,
" {:2} {} {}",
process.pid,
if self.pid.map(|p| p == process.pid).unwrap_or(false) {
'*'
} else {
' '
},
system_services.process_name(process.pid).unwrap_or("")
);
}
}
});
} else if cmd.starts_with("h") {
gdbstub::outputln!(out, "Here is a list of help commands:");
gdbstub::outputln!(out, " process Print a list of processes");
gdbstub::outputln!(out, " process [n] Switch to debugging process [n]");
} else {
gdbstub::outputln!(out, "command not found -- try 'mon help'");
}
Ok(())
}
}
fn advance_gdb_or_recreate(byte: Option<u8>) {
advance_gdb_state(byte);
if unsafe { GDB_STATE.is_none() } {
println!("GDB went away -- recreating it");
init();
}
}
fn advance_gdb_state(byte: Option<u8>) -> bool {
let Some(XousDebugState {
mut target,
server: gdb,
}) = (unsafe { GDB_STATE.take() }) else {
println!("No GDB!");
return false;
};
let mut new_gdb = match gdb {
GdbStubStateMachine::Idle(gdb_stm_inner) => match byte {
Some(byte) => match gdb_stm_inner.incoming_data(&mut target, byte) {
Ok(gdb) => gdb,
Err(e) => {
println!("gdbstub error during idle operation: {:?}", e);
return true;
}
},
None => {
println!("gdbstub was idle with no characters?!");
GdbStubStateMachine::Idle(gdb_stm_inner)
}
},
GdbStubStateMachine::Running(gdb_stm_inner) => {
// If we're here we were running but have stopped now (either
// because we hit Ctrl+c in gdb and hence got a serial interrupt
// or we hit a breakpoint).
// let conn = gdb_stm_inner.borrow_conn();
// conn.disable_irq();
// let data_to_read = conn.peek().unwrap().is_some();
// let mut stop_reason = target.determine_stop_reason(reason);
if let Some(byte) = byte {
match gdb_stm_inner.incoming_data(&mut target, byte) {
Ok(pumped_stm) => {
if let GdbStubStateMachine::CtrlCInterrupt(_) = pumped_stm {
println!(
"Looks like we maybe just transitioned from running to ctrl-c?"
);
} else if let GdbStubStateMachine::Idle(_) = pumped_stm {
println!("Looks like we maybe just transitioned from running to idle?");
}
pumped_stm
}
Err(GdbStubError::TargetError(e)) => {
println!("Target raised a fatal error: {:?}", e);
return false;
}
Err(e) => {
println!("gdbstub error in DeferredStopReason.pump: {:?}", e);
return false;
}
}
// } else if let Some(reason) = stop_reason.take() {
// match gdb_stm_inner.report_stop(&mut target, MultiThreadStopReason::DoneStep) {
// Ok(gdb_stm_new) => gdb_stm_new,
// Err(GdbStubError::TargetError(e)) => {
// println!("Target raised a fatal error {:?}", e);
// return false;
// }
// Err(e) => {
// println!("gdbstub internal error {:?}", e);
// return false;
// }
// }
// } else if target.resume_with.is_some() {
// // // We don't have a `stop_reason` and we don't have something
// // // to read on the line. This probably means we're done and
// // // we should run again.
// // conn.enable_irq();
// // let r = GDB_STUB
// // .lock()
// // .replace(GdbStubStateMachine::Running(gdb_stm_inner));
// // assert!(
// // r.is_none(),
// // "Put something in GDB_STUB which we shouldn't have..."
// // );
// // return false;
// GdbStubStateMachine::Running(gdb_stm_inner)
} else {
panic!("Can't happen?");
}
}
GdbStubStateMachine::CtrlCInterrupt(_gdb_stm_inner) => {
panic!("debug server was in an unexpected state");
}
GdbStubStateMachine::Disconnected(_gdb_stm_inner) => {
println!("GdbStubStateMachine::Disconnected byebye");
return false;
}
};
if let GdbStubStateMachine::CtrlCInterrupt(gdb_stm_inner) = new_gdb {
println!("Just transitioned into CtrlCInterrupt");
match gdb_stm_inner.interrupt_handled(&mut target, Some(MultiThreadStopReason::DoneStep)) {
Ok(gdb) => new_gdb = gdb,
Err(e) => {
println!("gdbstub error during ctrl-c interrupt{:?}", e);
return false;
}
}
if let Some(pid) = target.pid {
println!("Starting debug on process {:?}", pid);
crate::services::SystemServices::with_mut(|system_services| {
system_services.pause_process_for_debug(pid).unwrap()
});
} else {
println!("No process specified! Not debugging");
}
}
unsafe {
GDB_STATE = Some(XousDebugState {
target,
server: new_gdb,
})
};
true
}
pub fn init() {
let uart = GdbUart::new(receive_irq).unwrap();
let mut target = XousTarget::new();
match GdbStubBuilder::new(uart)
.with_packet_buffer(unsafe { &mut GDB_BUFFER })
.build()
{
Ok(gdb) => match gdb.run_state_machine(&mut target) {
Ok(state) => unsafe {
GDB_STATE = Some(XousDebugState {
target: target,
server: state,
});
HALTED = true;
},
Err(e) => println!("Unable to start GDB state machine: {}", e),
},
Err(e) => println!("Unable to start GDB server: {}", e),
}
}
static mut HALTED: bool = false;

View file

@ -5,3 +5,6 @@
mod macros;
#[cfg(baremetal)]
pub mod shell;
#[cfg(all(baremetal, feature = "gdb-stub"))]
pub mod gdb;

View file

@ -0,0 +1,130 @@
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
// SPDX-FileCopyrightText: 2022 Foundation Devices, Inc. <hello@foundationdevices.com>
// SPDX-License-Identifier: Apache-2.0
use crate::{
io::{SerialRead, SerialWrite},
mem::MemoryManager,
PID,
};
use core::sync::atomic::{AtomicUsize, Ordering};
use utralib::generated::*;
use xous_kernel::{MemoryFlags, MemoryType};
static UART_USAGE_COUNT: AtomicUsize = AtomicUsize::new(0);
/// UART virtual address.
///
/// See https://github.com/betrusted-io/xous-core/blob/master/docs/memory.md
pub const APP_UART_ADDR: usize = 0xffcc_0000;
/// UART peripheral driver.
pub struct GdbUart {
uart_csr: CSR<u32>,
callback: fn(&mut Self),
}
impl GdbUart {
pub fn new(callback: fn(&mut Self)) -> Option<GdbUart> {
if UART_USAGE_COUNT
.compare_exchange(0, 1, Ordering::Relaxed, Ordering::Relaxed)
.is_err()
{
return None;
}
// Map the UART peripheral.
MemoryManager::with_mut(|memory_manager| {
memory_manager
.map_range(
utra::app_uart::HW_APP_UART_BASE as *mut u8,
(APP_UART_ADDR & !4095) as *mut u8,
4096,
PID::new(1).unwrap(),
MemoryFlags::R | MemoryFlags::W,
MemoryType::Default,
)
.expect("unable to map serial port")
});
let mut gdb_uart = GdbUart {
uart_csr: CSR::new(APP_UART_ADDR as *mut u32),
callback,
};
xous_kernel::claim_interrupt(
utra::app_uart::APP_UART_IRQ,
GdbUart::irq,
(&mut gdb_uart as *mut GdbUart) as *mut usize,
)
.expect("Couldn't claim debug interrupt");
Some(gdb_uart)
}
pub fn enable(&mut self) {
self.uart_csr.rmwf(utra::app_uart::EV_ENABLE_RX, 1);
}
pub fn irq(_irq_number: usize, arg: *mut usize) {
let uart = unsafe { &mut *(arg as *mut GdbUart) };
(uart.callback)(uart);
}
}
impl Drop for GdbUart {
fn drop(&mut self) {
if UART_USAGE_COUNT.fetch_sub(1, Ordering::Relaxed) != 1 {
panic!("UART ad a usage count of more than 1");
}
println!("Freeing interrupt since the count has gone to zero");
xous_kernel::rsyscall(xous_kernel::SysCall::FreeInterrupt(
utra::app_uart::APP_UART_IRQ,
))
.unwrap();
MemoryManager::with_mut(|memory_manager| {
memory_manager
.unmap_page((APP_UART_ADDR & !4095) as *mut usize)
.unwrap()
});
}
}
impl SerialWrite for GdbUart {
fn putc(&mut self, c: u8) {
// Wait until TXFULL is `0`
while self.uart_csr.r(utra::app_uart::TXFULL) != 0 {}
self.uart_csr.wfo(utra::app_uart::RXTX_RXTX, c as u32);
}
}
impl SerialRead for GdbUart {
fn getc(&mut self) -> Option<u8> {
// If EV_PENDING_RX is 1, return the pending character.
// Otherwise, return None.
match self.uart_csr.rf(utra::app_uart::EV_PENDING_RX) {
0 => None,
_ => {
let ret = Some(self.uart_csr.r(utra::app_uart::RXTX) as u8);
self.uart_csr.wfo(utra::app_uart::EV_PENDING_RX, 1);
ret
}
}
}
}
impl gdbstub::conn::Connection for GdbUart {
type Error = &'static str;
fn write(&mut self, byte: u8) -> Result<(), Self::Error> {
self.putc(byte);
Ok(())
}
fn flush(&mut self) -> Result<(), Self::Error> {
Ok(())
}
fn on_session_start(&mut self) -> Result<(), Self::Error> {
self.enable();
Ok(())
}
}

View file

@ -1,6 +1,8 @@
// SPDX-FileCopyrightText: 2022 Foundation Devices, Inc. <hello@foundationdevices.com>
// SPDX-License-Identifier: Apache-2.0
#[cfg(feature = "gdb-stub")]
pub mod gdbuart;
pub mod rand;
#[cfg(any(feature = "debug-print", feature = "print-panics"))]
pub mod uart;
@ -8,6 +10,10 @@ pub mod uart;
/// Precursor specific initialization.
pub fn init() {
self::rand::init();
#[cfg(any(feature = "debug-print", feature = "print-panics"))]
self::uart::init();
#[cfg(feature = "gdb-stub")]
crate::debug::gdb::init();
}

View file

@ -86,9 +86,15 @@ pub enum ProcessState {
/// The process is currently being debugged. When it is resumed,
/// this will turn into `Ready(usize)`
#[allow(dead_code)]
#[cfg(feature = "gdb-stub")]
Debug(usize),
/// The process is currently being debugged, but an interrupt happened
/// anyway. When the interrupt finishes, this will turn into `Debug(usize)`.
/// This generally should not happen, but is here in case NMIs are ever a thing.
#[cfg(feature = "gdb-stub")]
DebugIrq(usize),
/// This process is processing an exception. When it is resumed, it will
/// turn into `Ready(usize)`.
Exception(usize),
@ -107,7 +113,10 @@ impl core::fmt::Debug for ProcessState {
Setup(ti) => write!(fmt, "Setup({:?})", ti),
Ready(rt) => write!(fmt, "Ready({:b})", rt),
Running(rt) => write!(fmt, "Running({:b})", rt),
#[cfg(feature = "gdb-stub")]
Debug(rt) => write!(fmt, "Debug({:b})", rt),
#[cfg(feature = "gdb-stub")]
DebugIrq(rt) => write!(fmt, "DebugIrq({:b})", rt),
Exception(rt) => write!(fmt, "Exception({:b})", rt),
BlockedException(rt) => write!(fmt, "BlockedException({:b})", rt),
Sleeping => write!(fmt, "Sleeping"),
@ -343,7 +352,9 @@ impl SystemServices {
let init_offsets = {
let mut init_count = 1;
for arg in args.iter() {
if arg.name == u32::from_le_bytes(*b"IniE") || arg.name == u32::from_le_bytes(*b"IniF") {
if arg.name == u32::from_le_bytes(*b"IniE")
|| arg.name == u32::from_le_bytes(*b"IniF")
{
init_count += 1;
}
}
@ -557,6 +568,8 @@ impl SystemServices {
current.state = match current.state {
ProcessState::Running(0) => ProcessState::Sleeping,
ProcessState::Running(x) => ProcessState::Ready(x),
#[cfg(feature = "gdb-stub")]
ProcessState::DebugIrq(x) => ProcessState::Debug(x),
y => panic!("current process was {:?}, not 'Running(_)'", y),
};
// log_process_update(file!(), line!(), current, old_state);
@ -568,12 +581,14 @@ impl SystemServices {
// is in a very bad state.
{
let mut process = self.get_process_mut(pid)?;
#[cfg(feature = "gdb-stub")]
let ppid = process.ppid;
// Ensure the new context is available to be run
let available_threads = match process.state {
ProcessState::Ready(x) if x & 1 << tid != 0 => x & !(1 << tid),
// If we're currently debugging the process, return to its parent.
// This can happen when the process handles a debug interrupt.
#[cfg(feature = "gdb-stub")]
ProcessState::Debug(_) => {
crate::syscall::reset_switchto_caller();
return self.switch_to_thread(ppid, None);
@ -654,18 +669,29 @@ impl SystemServices {
{
let mut process = self.get_process_mut(pid)?;
let available_threads = match process.state {
ProcessState::Ready(x)
| ProcessState::Running(x)
| ProcessState::Debug(x)
| ProcessState::Exception(x) => x,
ProcessState::Ready(x) | ProcessState::Running(x) | ProcessState::Exception(x) => x,
#[cfg(feature = "gdb-stub")]
ProcessState::Debug(x) | ProcessState::DebugIrq(x) => x,
ProcessState::Sleeping | ProcessState::BlockedException(_) => 0,
ProcessState::Free => panic!("process was not allocated"),
ProcessState::Setup(_) | ProcessState::Allocated => {
panic!("process hasn't been set up yet")
}
};
#[cfg(feature = "gdb-stub")]
if let ProcessState::Debug(_) = process.state {
println!("Making a callback for IRQ {} to process {:?} which is currently in a debug state!", irq_no, pid);
process.state = ProcessState::DebugIrq(available_threads);
} else {
process.state = ProcessState::Running(available_threads);
}
// let old_state = process.state;
process.state = ProcessState::Running(available_threads);
#[cfg(not(feature = "gdb-stub"))]
{
process.state = ProcessState::Running(available_threads);
}
// log_process_update(file!(), line!(), process, old_state);
process.previous_thread = process.current_thread;
process.current_thread = arch::process::IRQ_TID;
@ -734,7 +760,12 @@ impl SystemServices {
}
ProcessState::Ready(x) if x & (1 << tid) == 0 => ProcessState::Ready(x | (1 << tid)),
ProcessState::Sleeping => ProcessState::Ready(1 << tid),
#[cfg(feature = "gdb-stub")]
ProcessState::Debug(x) if x & (1 << tid) == 0 => ProcessState::Debug(x | (1 << tid)),
#[cfg(feature = "gdb-stub")]
ProcessState::DebugIrq(x) if x & (1 << tid) == 0 => {
ProcessState::DebugIrq(x | (1 << tid))
}
ProcessState::Exception(ready_threads)
| ProcessState::BlockedException(ready_threads) => {
ProcessState::Exception(ready_threads)
@ -845,7 +876,10 @@ impl SystemServices {
ProcessState::BlockedException(_) => {
panic!("tried to switch to an exception handler that was blocked")
}
ProcessState::Debug(_) => return Err(xous_kernel::Error::DebugInProgress),
#[cfg(feature = "gdb-stub")]
ProcessState::Debug(_) | ProcessState::DebugIrq(_) => {
return Err(xous_kernel::Error::DebugInProgress)
}
ProcessState::Exception(x) => {
process.activate()?;
let mut p = ArchProcess::current();
@ -1083,9 +1117,11 @@ impl SystemServices {
ProcessState::Running(_) => {
panic!("process was running even though the pid was different")
}
ProcessState::Sleeping
| ProcessState::Debug(_)
| ProcessState::BlockedException(_) => {
#[cfg(feature = "gdb-stub")]
ProcessState::Debug(_) | ProcessState::DebugIrq(_) => {
return Err(xous_kernel::Error::ProcessNotFound)
}
ProcessState::Sleeping | ProcessState::BlockedException(_) => {
// println!("PID {} was sleeping or being debugged", new_pid);
return Err(xous_kernel::Error::ProcessNotFound);
}
@ -1121,7 +1157,10 @@ impl SystemServices {
ProcessState::BlockedException(_) => {
panic!("process was blocked handling an exception")
}
ProcessState::Debug(_) => panic!("process was being debugged"),
#[cfg(feature = "gdb-stub")]
ProcessState::Debug(_) | ProcessState::DebugIrq(_) => {
panic!("process was being debugged")
}
};
// log_process_update(file!(), line!(), new, old_state);
new.activate()?;
@ -2215,11 +2254,24 @@ impl SystemServices {
}
#[cfg(feature = "gdb-stub")]
pub fn suspend_process(&mut self, pid: PID) -> Result<(), xous_kernel::Error> {
pub fn pause_process_for_debug(&mut self, pid: PID) -> Result<(), xous_kernel::Error> {
println!("Pausing process {:?} for debug...", pid);
let (process_state, parent_pid) = {
let process = self.get_process_mut(pid)?;
(process.state, process.ppid)
};
// Disable all interrupts that belong to this process
crate::irq::for_each_irq(|irq_no, irq_pid, _, _| {
println!("Examining IRQ {}...", irq_no);
if pid == *irq_pid {
println!(
"Disabling IRQ {} since it's owned by process {:?}",
irq_no, pid
);
crate::arch::irq::disable_irq(irq_no);
}
});
let new_process_state = match process_state {
ProcessState::Allocated => ProcessState::Allocated,
ProcessState::Free => ProcessState::Free,
@ -2229,6 +2281,7 @@ impl SystemServices {
ProcessState::BlockedException(tids) => ProcessState::BlockedException(tids),
ProcessState::Sleeping => ProcessState::Debug(0),
ProcessState::Debug(tids) => ProcessState::Debug(tids),
ProcessState::DebugIrq(tids) => ProcessState::DebugIrq(tids),
ProcessState::Running(tids) => {
// Switch to the parent process when we return.
let current_tid = arch::process::current_tid();
@ -2260,6 +2313,10 @@ impl SystemServices {
};
{
let process = self.get_process_mut(pid).unwrap();
println!(
"Process {:?} went from {:?} to {:?}",
pid, process.state, new_process_state
);
// let old_state = process.state;
process.state = new_process_state;
// log_process_update(file!(), line!(), process, old_state);
@ -2269,9 +2326,9 @@ impl SystemServices {
}
#[cfg(feature = "gdb-stub")]
pub fn continue_process(&mut self, pid: PID) -> Result<(), xous_kernel::Error> {
pub fn resume_process_from_debug(&mut self, pid: PID) -> Result<(), xous_kernel::Error> {
let process = self.get_process_mut(pid)?;
// let old_state = process.state;
let old_state = process.state;
process.state = match process.state {
ProcessState::Allocated => ProcessState::Allocated,
ProcessState::Free => ProcessState::Free,
@ -2280,11 +2337,22 @@ impl SystemServices {
ProcessState::Sleeping => ProcessState::Sleeping,
ProcessState::Exception(x) => ProcessState::Exception(x),
ProcessState::BlockedException(tids) => ProcessState::BlockedException(tids),
ProcessState::DebugIrq(tids) => ProcessState::Ready(tids),
ProcessState::Debug(0) => ProcessState::Sleeping,
ProcessState::Debug(tids) => ProcessState::Ready(tids),
ProcessState::Running(tids) => ProcessState::Running(tids),
};
// log_process_update(file!(), line!(), process, old_state);
println!(
"Resuming process {:?} from debug, going from {:?} to {:?}",
pid, old_state, process.state
);
// Resume all interrupts that belong to this process
crate::irq::for_each_irq(|irq, irq_pid, _, _| {
if pid == *irq_pid {
crate::arch::irq::enable_irq(irq);
}
});
Ok(())
}