buninu-linux 0.5.1 → 0.7.0

package/initramfs/bin/bunterm

@@ -3,16 +3,22 @@
 
 import { showDocument } from "../lib/document.js";
 import { runTerminal } from "../lib/bunterm/terminal.js";
+import { activeConsole, openConsole } from "../lib/fbdev.js";
+import { virtualConsoleNumber } from "../lib/bunterm/vt.js";
+import { closeSync, openSync, readFileSync } from "node:fs";
+
+const CANONICAL_BUNTERM = "/bin/bunterm";
 
 const usage = () => {
   console.error(`Usage:
-  bunterm [/dev/ttyN] [--font-size N] [--fb /dev/fb0] [--no-mouse] [-e command [argument...]]
+  bunterm [N | /dev/ttyN] [-s N | --font-size N] [--fb /dev/fb0] [--no-mouse] [-e command [argument...]]
   bunterm -h | --help`);
 };
 
 const main = async () => {
   const options = { argv: [] };
   const arguments_ = process.argv.slice(2);
+  let consoleArgumentIndex = -1;
   for (let index = 0; index < arguments_.length; index++) {
     const argument = arguments_[index];
     if (argument === "-h" || argument === "--help") {
@@ -36,8 +42,10 @@ const main = async () => {
       }
       return value;
     };
-    if (argument === "--font-size" || argument.startsWith("--font-size=")) {
-      options.fontSize = Number(valued("--font-size"));
+    if (argument === "-s" || argument.startsWith("-s=")
+        || argument === "--font-size" || argument.startsWith("--font-size=")) {
+      const name = argument === "-s" || argument.startsWith("-s=") ? "-s" : "--font-size";
+      options.fontSize = Number(valued(name));
       if (!Number.isFinite(options.fontSize) || options.fontSize < 6) throw new Error("--font-size must be a number of at least 6");
     } else if (argument === "--line-height" || argument.startsWith("--line-height=")) {
       options.lineHeight = Number(valued("--line-height"));
@@ -50,13 +58,64 @@ const main = async () => {
       options.mouse = true;
     } else if (argument === "--no-mouse") {
       options.mouse = false;
-    } else if (argument.startsWith("/dev/")) {
-      options.console = argument;
+    } else if (/^[1-9][0-9]*$/.test(argument) || argument.startsWith("/dev/")) {
+      const number = /^[1-9][0-9]*$/.test(argument) ? Number(argument) : virtualConsoleNumber(argument);
+      if (number === null) throw new Error(`expected N or /dev/ttyN, got ${argument}`);
+      if (consoleArgumentIndex !== -1) throw new Error("only one virtual console may be specified");
+      options.console = `/dev/tty${number}`;
+      consoleArgumentIndex = index;
     } else {
       usage();
       throw new Error(`unexpected argument: ${argument}`);
     }
   }
+
+  const probe = openConsole(["/dev/tty0"]);
+  let activeConsoleNumber;
+  try {
+    activeConsoleNumber = activeConsole(probe);
+  } finally {
+    probe.close();
+  }
+  if (!options.console) options.console = `/dev/tty${activeConsoleNumber}`;
+
+  // Every live bunterm converges on one unambiguous /proc/<pid>/cmdline:
+  //   /bin/bunterm /bin/bunterm /dev/ttyN [options...]
+  // execve replaces the original process, so no forwarding parent remains.
+  const remaining = arguments_.filter((_argument, index) => index !== consoleArgumentIndex);
+  const canonicalArgv = [CANONICAL_BUNTERM, CANONICAL_BUNTERM, options.console, ...remaining];
+  const currentArgv = readFileSync("/proc/self/cmdline").toString("utf8").split("\0");
+  if (currentArgv.at(-1) === "") currentArgv.pop();
+  if (currentArgv.length !== canonicalArgv.length
+      || currentArgv.some((argument, index) => argument !== canonicalArgv[index])) {
+    const environment = Object.fromEntries(
+      Object.entries(process.env).filter((entry) => typeof entry[1] === "string"),
+    );
+    const targetConsoleNumber = virtualConsoleNumber(options.console);
+    if (consoleArgumentIndex !== -1 && targetConsoleNumber !== activeConsoleNumber) {
+      const consoleFd = openSync(options.console, "r+");
+      try {
+        const child = Bun.spawn(
+          [process.execPath, CANONICAL_BUNTERM, options.console, ...remaining],
+          {
+            argv0: CANONICAL_BUNTERM,
+            detached: true,
+            env: environment,
+            stdin: "ignore",
+            stdout: consoleFd,
+            stderr: consoleFd,
+          },
+        );
+        child.unref();
+      } finally {
+        closeSync(consoleFd);
+      }
+      return 0;
+    }
+    process.execve(process.execPath, canonicalArgv, environment);
+    throw new Error("process.execve returned unexpectedly");
+  }
+
   return runTerminal(options);
 };
 

package/initramfs/bin/chroot

@@ -8,7 +8,7 @@
 // /etc/resolv.conf, so `chroot /mnt/rootfs` lands in a usable system. Every
 // mount it makes is undone when the command exits.
 
-import { existsSync, mkdirSync, realpathSync, statSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, realpathSync, statSync, readFileSync, writeFileSync } from "node:fs";
 import { libc, cString, ptr, errno, strerror, Errno } from "../lib/dlopen.js";
 import { showDocument } from "../lib/document.js";
 
@@ -125,6 +125,9 @@ if (options.mount) {
   // A bound file, so name resolution inside follows the host's configuration
   // and nothing inside the root is modified.
   if (existsSync("/etc/resolv.conf") && existsSync(`${root}/etc`)) {
+  
+    chmodSync(`/etc/resolv.conf`, 0o644);
+    
     prepare({ inside: "/etc/resolv.conf", source: "/etc/resolv.conf", type: "none", flags: MS.BIND, file: true });
   }
 }

package/initramfs/bin/ip

@@ -498,8 +498,9 @@ const commandAddress = (words, options) => {
   });
 };
 
-// struct rtentry on x86_64: rt_dst @8, rt_gateway @24, rt_genmask @40 (each a
-// 16-byte sockaddr), rt_flags u16 @56, rt_metric i16 @80, rt_dev char* @88.
+// struct rtentry on 64-bit Linux, x86_64 and aarch64 alike: rt_dst @8,
+// rt_gateway @24, rt_genmask @40 (each a 16-byte sockaddr), rt_flags u16 @56,
+// rt_metric i16 @80, rt_dev char* @88.
 const rtentry = ({ destination, prefix, gateway, device, metric }) => {
   const route = new Uint8Array(120);
   const routeView = view(route);

package/initramfs/bin/ps

@@ -16,6 +16,9 @@ const ttyName = (number) => {
   const minor = (device & 0xff) | ((device >>> 12) & 0xfff00);
   if (major >= 136 && major <= 143) return `pts/${minor}`;
   if (major === 4 && minor < 64) return `tty${minor}`;
+  // Serial ports: the 8250 UARTs of a PC and the PL011 of QEMU's aarch64 virt.
+  if (major === 4) return `ttyS${minor - 64}`;
+  if (major === 204 && minor >= 64) return `ttyAMA${minor - 64}`;
   if (major === 5 && minor === 0) return "tty";
   return `${major}:${minor}`;
 };

package/initramfs/bin/tar

@@ -41,6 +41,14 @@ for (let index = 0; index < argv.length; index++) {
   }
   if (argument === "--zstd") { options.compression = "zstd"; continue; }
   if (argument === "--gzip") { options.compression = "gzip"; continue; }
+  // GNU tar compatibility used by js-udocker. Bun.Archive never restores
+  // ownership or permissions, and extraction replaces existing files, so
+  // these options already describe its normal extraction behaviour.
+  if (argument === "--no-same-owner" || argument === "--no-same-permissions" || argument === "--overwrite") continue;
+  // Bun.Archive does not extract device nodes. js-udocker separately removes
+  // whiteout files after extraction, so its excludes are safe no-ops here.
+  if (argument === "--exclude") { take(index++, argument); continue; }
+  if (argument.startsWith("--exclude=")) continue;
   if (argument === "-C" || argument === "--directory") {
     options.directory = take(index++, argument);
     continue;
@@ -67,6 +75,7 @@ for (let index = 0; index < argv.length; index++) {
       } else if (flag === "r") {
         fail("-r append is not supported by Bun.Archive");
       } else if (flag === "v") options.verbose = true;
+      else if (flag === "o") {} // GNU tar: --no-same-owner
       else if (flag === "z") options.compression = "gzip";
       else if (flag === "f") {
         const attached = flags.slice(offset + 1);

package/initramfs/init.js

@@ -2,9 +2,19 @@ console.log("init.js: Bun runtime entered JavaScript");
 
 const { dlopen, FFIType, ptr, read } = await import("bun:ffi");
 
-console.log("init.js: loading physical musl libc for FFI");
-
-const libc = dlopen("/lib/libc.musl-x86_64.so.1", {
+// The musl file name and the number of finit_module, which musl has no
+// wrapper for, are all that differs per CPU in this file. /lib/dlopen.js has
+// the same table for the commands; it is repeated rather than imported so
+// that nothing but bun:ffi loads before the mounts below.
+const architecture = {
+  x64: { libc: "libc.musl-x86_64.so.1", SYS_finit_module: 313 },
+  arm64: { libc: "libc.musl-aarch64.so.1", SYS_finit_module: 273 },
+}[process.arch];
+if (!architecture) throw new Error(`init.js: unsupported CPU architecture ${process.arch}`);
+
+console.log(`init.js: loading physical musl libc /lib/${architecture.libc} for FFI`);
+
+const libc = dlopen(`/lib/${architecture.libc}`, {
   mount: {
     args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.ptr],
     returns: FFIType.i32,
@@ -152,11 +162,13 @@ try {
 // The input layer's character devices, so a pointing device has a
 // /dev/input/event* node for `bunterm --mouse` to read. Loading them only
 // creates those nodes: the console keyboard is unaffected, and nothing reads
-// a pointer unless it is asked to. A USB mouse also needs the usbhid stack,
-// which `cfg.all` or a --real boot brings in.
+// a pointer unless it is asked to. psmouse is the PS/2 mouse of a PC or q35;
+// QEMU's aarch64 virt machine has virtio-input instead. Each image ships only
+// the one its machine has, and tryModprobe skips the other. A USB mouse also
+// needs the usbhid stack, which `cfg.all` or a --real boot brings in.
 try {
   const { tryModprobe } = await import("/lib/modprobe.js");
-  const loaded = ["evdev", "psmouse"].filter((module) => tryModprobe(module) !== null);
+  const loaded = ["evdev", "psmouse", "virtio_input"].filter((module) => tryModprobe(module) !== null);
   const { readdirSync } = await import("node:fs");
   const devices = (() => {
     try { return readdirSync("/dev/input").filter((name) => name.startsWith("event")); } catch { return []; }
@@ -190,7 +202,11 @@ const loadModule = (path) => {
     const parameters = cString("");
     // -EEXIST is harmless when firmware or another module loaded it first.
     // musl has no finit_module wrapper, so use its generic syscall(2).
-    check(`finit_module(${path})`, libc.symbols.syscall(313, fd, ptr(parameters), 0), [-17]);
+    check(
+      `finit_module(${path})`,
+      libc.symbols.syscall(architecture.SYS_finit_module, fd, ptr(parameters), 0),
+      [-17],
+    );
   } finally {
     libc.symbols.close(fd);
   }
@@ -231,21 +247,14 @@ const bringUpLoopback = () => {
   }
 };
 
-const configureQemuNetwork = () => {
-  const release = process.env.KERNEL_RELEASE ?? "6.18.52-0-virt";
-  const modules = [
-    `lib/modules/${release}/kernel/net/core/failover.ko`,
-    `lib/modules/${release}/kernel/drivers/net/net_failover.ko`,
-    `lib/modules/${release}/kernel/drivers/net/virtio_net.ko`,
-  ];
-  if (release.endsWith("-lts")) modules.unshift(
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_ring.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_pci_legacy_dev.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_pci_modern_dev.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_pci.ko`,
-  );
-  for (const module of modules) loadModule(`/${module}`);
+// Which virtio pieces are modules differs per kernel flavor and CPU (linux-lts
+// has virtio_pci as a module, linux-virt builds it in), so /lib/modprobe.js
+// resolves them from the shipped modules.dep and modules.builtin: the PCI
+// transport first, since nothing in modules.dep depends on it, then the NIC.
+const configureQemuNetwork = async () => {
+  const { modprobe, tryModprobe } = await import("/lib/modprobe.js");
+  tryModprobe("virtio_pci");
+  modprobe("virtio_net");
 
   const fd = check("socket(AF_INET, SOCK_DGRAM)", libc.symbols.socket(2, 2, 0));
   const ioctl = (request, value, operation) =>
@@ -264,8 +273,9 @@ const configureQemuNetwork = () => {
 
     bringUp(ioctl, "eth0");
 
-    // struct rtentry on Linux x86_64. Only gateway and flags are needed for
-    // the default route; rt_dst and rt_genmask remain 0.0.0.0.
+    // struct rtentry on 64-bit Linux, the same on x86_64 and aarch64. Only
+    // gateway and flags are needed for the default route; rt_dst and
+    // rt_genmask remain 0.0.0.0.
     const route = new Uint8Array(120);
     const routeView = new DataView(route.buffer);
     writeSockaddrIpv4(route, 8, "0.0.0.0");
@@ -359,7 +369,7 @@ try {
 
 
 try {
-  configureQemuNetwork();
+  await configureQemuNetwork();
   console.log("network: eth0 10.0.2.15/24 via 10.0.2.2");
   const response = await fetch("http://example.com");
   console.log(`fetch example.com: HTTP ${response.status}, ${response.headers.get("content-type")}`);
@@ -412,7 +422,9 @@ const launchBunmsh = () => {
 
 
 
-const launchBuninu = () => {
+let replServer = null;
+
+const launchBuninu = async () => {
 
   console.log(`
 Type bunterm in bunmsh: Graphical Terminal
@@ -420,22 +432,36 @@ Type bunterm in bunmsh: Graphical Terminal
   Supports Kitty Graphics Protocol
 `)
 
+  const classic_path = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+  
+  const buninu_path = "/buninu/.local/bin:/buninu/.bun/bin:/buninu/bin"
+
   const entry = `/buninu/bin/init.js`;
   console.log(`buninu: Starting ${entry} --local`);
-  const shell = Bun.spawnSync([
-    "/bin/bun", entry, "--local"
-  ], {
-    env: {
-      ...process.env,
-      PATH:"/bin:/sbin:/usr/bin:/usr/sbin:/buninu/.bun/bin:/buninu/bin",
-      HOME:"/buninu"
-    },
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-  console.log(`buninu exited with status ${shell.exitCode}; returning to Bun REPL.`);
-  return shell.exitCode;
+  replServer?.pause();
+  try {
+    const shell = Bun.spawn([
+      "/bin/bun", entry, "--local"
+    ], {
+      env: {
+        ...process.env,
+        PATH:  classic_path + ":" +
+               buninu_path,
+        HOME:"/buninu"
+      },
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const exitCode = await shell.exited;
+    console.log(`buninu exited with status ${exitCode}; returning to Bun REPL.`);
+    return exitCode;
+  } finally {
+    // The child inherits the console directly. Keep the REPL from consuming
+    // the same input while it runs, but leave PID 1's event loop alive so its
+    // SIGCHLD handler can reap orphaned grandchildren such as Chromium.
+    replServer?.resume();
+  }
   
 }
 
@@ -551,12 +577,24 @@ Type start() to run buninu --local`);
 showWelcome();
 
 const startRepl = () => {
-  const server = repl.start({
+  const server = replServer = repl.start({
     prompt: "bun-repl> ",
     input: process.stdin,
     output: process.stdout,
     terminal: true,
   });
+  // `start()` returns a promise so PID 1's event loop can keep reaping
+  // children. Make the two convenient whole-line forms foreground commands;
+  // otherwise the REPL finishes evaluating the pending promise and resumes
+  // itself, competing with Buninu for the console input.
+  const defaultEval = server.eval.bind(server);
+  server.eval = (command, context, filename, callback) => {
+    const trimmed = command.trim();
+    if (trimmed === "start" || /^start\s*\(\s*\)\s*;?$/.test(trimmed)) {
+      command = "await start()\n";
+    }
+    return defaultEval(command, context, filename, callback);
+  };
   // Run before REPL's own line listener so its next prompt is printed after
   // the repeated welcome. Empty and whitespace-only lines both trigger it.
   server.prependListener("line", (line) => {

package/initramfs/lib/bunterm/images.js

@@ -53,6 +53,7 @@ export class ImageStore {
     this.term = term;
     this.renderer = renderer;
     this.images = new Map();      // image id → Skia Image
+    this.imageSources = new Map(); // image id → parser image object
     this.placements = new Map();  // placement key → placement
     this.counter = 0;
     this.coveredKey = "";
@@ -70,14 +71,26 @@ export class ImageStore {
     if (graphic.kind !== "placement") return "";
     const { control, image } = graphic;
     let decoded = this.images.get(image.id);
-    if (!decoded) {
+    const replacesImage = decoded && this.imageSources.get(image.id) !== image;
+    if (!decoded || replacesImage) {
       try {
-        decoded = await decodeImage(this.CanvasKit, image);
+        const replacement = await decodeImage(this.CanvasKit, image);
+        if (replacesImage) {
+          // Kitty requires retransmitting a non-zero image id to delete the
+          // old image and all its placements.  Screen-streaming clients such
+          // as casty deliberately reuse one id for every frame.
+          for (const placement of [...this.placements.values()]) {
+            if (placement.imageId === image.id) this.dispose(placement);
+          }
+          decoded.delete();
+        }
+        decoded = replacement;
       } catch (error) {
         graphic.responseMessage = `EBADPNG:${error.message}`;
         return "";
       }
       this.images.set(image.id, decoded);
+      this.imageSources.set(image.id, image);
     }
     const { cellWidth, cellHeight } = this.renderer;
     const buffer = this.term.buffer.active;
@@ -169,6 +182,7 @@ export class ImageStore {
         if (!used.has(id)) {
           image.delete();
           this.images.delete(id);
+          this.imageSources.delete(id);
         }
       }
     }
@@ -221,5 +235,6 @@ export class ImageStore {
     this.placements.clear();
     for (const image of this.images.values()) image.delete();
     this.images.clear();
+    this.imageSources.clear();
   }
 }

package/initramfs/lib/bunterm/terminal.js

@@ -20,6 +20,7 @@ import { UnicodeGraphemesAddon } from "../xterm/addon-unicode-graphemes.mjs";
 import { Renderer, defaultTheme } from "./renderer.js";
 import { ImageStore } from "./images.js";
 import { openKeyboard, translateKeys } from "./input.js";
+import { claimVirtualConsole } from "./vt.js";
 
 const require = createRequire(import.meta.url);
 
@@ -81,6 +82,7 @@ export const createSession = ({
   });
 
   let frameTimer = null;
+  let active = true;
   let blinkOn = true;
   const cursorHidden = () => Boolean(term._core?.coreService?.isCursorHidden);
   // Only set when a pointer is attached; without one the renderer is called
@@ -89,6 +91,7 @@ export const createSession = ({
   const paint = () => {
     if (frameTimer) clearTimeout(frameTimer);
     frameTimer = null;
+    if (!active) return false;
     const buffer = term.buffer.active;
     // cursorY counts from the buffer's base, so a scrolled-back viewport
     // moves the cursor down the screen and eventually off it.
@@ -104,8 +107,20 @@ export const createSession = ({
     });
   };
   const requestFrame = () => {
+    if (!active) return;
     frameTimer ??= setTimeout(paint, 16);
   };
+  const suspend = () => {
+    active = false;
+    if (frameTimer) clearTimeout(frameTimer);
+    frameTimer = null;
+  };
+  const resume = () => {
+    if (active) return;
+    active = true;
+    renderer.invalidate();
+    paint();
+  };
   const blinkTimer = cursorBlink
     ? setInterval(() => { blinkOn = !blinkOn; requestFrame(); }, 500)
     : null;
@@ -193,6 +208,9 @@ export const createSession = ({
   };
 
   const reportMouse = (report) => {
+    // /dev/input is global rather than routed through the active VT.  Do not
+    // draw or send mouse input to a terminal whose console is off-screen.
+    if (!active) return;
     pointer = { x: report.x, y: report.y };
     requestFrame();
     const service = term._core?.coreMouseService;
@@ -268,7 +286,7 @@ export const createSession = ({
   paint();
   return {
     term, backend, renderer, images, kitty,
-    paint, requestFrame, settle, input, exited, close, attachPointer, reportMouse, wheelScroll,
+    paint, requestFrame, suspend, resume, settle, input, exited, close, attachPointer, reportMouse, wheelScroll,
   };
 };
 
@@ -282,15 +300,13 @@ export const runTerminal = async ({ console: consoleDevice = null, device = "/de
   const fonts = loadFontSet(CanvasKit, "terminal");
   const consolePaths = consoleDevice ? [consoleDevice] : undefined;
 
-  return runGraphics(async (display, { onRestore, onAcquire }) => {
+  return runGraphics(async (display, { onRestore, onRelease, onAcquire }) => {
     const screen = openCanvas(CanvasKit, display);
     const session = createSession({ CanvasKit, screen, fonts, ...options });
-    // Coming back from another console (Ctrl-Alt-Fn): fbcon has drawn over
-    // the framebuffer, so repaint everything.
-    onAcquire(() => {
-      session.renderer.invalidate();
-      session.paint();
-    });
+    onRelease(session.suspend);
+    // Coming back from another console (Ctrl-Alt-Fn): fbcon or another
+    // bunterm has drawn over the framebuffer, so repaint everything.
+    onAcquire(session.resume);
     let keyboard = null;
     try {
       keyboard = openKeyboard({
@@ -320,5 +336,5 @@ export const runTerminal = async ({ console: consoleDevice = null, device = "/de
       session.close();
       screen.close();
     }
-  }, { device, console: consolePaths });
+  }, { device, console: consolePaths, prepareConsole: claimVirtualConsole });
 };

package/initramfs/lib/bunterm/vt.js

@@ -0,0 +1,91 @@
+// Cooperative ownership for one Linux virtual console.
+//
+// Linux VT_SETMODE replaces an existing VT_PROCESS owner rather than failing,
+// and VT_GETMODE does not expose that owner's pid.  bunterm therefore publishes
+// a short per-VT task name and verifies that another such process does not also
+// hold the console device open.  Both facts live under /proc/<pid> and disappear
+// with the process; there is no persistent pid or lock file to become stale.
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { libc, cString, check } from "../dlopen.js";
+
+const PR_SET_NAME = 15;
+const PR_GET_NAME = 16;
+
+export const virtualConsoleNumber = (path) => {
+  const match = /^\/dev\/tty([1-9][0-9]*)$/.exec(path);
+  return match ? Number(match[1]) : null;
+};
+
+const taskName = (number) => `bunterm:tty${number}`;
+
+const getTaskName = () => {
+  const name = new Uint8Array(16);
+  check("prctl(PR_GET_NAME)", libc.symbols.prctl(PR_GET_NAME, name, 0n, 0n, 0n));
+  const zero = name.indexOf(0);
+  return new TextDecoder().decode(zero === -1 ? name : name.subarray(0, zero));
+};
+
+const setTaskName = (name) => {
+  const encoded = cString(name);
+  if (encoded.byteLength > 16) throw new Error(`Linux task name is too long: ${name}`);
+  check("prctl(PR_SET_NAME)", libc.symbols.prctl(PR_SET_NAME, encoded, 0n, 0n, 0n));
+};
+
+const processHoldsDevice = (pid, deviceId) => {
+  let descriptors;
+  try {
+    descriptors = readdirSync(`/proc/${pid}/fd`);
+  } catch {
+    return false;
+  }
+  for (const descriptor of descriptors) {
+    try {
+      if (statSync(`/proc/${pid}/fd/${descriptor}`).rdev === deviceId) return true;
+    } catch {
+      // The process or descriptor disappeared between readdir and stat.
+    }
+  }
+  return false;
+};
+
+export const claimVirtualConsole = (consoleDevice) => {
+  const number = virtualConsoleNumber(consoleDevice.path);
+  if (number === null) throw new Error(`bunterm needs a canonical virtual console, got ${consoleDevice.path}`);
+  const name = taskName(number);
+  const previousName = getTaskName();
+  const deviceId = statSync(consoleDevice.path).rdev;
+
+  // Publish before scanning.  Two simultaneous starters can then reject each
+  // other, but they cannot both scan an unpublished peer and proceed.
+  setTaskName(name);
+  try {
+    const pids = readdirSync("/proc")
+      .filter((entry) => /^[0-9]+$/.test(entry) && Number(entry) !== process.pid);
+    for (const pid of pids) {
+      let otherName;
+      try {
+        otherName = readFileSync(`/proc/${pid}/comm`, "utf8").trim();
+      } catch {
+        continue;
+      }
+      if (otherName !== name || !processHoldsDevice(pid, deviceId)) continue;
+
+      throw new Error(`
+${consoleDevice.path} is occupied
+  Controlled by bunterm pid: ${pid}
+See --help or try another VT:
+  bunterm ${number- -1}
+Switch between TTYs by Ctrl+Alt+F1-12
+  or Alt-Left / Alt-Right
+`);
+    }
+  } catch (error) {
+    try { setTaskName(previousName); } catch {}
+    throw error;
+  }
+
+  return () => {
+    try { setTaskName(previousName); } catch {}
+  };
+};

package/initramfs/lib/dlopen.js

@@ -85,6 +85,10 @@ export const libc = dlopen(libcPath, {
     args: [FFIType.i32, FFIType.ptr, FFIType.i32],
     returns: FFIType.i32,
   },
+  prctl: {
+    args: [FFIType.i32, FFIType.ptr, FFIType.u64, FFIType.u64, FFIType.u64],
+    returns: FFIType.i32,
+  },
   chroot: {
     args: [FFIType.ptr],
     returns: FFIType.i32,