sergio/takana

1#!/bin/sh
2# instalador-initramfs.sh — empaqueta el instalador ENTERO en un initramfs que corre en RAM.
3#
4# ── PARA QUÉ ───────────────────────────────────────────────────────────────────────────────────
5# Es lo que hace posible reemplazar el Linux que está corriendo **sin un USB**: se salta a este
6# initramfs por `kexec` (`takana kernel kexec --jump`, ADR 0017), el sistema viejo muere en el salto
7# y su disco queda libre ⇒ recién entonces su raíz se puede formatear. El mismo initramfs sirve
8# arrancado por QEMU o por un medio cualquiera; el salto es sólo una forma de llegar.
9#
10# ── POR QUÉ EL PAYLOAD VIAJA ADENTRO Y NO EN EL DISCO ──────────────────────────────────────────
11# Porque el disco es justamente lo que se va a formatear. Dejar el rootfs en la partición destino y
12# formatearla después es morderse la cola; dejarlo en otra partición ata la instalación a que exista
13# esa otra partición. En RAM no depende de nada: el precio es que el initramfs pesa lo que pese el
14# rootfs, y por eso el script COMPRUEBA que entre en la memoria de la máquina antes de armarlo.
15#
16# Uso:
17#   ROOTFS=<product-rootfs> scripts/instalador-initramfs.sh --root-part /dev/nvme0n1p2 --esp /dev/nvme0n1p1
18#   # o sin destino fijo: lo decide el instalador al arrancar (--use-free-space)
19#
20# Salida: work/takana-instalador.cpio.gz  (+ el `takana kernel kexec` que lo salta, impreso al final)
21set -eu
22ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
23
24# Los argumentos son OPCIONALES a propósito. Un initramfs con el destino horneado sirve para UNA
25# máquina y hay que rehacerlo para la siguiente — eso no es un instalador, es un apaño. Sin
26# argumentos, el mismo fichero arranca en cualquier máquina y decide allí: lee la cmdline del kernel
27# (`takana.root=`, `takana.esp=`, `takana.free`) y, si no hay nada, muestra el censo del terreno y
28# pregunta. Lo que se pase acá queda sólo como VALOR POR DEFECTO.
29ARGS_INSTALADOR=""
30while [ $# -gt 0 ]; do ARGS_INSTALADOR="$ARGS_INSTALADOR $1"; shift; done
31
32OUT="${OUT:-work/takana-instalador.cpio.gz}"
33STAGE="${STAGE:-work/.instalador-initramfs-stage}"
34IRD_TREE="${IRD_TREE:-work/.instalador-initramfs-tree}"
35KERNEL="${KERNEL:-$(ls -dt store/*-linux-metal/boot/bzImage /store/*-linux-metal/boot/bzImage 2>/dev/null | head -1)}"
36[ -n "${KERNEL:-}" ] && [ -r "$KERNEL" ] || { echo "no encuentro un bzImage de linux-metal (set KERNEL=)" >&2; exit 1; }
37
38. "$(dirname "$0")/lib/herramientas-desde-store.sh"
39MKE2FS=$(herramienta e2fsprogs sbin/mke2fs mke2fs)  || exit 1
40SFDISK=$(herramienta util-linux sbin/sfdisk sfdisk) || exit 1
41MMD=$(herramienta    mtools usr/bin/mmd   mmd)      || exit 1
42MCOPY=$(herramienta  mtools usr/bin/mcopy mcopy)    || exit 1
43MDIR=$(herramienta   mtools usr/bin/mdir  mdir)     || exit 1
44CPIO=$(herramienta   libarchive usr/bin/bsdcpio cpio) || exit 1
45GZIP=$(herramienta   gzip bin/gzip gzip)            || exit 1
46
47# ── 1) el stage (rootfs a instalar + initramfs de pivote) lo arma el script validado ───────────
48echo "==> stage del sistema a instalar"
49STAGE_ONLY=1 KEEP_STORE=1 STAGE="$STAGE" ./scripts/install-image-efi.sh
50[ -d "$STAGE/root" ] && [ -r "$STAGE/initramfs.cpio.gz" ] || { echo "el stage no quedó completo" >&2; exit 1; }
51
52# ── 2) ¿entra en la RAM de esta máquina? ───────────────────────────────────────────────────────
53# Un initramfs vive ENTERO en memoria, y el kernel no lo avisa con elegancia: se queda sin RAM al
54# desempaquetar y el arranque muere sin un mensaje que diga por qué. Medirlo antes es la diferencia
55# entre «no entra, usá el USB» y un cuelgue mudo en la máquina del usuario.
56_mib_payload=$(du -sm "$STAGE/root" | cut -f1)
57_mib_ram=$(( $(awk '/^MemTotal:/ {print $2}' /proc/meminfo) / 1024 ))
58echo "    payload ${_mib_payload} MiB · RAM de esta máquina ${_mib_ram} MiB"
59if [ "$(( _mib_payload * 100 / _mib_ram ))" -gt 40 ]; then
60    echo "instalador-initramfs: el payload es más del 40 % de la RAM ($_mib_payload de $_mib_ram MiB)." >&2
61    echo "                      En RAM van el initramfs comprimido Y su contenido desempaquetado." >&2
62    echo "                      Este camino no sirve para este rootfs: instalá desde un medio." >&2
63    exit 1
64fi
65
66# ── 3) el árbol del initramfs ──────────────────────────────────────────────────────────────────
67echo "==> árbol del initramfs-instalador"
68# `/tmp` y `/run` NO son decorativos: el censo del terreno escribe ahí su fichero de trabajo, y sin
69# ellos el instalador fallaba diciendo «no veo ningún disco» con once discos delante.
70rm -rf "$IRD_TREE"; mkdir -p "$IRD_TREE/bin" "$IRD_TREE/dev" "$IRD_TREE/proc" "$IRD_TREE/sys" \
71    "$IRD_TREE/tmp" "$IRD_TREE/run" "$IRD_TREE/instalador/lib" "$IRD_TREE/payload"
72BUSYBOX="${BUSYBOX:-$STAGE/root/bin/busybox}"
73[ -r "$BUSYBOX" ] || { echo "no encuentro busybox estático en $BUSYBOX" >&2; exit 1; }
74cp "$BUSYBOX" "$IRD_TREE/bin/busybox"; chmod 0755 "$IRD_TREE/bin/busybox"
75# ⚠ `id` estaba fuera de esta lista y el instalador eligió la rama EQUIVOCADA por eso: sin `id -u`
76# concluyó «no soy root» y se fue a `unshare`, que tampoco existía. Los applets que el instalador usa
77# se enumeran acá y su ausencia ya no es silenciosa (el script aborta si le falta `id`).
78for a in sh mount umount mkdir echo sleep ls cat sed awk grep cut tr basename dirname readlink \
79         find sync reboot dmesg blkid setsid tee du wc head tail sort printf test sha256sum \
80         id sh chmod rm cp mv stat findfs; do
81    ln -sf busybox "$IRD_TREE/bin/$a"
82done
83# Las herramientas de disco NO salen de busybox: son las SELLADAS del corpus, estáticas musl. Dentro
84# del initramfs no hay store del que resolverlas por hash, así que viajan copiadas y el instalador
85# las recibe por `TOOL_<binario>` — el override que existe exactamente para esto.
86for t in "$MKE2FS" "$SFDISK" "$MMD" "$MCOPY" "$MDIR"; do
87    cp "$t" "$IRD_TREE/bin/$(basename "$t")"; chmod 0755 "$IRD_TREE/bin/$(basename "$t")"
88done
89TAKANA_MUSL="${TAKANA_MUSL:-$ROOT/target/x86_64-unknown-linux-musl/release/takana}"
90[ -x "$TAKANA_MUSL" ] || TAKANA_MUSL="$ROOT/target/release/takana"
91cp "$TAKANA_MUSL" "$IRD_TREE/bin/takana"; chmod 0755 "$IRD_TREE/bin/takana"
92cp scripts/takana-install-partition.sh "$IRD_TREE/instalador/"
93cp scripts/lib/herramientas-desde-store.sh "$IRD_TREE/instalador/lib/"
94cp "$KERNEL" "$IRD_TREE/payload/bzImage"
95mkdir -p "$IRD_TREE/payload/stage"
96cp -a "$STAGE/root" "$IRD_TREE/payload/stage/root"
97cp "$STAGE/initramfs.cpio.gz" "$IRD_TREE/payload/stage/initramfs.cpio.gz"
98printf '%s\n' "$ARGS_INSTALADOR" > "$IRD_TREE/instalador/args"
99
100# ── 4) /init — lo que corre cuando el kernel nuevo toma el control ─────────────────────────────
101cat > "$IRD_TREE/init" <<'INIT'
102#!/bin/busybox sh
103# PID 1 del instalador. No pivota a ningún disco: instala y reinicia.
104export PATH=/bin
105mount -t proc     proc /proc 2>/dev/null || true
106mount -t sysfs    sys  /sys  2>/dev/null || true
107mount -t devtmpfs dev  /dev  2>/dev/null || true
108# ⚠ El log va a tty0 **y** al serial, por lo mismo que el initramfs de pivote: el cmdline horneado
109# deja /dev/console en ttyS0 y en un metal sin puerto serie todo esto sería invisible.
110# El log va SÓLO a los devices: el stdout de PID 1 ya es /dev/console (= ttyS0 por el cmdline
111# horneado), así que un `echo` suelto duplicaba cada línea en el serial.
112log() { for d in /dev/tty0 /dev/ttyS0; do echo "$*" > "$d" 2>/dev/null || true; done; }
113rescate() {
114    log "TAKANA-INSTALADOR-FALLO: $*"
115    log "  bloques visibles: $(ls /dev/sd* /dev/nvme* /dev/vd* /dev/mmcblk* 2>/dev/null | tr '\n' ' ')"
116    log "  shell de rescate en tty1 — probá: blkid ; dmesg | tail -30"
117    setsid -c sh -c 'exec /bin/sh </dev/tty1 >/dev/tty1 2>&1' >/dev/null 2>&1 &
118    exec sh
119}
120# efivarfs: sin esto el instalador concluye «esta máquina no arrancó por UEFI» y NO registra la
121# entrada de arranque — en una máquina que sí arrancó por UEFI. Es el mismo diagnóstico falso que ya
122# costó una vuelta en el `/sbin/init` del rootfs: `switch_root` y un initramfs fresco no arrastran
123# /sys, y sin sysfs el directorio no existe. Tras un kexec los servicios EFI de runtime siguen ahí,
124# así que acá esto es lo único que falta.
125if [ -d /sys/firmware/efi ]; then
126    mkdir -p /sys/firmware/efi/efivars 2>/dev/null || true
127    mount -t efivarfs efivarfs /sys/firmware/efi/efivars 2>/dev/null || true
128fi
129# ── ¿POR DÓNDE SE LLEGÓ? ──────────────────────────────────────────────────────────────────────
130# Lo dice el pivote del medio, que exporta `TAKANA_MEDIO=1` antes de su `switch_root` — y el
131# entorno sobrevive al exec. No es un detalle: la diferencia cambia QUÉ ES LA RAÍZ VIVA (por el
132# salto, el sistema del usuario; por el medio, el propio USB) y con eso qué se ofrece formatear.
133#
134# ⚠ **La primera versión miraba `rdinit=` en /proc/cmdline y estaba MAL.** Con `CONFIG_CMDLINE_BOOL`
135# y sin `CONFIG_CMDLINE_OVERRIDE`, el cmdline horneado del kernel se CONCATENA con el que pasa quien
136# lo arranca: `rdinit=` aparece SIEMPRE, también tras un kexec, así que el instalador se creía en un
137# medio estando en el salto. Medido el 2026-09-23 — y el síntoma fue benigno de casualidad (un
138# mensaje raro), pero la consecuencia real era que la raíz viva del usuario habría quedado marcada
139# «es el MEDIO desde el que arrancaste» y NO SE HABRÍA PODIDO ELEGIR, que es justo el caso que el
140# salto existe para resolver.
141MEDIO="${TAKANA_MEDIO:-}"
142if [ -n "$MEDIO" ]; then
143    log "TAKANA-INSTALADOR: arrancado desde el MEDIO de instalación. Ningún disco de esta máquina está en uso."
144else
145    log "TAKANA-INSTALADOR: arrancado en RAM. El sistema viejo YA NO CORRE: su disco está libre."
146fi
147[ -d /sys/firmware/efi/efivars ] && log "TAKANA-INSTALADOR: firmware UEFI visible (efivarfs montado)" \
148    || log "TAKANA-INSTALADOR: sin efivarfs ⇒ no se registrará entrada NVRAM (BIOS, o kernel sin EFI)"
149
150# Los discos tardan en enumerar (USB y NVMe sobre todo). Misma espera larga que el pivote, y por el
151# mismo motivo: en QEMU aparecen al instante y la carrera sólo se ve en metal.
152# ⚠ Esto era `ls /dev/nvme* /dev/sd* /dev/vd* … && break` y **esperaba los 60 s completos incluso
153# con el disco presente**: `ls` sale ≠ 0 si CUALQUIERA de sus argumentos no existe, y los globs sin
154# coincidencia quedan literales. O sea que bastaba con no tener NVMe para que un disco virtio ya
155# enumerado no contara. Medido en QEMU: 60 s de «esperando discos» con /dev/vda ahí desde el
156# segundo uno. En metal eso se lee como un arranque colgado.
157i=0
158while [ "$i" -lt 60 ]; do
159    hay=""
160    for d in /dev/vd? /dev/sd? /dev/nvme?n? /dev/mmcblk?; do [ -b "$d" ] && hay=1; done
161    [ -n "$hay" ] && break
162    i=$(( i + 1 )); [ $(( i % 5 )) -eq 0 ] && log "TAKANA-INSTALADOR: esperando discos… ${i}s"
163    sleep 1
164done
165
166cd /instalador
167# ── De dónde sale QUÉ instalar, en orden de precedencia ───────────────────────────────────────
168#   1. la CMDLINE del kernel  (`takana.root=PARTUUID=… takana.esp=… takana.free takana.yes`)
169#   2. los valores por defecto horneados al armar el initramfs, si los hubo
170#   3. NADA ⇒ modo interactivo: el censo del terreno y una pregunta
171# El 1 es lo que hace que este mismo initramfs sirva en cualquier máquina: quien salta por kexec
172# pasa la elección por la cmdline, y quien arranca de un USB la edita en el menú del loader.
173ARGS=""; YES=""; CONSOLA_PEDIDA=""
174for _w in $(cat /proc/cmdline 2>/dev/null); do
175    case "$_w" in
176        takana.root=*) ARGS="$ARGS --root-part ${_w#takana.root=}" ;;
177        takana.esp=*)  ARGS="$ARGS --esp ${_w#takana.esp=}" ;;
178        takana.disk=*) ARGS="$ARGS --disk ${_w#takana.disk=}" ;;
179        takana.free)   ARGS="$ARGS --use-free-space" ;;
180        takana.yes)    YES=1 ;;
181        takana.console=*) CONSOLA_PEDIDA="${_w#takana.console=}" ;;
182    esac
183done
184# ── DÓNDE SE PREGUNTA ─────────────────────────────────────────────────────────────────────────
185# ⚠ `/dev/console` es la ÚLTIMA `console=` del cmdline, y **el cmdline HORNEADO del kernel pone
186# `tty0` PRIMERO y `ttyS0` último** ⇒ arrancado de un USB, `/dev/console` es el SERIAL. En un
187# portátil sin puerto serie eso significa que el censo y la pregunta salen por un sitio que no
188# existe: pantalla muerta y un instalador que parece colgado esperando una tecla que nadie puede
189# escribir. Por el salto el cmdline lo ponemos nosotros y `tty0` va último, pero por USB no se
190# puede elegir sin recompilar el kernel.
191#
192# Regla: si hay una VT de verdad, se pregunta en la PANTALLA. Y se dice en voz alta por los dos
193# lados, porque el caso contrario —una máquina sin monitor, administrada por serie— existe y tiene
194# que poder corregirlo sin adivinar: `takana.console=/dev/ttyS0` en la cmdline.
195# ⚠ Y no alcanza con que `tty0` EXISTA: con `console=tty0` en el cmdline el kernel lo registra
196# igual en una máquina sin pantalla, con el driver `dummy` detrás — o sea un dispositivo que acepta
197# todo lo que le escribas y no lo muestra en ningún lado. La pregunta se iría a un agujero. Lo que
198# distingue una pantalla de verdad es el vtconsole: `dummy device` contra `frame buffer device` o
199# `VGA+`. Medido en QEMU, que da las dos según se le pida `-vga std` o `-vga none`.
200hay_pantalla() {
201    for _v in /sys/class/vtconsole/vtcon*/name; do
202        [ -r "$_v" ] || continue
203        grep -qi 'dummy' "$_v" || return 0
204    done
205    return 1
206}
207CONSOLA=/dev/console
208if [ -n "$CONSOLA_PEDIDA" ]; then
209    CONSOLA="$CONSOLA_PEDIDA"
210elif [ -c /dev/tty0 ] && hay_pantalla; then
211    CONSOLA=/dev/tty0
212fi
213[ -z "$ARGS" ] && [ -s /instalador/args ] && ARGS=$(cat /instalador/args)
214log "TAKANA-INSTALADOR: takana-install-partition.sh ${ARGS:-(sin parámetros ⇒ interactivo)}"
215# Las herramientas viajan en /bin: el instalador las toma por TOOL_<binario> en vez de buscarlas en
216# un store que acá no existe. STAGE_LISTO dice que el árbol ya vino armado.
217export TOOL_mke2fs=/bin/mke2fs TOOL_sfdisk=/bin/sfdisk TOOL_mmd=/bin/mmd \
218       TOOL_mcopy=/bin/mcopy TOOL_mdir=/bin/mdir
219export STAGE=/payload/stage STAGE_LISTO=1 KERNEL=/payload/bzImage HAMMER=/bin/takana
220# El instalador necesita saberlo para clasificar bien la raíz viva: por el salto es el sistema del
221# usuario (se puede reemplazar); por el medio es el propio USB (no se toca nunca).
222[ -n "$MEDIO" ] && export TAKANA_MEDIO=1
223# ⚠ **El estado de un PIPE es el del ÚLTIMO comando, no el del primero.** Esto era
224# `if sh instalador… | tee …; then OK else rescate fi` y el `if` evaluaba el `tee`, que siempre sale
225# 0 ⇒ **el instalador falló, no formateó NADA, y esta pantalla dijo «instalado»**. Medido en QEMU el
226# 2026-09-23, y es el modo de fallo más caro posible: el usuario reinicia confiando y se queda sin
227# sistema. El estado del instalador se guarda aparte y se lee después; el pipe ya no decide nada.
228# shellcheck disable=SC2086
229# `< /dev/null`: nada de esto debe leer del teclado —las confirmaciones ya van por `--yes`— y si
230# algo lo intenta tiene que FALLAR, no quedarse esperando en una consola que nadie está mirando.
231# Desatendido SÓLO si la cmdline lo autorizó con `takana.yes`. Si hay parámetros pero nadie dijo
232# que sí, se entra igual por la rama interactiva: preguntar y que nadie conteste es un cuelgue, pero
233# formatear sin que nadie lo haya pedido es peor.
234if [ -n "$ARGS" ] && [ -n "$YES" ]; then
235    { sh /instalador/takana-install-partition.sh $ARGS --yes < /dev/null; echo $? > /rc; } 2>&1 | tee /dev/tty0 > /dev/ttyS0
236else
237    # Interactivo: la consola del kernel es la pantalla (tty0 va ÚLTIMO en la cmdline del salto),
238    # así que entrada y salida van ahí y el instalador ve una terminal de verdad — sin eso su
239    # `[ -t 0 ]` sale falso y se niega a preguntar.
240    log "TAKANA-INSTALADOR: el censo y la pregunta salen por $CONSOLA"
241    log "TAKANA-INSTALADOR: si estás mirando esto por el puerto serie y la pregunta no aparece acá,"
242    log "                   rearrancá con  takana.console=/dev/ttyS0  en la cmdline."
243    sh /instalador/takana-install-partition.sh $ARGS < "$CONSOLA" > "$CONSOLA" 2>&1
244    echo $? > /rc
245fi
246if [ "$(cat /rc 2>/dev/null || echo 1)" = "0" ]; then
247    log "TAKANA-INSTALADOR-OK: instalado. Reiniciando en 10 s (sacá el medio si lo hubiera)."
248    sync; sleep 10; reboot -f
249else
250    rescate "el instalador salió con error — NADA se reinicia solo, mirá el log de arriba"
251fi
252INIT
253chmod +x "$IRD_TREE/init"
254
255# ── 5) empaquetar ──────────────────────────────────────────────────────────────────────────────
256mkdir -p "$(dirname "$OUT")"
257# `TREE_ONLY=1` corta acá: el ÁRBOL es la pieza, y tiene dos medios. Comprimido en un cpio viaja
258# por kexec y dentro del `.run`; escrito en un ext4 es el USB, que existe para las máquinas donde el
259# salto no se puede. Duplicar el armado del árbol en el script del USB sería tener dos instaladores
260# que se parecen — y el que se olvide de actualizar es el que alguien va a arrancar.
261if [ -n "${TREE_ONLY:-}" ]; then
262    echo "==> TREE_ONLY: árbol listo en $IRD_TREE — no se comprime"
263    exit 0
264fi
265( cd "$IRD_TREE" && find . -print0 | "$CPIO" --null -o -H newc --owner=root:root 2>/dev/null | "$GZIP" -1 ) > "$OUT"
266echo "==> $OUT: $(du -h "$OUT" | cut -f1)"
267echo
268echo "Este initramfs NO lleva ninguna máquina horneada: decide al arrancar."
269echo "  · sin parámetros                  ⇒ censo del terreno + pregunta (sirve en cualquier máquina)"
270echo "  · takana.root=PARTUUID=…          ⇒ destino por identidad estable"
271echo "  · takana.free takana.disk=/dev/…  ⇒ instalar al lado, en espacio sin asignar"
272echo "  · takana.yes                      ⇒ sin preguntar (sólo junto a lo de arriba)"
273echo
274echo "Para SALTAR a él sin pasar por el firmware (el userspace de esta máquina muere ACÁ), lo normal
275es NO tocar esto y usar el verbo, que comprueba, avisa y arma la cmdline solo (ADR 0021):
276  sudo takana metal check      # ¿se puede?
277  sudo takana metal survey     # el terreno
278  sudo takana metal install    # el viaje entero
279El motor a la vista, por si hace falta:
280  sudo takana kernel kexec <linux-metal> --initrd work/instalador-salida/takana-instalador.cpio.gz \
281       --cmdline 'console=ttyS0,115200 console=tty0' --jump   # tty0 ÚLTIMO = la pantalla
282
283Para probarlo SIN saltar (y sin riesgo), en QEMU:"
284echo "  qemu-system-x86_64 -m 4096 -kernel $KERNEL -initrd $OUT \\"
285echo "       -append 'console=ttyS0' -drive file=<disco.img>,format=raw -nographic"