kernel: the clock ran 7x slow because the GPU never acknowledged its interrupt

fastfetch reported 3 seconds of uptime after 15 real ones, `time` claimed
3.12s for a 20-second command, and ping's one-second interval was closer to
six. One cause, not three: `ticks` was advancing at ~14.5 Hz instead of 100.

It was not the timer. virtio-gpu-pci shares IRQ 11 with the e1000 and
registered no interrupt handler at all. PCI INTx is level-triggered, so the
device held the line asserted, the kernel signalled EOI, and it fired again
immediately -- 72,000 interrupts a second, 83% of CPU0, starving the tick.
The e1000's handler read ICR as zero half a million times, correctly
answering "not mine", which is what made it look like a network-free problem.

Reading virtio's ISR byte clears it and drops the line. That is the fix.

irq_dispatch now measures each line's rate against the TSC -- not ticks,
which is the first casualty of a storm -- and names the attached handlers
once above 20000/s. It reproduces the original fault as a single line.

Found along the way, and fixed because they were real:

  - lapicinit loaded TICR with xv6's uncalibrated 10000000, whose own comment
    admitted it was never measured. calibrate_timers() now measures the LAPIC
    and the TSC against the 8254 PIT. (It came back at 999.9 MHz, so this was
    not the bug -- but the next machine is not obliged to be 1 GHz.)
  - microdelay() was an empty function body. Every microdelay(1000) in the
    xHCI reset path and the USB hub power-on sequence returned instantly.
  - HZ is a constant in param.h now, not the literal 100 written out at a
    dozen ticks-to-seconds conversions. USER_HZ is separate and deliberately
    does not follow it: musl answers sysconf(_SC_CLK_TCK) with 100 always, so
    times() and /proc/stat scale at the syscall boundary the way Linux does.
  - TIOCGWINSZ answered a hardcoded 24x80. gfx_cols()/gfx_rows() have known
    the real geometry all along; at 1024x768 the console is 128x48, so every
    program that lays out a screen was formatting for the wrong one.
  - TCFLSH fell through to the catch-all `return 0`, claiming to discard
    input without discarding any.

uptime now advances 5.01 seconds per 5 real seconds. schfs-check passes.

Full investigation, including the two wrong hypotheses and the measurement
flaw that protected them, in docs/history/kernel.md section 13.

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

kernel/core/console.c

@@ -567,6 +567,23 @@ cons_set_termios(const struct termios *in)
   wakeup(&input.r);
 }
 
+// Discard everything typed but not yet consumed: completed lines waiting in
+// the buffer and the partial line still being edited. TCFLSH (tcflush) is the
+// caller, and a line editor issues one whenever it takes the terminal back --
+// after an interrupt, or when a command that read from the tty exits. Without
+// it the keys pressed while the last command ran arrive at the next prompt.
+//
+// A pending EOF goes too: end of input is buffer state like any other, and
+// leaving it set would end the *next* read instead of the one it was typed at.
+void
+cons_flush_input(void)
+{
+  acquire(&input.lock);
+  input.e = input.w = input.r;
+  input.eof = 0;
+  release(&input.lock);
+}
+
 static void
 echo(int c)
 {

kernel/core/panic.c

@@ -257,7 +257,7 @@ gather(char *reason, addr_t *pcs, int npcs)
   {
     char *p = put_dec(f->value, e, (uint64)ticks);
     p = put_str(p, e, " ticks (about ");
-    p = put_dec(p, e, (uint64)ticks / 100);
+    p = put_dec(p, e, (uint64)ticks / HZ);
     put_str(p, e, " s)");
   }
 

kernel/core/time.c

@@ -91,7 +91,7 @@ time_init(void)
   // Subtract the uptime so far, so boot_epoch is the moment of boot rather than
   // the moment this function ran. It is only a fraction of a second, but it
   // keeps boot_epoch meaning exactly what its name says.
-  uint64 up = ticks / 100;
+  uint64 up = ticks / HZ;
   boot_epoch = now > up ? now - up : now;
 
   cprintf("time: %d-%d-%d %d:%d:%d UTC from the hardware clock\n",
@@ -110,7 +110,7 @@ wallclock(uint64 *sec, uint64 *usec)
   release(&tickslock);
 
   if (sec)
-    *sec = boot_epoch + xticks / 100;
+    *sec = boot_epoch + xticks / HZ;
   if (usec)
-    *usec = (uint64)(xticks % 100) * 10000;
+    *usec = (uint64)(xticks % HZ) * (1000000 / HZ);
 }