sergio/hammer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a5be781ef6ef04f6e75d3ba5d0db2d3eaac39363
hammer/scripts/hammer-live-install.sh
T
sergioandClaude Opus 4.8 a5be781ef6 arranque-grafo: hammer boot menu — orquestador del menú + wiring en el init (ADR 0010) 
hammer boot menu ata las tres piezas del contrato: emite el grafo → lanza el
compositor (mirada, --compositor configurable) → activa el nodo que el usuario
dejó en boot-select. Graceful: sin compositor (servidor headless) emite el grafo
y sigue el arranque. Refactor: activate_and_report compartido con boot activate;
--out/--select configurables (testeable sin /run/hammer root-only).

Wiring: iso-image INSTALLER=1 + install-image-efi bundlean el CLI hammer (static
musl) al sistema instalado (el producto trae arje-zero/hammerd pero no el CLI);
el wrapper /sbin/init lo invoca tras hammer-recover, salida al serial (no pinta
tty0 ⇒ respeta cero-parpadeo). Cierra la pieza #3 del handoff mirada (quién
lanza el menú en el boot): lo ownea hammer, desde el hook de init.

Tests: boot_menu.rs (3 caminos del glue: graceful/sin-selección/selección→activate)
+ efi-disk-boot-test asevera que el menú corre. Validado en OVMF: pivote →
INIT-OK → menú (emite boot-graph.json + saltea sin mirada) → arje-zero.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-10 21:30:30 -04:00

309 lines
14 KiB
Bash
Executable File
Raw Blame History

#!/bin/sh
# hammer-install — instalador a disco DESDE el medio live (Etapa E5 / refinamiento #1).
#
# Se inyecta en el rootfs del producto como /usr/bin/hammer-install (ver scripts/iso-image.sh
# INSTALLER=1). Corre DENTRO del live, como root real (arje-zero es PID1) ⇒ NO necesita unshare -r
# ni los rodeos rootless de install-image.sh: particiona, formatea, monta y copia con privilegios
# reales, usando sólo herramientas que el producto ya trae (busybox fdisk/mke2fs/mount/dd + uutils cp).
#
# El sistema que se instala es EL PROPIO LIVE: la raíz en RAM se copia al disco (autoinstalador). El
# payload de arranque (kernel + GRUB) viaja en /usr/lib/hammer/install/, armado en build-time (el host
# tiene grub-mkimage; el live no lo necesita).
#
# Layout en disco (MBR, no GPT — más simple y busybox-friendly; GRUB va en el hueco post-MBR):
# /dev/<dev>1 / ext2(montable ext4) + /boot/bzImage + /boot/grub + wrapper /sbin/init
# /dev/<dev>2 /store ext2
# /dev/<dev>3 /var/lib/hammer ext2
#
# Cadena de arranque del disco resultante: BIOS → MBR (boot.img) → core.img (hueco post-MBR) →
# (hd0,msdos1)/boot/grub/grub.cfg → linux /boot/bzImage root=/dev/<dev>1 → wrapper /sbin/init.
#
# Uso (en el live): hammer-install /dev/vdb [ROOT_MB] [STORE_MB]
set -eu
DEV="${1:-/dev/vdb}"
ROOT_MB="${2:-1500}"
STORE_MB="${3:-400}" # /var/lib/hammer toma el resto
PAYLOAD=/usr/lib/hammer/install
BB=/bin/busybox
[ -b "$DEV" ] || { echo "hammer-install: $DEV no es un block device" >&2; exit 1; }
[ -d "$PAYLOAD" ] || { echo "hammer-install: falta el payload $PAYLOAD (¿ISO sin INSTALLER=1?)" >&2; exit 1; }
# --- Detección de firmware: UEFI ⇒ rama EFI-stub SOBERANA (ADR 0010 paso 5); BIOS ⇒ MBR+GRUB (abajo) ---
# La rama EFI usa una ESP tipo 0xEF en tabla MBR (UEFI arranca \EFI\BOOT\BOOTX64.EFI de una ESP MBR igual
# que de GPT) ⇒ alcanza con busybox fdisk/mkfs.vfat/mount, sin GPT-tool ni mtools. El bzImage metal ES el
# binario EFI (EFI-stub, cmdline horneada carga el initrd); un initramfs mínimo pivota por LABEL. Mismos
# artefactos que scripts/install-image-efi.sh (validado en OVMF), armados desde dentro del live.
if [ -d /sys/firmware/efi ]; then
[ -r "$PAYLOAD/kernel/bzImage-efi" ] || { echo "hammer-install: live en UEFI pero falta $PAYLOAD/kernel/bzImage-efi (ISO sin kernel metal)" >&2; exit 1; }
ESP_MB="${ESP_MB:-64}"
echo "==> hammer-install (UEFI): EFI-stub soberano en $DEV (ESP ${ESP_MB}M, root ${ROOT_MB}M, store ${STORE_MB}M, estado=resto)"
echo " ¡esto BORRA $DEV!"
# MBR, 4 primarias: p1=ESP(0xEF) p2=root p3=store p4=estado. Sectores explícitos (como la rama BIOS).
SPM=2048
P1S=2048; P1E=$(( P1S + ESP_MB * SPM - 1 ))
P2S=$(( P1E + 1 )); P2E=$(( P2S + ROOT_MB * SPM - 1 ))
P3S=$(( P2E + 1 )); P3E=$(( P3S + STORE_MB* SPM - 1 ))
P4S=$(( P3E + 1 )) # estado = resto del disco
echo "==> particionando $DEV (MBR: ESP ${P1S}-${P1E} tipo ef, root ${P2S}-${P2E}, store ${P3S}-${P3E}, estado ${P4S}-fin)"
"$BB" fdisk "$DEV" >/dev/null 2>&1 <<FDISK || true
o
n
p
1
$P1S
$P1E
n
p
2
$P2S
$P2E
n
p
3
$P3S
$P3E
n
p
4
$P4S
t
1
ef
a
1
w
FDISK
"$BB" partprobe "$DEV" 2>/dev/null || true
"$BB" sync; sleep 1
P1="${DEV}1"; P2="${DEV}2"; P3="${DEV}3"; P4="${DEV}4"
for p in "$P1" "$P2" "$P3" "$P4"; do
[ -b "$p" ] || { echo "hammer-install: no apareció la partición $p tras particionar" >&2; exit 1; }
done
echo "==> formateando (ESP FAT32 + 3 ext2 etiquetadas para el pivote por LABEL)"
"$BB" mkfs.vfat -F 32 -n HAMMER "$P1" >/dev/null 2>&1
"$BB" mke2fs -F -L hammer-root "$P2" >/dev/null 2>&1
"$BB" mke2fs -F -L hammer-store "$P3" >/dev/null 2>&1
"$BB" mke2fs -F -L hammer-state "$P4" >/dev/null 2>&1
# initramfs de pivote (busybox estático del live + /init: findfs LABEL=hammer-root → switch_root).
echo "==> armando el initramfs de pivote (busybox + /init switch_root a hammer-root)"
IRD_TREE=/run/hammer-efi-ird
"$BB" rm -rf "$IRD_TREE"
"$BB" mkdir -p "$IRD_TREE/bin" "$IRD_TREE/dev" "$IRD_TREE/proc" "$IRD_TREE/sys" "$IRD_TREE/newroot"
cp "$BB" "$IRD_TREE/bin/busybox"; "$BB" chmod 0755 "$IRD_TREE/bin/busybox"
for a in sh mount umount findfs switch_root mkdir echo sleep; do "$BB" ln -sf busybox "$IRD_TREE/bin/$a"; done
cat > "$IRD_TREE/init" <<'INIT'
#!/bin/busybox sh
export PATH=/bin
mount -t proc proc /proc 2>/dev/null || true
mount -t sysfs sys /sys 2>/dev/null || true
mount -t devtmpfs dev /dev 2>/dev/null || true
log() { echo "$*"; echo "$*" > /dev/ttyS0 2>/dev/null || true; }
log "HAMMER-EFI: initramfs de pivote — resolviendo hammer-root por LABEL"
ROOTDEV=""
for _try in 1 2 3 4 5; do
ROOTDEV="$(findfs LABEL=hammer-root 2>/dev/null || true)"
[ -n "$ROOTDEV" ] && break
log "HAMMER-EFI: hammer-root aún no visible, reintento $_try…"; sleep 1
done
[ -n "$ROOTDEV" ] || { log "HAMMER-EFI-FALLO: no encuentro LABEL=hammer-root"; exec sh; }
log "HAMMER-EFI: hammer-root = $ROOTDEV → montando en /newroot"
mount -t ext4 "$ROOTDEV" /newroot || { log "HAMMER-EFI-FALLO: no pude montar $ROOTDEV"; exec sh; }
STOREDEV="$(findfs LABEL=hammer-store 2>/dev/null || true)"
STATEDEV="$(findfs LABEL=hammer-state 2>/dev/null || true)"
[ -n "$STOREDEV" ] && mount -t ext4 "$STOREDEV" /newroot/store 2>/dev/null || true
[ -n "$STATEDEV" ] && mount -t ext4 "$STATEDEV" /newroot/var/lib/hammer 2>/dev/null || true
log "HAMMER-EFI-DISK-PIVOT-OK: switch_root → /sbin/init"
exec switch_root /newroot /sbin/init
INIT
"$BB" chmod +x "$IRD_TREE/init"
( cd "$IRD_TREE" && "$BB" find . | "$BB" cpio -o -H newc 2>/dev/null | "$BB" gzip -1 ) > /run/hammer-efi-ird.cpio.gz
# Poblar la ESP (FAT32, montable por el live): BOOTX64.EFI = bzImage metal + el initramfs de pivote.
echo "==> poblando la ESP (\\EFI\\BOOT\\BOOTX64.EFI = kernel metal + \\initramfs.cpio.gz)"
ESPMNT=/run/hammer-esp
"$BB" mkdir -p "$ESPMNT"
"$BB" mount -t vfat "$P1" "$ESPMNT"
"$BB" mkdir -p "$ESPMNT/EFI/BOOT"
cp "$PAYLOAD/kernel/bzImage-efi" "$ESPMNT/EFI/BOOT/BOOTX64.EFI"
cp /run/hammer-efi-ird.cpio.gz "$ESPMNT/initramfs.cpio.gz"
"$BB" sync; "$BB" umount "$ESPMNT"
# Poblar la root (copia del live) — sin wrapper que monte particiones (el pivote ya montó store/estado).
echo "==> copiando la raíz del live → $P2 (excluye virtuales/efímeros, /store, /var/lib/hammer, payload)"
MNT=/run/hammer-install
"$BB" mkdir -p "$MNT"
"$BB" mount -t ext4 "$P2" "$MNT"
for entry in /* /.[!.]*; do
[ -e "$entry" ] || continue
name="${entry##*/}"
case "$name" in
proc|sys|dev|run|tmp|store|init) continue ;;
*) cp -a "$entry" "$MNT/" 2>/dev/null || true ;;
esac
done
"$BB" rm -rf "$MNT/var/lib/hammer" 2>/dev/null || true
"$BB" rm -rf "$MNT/usr/lib/hammer/install" 2>/dev/null || true
"$BB" mkdir -p "$MNT/store" "$MNT/var/lib/hammer" "$MNT/proc" "$MNT/sys" "$MNT/dev" "$MNT/run" "$MNT/tmp"
# /sbin/init: wrapper que auto-sana un upgrade interrumpido y arranca arje-zero (el pivote ya montó
# store/estado por LABEL, así que acá NO hace falta montar nada — sólo hammer-recover + exec).
if [ -x "$PAYLOAD/hammer-recover" ]; then
"$BB" mkdir -p "$MNT/usr/sbin"
cp "$PAYLOAD/hammer-recover" "$MNT/usr/sbin/hammer-recover"; "$BB" chmod 0755 "$MNT/usr/sbin/hammer-recover"
fi
# CLI hammer (static musl) para el menú de arranque por grafo (ADR 0010): lo copia al disco desde el
# payload; el wrapper lo invoca como `hammer boot menu`.
if [ -x "$PAYLOAD/hammer" ]; then
cp "$PAYLOAD/hammer" "$MNT/usr/bin/hammer"; "$BB" chmod 0755 "$MNT/usr/bin/hammer"
fi
"$BB" rm -f "$MNT/sbin/init"
cat > "$MNT/sbin/init" <<'INIT'
#!/bin/sh
# Wrapper PID1 (rama UEFI): el initramfs de pivote ya montó / /store /var/lib/hammer por LABEL antes del
# switch_root; sólo auto-sanamos un upgrade interrumpido y arrancamos el init real. El marcador a
# /dev/ttyS0 sobrevive `quiet` (que suprime el printk kernel-side) ⇒ prueba serie de que llegó a PID1.
# busybox switch_root NO mueve /dev ⇒ montamos devtmpfs antes (si no, /dev/ttyS0 aún no existe).
/bin/busybox mount -t devtmpfs dev /dev 2>/dev/null || true
echo "HAMMER-EFI-INIT-OK: arje-zero PID1" > /dev/ttyS0 2>/dev/null || true
[ -x /usr/sbin/hammer-recover ] && /usr/sbin/hammer-recover || true
# Menú de arranque por grafo (ADR 0010): emite /run/hammer/boot-graph.json y, si hay compositor (mirada),
# lo pinta sobre KMS. Graceful (sin compositor sigue) y al serial (no pinta tty0 ⇒ cero-parpadeo).
[ -x /usr/bin/hammer ] && /usr/bin/hammer boot menu > /dev/ttyS0 2>&1 || true
exec /usr/bin/arje-zero
INIT
"$BB" chmod +x "$MNT/sbin/init"
"$BB" sync
"$BB" umount "$MNT"
echo "✓ hammer-install (UEFI): $DEV instalado con EFI-stub SOBERANO (sin GRUB ni systemd-boot). Reiniciá sin el medio live."
exit 0
fi
# ===================== rama BIOS (MBR + GRUB) — el firmware NO es UEFI ==============================
[ -r "$PAYLOAD/grub/boot.img" ] && [ -r "$PAYLOAD/grub/core.img" ] || { echo "hammer-install: payload GRUB incompleto" >&2; exit 1; }
[ -r "$PAYLOAD/kernel/bzImage" ] || { echo "hammer-install: falta el kernel en el payload" >&2; exit 1; }
echo "==> hammer-install: instalando el sistema live en $DEV (root ${ROOT_MB}M, store ${STORE_MB}M, estado=resto)"
echo " ¡esto BORRA $DEV!"
# --- particionar MBR con busybox fdisk (3 primarias; p1 bootable) ---
# Pasamos sectores de inicio/fin EXPLÍCITOS para las tres: busybox fdisk, al pedir el inicio por
# defecto, ofrece el sector LIBRE MÁS BAJO (= el hueco 63..2047 que dejamos antes de p1) ⇒ con <enter>
# colocaría p2 en ese hueco. Por eso computamos los sectores y los tecleamos.
# p1 ARRANCA EN 2048 (1 MiB) A PROPÓSITO: deja un hueco post-MBR de 2047 sectores para el core.img de
# GRUB (~281 sectores). El default CHS de busybox (sector 63 ⇒ hueco de 62) lo DESBORDA, pisando el
# filesystem de p1 ⇒ GRUB cae a `grub>`.
SPM=2048
P1S=2048; P1E=$(( P1S + ROOT_MB * SPM - 1 ))
P2S=$(( P1E + 1 )); P2E=$(( P2S + STORE_MB * SPM - 1 ))
P3S=$(( P2E + 1 )) # p3 toma hasta el final del disco (último sector = default)
echo "==> particionando $DEV (MBR: p1 ${P1S}-${P1E}, p2 ${P2S}-${P2E}, p3 ${P3S}-fin)"
"$BB" fdisk "$DEV" >/dev/null 2>&1 <<FDISK || true
o
n
p
1
$P1S
$P1E
n
p
2
$P2S
$P2E
n
p
3
$P3S
a
1
w
FDISK
"$BB" partprobe "$DEV" 2>/dev/null || true
"$BB" sync; sleep 1
P1="${DEV}1"; P2="${DEV}2"; P3="${DEV}3"
for p in "$P1" "$P2" "$P3"; do
[ -b "$p" ] || { echo "hammer-install: no apareció la partición $p tras particionar" >&2; exit 1; }
done
# --- formatear (busybox mke2fs = ext2; el driver ext4 del kernel lo monta) ---
echo "==> formateando particiones (ext2, montables como ext4)"
"$BB" mke2fs -F -L hammer-root "$P1" >/dev/null 2>&1
"$BB" mke2fs -F -L hammer-store "$P2" >/dev/null 2>&1
"$BB" mke2fs -F -L hammer-state "$P3" >/dev/null 2>&1
# --- copiar la raíz del live a la partición root, excluyendo virtuales + el payload ---
MNT=/run/hammer-install
"$BB" mkdir -p "$MNT"
"$BB" mount -t ext4 "$P1" "$MNT"
echo "==> copiando la raíz del live → $P1 (excluye virtuales/efímeros, /store, /var/lib/hammer y el payload)"
# Enumeramos TODO el top-level de / y copiamos salvo lo virtual/efímero — así no se nos escapa ningún
# dir del producto (p.ej. /ente con la seed.card, /linuxrc). uutils cp -a preserva modos/symlinks.
for entry in /* /.[!.]*; do
[ -e "$entry" ] || continue
name="${entry##*/}"
case "$name" in
proc|sys|dev|run|tmp|store|init) continue ;; # virtuales/efímeros + el /init marcador del live
*) cp -a "$entry" "$MNT/" 2>/dev/null || true ;;
esac
done
# /var sin /var/lib/hammer (estado) — se recrea vacío como mountpoint.
"$BB" rm -rf "$MNT/var/lib/hammer" 2>/dev/null || true
# Quitar el payload del disco instalado (sólo sirve en el live) y recrear mountpoints.
"$BB" rm -rf "$MNT/usr/lib/hammer/install" 2>/dev/null || true
"$BB" mkdir -p "$MNT/store" "$MNT/var/lib/hammer" "$MNT/proc" "$MNT/sys" "$MNT/dev" "$MNT/run" "$MNT/tmp" "$MNT/boot/grub/i386-pc"
# --- /boot: kernel + módulos GRUB + grub.cfg, y wrapper /sbin/init (monta las particiones dedicadas) ---
echo "==> poblando /boot (kernel + GRUB) y wrapper /sbin/init"
cp "$PAYLOAD/kernel/bzImage" "$MNT/boot/bzImage"; "$BB" chmod 0644 "$MNT/boot/bzImage"
cp "$PAYLOAD"/grub/i386-pc/*.mod "$MNT/boot/grub/i386-pc/" 2>/dev/null || true
cp "$PAYLOAD"/grub/i386-pc/*.lst "$MNT/boot/grub/i386-pc/" 2>/dev/null || true
ROOTDEV="${P1##*/}" # p.ej. vda1 cuando el disco instalado sea el único
cat > "$MNT/boot/grub/grub.cfg" <<CFG
set timeout=2
set default=0
serial --unit=0 --speed=115200
terminal_input serial console
terminal_output serial console
insmod part_msdos
insmod ext2
menuentry "hammer" {
linux /boot/bzImage console=ttyS0 root=/dev/vda1 rw rdinit=/sbin/init
}
CFG
# hammer-recover: auto-sana un upgrade interrumpido al arranque (E4 #4b). Lo dejamos en /usr/sbin del
# disco; el wrapper lo corre tras montar /store y /var/lib/hammer (que necesita) y antes de incarnar.
if [ -x "$PAYLOAD/hammer-recover" ]; then
"$BB" mkdir -p "$MNT/usr/sbin"
cp "$PAYLOAD/hammer-recover" "$MNT/usr/sbin/hammer-recover"; "$BB" chmod 0755 "$MNT/usr/sbin/hammer-recover"
fi
"$BB" rm -f "$MNT/sbin/init"
cat > "$MNT/sbin/init" <<'INIT'
#!/bin/sh
# Wrapper PID1: el kernel monta la partición root; montamos las dedicadas, auto-sanamos un upgrade
# interrumpido (si lo hay) y arrancamos el init real.
/bin/busybox mount -t ext4 /dev/vda2 /store || echo "init: no pude montar /store (/dev/vda2)"
/bin/busybox mount -t ext4 /dev/vda3 /var/lib/hammer || echo "init: no pude montar /var/lib/hammer (/dev/vda3)"
[ -x /usr/sbin/hammer-recover ] && /usr/sbin/hammer-recover || true
exec /usr/bin/arje-zero
INIT
"$BB" chmod +x "$MNT/sbin/init"
"$BB" sync
"$BB" umount "$MNT"
# --- instalar GRUB: boot.img→MBR (440 B, sin pisar la tabla de particiones) + core.img→hueco post-MBR.
# Con install contiguo MBR los punteros por defecto de GRUB (kernel_sector=1, blocklist=2) ya valen
# ⇒ NO hace falta el parcheo binario que sí pide el caso GPT de install-image.sh.
echo "==> instalando GRUB (boot.img→MBR + core.img→hueco post-MBR)"
"$BB" dd if="$PAYLOAD/grub/boot.img" of="$DEV" bs=1 count=440 conv=notrunc 2>/dev/null
"$BB" dd if="$PAYLOAD/grub/core.img" of="$DEV" bs=512 seek=1 conv=notrunc 2>/dev/null
"$BB" sync
echo "✓ hammer-install: $DEV instalado. Reiniciá sin el medio live para arrancar del disco."
Reference in New Issue View Git Blame Copy Permalink