diff --git a/kernel/src/arch/riscv/irq.rs b/kernel/src/arch/riscv/irq.rs index 11c4b966e..f5d916dad 100644 --- a/kernel/src/arch/riscv/irq.rs +++ b/kernel/src/arch/riscv/irq.rs @@ -33,6 +33,9 @@ fn sim_write(new: usize) { /// Disable external interrupts pub fn disable_all_irqs() { + if !IRQ_ENABLED.load(Ordering::Relaxed) { + panic!("IRQs were disabled twice!"); + } SIM_BACKING.store(sim_read(), Ordering::Relaxed); IRQ_ENABLED.store(false, Ordering::Relaxed); sim_write(0x0); @@ -51,11 +54,16 @@ pub fn enable_irq(irq_no: usize) { // Note that the vexriscv "IRQ Mask" register is inverse-logic -- // that is, setting a bit in the "mask" register unmasks (i.e. enables) it. if IRQ_ENABLED.load(Ordering::Relaxed) { - sim_write(sim_read() | (1 << irq_no)); + let existing = sim_read(); + let new = existing | (1 << irq_no); + // println!("Enabling IRQ {} (active): {:08x} -> {:08x}", irq_no, existing, new); + sim_write(new); } else { SIM_BACKING - .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |v| { - Some(v | (1 << irq_no)) + .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |existing| { + let new = existing | (1 << irq_no); + // println!("Enabling IRQ {} (masked: {:08x}): {:08x} -> {:08x}", irq_no, sim_read(), existing, new); + Some(new) }) .ok(); } @@ -65,11 +73,25 @@ pub fn enable_irq(irq_no: usize) { /// SIM backing instead so that it will be disabled when interrupts are restored. pub fn disable_irq(irq_no: usize) { if IRQ_ENABLED.load(Ordering::Relaxed) { - sim_write(sim_read() & !(1 << irq_no)); + let existing = sim_read(); + let new = existing & !(1 << irq_no); + // println!( + // "Disabling IRQ {} (active): {:08x} -> {:08x}", + // irq_no, existing, new + // ); + sim_write(new); } else { SIM_BACKING - .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |v| { - Some(v & !(1 << irq_no)) + .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |existing| { + let new = existing & !(1 << irq_no); + println!( + "Disabling IRQ {} (masked: {:08x}): {:08x} -> {:08x}", + irq_no, + sim_read(), + existing, + new + ); + Some(new) }) .ok(); } @@ -371,6 +393,7 @@ pub extern "C" fn trap_handler( { ss.pause_process_for_debug(pid) .expect("couldn't debug current process"); + crate::debug::gdb::report_terminated(pid); println!("Program suspended. You may inspect it using gdb."); } #[cfg(not(feature = "gdb-stub"))] diff --git a/kernel/src/debug/gdb.rs b/kernel/src/debug/gdb.rs index c05177acd..dd2efb8c8 100644 --- a/kernel/src/debug/gdb.rs +++ b/kernel/src/debug/gdb.rs @@ -1,4 +1,5 @@ use gdbstub::common::{Signal, Tid}; +use gdbstub::conn::Connection; use gdbstub::stub::state_machine::GdbStubStateMachine; use gdbstub::stub::{GdbStubBuilder, GdbStubError, MultiThreadStopReason}; use gdbstub::target; @@ -8,35 +9,49 @@ use gdbstub::target::ext::base::single_register_access::{ }; use gdbstub::target::ext::base::BaseOps; use gdbstub::target::ext::monitor_cmd::MonitorCmd; -use gdbstub::target::TargetError; -use gdbstub::target::{Target, TargetResult}; +use gdbstub::target::{Target, TargetError, TargetResult}; use gdbstub_arch::riscv::reg::id::RiscvRegId; use crate::io::SerialRead; use crate::platform::precursor::gdbuart::GdbUart; use core::convert::TryInto; +// use core::num::{NonZeroU16, NonZeroUsize}; pub struct XousTarget { pid: Option, + // breakpoints: [Option<(NonZeroUsize, NonZeroU16)>; 16], } pub struct XousDebugState<'a> { pub target: XousTarget, pub server: GdbStubStateMachine<'a, XousTarget, crate::platform::precursor::gdbuart::GdbUart>, } -pub static mut GDB_STATE: Option = None; -pub static mut GDB_BUFFER: [u8; 4096] = [0u8; 4096]; +static mut GDB_STATE: Option = None; +static mut GDB_BUFFER: [u8; 4096] = [0u8; 4096]; + +trait ProcessPid { + fn pid(&self) -> Option; +} + +impl ProcessPid for XousTarget { + fn pid(&self) -> Option { + self.pid + } +} fn receive_irq(uart: &mut GdbUart) { while let Some(c) = uart.getc() { - advance_gdb_or_recreate(Some(c)); + process_character(c); } } impl XousTarget { pub fn new() -> XousTarget { - XousTarget { pid: None } + XousTarget { + pid: None, + // breakpoints: [None; 16], + } } } @@ -54,6 +69,12 @@ impl Target for XousTarget { Some(self) } + /// Opt in to having GDB handle breakpoints for us. This allows for an unlimited number + /// of breakpoints without having us keep track of the breakpoints ourselves. + fn guard_rail_implicit_sw_breakpoints(&self) -> bool { + true + } + fn support_monitor_cmd(&mut self) -> Option> { Some(self) } @@ -380,7 +401,7 @@ impl SingleRegisterAccess for XousTarget { impl MultiThreadResume for XousTarget { fn resume(&mut self) -> Result<(), Self::Error> { - println!("Resuming process {:?}", self.pid); + // println!("Resuming process {:?}", self.pid); // unsafe { HALTED = false }; // match default_resume_action { // ResumeAction::Step | ResumeAction::StepWithSignal(_) => { @@ -398,7 +419,7 @@ impl MultiThreadResume for XousTarget { } fn clear_resume_actions(&mut self) -> Result<(), Self::Error> { - println!("Clearing resume actions"); + // println!("Clearing resume actions"); Ok(()) } @@ -422,33 +443,30 @@ impl MultiThreadResume for XousTarget { } impl target::ext::breakpoints::Breakpoints for XousTarget { - #[inline(always)] - fn support_sw_breakpoint( - &mut self, - ) -> Option> { - Some(self) - } + // fn support_sw_breakpoint( + // &mut self, + // ) -> Option> { + // Some(self) + // } } -impl target::ext::breakpoints::SwBreakpoint for XousTarget { - #[inline(never)] - fn add_sw_breakpoint(&mut self, _addr: u32, _kind: usize) -> TargetResult { - println!( - "GDB asked us to add a software breakpoint at {:08x} of kind {:?}", - _addr, _kind - ); - Ok(true) - } +// impl target::ext::breakpoints::SwBreakpoint for XousTarget { +// fn add_sw_breakpoint(&mut self, _addr: u32, _kind: usize) -> TargetResult { +// 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 { - println!( - "GDB asked us to remove a software breakpoint at {:08x} of kind {:?}", - _addr, _kind - ); - Ok(true) - } -} +// fn remove_sw_breakpoint(&mut self, _addr: u32, _kind: usize) -> TargetResult { +// 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( @@ -521,128 +539,170 @@ impl MonitorCmd for XousTarget { } } -fn advance_gdb_or_recreate(byte: Option) { - advance_gdb_state(byte); - if unsafe { GDB_STATE.is_none() } { - println!("GDB went away -- recreating it"); - init(); +fn state_can_accept_characters<'a, T: Target + ProcessPid, C: Connection>( + machine: &GdbStubStateMachine<'a, T, C>, +) -> bool { + match machine { + GdbStubStateMachine::Idle(_) | GdbStubStateMachine::Running(_) => true, + GdbStubStateMachine::CtrlCInterrupt(_) | GdbStubStateMachine::Disconnected(_) => false, } } -fn advance_gdb_state(byte: Option) -> bool { - let Some(XousDebugState { - mut target, - server: gdb, - }) = (unsafe { GDB_STATE.take() }) else { - println!("No GDB!"); - return false; +fn ensure_can_accept_characters_inner<'a, T: Target + ProcessPid, C: Connection>( + machine: GdbStubStateMachine<'a, T, C>, + target: &mut T, + recurse_count: usize, +) -> Option> { + if recurse_count == 0 { + return None; + } + + match machine { + GdbStubStateMachine::Idle(_) | GdbStubStateMachine::Running(_) => Some(machine), + GdbStubStateMachine::CtrlCInterrupt(gdb_stm_inner) => { + 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"); + } + + let Ok(new_server) = gdb_stm_inner.interrupt_handled(target, Some(MultiThreadStopReason::Signal(Signal::SIGINT))) else { + return None + }; + ensure_can_accept_characters_inner(new_server, target, recurse_count - 1) + } + GdbStubStateMachine::Disconnected(gdb_stm_inner) => { + println!( + "GdbStubStateMachine::Disconnected due to {:?}", + gdb_stm_inner.get_reason() + ); + ensure_can_accept_characters_inner( + gdb_stm_inner.return_to_idle(), + target, + recurse_count - 1, + ) + } + } +} + +fn ensure_can_accept_characters<'a, T: Target + ProcessPid, C: Connection>( + machine: GdbStubStateMachine<'a, T, C>, + target: &mut T, +) -> Option> { + ensure_can_accept_characters_inner(machine, target, 4) +} + +/// Advance the GDB state. +/// +/// Two states accept characters: +/// +/// GdbStubStateMachine::Idle +/// GdbStubStateMachine::Running +/// +/// Two states exist merely to transition to other states: +/// +/// GdbStubStateMachine::CtrlCInterrupt +/// GdbStubStateMachine::Disconnected +fn process_character(byte: u8) { + let XousDebugState { mut target, server } = unsafe { + GDB_STATE.take().unwrap_or_else(|| { + let gdb = GdbStubBuilder::new(GdbUart::new(receive_irq).unwrap()) + .with_packet_buffer(&mut GDB_BUFFER) + .build() + .unwrap(); + let mut target = XousTarget::new(); + let server = gdb + .run_state_machine(&mut target) + .expect("couldn't create gdb"); + XousDebugState { target, server } + }) }; - 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) - } - }, + if !state_can_accept_characters(&server) { + println!("GDB server was not in a state to accept characters"); + return; + } + + let new_server = match server { + GdbStubStateMachine::Idle(gdb_stm_inner) => { + let Ok(gdb) = gdb_stm_inner.incoming_data(&mut target, byte).map_err(|e| println!("gdbstub error during idle operation: {:?}", e)) else { + return; + }; + gdb + } 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; - } + match gdb_stm_inner.incoming_data(&mut target, byte) { + Ok(pumped_stm) => pumped_stm, + Err(GdbStubError::TargetError(e)) => { + println!("Target raised a fatal error: {:?}", e); + return; + } + Err(e) => { + println!("gdbstub error in DeferredStopReason.pump: {:?}", e); + return; } - // } 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; + _ => { + println!("GDB is in an unexpected state!"); + return; } }; - 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; + let Some(server) = ensure_can_accept_characters(new_server, &mut target) else { + println!("Couldn't convert GDB into a state that accepts characters"); + return; + }; + + unsafe { GDB_STATE = Some(XousDebugState { target, server }) }; +} + +pub fn report_terminated(pid: xous_kernel::PID) { + println!("Reporting that process {:?} has terminated!", pid); + let Some(XousDebugState { + mut target, + server: gdb, + }) = (unsafe { GDB_STATE.take() }) else { + println!("No GDB!"); + return; + }; + + let new_gdb = match gdb { + GdbStubStateMachine::Running(inner) => { + println!("Reporting a STOP"); + match inner.report_stop( + &mut target, + MultiThreadStopReason::Signal(Signal::EXC_BAD_ACCESS), + ) { + Ok(new_gdb) => new_gdb, + Err(e) => { + println!("Unable to report stop: {:?}", e); + return; + } } } - - 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"); + GdbStubStateMachine::CtrlCInterrupt(_inner) => { + println!("GDB state was in CtrlCInterrupt, which shouldn't be possible!"); + return; } - } + GdbStubStateMachine::Disconnected(_inner) => { + println!("GDB state was in Disconnect, which shouldn't be possible!"); + return; + } + GdbStubStateMachine::Idle(_inner) => { + println!("GDB state was in Idle, which shouldn't be possible!"); + return; + } + }; unsafe { GDB_STATE = Some(XousDebugState { @@ -650,28 +710,21 @@ fn advance_gdb_state(byte: Option) -> bool { server: new_gdb, }) }; - true } pub fn init() { let uart = GdbUart::new(receive_irq).unwrap(); let mut target = XousTarget::new(); - match GdbStubBuilder::new(uart) + let server = 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), + .expect("unable to build gdb server") + .run_state_machine(&mut target) + .expect("unable to start gdb state machine"); + unsafe { + GDB_STATE = Some(XousDebugState { target, server }); + HALTED = true; } } diff --git a/kernel/src/platform/precursor/gdbuart.rs b/kernel/src/platform/precursor/gdbuart.rs index ed7ced7cf..c7009955f 100644 --- a/kernel/src/platform/precursor/gdbuart.rs +++ b/kernel/src/platform/precursor/gdbuart.rs @@ -7,11 +7,12 @@ use crate::{ mem::MemoryManager, PID, }; -use core::sync::atomic::{AtomicUsize, Ordering}; +use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use utralib::generated::*; use xous_kernel::{MemoryFlags, MemoryType}; -static UART_USAGE_COUNT: AtomicUsize = AtomicUsize::new(0); +static UART_CALLBACK_POINTER: AtomicUsize = AtomicUsize::new(0); +static UART_ALLOCATED: AtomicBool = AtomicBool::new(false); /// UART virtual address. /// @@ -21,16 +22,41 @@ pub const APP_UART_ADDR: usize = 0xffcc_0000; /// UART peripheral driver. pub struct GdbUart { uart_csr: CSR, - callback: fn(&mut Self), +} + +fn gdbuart_isr(_irq_no: usize, _arg: *mut usize) { + let target = UART_CALLBACK_POINTER.load(Ordering::Relaxed); + // Return if uninitialized + if target == 0 { + return; + } + + let cb = unsafe { core::mem::transmute::<_, fn(&mut GdbUart)>(target) }; + cb(&mut GdbUart { + uart_csr: CSR::new(APP_UART_ADDR as *mut u32), + }); } impl GdbUart { pub fn new(callback: fn(&mut Self)) -> Option { - if UART_USAGE_COUNT - .compare_exchange(0, 1, Ordering::Relaxed, Ordering::Relaxed) + UART_CALLBACK_POINTER.store(callback as usize, Ordering::Relaxed); + + Some(GdbUart { + uart_csr: CSR::new(APP_UART_ADDR as *mut u32), + }) + } + + pub fn enable(&mut self) { + self.allocate(); + self.uart_csr.rmwf(utra::app_uart::EV_ENABLE_RX, 1); + } + + pub fn allocate(&mut self) { + if UART_ALLOCATED + .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed) .is_err() { - return None; + return; } // Map the UART peripheral. @@ -46,38 +72,28 @@ impl GdbUart { ) .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, + gdbuart_isr, + core::ptr::null_mut(), ) .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); - } + #[allow(dead_code)] + pub fn deallocate(&mut self) { + self.uart_csr.rmwf(utra::app_uart::EV_ENABLE_RX, 0); - 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"); + // Note: This can cause an ABA error if it's multi-threaded and `.allocate()` + // is called at the same time as `.deallocate()`. + if UART_ALLOCATED + .compare_exchange(true, false, Ordering::Relaxed, Ordering::Relaxed) + .is_err() + { + return; } - println!("Freeing interrupt since the count has gone to zero"); xous_kernel::rsyscall(xous_kernel::SysCall::FreeInterrupt( utra::app_uart::APP_UART_IRQ, )) @@ -116,13 +132,16 @@ impl SerialRead for GdbUart { 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(()) diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 564b80bbc..e6acb10e3 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -2255,7 +2255,6 @@ impl SystemServices { #[cfg(feature = "gdb-stub")] 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) @@ -2263,12 +2262,7 @@ impl SystemServices { // 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); } }); @@ -2313,10 +2307,6 @@ 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); @@ -2328,7 +2318,6 @@ impl SystemServices { #[cfg(feature = "gdb-stub")] 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; process.state = match process.state { ProcessState::Allocated => ProcessState::Allocated, ProcessState::Free => ProcessState::Free, @@ -2342,10 +2331,6 @@ impl SystemServices { ProcessState::Debug(tids) => ProcessState::Ready(tids), ProcessState::Running(tids) => ProcessState::Running(tids), }; - 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, _, _| {