sergio/takana

1#!/usr/bin/env bash
2# selfhost-verify.sh — Verifica el auto-alojamiento bit a bit de Stage 1 de punta a punta
3# (SDD 11 §7; runbook docs/runbooks/stage1-vm-boot.md §8c).
4#
5# Hace TODO el pipeline en una corrida, pensado para un host con KVM + RAM holgada (p. ej. una
6# laptop): construye el store baseline, ensambla el builder, lo empaqueta como initramfs y lo bootea
7# en QEMU, donde `rebuild-stage1` reconstruye stage1' con el toolchain de adentro y compara su
8# content-hash (`of_tree`) con la referencia anclada afuera → ✓ REPRODUCIBLE / ✗ DIVERGENTE.
9#
10# Prerequisitos:
11#   - Lab de dev:  ./scripts/bootstrap-devfs.sh   (deja .dev-fs/alpine + .dev-fs/tools/zig)
12#   - qemu-system-x86_64, cpio, gzip; un kernel x86_64 en $KERNEL.
13#   - Red (el fetch de Rust hace `cargo vendor` desde crates.io).
14#
15# Variables (override por entorno):
16#   STORE      store content-addressed         (default ./store)
17#   KERNEL     kernel a bootear en la VM        (default /boot/vmlinuz-linux)
18#   MEM        RAM de la VM en MiB              (default 6144; con KVM subí a 8192+)
19#   KVM        1 ⇒ -enable-kvm -cpu host        (default auto: 1 si hay /dev/kvm)
20#   PRESEED    "all" rebuild 4/4 in-VM | "hammerd" preseed C+arje, sólo hammerd in-VM
21#              (default all; "hammerd" es el camino barato/rápido si la RAM va justa)
22#   EXPECT_REF content-hash esperado (cross-check de reproducibilidad entre máquinas; opcional)
23#   STAGE0_URL / STAGE0_SHA256 / SEED_VERSION  semilla zig (defaults: zig 0.16.0)
24#
25# Uso típico en la laptop (con KVM):
26#   KVM=1 MEM=10240 ./scripts/selfhost-verify.sh
27set -euo pipefail
28
29REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
30cd "$REPO_ROOT"
31
32STORE="${STORE:-store}"
33KERNEL="${KERNEL:-/boot/vmlinuz-linux}"
34MEM="${MEM:-6144}"
35PRESEED="${PRESEED:-all}"
36SEED_VERSION="${SEED_VERSION:-0.16.0}"
37STAGE0_URL="${STAGE0_URL:-https://ziglang.org/download/0.16.0/zig-x86_64-linux-0.16.0.tar.xz}"
38STAGE0_SHA256="${STAGE0_SHA256:-70e49664a74374b48b51e6f3fdfbf437f6395d42509050588bd49abe52ba3d00}"
39TOOLCHAIN="${TOOLCHAIN:-.dev-fs/alpine}"
40TOOLCHAIN_TAG="${TOOLCHAIN_TAG:-alpine-3.23.4-builder}"
41# Referencia conocida-buena (store baseline en el host de dev, runbook §8c). Si tu corrida produce
42# otra, o bien cambió algo del pin (toolchain/recipes/seed) o hay un no-determinismo nuevo.
43# Baseline DETERMINISTA con codegen-units=1 + CARGO_BUILD_JOBS=1 en el sandbox: el segundo serializa
44# el backend paralelo de rustc/LLVM (ThinLTO), sin el cual arje-zero divergía ~62 KB a >1 CPU (el
45# viejo 0039b2b9… era un build paralelo no-reproducible). Ver §8c y SDD 09 §2.
46EXPECT_REF="${EXPECT_REF:-b3:9adefb82b8457c8616cc89e6bb725a787ea52641f65d60d989d819e4872735ac}"
47: "${KVM:=$([[ -w /dev/kvm ]] && echo 1 || echo 0)}"
48
49say() { printf '\n\033[1;36m==> %s\033[0m\n' "$*"; }
50die() { printf '\033[1;31mERROR: %s\033[0m\n' "$*" >&2; exit 1; }
51
52[[ -x "$TOOLCHAIN/usr/bin/rustc" ]] || die "falta el lab: corré ./scripts/bootstrap-devfs.sh (no veo $TOOLCHAIN)"
53[[ -r "$KERNEL" ]] || die "no puedo leer el kernel $KERNEL (set KERNEL=…)"
54command -v qemu-system-x86_64 >/dev/null || die "falta qemu-system-x86_64"
55
56# 0) Binario hammer estático (musl, crt-static) — el builder lo bootea adentro.
57HAMMER_BIN="target/x86_64-unknown-linux-musl/release/hammer"
58say "build hammer estático ($HAMMER_BIN)"
59cargo build --release --target x86_64-unknown-linux-musl -p hammer-cli
60HAMMER="./$HAMMER_BIN"
61
62say "stage0 — ingerir la semilla zig (idempotente)"
63"$HAMMER" --store "$STORE" bootstrap stage0 \
64    --url "$STAGE0_URL" --sha256 "$STAGE0_SHA256" --version "$SEED_VERSION"
65# El seed_hash sale del nombre del artefacto sellado (robusto: no parsea stdout, donde el sha256 del
66# tarball también es 64-hex y podría confundirse).
67SEED_HASH="$(ls -d "$STORE"/*-seed-zig 2>/dev/null | head -1 | sed -E 's#.*/([0-9a-f]{64})-seed-zig#b3:\1#')"
68[[ "$SEED_HASH" == b3:* && ${#SEED_HASH} -eq 67 ]] || die "no encuentro la semilla sellada en $STORE"
69say "semilla: $SEED_HASH"
70
71# 1) Store baseline: stage1 (idempotente; rebuildea lo que falte con -mcpu=baseline ya en fuente).
72say "stage1 — construir y sellar el rootfs baseline"
73"$HAMMER" --store "$STORE" bootstrap stage1 --seed-hash "$SEED_HASH" --recipes recipes
74ROOTFS_HASH="$(ls -d "$STORE"/*-stage1-rootfs | head -1 | sed -E 's#.*/([0-9a-f]{64})-stage1-rootfs#b3:\1#')"
75[[ "$ROOTFS_HASH" == b3:* ]] || die "no encuentro el stage1-rootfs en $STORE"
76say "stage1 rootfs: $ROOTFS_HASH"
77
78# 2) Referencia of_tree(stage1) que la VM debe reproducir.
79REF="$("$HAMMER" --store "$STORE" bootstrap stage2 --rootfs "$ROOTFS_HASH" 2>&1 \
80    | grep -oE 'content-hash: b3:[0-9a-f]{64}|content=b3:[0-9a-f]{64}' | grep -oE 'b3:[0-9a-f]{64}' | tail -1)"
81[[ "$REF" == b3:* ]] || die "no obtuve la referencia de stage2"
82say "referencia of_tree(stage1) = $REF"
83if [[ -n "$EXPECT_REF" && "$REF" != "$EXPECT_REF" ]]; then
84    printf '\033[1;33mAVISO: la referencia difiere de la conocida-buena del host de dev:\n  esta   %s\n  espera %s\nReproducibilidad entre máquinas rota O cambió un pin (toolchain/recipes/seed). Seguimos igual.\033[0m\n' "$REF" "$EXPECT_REF"
85fi
86
87# 3) Inyectar los módulos del kernel DE ESTA máquina al toolchain (el builder los carga: overlay para
88#    el sandbox bwrap, e1000 para la red del vendoring). Deben matchear el kernel que bootea la VM.
89# La versión de los módulos DEBE matchear el kernel que bootea la VM ($KERNEL), no el del host
90# corriendo el script ($(uname -r)) — en máquinas con varios kernels instalados difieren y el
91# insmod falla con "version magic mismatch" → sin overlayfs, bwrap revienta. Sacamos la versión
92# del propio bzImage; si no se puede, caemos a uname -r.
93KVER="$(file -bL "$KERNEL" 2>/dev/null | grep -oE 'version [0-9][^ ]*' | awk '{print $2}')"
94[[ -n "$KVER" && -d "/lib/modules/$KVER" ]] || KVER="$(uname -r)"
95say "inyectar overlay.ko + e1000.ko (kernel $KVER) al toolchain"
96moddir="/lib/modules/$KVER"
97for m in overlay e1000; do
98    src="$(find "$moddir" -name "$m.ko*" 2>/dev/null | head -1)"
99    if [[ -n "$src" ]]; then
100        # Descomprimir si viene .ko.zst/.ko.gz/.ko.xz; el builder hace insmod del .ko crudo.
101        case "$src" in
102            *.zst) zstd -dqf "$src" -o "$TOOLCHAIN/lib/$m.ko" 2>/dev/null || cp "$src" "$TOOLCHAIN/lib/$(basename "$src")" ;;
103            *.gz)  gzip -dc "$src" > "$TOOLCHAIN/lib/$m.ko" ;;
104            *.xz)  xz -dc "$src" > "$TOOLCHAIN/lib/$m.ko" ;;
105            *)     cp "$src" "$TOOLCHAIN/lib/$m.ko" ;;
106        esac
107        echo "    $m: $src"
108    else
109        echo "    $m: NO encontrado en $moddir (si la VM lo necesita, fallará: bwrap overlay / red)"
110    fi
111done
112
113# 3b) Auto-alojamiento *puro* (variante b, SDD 11 §7.2b): reemplazar piezas del toolchain Alpine por
114#     recetas hammer construidas desde fuente, con Stage 2 reverificando que `of_tree(stage1')` NO
115#     cambia (el make hammer compila los 4/4 igual de bit-a-bit que el de Alpine). Opt-in:
116#       SWAP_MAKE=1     → construye recipes/make.toml y lo monta sobre /toolchain/usr/bin/make.
117#       SWAP_BUSYBOX=1  → monta el busybox de hammer sobre /toolchain/bin/busybox (los symlinks de
118#                         applets de Alpine — sh/sed/grep/awk/tar/find — pasan a usarlo; cp/mkdir/
119#                         install siguen siendo GNU coreutils, intactos).
120#       SWAP_LINUX_HEADERS=1 → construye recipes/linux-headers.toml y swap-directorio de los 13 subdirs
121#                         kernel-owned de /toolchain/usr/include (linux/asm/…); musl bits/sys intactos.
122#       SWAP_BWRAP=1    → construye recipes/bwrap.toml (+libcap, su dep, vía deps.build) y lo monta
123#                         sobre /toolchain/usr/bin/bwrap (el sandbox del propio lab).
124#       SWAPS="name=hash[:rel] …" → swaps explícitos extra (formato del flag --swap).
125#     Por defecto, off ⇒ corrida pura-Alpine (variante a), idéntica a la baseline conocida-buena.
126#     Piezas validadas en host: make+busybox reproducen of_tree=9adefb82 in-VM; linux-headers da un
127#     header-tree byte-idéntico a Alpine (diff -r vacío); bwrap rebuildea musl byte-idéntico de sandbox.
128SWAP_ARGS=()
129if [[ "${SWAP_MAKE:-0}" == 1 ]]; then
130    say "variante b — construir make desde fuente (recipes/make.toml) y swapearlo en /toolchain"
131    MAKE_HASH="$("$HAMMER" --store "$STORE" build recipes/make.toml | grep -oE 'b3:[0-9a-f]{64}' | tail -1)"
132    [[ "$MAKE_HASH" == b3:* ]] || die "no obtuve el hash sellado de make"
133    say "make hammer: $MAKE_HASH"
134    SWAP_ARGS+=(--swap "make=$MAKE_HASH")
135fi
136if [[ "${SWAP_BUSYBOX:-0}" == 1 ]]; then
137    say "variante b — construir busybox desde fuente y swapearlo en /toolchain/bin/busybox"
138    BB_HASH="$("$HAMMER" --store "$STORE" build recipes/busybox.toml | grep -oE 'b3:[0-9a-f]{64}' | tail -1)"
139    [[ "$BB_HASH" == b3:* ]] || die "no obtuve el hash sellado de busybox"
140    say "busybox hammer: $BB_HASH"
141    SWAP_ARGS+=(--swap "busybox=$BB_HASH:bin/busybox")
142fi
143if [[ "${SWAP_LINUX_HEADERS:-0}" == 1 ]]; then
144    # Pieza 3: los headers UAPI del kernel. NO es un binario sino un árbol — el swap-directorio
145    # (assemble_builder) reemplaza cada subdir entero. Swapeamos exactamente los subdirs que el
146    # artefacto sellado produce (linux/asm/asm-generic/cxl/fwctl/misc/mtd/rdma/regulator/scsi/sound/
147    # video/xen), que son justo los que el paquete linux-headers de Alpine posee; los de musl
148    # (bits/sys/net/…) quedan intactos.
149    say "variante b — construir linux-headers desde fuente y swapear /toolchain/usr/include/{linux,asm,…}"
150    LH_HASH="$("$HAMMER" --store "$STORE" build recipes/linux-headers.toml | grep -oE 'b3:[0-9a-f]{64}' | tail -1)"
151    [[ "$LH_HASH" == b3:* ]] || die "no obtuve el hash sellado de linux-headers"
152    say "linux-headers hammer: $LH_HASH"
153    LH_INC="$(ls -d "$STORE"/*-linux-headers/usr/include 2>/dev/null | head -1)"
154    [[ -d "$LH_INC" ]] || die "no encuentro usr/include en el linux-headers sellado"
155    for d in "$LH_INC"/*/; do
156        sub="$(basename "$d")"
157        SWAP_ARGS+=(--swap "linux-headers=${LH_HASH}:usr/include/$sub")
158    done
159fi
160if [[ "${SWAP_BWRAP:-0}" == 1 ]]; then
161    # Pieza 4: bwrap (bubblewrap), EL sandbox del lab. Binario estático ⇒ swap de archivo sobre
162    # /toolchain/usr/bin/bwrap. Su dep libcap la construye y materializa el lab solo (deps.build).
163    # bwrap es herramienta, no input del 4/4: no necesita casar byte-a-byte con Alpine, sólo aislar
164    # igual (validado en host — musl rebuildeó byte-idéntico bajo hammer-bwrap).
165    say "variante b — construir bwrap (+libcap) desde fuente y swapearlo en /toolchain/usr/bin/bwrap"
166    BW_HASH="$("$HAMMER" --store "$STORE" build recipes/bwrap.toml | grep -oE 'b3:[0-9a-f]{64}' | tail -1)"
167    [[ "$BW_HASH" == b3:* ]] || die "no obtuve el hash sellado de bwrap"
168    say "bwrap hammer: $BW_HASH"
169    SWAP_ARGS+=(--swap "bwrap=${BW_HASH}:usr/bin/bwrap")
170fi
171for s in ${SWAPS:-}; do SWAP_ARGS+=(--swap "$s"); done
172
173# 4) Ensamblar el builder con la referencia embebida.
174say "ensamblar builder (toolchain in-rootfs + hammer baseline + ref${SWAP_ARGS:+ + swaps})"
175"$HAMMER" --store "$STORE" bootstrap builder \
176    --stage1 "$ROOTFS_HASH" --seed-hash "$SEED_HASH" \
177    --hammer-bin "$HAMMER_BIN" \
178    --toolchain "$TOOLCHAIN" --toolchain-tag "$TOOLCHAIN_TAG" \
179    --ref-content "$REF" \
180    "${SWAP_ARGS[@]}" \
181    --work-cache work --out work/builder-rootfs
182
183# 4b) Preseed opcional para abaratar el rebuild in-VM (sólo hammerd se reconstruye).
184if [[ "$PRESEED" == "hammerd" ]]; then
185    say "preseed musl+busybox+arje-zero (sólo hammerd se reconstruye in-VM)"
186    for n in musl busybox arje-zero; do
187        d="$(ls -d "$STORE"/*-"$n" 2>/dev/null | head -1)"
188        [[ -n "$d" ]] && cp -a "$d" work/builder-rootfs/store/ && echo "    preseed: $(basename "$d")"
189    done
190fi
191
192# 5) Empaquetar como initramfs. --owner=root:root OBLIGATORIO: si los ficheros viajan con el uid del
193#    host, el userns de bwrap (mapea 0→0) no lo mapea y el copy-up de overlay falla con EACCES.
194say "empaquetar initramfs (cpio newc, --owner=root:root)"
195( cd work/builder-rootfs && find . -print0 | cpio --null -o -H newc --owner=root:root 2>/dev/null | gzip -1 ) > work/builder.cpio.gz
196echo "    work/builder.cpio.gz: $(du -h work/builder.cpio.gz | cut -f1)"
197
198# 6) Bootear + driver no-interactivo → veredicto.
199say "bootear la VM y correr rebuild-stage1 (KVM=$KVM MEM=$MEM)"
200KVM="$KVM" MEM="$MEM" KERNEL="$KERNEL" BUILDER_CPIO="work/builder.cpio.gz" \
201    python3 scripts/drive-rebuild.py