use crate::config::{ConfigError, SchedulerConfig, Slice};
use core::cell::UnsafeCell;
struct LogCell(UnsafeCell<Option<fn(core::fmt::Arguments)>>);
unsafe impl Sync for LogCell {}
static LOG: LogCell = LogCell(UnsafeCell::new(None));
pub fn install_log(f: fn(core::fmt::Arguments)) {
let g = crate::critical::enter();
unsafe { *LOG.0.get() = Some(f) };
drop(g);
}
pub fn log_fmt(args: core::fmt::Arguments) {
log_to_buffer(args);
let g = crate::critical::enter();
let sink = unsafe { *LOG.0.get() };
drop(g);
if let Some(f) = sink {
f(args);
}
}
const LOG_CAP: usize = 512;
struct LogBuf(core::cell::UnsafeCell<[u8; LOG_CAP]>);
unsafe impl Sync for LogBuf {}
struct LenCell(core::cell::UnsafeCell<usize>);
unsafe impl Sync for LenCell {}
static BUFFER: LogBuf = LogBuf(core::cell::UnsafeCell::new([0; LOG_CAP]));
static BUFFER_LEN: LenCell = LenCell(core::cell::UnsafeCell::new(0));
pub fn log_to_buffer(args: core::fmt::Arguments) {
struct W;
impl core::fmt::Write for W {
fn write_str(&mut self, s: &str) -> core::fmt::Result {
for b in s.bytes() {
push(b);
}
Ok(())
}
}
let _ = core::fmt::Write::write_fmt(&mut W, args);
}
fn push(b: u8) {
let g = crate::critical::enter();
let i = unsafe { *BUFFER_LEN.0.get() };
unsafe { *BUFFER_LEN.0.get() = i.wrapping_add(1) };
drop(g);
if i + 1 < LOG_CAP {
unsafe {
let p = BUFFER.0.get() as *mut u8;
core::ptr::write_volatile(p.add(i), b);
core::ptr::write_volatile(p.add(i + 1), 0);
}
}
}
pub fn log_bytes() -> &'static [u8] {
let g = crate::critical::enter();
let n = unsafe { *BUFFER_LEN.0.get() }.min(LOG_CAP - 1);
drop(g);
unsafe { core::slice::from_raw_parts(BUFFER.0.get() as *const u8, n) }
}
pub fn init(clock: u32, slice: Slice, stack: usize) -> Result<(), ConfigError> {
crate::scheduler::init_with(SchedulerConfig::embedded(slice, clock).stack_size(stack))
}
pub fn park() -> ! {
crate::scheduler::shutdown(0)
}
pub fn log_with(f: fn(core::fmt::Arguments)) {
install_log(f);
}
pub fn configure(clock: u32, slice: Slice, stack: usize) {
let g = crate::critical::enter();
let started = init(clock, slice, stack);
drop(g);
if let Err(e) = started {
log_fmt(format_args!("rrkernel: configure failed: {:?}\r\n", e));
panic!("rrkernel: configure failed: {:?}", e);
}
}
pub fn exit_main() -> ! {
let me = {
let g = crate::critical::enter();
let me = unsafe { crate::tcb::KERNEL.current() };
drop(g);
me
};
assert!(
!me.is_null(),
"rrkernel: `configure(...)` was never called before `main` returned"
);
unsafe { crate::trampoline::exit_task(me) }
}
#[cfg(all(target_arch = "arm", target_feature = "mclass"))]
pub fn hard_fault() -> ! {
let cfsr = unsafe { core::ptr::read_volatile(0xE000_ED28 as *const u32) };
let hfsr = unsafe { core::ptr::read_volatile(0xE000_ED2C as *const u32) };
let bfar = unsafe { core::ptr::read_volatile(0xE000_ED38 as *const u32) };
let mmfar = unsafe { core::ptr::read_volatile(0xE000_ED34 as *const u32) };
let psp: u32;
unsafe { core::arch::asm!("mrs {}, psp", out(reg) psp, options(nomem, nostack)) };
let pc = unsafe { core::ptr::read_volatile((psp as usize + 24) as *const u32) };
log_fmt(format_args!(
"!!! HardFault CFSR {:#010x} HFSR {:#010x}\r\n",
cfsr, hfsr
));
log_fmt(format_args!(
" BFAR {:#010x} MMFAR {:#010x} PSP {:#010x} faulting PC {:#010x}\r\n",
bfar, mmfar, psp, pc
));
park()
}
#[cfg(all(target_arch = "arm", not(target_feature = "mclass")))]
pub fn hard_fault() -> ! {
let cpsr: u32;
let sp: u32;
let lr: u32;
unsafe {
core::arch::asm!(
"mrs {}, cpsr",
out(reg) cpsr,
options(nomem, nostack, preserves_flags)
);
core::arch::asm!("mov {}, sp", out(reg) sp, options(nomem, nostack));
core::arch::asm!("mov {}, lr", out(reg) lr, options(nomem, nostack));
}
log_fmt(format_args!(
"!!! fault (ARM A/R profile) CPSR {:#010x} SP {:#010x} LR {:#010x}\r\n",
cpsr, sp, lr
));
log_fmt(format_args!(
" no CFSR/HFSR on this profile (those are M-profile SCB registers); \
the A/R port reports through its own trap entry\r\n"
));
park()
}
pub fn unexpected_exception() -> ! {
log_fmt(format_args!(
"!!! unexpected exception: an unhandled vector fired\r\n"
));
park()
}
pub fn panic(info: &core::panic::PanicInfo) -> ! {
log_fmt(format_args!("!!! panic: {}\r\n", info.message()));
park()
}
#[cfg(target_arch = "arm")]
#[macro_export]
macro_rules! app {
(
clock: $clock:expr,
slice: $slice:expr,
stack: $stack:expr,
log: $log:expr,
main: $main:block
$(,)?
) => {
#[cortex_m_rt::entry]
fn main() -> ! {
$crate::app_support::install_log($log);
let started =
cortex_m::interrupt::free(|_cs| $crate::app_support::init($clock, $slice, $stack));
if let Err(e) = started {
$crate::app_support::log_fmt(format_args!("rrkernel: init failed: {:?}\r\n", e));
unsafe { core::arch::asm!("bkpt 0", options(nomem, nostack)) };
$crate::app_support::park();
}
$crate::scheduler::main_body(|| $main)
}
#[no_mangle]
pub extern "C" fn HardFault() -> ! {
$crate::app_support::hard_fault()
}
#[no_mangle]
pub extern "C" fn DefaultHandler() -> ! {
$crate::app_support::unexpected_exception()
}
#[panic_handler]
fn __rrkernel_panic(info: &core::panic::PanicInfo) -> ! {
$crate::app_support::panic(info)
}
};
}