buninu-linux 0.2.0

package/initramfs/init.js

@@ -0,0 +1,339 @@
+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", {
+  mount: {
+    args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.ptr],
+    returns: FFIType.i32,
+  },
+  __errno_location: {
+    args: [],
+    returns: FFIType.ptr,
+  },
+  waitpid: {
+    args: [FFIType.i32, FFIType.ptr, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  open: {
+    args: [FFIType.ptr, FFIType.i32, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  syscall: {
+    args: [FFIType.i64, FFIType.i64, FFIType.ptr, FFIType.i64],
+    returns: FFIType.i32,
+  },
+  socket: {
+    args: [FFIType.i32, FFIType.i32, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  ioctl: {
+    args: [FFIType.i32, FFIType.u64, FFIType.ptr],
+    returns: FFIType.i32,
+  },
+  close: {
+    args: [FFIType.i32],
+    returns: FFIType.i32,
+  },
+});
+
+const cString = (value) => new TextEncoder().encode(`${value}\0`);
+const check = (operation, result, allowed = []) => {
+  if (result < 0 && !allowed.includes(result)) {
+    throw new Error(`${operation} failed: Linux errno ${-result}`);
+  }
+  return result;
+};
+
+// The libc wrappers report failure as -1 plus errno, unlike the raw syscalls
+// used elsewhere in this file, which return the negated error directly.
+const errnoLocation = libc.symbols.__errno_location();
+const errno = () => read.i32(errnoLocation);
+
+// Bun is PID 1 on a kernel that mounted nothing but the initramfs, so these
+// are the first syscalls of the system. Bun gets this far on the cpio alone:
+// `-e` never opens an entry file, so it never readlinks /proc/self/fd/N, and
+// the devices it does need are recorded in the archive by scripts/pack-initramfs.sh.
+// From here on /proc must exist, because path canonicalization (`bun install`,
+// `node:fs` realpath, the resolver's symlink handling) uses /proc/self/fd/N,
+// and /dev has to become devtmpfs for anything beyond the handful of nodes the
+// archive carries.
+//
+// EBUSY is tolerated so this still works if something else mounted them first.
+const mountFilesystems = () => {
+  for (const [source, target, type] of [
+    ["proc", "/proc", "proc"],
+    ["sysfs", "/sys", "sysfs"],
+    ["devtmpfs", "/dev", "devtmpfs"],
+    ["tmpfs", "/tmp", "tmpfs"],
+  ]) {
+    const result = libc.symbols.mount(
+      ptr(cString(source)),
+      ptr(cString(target)),
+      ptr(cString(type)),
+      0n,
+      null,
+    );
+    if (result === 0) continue;
+    if (errno() === 16) continue; // EBUSY: already mounted
+    console.error(`mount(${type}, ${target}) failed: errno ${errno()}`);
+  }
+};
+
+mountFilesystems();
+console.log("init.js: mounted /proc, /sys, /dev, /tmp");
+
+const { default: repl } = await import("node:repl");
+const { mkdirSync, writeFileSync } = await import("node:fs");
+
+global.repl = repl;
+
+
+const loadModule = (path) => {
+  const name = cString(path);
+  const fd = check(`open(${path})`, libc.symbols.open(ptr(name), 0, 0));
+  try {
+    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]);
+  } finally {
+    libc.symbols.close(fd);
+  }
+};
+
+const writeInterfaceName = (buffer, name = "eth0") => {
+  buffer.set(new TextEncoder().encode(name), 0);
+};
+
+const writeSockaddrIpv4 = (buffer, offset, address) => {
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  view.setUint16(offset, 2, true); // AF_INET (host endian)
+  buffer.set(address.split(".").map(Number), offset + 4); // network byte order
+};
+
+// Sets IFF_UP on an interface: read its flags, or in the bit, write them back.
+const bringUp = (ioctl, name) => {
+  const flags = new Uint8Array(40);
+  const flagsView = new DataView(flags.buffer);
+  writeInterfaceName(flags, name);
+  ioctl(0x8913, flags, "SIOCGIFFLAGS");
+  flagsView.setUint16(16, flagsView.getUint16(16, true) | 1, true); // IFF_UP
+  ioctl(0x8914, flags, "SIOCSIFFLAGS");
+};
+
+// The kernel creates `lo` down, and only assigns 127.0.0.1/8 once it comes
+// up. Normally an init system does that; here that is us, and until it is
+// done every bind to 127.0.0.1 fails with EADDRNOTAVAIL. Kept apart from the
+// virtio/QEMU setup so loopback works even when that part fails.
+const bringUpLoopback = () => {
+  const fd = check("socket(AF_INET, SOCK_DGRAM)", libc.symbols.socket(2, 2, 0));
+  try {
+    const ioctl = (request, value, operation) =>
+      check(operation, libc.symbols.ioctl(fd, request, ptr(value)));
+    bringUp(ioctl, "lo");
+  } finally {
+    libc.symbols.close(fd);
+  }
+};
+
+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}`);
+
+  const fd = check("socket(AF_INET, SOCK_DGRAM)", libc.symbols.socket(2, 2, 0));
+  const ioctl = (request, value, operation) =>
+    check(operation, libc.symbols.ioctl(fd, request, ptr(value)));
+
+  try {
+    const address = new Uint8Array(40);
+    writeInterfaceName(address);
+    writeSockaddrIpv4(address, 16, "10.0.2.15");
+    ioctl(0x8916, address, "SIOCSIFADDR");
+
+    const netmask = new Uint8Array(40);
+    writeInterfaceName(netmask);
+    writeSockaddrIpv4(netmask, 16, "255.255.255.0");
+    ioctl(0x891c, netmask, "SIOCSIFNETMASK");
+
+    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.
+    const route = new Uint8Array(120);
+    const routeView = new DataView(route.buffer);
+    writeSockaddrIpv4(route, 8, "0.0.0.0");
+    writeSockaddrIpv4(route, 24, "10.0.2.2");
+    writeSockaddrIpv4(route, 40, "0.0.0.0");
+    routeView.setUint16(56, 0x0001 | 0x0002, true); // RTF_UP | RTF_GATEWAY
+    const device = cString("eth0");
+    routeView.setBigUint64(88, BigInt(ptr(device)), true);
+    ioctl(0x890b, route, "SIOCADDRT");
+  } finally {
+    libc.symbols.close(fd);
+  }
+};
+
+const configureRealKeyboard = () => {
+  if (process.env.REAL_MACHINE !== "1") return;
+  const release = process.env.KERNEL_RELEASE;
+  for (const module of [
+    "drivers/usb/common/usb-common.ko",
+    "drivers/usb/core/usbcore.ko",
+    "drivers/usb/host/xhci-hcd.ko",
+    "drivers/usb/host/xhci-pci.ko",
+    "drivers/usb/host/xhci-pci-renesas.ko",
+    "drivers/hid/hid.ko",
+    "drivers/hid/hid-generic.ko",
+    "drivers/hid/usbhid/usbhid.ko",
+  ]) loadModule(`/lib/modules/${release}/kernel/${module}`);
+};
+
+const reapChildren = () => {
+  const status = new Int32Array(1);
+  while (libc.symbols.waitpid(-1, ptr(status), 1) > 0) {}
+};
+
+process.on("SIGCHLD", reapChildren);
+
+process.on("SIGTERM", () => console.log("PID 1 received SIGTERM"));
+process.on("SIGINT", () => console.log("PID 1 received SIGINT"));
+
+
+try {
+  bringUpLoopback();
+  console.log("network: lo 127.0.0.1/8");
+} catch (error) {
+  console.error("loopback setup failed:", error);
+}
+
+try {
+  configureRealKeyboard();
+  if (process.env.REAL_MACHINE === "1") console.log("input: USB xHCI/HID enabled");
+} catch (error) {
+  console.error("USB keyboard setup failed:", error);
+}
+
+try {
+  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")}`);
+} catch (error) {
+  console.error("network setup failed:", error);
+}
+
+const launchBunmsh = () => {
+  const runtimeDirectory = "/tmp/bunmsh-runtime";
+  const homeDirectory = "/tmp/home";
+  const environment = {
+    PATH: "/bin",
+    HOME: homeDirectory,
+    TMPDIR: "/tmp",
+    TERM: process.env.TERM ?? "linux",
+    //PS1: "bunmsh$ ",
+  };
+
+  mkdirSync(runtimeDirectory, { recursive: true });
+  mkdirSync(homeDirectory, { recursive: true });
+  writeFileSync(`${runtimeDirectory}/package.json`, JSON.stringify({
+    private: true,
+    dependencies: { bunmsh: "0.3.6" },
+  }));
+
+  console.log("bunmsh: installing bunmsh@0.3.6 into /tmp/bunmsh-runtime");
+  const install = Bun.spawnSync([
+    "/bin/bun", "install", "--cwd", runtimeDirectory, "--production", "--no-progress",
+  ], {
+    cwd: runtimeDirectory,
+    env: environment,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  if (install.exitCode !== 0) throw new Error(`bun install exited with ${install.exitCode}`);
+
+  const entry = `${runtimeDirectory}/node_modules/bunmsh/src/main.js`;
+  console.log(`bunmsh: starting ${entry}`);
+  const shell = Bun.spawnSync(["/bin/bun", entry], {
+    cwd: "/",
+    env: environment,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+  console.log(`bunmsh exited with status ${shell.exitCode}; returning to Bun REPL.`);
+  return shell.exitCode;
+};
+
+
+
+const launchBuninu = () => {
+
+  const entry = `/buninu/bin/init.js`;
+  console.log(`buninu: Starting ${entry} --local`);
+  const shell = Bun.spawnSync([
+    "/bin/bun", entry, "--local"
+  ], {
+    env: { 
+      PATH:"/bin:/usr/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;
+  
+}
+
+
+
+
+
+//  Configuration complete
+
+
+
+
+
+console.log(`
+Welcome to Buninu Linux!
+Bun ${Bun.version} is now PID ${process.pid}
+`);
+
+globalThis.bunmsh = launchBunmsh;
+//console.log("Type bunmsh() to install and enter the bunmsh shell.");
+
+globalThis.start = launchBuninu;
+console.log("Type start() to run buninu --local");
+
+const startRepl = () => {
+  const server = repl.start({
+    prompt: "bun-repl> ",
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+  });
+  server.on("exit", () => {
+    console.log("REPL exited; restarting it to keep PID 1 alive.");
+    setTimeout(startRepl, 0);
+  });
+};
+
+startRepl();

package/initramfs/usr/bin/env

@@ -0,0 +1,7 @@
+#!/bin/bun
+
+process.argv.splice(2,0,"-cc","builtin","env");
+
+await import(
+  "../../buninu/apps/bunmsh/src/main.js"
+);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "buninu-linux",
+  "version": "0.2.0",
+  "description": "A Linux distribution running Bun as PID 1 with the Buninu userspace.",
+  "type": "module",
+  "main": "./index.js",
+  "bin": {
+    "buninu-linux": "./index.js"
+  },
+  "license": "MIT",
+  "author": "Dr. John (醫者小智)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jjtseng93/buninu-linux.git"
+  },
+  "homepage": "https://github.com/jjtseng93/buninu-linux#readme",
+  "bugs": {
+    "url": "https://github.com/jjtseng93/buninu-linux/issues"
+  },
+  "keywords": [
+    "bun",
+    "linux",
+    "distribution",
+    "pid1",
+    "init",
+    "initramfs",
+    "uki",
+    "uefi",
+    "alpine",
+    "musl",
+    "qemu",
+    "buninu",
+    "userspace"
+  ],
+  "scripts": {
+    "fb": "./index.js -fb",
+    "fetch": "./index.js -f",
+    "pack": "./index.js -b",
+    "start": "./index.js -r",
+    "check": "node --check ./index.js && node --check ./initramfs/init.js"
+  }
+}

package/run-qemu.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+
+cd "$(dirname "$0")"
+
+test -f vda.img || ./build-image.sh
+
+if [ -z "$PREFIX" ] ; then
+  PREFIX=/usr
+fi
+
+ovmf_filepath="$PREFIX"/share/qemu/edk2-x86_64-code.fd
+
+if [ -f /usr/share/OVMF/OVMF_CODE_4M.fd ] ; then
+  ovmf_filepath=/usr/share/OVMF/OVMF_CODE_4M.fd
+elif [ -f "$OVMF_FILE" ] ; then
+  ovmf_filepath=$OVMF_FILE
+fi
+
+# User-mode networking is NAT: the guest can reach out, nothing reaches in
+# unless a port is forwarded. PORTS lists them, space-separated, as
+# host[:guest] with guest defaulting to host, e.g. PORTS="8080 2222:22".
+# The host side binds to 127.0.0.1 only. A forwarded port reaches the guest
+# at its eth0 address (10.0.2.15), so the service there has to listen on
+# 0.0.0.0 or 10.0.2.15 — one bound to the guest's 127.0.0.1 is not reachable.
+nic="user,model=virtio-net-pci"
+for port in ${PORTS:-}; do
+    # Both expansions return the whole word when there is no colon, so a bare
+    # "8080" maps to itself without a case statement.
+    host="${port%%:*}"
+    guest="${port#*:}"
+    nic="$nic,hostfwd=tcp:127.0.0.1:$host-:$guest"
+done
+
+exec qemu-system-x86_64 \
+    -machine q35,accel=tcg \
+    -cpu max \
+    -m 512M \
+    -drive if=pflash,format=raw,readonly=on,file="$ovmf_filepath" \
+    -drive if=virtio,format=raw,file=vda.img \
+    -nic "$nic" \
+    -display none \
+    -serial stdio \
+    -no-reboot \
+    "$@"

package/scripts/fetch.sh

@@ -0,0 +1,26 @@
+# Sourced by fetch-alpine.sh and fetch-bun.sh; not executable on its own.
+#
+# fetch <url> <name> <sha256>
+#
+# Downloads to downloads/<name>, unless a file with that exact SHA-256 is
+# already sitting there. The hash is both the cache key and the integrity
+# check, so there is no weaker "file exists" path: a truncated, stale or
+# tampered file fails the first comparison, gets fetched again, and still has
+# to pass the second one before any script extracts from it.
+#
+# Re-running the pinned build therefore costs no network at all, while bumping
+# a version (which changes both the name and the hash) always refetches.
+fetch() {
+    local url=$1 name=$2 sha=$3
+    local path="downloads/$name"
+
+    if [ -f "$path" ] && printf '%s  %s\n' "$sha" "$path" | sha256sum --check --status; then
+        echo "cached $name"
+        return
+    fi
+
+    echo "fetch  $name"
+    curl -fL "$url" -o "$path"
+    # --quiet prints only failures; a mismatch exits non-zero under `set -e`.
+    printf '%s  %s\n' "$sha" "$path" | sha256sum --check --quiet
+}

package/scripts/pack-initramfs.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+mkdir -p build
+
+staging="$(mktemp -d "$PWD/.initramfs.XXXXXX")"
+archive="$(mktemp "$PWD/.initramfs.XXXXXX.cpio")"
+trap 'rm -rf "$staging"; rm -f "$archive"' EXIT
+
+cp -a --reflink=auto initramfs/. "$staging/"
+
+# fakeroot lets cpio record the character devices without real root. Nothing
+# has mounted devtmpfs when the kernel execs Bun as PID 1, so every device
+# Bun's startup needs has to be in the archive itself:
+#
+#   console  the kernel opens it as init's fd 0/1/2 before the exec
+#   urandom  JSC's OSRandomSource calls CRASH() outright if open() fails, which
+#            is the `panic(main thread): abort() called` you get without it.
+#            This is the one device that actually blocks booting Bun as PID 1.
+#
+# The rest are cheap to include and keep /dev usable if the devtmpfs mount in
+# init.js ever fails.
+fakeroot-tcp -- sh -c '
+    mknod -m 0600 "$1/dev/console" c 5 1
+    mknod -m 0620 "$1/dev/ttyS0" c 4 64
+    mknod -m 0666 "$1/dev/null" c 1 3
+    mknod -m 0666 "$1/dev/zero" c 1 5
+    mknod -m 0666 "$1/dev/random" c 1 8
+    mknod -m 0666 "$1/dev/urandom" c 1 9
+    mknod -m 0666 "$1/dev/tty" c 5 0
+    cd "$1"
+    find . -mindepth 1 -print0 \
+        | sort -z \
+        | cpio --null --create --format=newc --owner=0:0 --reproducible 2>/dev/null \
+        > "$2"
+' sh "$staging" "$archive"
+
+gzip -9n < "$archive" > build/initramfs.cpio.gz
+
+echo "Built build/initramfs.cpio.gz"

package/test/build-init-bootstrap.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Retired: the native bootstrap that used to be /init.
+#
+# Bun now boots as PID 1 directly (rdinit=/bin/bun -- -e import('/init.js')),
+# so nothing in the normal build path needs this. It is kept because it is the
+# only way to run something before Bun starts — mounting a filesystem Bun needs
+# at startup, or bisecting a boot failure by exec'ing Bun with different
+# arguments. Build it, then point the kernel at it with rdinit=/init.
+#
+# init-bootstrap.c, next to this script, mounts devtmpfs, proc, sysfs and
+# tmpfs, wires fd 0/1/2 to /dev/ttyS0 (falling back to /dev/console), and
+# execve()s `/bin/bun /init.js`, so Bun replaces it and still ends up as PID 1.
+# Freestanding: raw syscalls, no libc.
+
+cd "$(dirname "$0")/.."
+
+clang --target=x86_64-linux-gnu -fuse-ld=lld -nostdlib -static -fno-stack-protector \
+    -fno-pic -Wl,-e,_start -Wl,--build-id=none \
+    test/init-bootstrap.c -o initramfs/init
+
+echo "Built initramfs/init; boot it with rdinit=/init and repack with ./scripts/pack-initramfs.sh"

package/test/init-bootstrap.c

@@ -0,0 +1,55 @@
+typedef unsigned long usize;
+
+static long syscall6(long number, long a1, long a2, long a3,
+                     long a4, long a5, long a6) {
+    register long r10 __asm__("r10") = a4;
+    register long r8 __asm__("r8") = a5;
+    register long r9 __asm__("r9") = a6;
+    long result;
+    __asm__ volatile("syscall"
+                     : "=a"(result)
+                     : "a"(number), "D"(a1), "S"(a2), "d"(a3),
+                       "r"(r10), "r"(r8), "r"(r9)
+                     : "rcx", "r11", "memory");
+    return result;
+}
+
+static long mount_fs(const char *source, const char *target, const char *type) {
+    return syscall6(165, (long)source, (long)target, (long)type, 0, 0, 0);
+}
+
+__attribute__((noreturn)) void _start(void) {
+    static char bun[] = "/bin/bun";
+    static char script[] = "/init.js";
+    static char path[] = "PATH=/bin";
+    static char home[] = "HOME=/";
+    static char term[] = "TERM=linux";
+    char *argv[] = {bun, script, 0};
+    char *envp[] = {path, home, term, 0};
+
+    mount_fs("devtmpfs", "/dev", "devtmpfs");
+    mount_fs("proc", "/proc", "proc");
+    mount_fs("sysfs", "/sys", "sysfs");
+    mount_fs("tmpfs", "/tmp", "tmpfs");
+
+    long console = syscall6(2, (long)"/dev/ttyS0", 2, 0, 0, 0, 0);
+    if (console < 0)
+        console = syscall6(2, (long)"/dev/console", 2, 0, 0, 0, 0);
+    if (console >= 0) {
+        syscall6(33, console, 0, 0, 0, 0, 0);
+        syscall6(33, console, 1, 0, 0, 0, 0);
+        syscall6(33, console, 2, 0, 0, 0, 0);
+        if (console > 2)
+            syscall6(3, console, 0, 0, 0, 0, 0);
+    }
+
+    static const char starting[] = "bootstrap: mounted filesystems; exec Bun 1.4.2\n";
+    syscall6(1, 2, (long)starting, sizeof(starting) - 1, 0, 0, 0);
+
+    syscall6(59, (long)bun, (long)argv, (long)envp, 0, 0, 0);
+
+    static const char error[] = "init: execve(/bin/bun) failed\n";
+    syscall6(1, 2, (long)error, sizeof(error) - 1, 0, 0, 0);
+    for (;;)
+        syscall6(34, 0, 0, 0, 0, 0, 0);
+}