GMMOS: the Guru Meditation Micro OS, alive under the PSOGM

A panic no longer ends in a picture. The report is drawn as before, and
then GMMOS runs under it: the real kernel stays dead -- the other
processors are halted, and nothing of it is called that locks, sleeps,
allocates or waits for an interrupt -- and GMMOS keeps its own clock
(the TSC), its own keyboard (micro drivers, polled), and the screen.

On the report: a live status line counting down the three-minute
power-off, which any key cancels, and the keys.

  Space  the last 300 lines of this boot's log as QR codes, a page per
         symbol, numbered; + and - trade module size for capacity
  L      the log on screen, scrolled
  T      a terminal: why, log, grep, ps, cpus, pci, mem (page tables
         walked first, so a bad address cannot fault), uptime, restart,
         poweroff
  R R    restart; P P power off -- twice, so a stray key does neither

The first micro driver is PS/2, polled: kbd.c with everything but the
keys taken out. The probe asks the keyboard to echo, so a controller
with nothing behind it is not offered as one. Polling also sidesteps the
IRQ 1 polarity quirk, which is about interrupt routing.

A panic inside GMMOS (or a second one in the report) is reported and
then only blinks; it does not re-enter GMMOS.

Checked under QEMU: every screen; two QR pages read off a screenshot
with zbar decode to the log text exactly; restart reboots; left alone it
still powers off at three minutes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S1giNvrHTrPMPw7V6x1kQ4

kernel/proc/proc.c

@@ -1857,6 +1857,31 @@ procdump(void)
 
 // Fill `out` with the `idx`-th live process (0-based, in table order).
 // Returns 0 on success, -1 when idx is past the end.
+// proc_snapshot without the lock, and only the fields a crash screen lists.
+// For GMMOS: the lock may be held by a processor the panic stopped, and a torn
+// read of one line is a far smaller loss than a crash screen that hangs.
+int
+proc_peek(int idx, struct procinfo *out)
+{
+  struct proc *p;
+  int n = 0;
+
+  for (p = ptable.proc; p < &ptable.proc[NPROC]; p++) {
+    if (p->state == UNUSED)
+      continue;
+    if (n++ != idx)
+      continue;
+    out->pid   = p->pid;
+    out->ppid  = p->parent ? p->parent->pid : 0;
+    out->state = p->state;
+    out->sz    = p->sz;
+    out->killed = p->killed;
+    safestrcpy(out->name, p->name, sizeof(out->name));
+    return 0;
+  }
+  return -1;
+}
+
 int
 proc_snapshot(int idx, struct procinfo *out)
 {