tty: six virtual terminals, and the plumbing that makes them terminals

/dev/tty1..tty6, Alt+F1..F6 or `chvt N`. Each is an independent terminal --
its own screen, cursor, line discipline, foreground process group and
session. Two shells on two terminals are unrelated processes that share a
keyboard and a screen.

What made it possible is a backing store. The console drew straight into the
framebuffer and scrolled by moving pixels, which works exactly as long as
nothing else wants the screen: there was nowhere to put terminal 2 while
terminal 1 was visible, and nothing to repaint terminal 1 from. Each terminal
owns a grid of cells now and the framebuffer shows whichever grid is active,
so vt_switch() is set-index, repaint, return -- nothing is saved on the way
out because the outgoing grid has been current all along.

The rule the layer is built on: a terminal does not know whether it is
visible. Writes land in the grid, the cursor moves, the grid scrolls, all
unconditionally; drawing is one question asked at the bottom of vt.c. Every
alternative spreads "am I on screen" through the escape parser, and then a
terminal switched away from mid-sequence comes back wrong.

Everything that was a single global is per-terminal now: tty_fg_pgrp (deleted),
termios, the input ring, the escape parser, the UTF-8 decoder, and the cursor
-- which also stops being pixels in gfx.c and becomes cells in the terminal.
TIOCSCTTY was `return 0` and now records proc->ctty, which is what /dev/tty
resolves through; /dev/tty was an alias for /dev/console with the same minor,
and they are different questions.

kbd.c names Alt+F1..F6 as KEY_ALT_F1+n, above 0xFF on purpose -- every byte
value is already a character or a UTF-8 continuation, and a chord colliding
with one would be typed into the terminal instead of switching away from it.
What the chord means is decided in console.c, where the terminals are.

VT_ACTIVATE / VT_WAITACTIVE / VT_GETSTATE / VT_OPENQRY, Linux's numbers.
The argument to ACTIVATE is by value, not a pointer -- same shape as TCFLSH.

Two bugs found by screenshotting the result rather than reading the log:

  - zsh emits 0x0F to leave alt-charset mode, because that is what the `linux`
    terminfo says rmacs is, and the console drew CP437 glyph 0x0F: a sun, in
    the prompt, on every line. A terminal never draws a C0 control character.
  - SGR 7 was unimplemented, so zsh's partial-line marker rendered as a bare
    '#' instead of a reversed block. Reverse video swaps the colours at draw
    time, not at store time, so turning it off restores what was underneath.

Verified by screendump: tty1 and tty2 show different screens, and switching
back repaints tty1's earlier content from its grid. schfs-check passes.

docs/architecture/terminals.md, including what it does not do -- no
scrollback, no reflow, no VT_PROCESS mode for a display server to veto a
switch, which Schcom will need before it owns Alt+F7.

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

kernel/dev/gfx.c

@@ -202,6 +202,55 @@ gfx_putc(int c, uint32 color)
   }
 }
 
+// --- primitives for the text layer ----------------------------------------
+//
+// kernel/dev/vt.c owns a grid of cells and needs exactly two things the
+// console-cursor interface above cannot give it: draw one cell at a grid
+// position with its *own* background, and scroll the whole screen without
+// consulting a cursor. Everything else a terminal does is bookkeeping on the
+// grid, which is not this file's business.
+
+// One cell, addressed in cells rather than pixels, with its own colours.
+// gfx_draw_char paints its background from the file-static gfx_bg, which is
+// right for a console that has one background and wrong for a terminal where
+// every cell carries its own.
+void
+gfx_draw_cell(int col, int row, uchar glyph, uint32 fg, uint32 bg)
+{
+  if (!fb)
+    return;
+
+  int x = col * CHAR_WIDTH, y = row * CHAR_HEIGHT;
+  if (x < 0 || y < 0 ||
+      x + CHAR_WIDTH > (int)scanout.width || y + CHAR_HEIGHT > (int)scanout.height)
+    return;
+
+  for (int r = 0; r < CHAR_HEIGHT; r++) {
+    uchar bits = font_data[glyph][r];
+    for (int c = 0; c < CHAR_WIDTH; c++)
+      gfx_draw_pixel(x + c, y + r, (bits & (0x80 >> c)) ? fg : bg);
+  }
+}
+
+// Move the whole screen up one text row and clear the row it exposes. The
+// cursor is not touched: the caller tracks it in cells and knows where it
+// wants to be, which is not necessarily where a pixel-scroll would leave it.
+void
+gfx_scroll_up(uint32 bg)
+{
+  if (!fb || scanout.height < CHAR_HEIGHT)
+    return;
+
+  uint32 line_size  = scanout.stride * CHAR_HEIGHT;
+  uint32 total_size = scanout.stride * scanout.height;
+
+  memmove((void*)fb, (void*)(fb + line_size), total_size - line_size);
+
+  for (int y = (int)scanout.height - CHAR_HEIGHT; y < (int)scanout.height; y++)
+    for (int x = 0; x < (int)scanout.width; x++)
+      gfx_draw_pixel(x, y, bg);
+}
+
 void
 gfx_screen_reset(void)
 {