buninu-linux 0.4.0 → 0.6.0

package/scripts/fetch.sh

@@ -2,8 +2,9 @@
 #
 # 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
+# Downloads to $downloads_dir/<name> (downloads/<arch>/, set by
+# scripts/arch.sh), 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.
@@ -12,7 +13,7 @@
 # a version (which changes both the name and the hash) always refetches.
 fetch() {
     local url=$1 name=$2 sha=$3
-    local path="downloads/$name"
+    local path="$downloads_dir/$name"
 
     if [ -f "$path" ] && printf '%s  %s\n' "$sha" "$path" | sha256sum --check --status; then
         echo "cached $name"
@@ -20,6 +21,7 @@ fetch() {
     fi
 
     echo "fetch  $name"
+    mkdir -p "$downloads_dir"
     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

@@ -2,13 +2,26 @@
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
+
+. ./scripts/arch.sh
+
+test -x "$native_dir/bin/bun" || {
+    echo "error: no $native_dir/bin/bun yet; run the fetch stage first (./index.js -f)" >&2
+    exit 1
+}
 mkdir -p build
 
 staging="$(mktemp -d "$PWD/.initramfs.XXXXXX")"
 archive="$(mktemp "$PWD/.initramfs.XXXXXX.cpio")"
 trap 'rm -rf "$staging"; rm -f "$archive"' EXIT
 
+# initramfs/ is the same for every architecture; native/<arch>/ adds bun, the
+# musl loader, the GCC runtime and the kernel modules on top of it.
+# A checkout fetched before native/ existed still has an x86_64 bun and its
+# modules under initramfs/; they are dropped rather than packed.
 cp -a --reflink=auto initramfs/. "$staging/"
+rm -rf "$staging/bin/bun" "$staging/lib/modules"
+cp -a --reflink=auto "$native_dir/." "$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
@@ -20,10 +33,11 @@ cp -a --reflink=auto initramfs/. "$staging/"
 #            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.
+# init.js ever fails. The serial port is ttyS0 (4, 64) on x86_64 and the
+# PL011 ttyAMA0 (204, 64) on aarch64.
 fakeroot-tcp -- sh -c '
     mknod -m 0600 "$1/dev/console" c 5 1
-    mknod -m 0620 "$1/dev/ttyS0" c 4 64
+    mknod -m 0620 "$1/dev/$3" 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
@@ -34,8 +48,8 @@ fakeroot-tcp -- sh -c '
         | sort -z \
         | cpio --null --create --format=newc --owner=0:0 --reproducible 2>/dev/null \
         > "$2"
-' sh "$staging" "$archive"
+' sh "$staging" "$archive" "$serial_console" "$serial_major"
 
 gzip -9n < "$archive" > build/initramfs.cpio.gz
 
-echo "Built build/initramfs.cpio.gz"
+echo "Built build/initramfs.cpio.gz for $arch"

package/test/host/Dockerfile

@@ -0,0 +1,13 @@
+# The "ordinary Debian 13 machine" host-test.sh builds and boots the guests on:
+# the README's build packages for both guests, QEMU with OVMF and AAVMF, node
+# to run index.js, git to clone the checkout and expect to drive the serial
+# console. Built for linux/amd64 or linux/arm64, whichever host is simulated.
+FROM debian:13-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      binutils-mingw-w64-x86-64 binutils-aarch64-linux-gnu cpio curl dosfstools fakeroot mtools parted unzip \
+      ca-certificates git nodejs expect \
+      qemu-system-x86 ovmf qemu-system-arm qemu-efi-aarch64 \
+    && rm -rf /var/lib/apt/lists/*
+
+# parted asks udev to settle after writing a partition table; see ../../Dockerfile.
+RUN ln -s /bin/true /usr/local/bin/udevadm

package/test/host/boot-test.exp

@@ -0,0 +1,70 @@
+#!/usr/bin/expect -f
+# Boots vda.img with `node ./index.js -r --arch <arch>` and drives the serial
+# console: the REPL, the Buninu shell, eth0, PID 1, a tmpfs mount, a fetch from
+# inside the guest and poweroff. Each step waits for the output it expects, so
+# a hang or a wrong answer fails with a message instead of racing ahead.
+#
+# Usage: boot-test.exp <checkout> x86_64|aarch64 [boot timeout in seconds]
+
+set checkout [lindex $argv 0]
+set arch [lindex $argv 1]
+set boot_timeout [expr {[llength $argv] > 2 ? [lindex $argv 2] : 900}]
+switch -- $arch {
+    x86_64 { set js_arch x64 }
+    aarch64 { set js_arch arm64 }
+    default {
+        puts "usage: boot-test.exp <checkout> x86_64|aarch64 \[boot timeout\]"
+        exit 2
+    }
+}
+
+proc fail {message} {
+    puts "\n### FAIL: $message"
+    exit 1
+}
+
+# Sends one line to the guest, then waits for a regular expression in the
+# output. The patterns match what the command prints, not its echo.
+proc step {what line pattern} {
+    send -- "$line\r"
+    expect {
+        -re $pattern { puts "\n### ok: $what" }
+        timeout { fail "$what: no match for /$pattern/ within $::timeout s" }
+        eof { fail "$what: QEMU exited" }
+    }
+}
+
+cd $checkout
+set start [clock seconds]
+spawn node ./index.js -r --arch $arch
+
+set timeout $boot_timeout
+expect {
+    "bun-repl>" { puts "\n### ok: REPL after [expr {[clock seconds] - $start}] s" }
+    "Kernel panic" { fail "kernel panic before the REPL" }
+    timeout { fail "no REPL within $boot_timeout s" }
+    eof { fail "QEMU exited before the REPL" }
+}
+
+# bunmsh switches bracketed paste off (ESC[?2004l) before a command's output
+# and Bun colours the numbers it prints, so a line of output can carry escape
+# sequences around the text.
+set esc {(?:\x1b\[[0-9;?]*[a-zA-Z])*}
+
+set timeout 180
+step "process.arch is $js_arch" "process.arch" "'$js_arch'"
+step "Buninu shell" "start()" {\$ }
+step "uname reports $arch" "uname -a" "Linux \\(none\\) \[^\r\n\]* $arch"
+step "eth0 is 10.0.2.15" "ip -br addr" {eth0 +UP +10\.0\.2\.15/24}
+step "PID 1 is bun" "ps -eo pid,args" {\n +1 /bin/bun -e import}
+step "tmpfs mount" \
+    "mount -t tmpfs -o size=8M tmpfs /tmp/x --mkdir && echo hi > /tmp/x/f && cat /tmp/x/f && umount /tmp/x" \
+    "\n${esc}hi${esc}\r"
+step "fetch from the guest" \
+    {bun -e 'console.log((await fetch("http://example.com")).status)'} \
+    "\n${esc}200${esc}\r"
+step "poweroff" "poweroff" "reboot: Power down"
+expect {
+    eof { puts "\n### ok: QEMU exited, [expr {[clock seconds] - $start}] s in total" }
+    timeout { fail "QEMU still running after poweroff" }
+}

package/test/host/host-test.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Builds and boots both guests on a fresh Debian 13 host of either CPU, in
+# Docker:
+#
+#   test/host/host-test.sh [amd64|arm64]
+#
+# The platform defaults to this machine's own CPU; the other one runs
+# emulated and takes a few times longer. The container (./Dockerfile) has the
+# README's build packages and QEMU. It clones the committed HEAD of this
+# checkout, so uncommitted changes to the project are not tested, then builds
+# with the host toolchain rather than --docker and boots each guest through
+# boot-test.exp. The exit status is 0 only when every step passed.
+#
+#   GUESTS="aarch64"         which guests to test (default: x86_64 aarch64)
+#   BUILD_FLAGS=--linux-lts  extra flags for the build stage
+#   BOOT_TIMEOUT=900         seconds to wait for the REPL
+#   ALPINE_MIRROR=...        passed through to the fetch stage
+#
+# downloads/ is mounted read-only as a cache; running `./index.js -f --arch
+# <arch>` here first saves the container from downloading.
+set -euo pipefail
+
+cd "$(dirname "$0")/../.."
+
+case "${1:-$(uname -m)}" in
+    amd64 | x86_64) platform=amd64 ;;
+    arm64 | aarch64) platform=arm64 ;;
+    *)
+        echo "usage: $0 [amd64|arm64]" >&2
+        exit 2
+        ;;
+esac
+
+image="buninu-linux-hosttest:$platform"
+echo "### building $image (the first build takes a few minutes)"
+docker build --quiet --platform "linux/$platform" --tag "$image" test/host > /dev/null
+
+# A Linux host's KVM reaches the container too, so a guest that matches the
+# platform runs accelerated. Docker Desktop on macOS exposes no /dev/kvm.
+kvm_device=
+if [ -e /dev/kvm ]; then kvm_device=--device=/dev/kvm; fi
+
+mkdir -p downloads
+# $kvm_device is empty or a single word.
+exec docker run --rm --platform "linux/$platform" $kvm_device \
+    --mount "type=bind,src=$PWD,dst=/repo,readonly" \
+    --mount "type=bind,src=$PWD/downloads,dst=/cache,readonly" \
+    --env GUESTS --env BUILD_FLAGS --env BOOT_TIMEOUT --env ALPINE_MIRROR \
+    "$image" /repo/test/host/in-container.sh

package/test/host/in-container.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# Runs inside the container host-test.sh starts: an ordinary Debian 13 machine
+# of the chosen CPU. Clones the committed HEAD of the checkout mounted at
+# /repo, builds each guest with the host toolchain (no --docker), boots it
+# through boot-test.exp, and checks that the builds leave git status clean.
+set -euo pipefail
+
+here=$(cd "$(dirname "$0")" && pwd)
+guests=${GUESTS:-x86_64 aarch64}
+kvm=no
+if [ -r /dev/kvm ] && [ -w /dev/kvm ]; then kvm=yes; fi
+echo "### host: $(uname -sm), node $(node --version), /dev/kvm: $kvm"
+
+git config --global --add safe.directory '*'
+git clone --quiet /repo /work
+echo "### testing $(git -C /work log -1 --format='%h %s')"
+# /cache is the host's downloads/, read-only; every file in it is still
+# checked against its pinned SHA-256, and anything missing is fetched.
+mkdir -p /work/downloads
+cp -R /cache/. /work/downloads/
+cd /work
+
+strip_ansi() { sed 's/\x1b\[[0-9;?]*[a-zA-Z]//g' | tr -d '\r'; }
+
+status=0
+for guest in $guests; do
+    echo "### $guest: fetch + build ${BUILD_FLAGS:-}"
+    log=/tmp/build-$guest.log
+    # BUILD_FLAGS is split on purpose: it holds flags such as --linux-lts.
+    if node ./index.js -fb --arch "$guest" ${BUILD_FLAGS:-} > "$log" 2>&1; then
+        grep -E '^==>|^Fetched|^Built|^Packed|^note' "$log" || true
+    else
+        echo "### FAIL: $guest build; last lines:"
+        tail -n 30 "$log"
+        status=1
+        continue
+    fi
+
+    echo "### $guest: boot"
+    log=/tmp/boot-$guest.log
+    if expect "$here/boot-test.exp" /work "$guest" "${BOOT_TIMEOUT:-900}" > "$log" 2>&1; then
+        strip_ansi < "$log" | grep -a -E '^run-qemu.sh:|^network: eth0|^fetch example|^### ' || true
+    else
+        strip_ansi < "$log" | grep -a -E '^run-qemu.sh:|^### ok' || true
+        echo "### FAIL: $guest boot; last lines:"
+        strip_ansi < "$log" | tail -n 40
+        status=1
+    fi
+done
+
+echo "### git status after the builds (should be empty):"
+if [ -n "$(git status --porcelain)" ]; then
+    git status --short
+    status=1
+fi
+
+if [ "$status" = 0 ]; then echo "### PASS"; else echo "### FAIL"; fi
+exit "$status"