use core::fmt;
use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
pub const CK_ACCESS: u32 = 1; pub const CK_ILLEGAL: u32 = 2; pub const CK_DIVIDE: u32 = 3; pub const CK_BUS: u32 = 4; pub const CK_STACK: u32 = 5; pub const CK_OTHER: u32 = 6;
pub const CK_PANIC: u32 = 7; pub const FRAMES_MAX: usize = 32;
pub struct CrashInfo<'a> {
pub code: u32, pub kind: u32, pub access: u32, pub addr: u64, pub ip: u64, pub base: u64, pub code0: u64, pub code1: u64,
pub regs: [u64; 17], pub frames: [u64; FRAMES_MAX], pub nframes: u32,
pub msg: &'a str, }
impl CrashInfo<'_> {
pub const fn empty() -> Self {
CrashInfo {
code: 0,
kind: CK_OTHER,
access: 2,
addr: 0,
ip: 0,
base: 0,
code0: 0,
code1: 0,
regs: [0; 17],
frames: [0; FRAMES_MAX],
nframes: 0,
msg: "",
}
}
}
pub type CrashHook = fn(&CrashInfo);
static HOOK: AtomicUsize = AtomicUsize::new(0);
static PRE_HOOK: AtomicUsize = AtomicUsize::new(0);
static BUSY: AtomicBool = AtomicBool::new(false);
pub fn set_hook(f: Option<CrashHook>) {
HOOK.store(f.map_or(0, |f| f as usize), Ordering::SeqCst);
}
pub fn set_pre_hook(f: Option<CrashHook>) {
PRE_HOOK.store(f.map_or(0, |f| f as usize), Ordering::SeqCst);
}
pub fn busy() -> bool {
BUSY.load(Ordering::SeqCst)
}
pub fn report(info: &CrashInfo) -> ! {
if BUSY.swap(true, Ordering::SeqCst) {
crate::os::exit(3); }
for h in [PRE_HOOK.load(Ordering::SeqCst), HOOK.load(Ordering::SeqCst)] {
if h != 0 && info.kind != CK_STACK {
let f: CrashHook = unsafe { core::mem::transmute::<usize, CrashHook>(h) };
f(info);
}
}
crate::os::exit(3)
}
pub struct StackText<const N: usize> {
buf: [u8; N],
len: usize,
}
impl<const N: usize> Default for StackText<N> {
fn default() -> Self {
Self::new()
}
}
impl<const N: usize> StackText<N> {
pub const fn new() -> Self {
StackText { buf: [0; N], len: 0 }
}
pub fn bytes(&self) -> &[u8] {
&self.buf[..self.len]
}
pub fn as_str(&self) -> &str {
core::str::from_utf8(self.bytes()).unwrap_or("")
}
}
impl<const N: usize> fmt::Write for StackText<N> {
fn write_str(&mut self, s: &str) -> fmt::Result {
let mut n = s.len().min(N - self.len);
while n < s.len() && !s.is_char_boundary(n) {
n -= 1;
}
self.buf[self.len..self.len + n].copy_from_slice(&s.as_bytes()[..n]);
self.len += n;
Ok(())
}
}