rsnix: preemptive kernel tasks (ADR 0003) — sched, IST fault stacks, 176-byte frames

- sched: 16-slot static table, shell=task 0, idle=task 1, spawn with
  guard page + 8 KiB stack, RR on the 100 Hz tick, int 0x60 yield,
  sleep_ms, lazy reap, jobs/bg/sleep/kill shell commands
- gdt: own GDT mirroring UEFI selectors + TSS with IST1/IST2
  (guard-page overflows die gracefully instead of triple-faulting)
- interrupts: isr_dispatch returns next frame in rax; IntFrame grows
  rsp/ss fields — QEMU's 64-bit iretq always pops all five slots from
  a 176-byte frame, so synthetic task frames must carry rsp=top+ss
  (a 160-byte frame made the first iretq pop rsp/ss from the unmapped
  page beyond the frame)
- panic handler: task panics abort the task, shell keeps running
- main: sched::init moved after page allocator + adopted tables
  (the idle's stack+guard need both; it was silently not spawning)

1 files changed, 10 insertions, 7 deletions

diff --git a/rsnix/src/klog.rs b/rsnix/src/klog.rs
index 0c7dc06..5da5094 100644
--- a/rsnix/src/klog.rs
+++ b/rsnix/src/klog.rs
@@ -79,16 +79,19 @@ pub fn append(line: &str, mut ms: u64) {
     r.seq += 1;
 }
 
-/// Append the formatted output of a `serial_println!` — the macro hook.
-/// `fmt::Write` may deliver the line in several chunks, so accumulate
-/// into one line buffer first, then append the whole line.  The
-/// timestamp is taken when the line is emitted (monotonic ms since
-/// boot, from the PIT tick + live-counter interpolation).
-pub fn append_fmt(args: core::fmt::Arguments<'_>) {
-    let ms = crate::interrupts::uptime_ms();
+/// Format one serial line, write it to the serial port, and append it
+/// to the ring — all under the scheduler lock, so a line from one task
+/// never interleaves with another task's line (line atomicity).
+/// `serial_println!` funnels through here.
+pub fn emit(args: core::fmt::Arguments<'_>) {
     let mut line = LineBuf::new();
     let _ = core::fmt::write(&mut line, args);
+    let ms = crate::interrupts::uptime_ms();
+    crate::sched::lock();
+    crate::serial::write_raw(line.as_str());
+    crate::serial::write_raw("\r\n");
     append(line.as_str(), ms);
+    crate::sched::unlock();
 }
 
 struct LineBuf {