1 files changed, 52 insertions, 7 deletions

diff --git a/rsnix/src/sched.rs b/rsnix/src/sched.rs
index dbe3647..cfce58f 100644
--- a/rsnix/src/sched.rs
+++ b/rsnix/src/sched.rs
@@ -28,7 +28,9 @@ use core::fmt;
 use core::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 
 extern crate alloc;
+use alloc::format;
 use alloc::string::String;
+use alloc::string::ToString;
 use alloc::vec::Vec;
 
 use crate::interrupts::IntFrame;
@@ -280,11 +282,7 @@ pub fn spawn(entry: fn(), name: &str) -> Option<usize> {
     };
     let ok = spawn_at(id, entry, name);
     unlock();
-    if ok {
-        Some(id)
-    } else {
-        None
-    }
+    if ok { Some(id) } else { None }
 }
 
 unsafe fn reap(id: usize) {
@@ -548,10 +546,57 @@ pub fn abort_current(msg: &str) -> ! {
 /// Vector 14 (page fault) handler — runs on the dedicated IST stack.
 /// A fault in a real task (id >= 2) kills the task gracefully; anything
 /// else (shell, idle, pre-scheduler) is a kernel bug: halt.
+/// Dump a fatal exception to serial *and* the screen (raw, bypassing the
+/// vt), then halt the shell or abort the faulting background task.
+///
+/// Real hardware has no serial console, so the screen dump is what lets
+/// a user report a crash precisely — vector, fault address, RIP and task.
+/// Runs with interrupts disabled (we're inside the ISR).
+#[allow(clippy::needless_return)]
+pub(crate) fn fault_dump(kind: &str, cr2: u64, frame: &crate::interrupts::IntFrame) -> ! {
+    let vector = frame.vector;
+    let error = frame.error;
+    let rip = frame.rip;
+    let rflags = frame.rflags;
+    let rsp = frame.rsp;
+    let id = unsafe { CURRENT };
+    let name = name_str(id);
+    let name_buf = name.to_string();
+    let in_kernel = unsafe { CURRENT } <= IDLE_TID;
+
+    // Serial: a full, parseable line.
+    crate::serial_println!(
+        "!!! {} vec={} err={:#x} rip={:#x} cr2={:#x} rsp={:#x} rflags={:#x} task={} \"{}\"",
+        kind,
+        vector,
+        error,
+        rip,
+        cr2,
+        rsp,
+        rflags,
+        id,
+        name_buf
+    );
+    crate::serial_println!("!!! halting (shell task fault — machine stops)");
+
+    // Screen: white-on-red band via the clamped raw dump path.
+    let l1 = alloc::format!("!!! {} vec={} err={:#x}", kind, vector, error);
+    let l2 = alloc::format!("rip={:#x} cr2={:#x}", rip, cr2);
+    let l3 = alloc::format!("rsp={:#x} task={} {}", rsp, id, name_buf);
+    let lines = [l1.as_str(), l2.as_str(), l3.as_str()];
+    crate::gop::dump_lines(&lines);
+
+    if in_kernel {
+        crate::interrupts::halt()
+    } else {
+        abort_current(&format!("{} vec={}", kind, vector))
+    }
+}
+
 pub fn page_fault(cr2: u64, frame_ptr: usize) -> usize {
     if !is_ready() || unsafe { CURRENT } <= IDLE_TID {
-        crate::serial_println!("pgfault: kernel page fault at {:#x} — halting", cr2);
-        crate::interrupts::halt();
+        let frame = unsafe { &*(frame_ptr as *const crate::interrupts::IntFrame) };
+        fault_dump("page fault", cr2, frame)
     }
     let g = unsafe { TASKS[CURRENT].guard };
     let in_guard = g != 0 && cr2 >= g as u64 && cr2 < (g + memory::PAGE_SIZE) as u64;