sergio/takana

1#!/bin/sh
2# hammer-install — instalador a disco DESDE el medio live (Etapa E5 / refinamiento #1).
3#
4# Se inyecta en el rootfs del producto como /usr/bin/hammer-install (ver scripts/iso-image.sh
5# INSTALLER=1). Corre DENTRO del live, como root real (arje-zero es PID1) ⇒ NO necesita unshare -r
6# ni los rodeos rootless de install-image.sh: particiona, formatea, monta y copia con privilegios
7# reales, usando sólo herramientas que el producto ya trae (busybox fdisk/mke2fs/mount/dd + uutils cp).
8#
9# El sistema que se instala es EL PROPIO LIVE: la raíz en RAM se copia al disco (autoinstalador). El
10# payload de arranque (kernel + GRUB) viaja en /usr/lib/hammer/install/, armado en build-time (el host
11# tiene grub-mkimage; el live no lo necesita).
12#
13# Layout en disco (MBR, no GPT — más simple y busybox-friendly; GRUB va en el hueco post-MBR):
14#   /dev/<dev>1  /                ext2(montable ext4)   + /boot/bzImage + /boot/grub + wrapper /sbin/init
15#   /dev/<dev>2  /store           ext2
16#   /dev/<dev>3  /var/lib/hammer  ext2
17#
18# Cadena de arranque del disco resultante: BIOS → MBR (boot.img) → core.img (hueco post-MBR) →
19# (hd0,msdos1)/boot/grub/grub.cfg → linux /boot/bzImage root=/dev/<dev>1 → wrapper /sbin/init.
20#
21# Modo de uso:
22#   INTERACTIVO (sin argumentos, con TTY):  hammer-install
23#       TUI en busybox sh: detecta discos, el usuario elige destino + confirma el borrado, recoge
24#       hostname / credencial de root / zona horaria / teclado / tamaños de partición, y recién ahí
25#       particiona+instala. Es la cara humana del instalador (el /init del ISO installer lo lanza).
26#   DESATENDIDO (con device):  hammer-install /dev/vdb [ROOT_MB] [STORE_MB]
27#       Autoinstalador (lo usa iso-install-test.sh con AUTO_INSTALL). La config sale de env:
28#       HAMMER_HOSTNAME / HAMMER_ROOT_PW / HAMMER_ROOT_AUTHKEYS / HAMMER_TZ / HAMMER_KEYMAP.
29set -eu
30
31DEV="${1:-}"
32ROOT_MB="${2:-}"
33STORE_MB="${3:-}"        # /var/lib/hammer toma el resto
34PAYLOAD=/usr/lib/hammer/install
35BB="${BB:-/bin/busybox}"
36SYS_BLOCK="${SYS_BLOCK:-/sys/block}"   # override para tests
37MOUNTS="${MOUNTS:-/proc/mounts}"       # override para tests
38
39# bb: usa el busybox del live si existe; si no (p.ej. tests en el host), cae a las herramientas del PATH.
40# Sólo lo usan las funciones NUEVAS (config/TUI). Las ramas EFI/BIOS validadas siguen con "$BB" literal
41# y jamás corren en el host (el dry-run sale antes).
42bb() { if [ -x "$BB" ]; then "$BB" "$@"; else "$@"; fi; }
43
44_human() {  # bytes → humano
45    _b="$1"
46    if   [ "$_b" -ge 1073741824 ]; then printf '%s.%s GiB' "$((_b/1073741824))" "$(( (_b%1073741824)*10/1073741824 ))"
47    elif [ "$_b" -ge 1048576    ]; then printf '%s MiB' "$((_b/1048576))"
48    else printf '%s B' "$_b"; fi
49}
50
51_is_mounted() {  # ¿alguna partición del disco $1 aparece en MOUNTS? (heurística "es el medio live")
52    _d="$1"
53    while read -r _src _rest; do
54        case "$_src" in "/dev/$_d"|"/dev/$_d"[0-9]*|"/dev/$_d"p[0-9]*) return 0 ;; esac
55    done < "$MOUNTS" 2>/dev/null
56    return 1
57}
58
59list_disks() {  # emite por disco candidato:  name<TAB>bytes<TAB>model<TAB>mounted(0|1)
60    for _p in "$SYS_BLOCK"/*; do
61        [ -d "$_p" ] || continue
62        _n=${_p##*/}
63        case "$_n" in loop*|ram*|sr*|fd*|dm-*|md*|zram*) continue ;; esac
64        [ -r "$_p/size" ] || continue
65        _sz=$(cat "$_p/size" 2>/dev/null || echo 0); [ "$_sz" -gt 0 ] || continue
66        _model=$(cat "$_p/device/model" 2>/dev/null | tr -d '\n'); _model=$(printf '%s' "$_model" | sed 's/[[:space:]]*$//')
67        _m=0; _is_mounted "$_n" && _m=1
68        printf '%s\t%s\t%s\t%s\n' "$_n" "$((_sz*512))" "${_model:-disco}" "$_m"
69    done
70}
71
72ask() {  # ask VAR "prompt" "default"
73    if [ -n "$3" ]; then printf '%s [%s]: ' "$2" "$3"; else printf '%s: ' "$2"; fi
74    IFS= read -r _ans || _ans=""
75    [ -n "$_ans" ] || _ans="$3"
76    eval "$1=\$_ans"
77}
78
79read_secret() {  # read_secret VAR "prompt"  (sin eco si hay stty)
80    printf '%s: ' "$2"
81    bb stty -echo 2>/dev/null || true
82    IFS= read -r _sec || _sec=""
83    bb stty echo 2>/dev/null || true
84    echo
85    eval "$1=\$_sec"
86}
87
88have_cryptpw() { bb 2>&1 | grep -qw cryptpw; }
89
90# Reescribe el campo de contraseña de un usuario en $mnt/etc/shadow (o crea el fichero).
91_set_shadow() {
92    _u="$1"; _h="$2"; _f="$3/etc/shadow"
93    if [ ! -f "$_f" ]; then
94        bb mkdir -p "$3/etc"
95        printf '%s:%s:19000:0:99999:7:::\n' "$_u" "$_h" > "$_f"; bb chmod 600 "$_f"; return
96    fi
97    _t="$_f.hammer-tmp"
98    bb awk -F: -v u="$_u" -v h="$_h" 'BEGIN{OFS=":"}
99        { if ($1==u){ $2=h; seen=1 } print }
100        END{ if(!seen) print u,h,"19000","0","99999","7","","","" }' "$_f" > "$_t" && bb mv "$_t" "$_f"
101    bb chmod 600 "$_f"
102}
103
104# Aplica la config recogida al rootfs YA copiado y montado en $1 (llamada por ambas ramas tras la copia).
105apply_post_install_config() {
106    _mnt="$1"
107    bb mkdir -p "$_mnt/etc/hammer"
108    if [ -n "${CFG_HOSTNAME:-}" ]; then
109        printf '%s\n' "$CFG_HOSTNAME" > "$_mnt/etc/hostname"
110        if ! grep -q "[[:space:]]$CFG_HOSTNAME\$" "$_mnt/etc/hosts" 2>/dev/null; then
111            printf '127.0.0.1\tlocalhost %s\n::1\t\tlocalhost %s\n' "$CFG_HOSTNAME" "$CFG_HOSTNAME" >> "$_mnt/etc/hosts"
112        fi
113    fi
114    if [ -n "${CFG_ROOT_HASH:-}" ]; then _set_shadow root "$CFG_ROOT_HASH" "$_mnt"; fi
115    if [ -n "${CFG_ROOT_AUTHKEYS:-}" ]; then
116        bb mkdir -p "$_mnt/root/.ssh"; bb chmod 700 "$_mnt/root/.ssh"
117        printf '%s\n' "$CFG_ROOT_AUTHKEYS" >> "$_mnt/root/.ssh/authorized_keys"
118        bb chmod 600 "$_mnt/root/.ssh/authorized_keys"
119    fi
120    if [ -n "${CFG_TZ:-}" ] && [ -e "$_mnt/usr/share/zoneinfo/$CFG_TZ" ]; then
121        bb ln -sf "/usr/share/zoneinfo/$CFG_TZ" "$_mnt/etc/localtime"
122        printf '%s\n' "$CFG_TZ" > "$_mnt/etc/timezone"
123    fi
124    _ts=$(bb date -u +%FT%TZ 2>/dev/null || echo unknown)
125    {
126        echo "# escrito por hammer-install en $_ts"
127        echo "HOSTNAME=${CFG_HOSTNAME:-}"
128        echo "TIMEZONE=${CFG_TZ:-}"
129        echo "KEYMAP=${CFG_KEYMAP:-}"     # best-effort: el producto aún no trae kbd/loadkeys
130        echo "TARGET=${DEV:-}"
131    } > "$_mnt/etc/hammer/install.conf"
132}
133
134# ---- recolección de config: interactiva (TUI) o desde env (desatendido) ----
135CFG_HOSTNAME="${HAMMER_HOSTNAME:-hammer}"
136CFG_ROOT_AUTHKEYS="${HAMMER_ROOT_AUTHKEYS:-}"
137CFG_ROOT_HASH="${HAMMER_ROOT_HASH:-}"
138CFG_TZ="${HAMMER_TZ:-}"
139CFG_KEYMAP="${HAMMER_KEYMAP:-us}"
140
141interactive_setup() {
142    echo
143    echo "   #  instalador de hammer"
144    echo "   ─────────────────────────"
145    echo
146    _disks=$(list_disks)
147    [ -n "$_disks" ] || { echo "No detecté discos instalables (¿el medio live es el único dispositivo?)."; exit 1; }
148    echo "Discos detectados:"
149    OLDIFS=$IFS; IFS='
150'; set --
151    for _l in $_disks; do set -- "$@" "$_l"; done
152    IFS=$OLDIFS
153    _i=1
154    for _l in "$@"; do
155        _n=$(printf '%s' "$_l" | cut -f1); _by=$(printf '%s' "$_l" | cut -f2)
156        _mo=$(printf '%s' "$_l" | cut -f3); _mm=$(printf '%s' "$_l" | cut -f4)
157        _w=""; [ "$_mm" = 1 ] && _w="   ⚠ montado (¿medio live?)"
158        printf '  %s) /dev/%-8s %10s   %s%s\n' "$_i" "$_n" "$(_human "$_by")" "$_mo" "$_w"
159        _i=$((_i+1))
160    done
161    _total=$#
162    while :; do
163        ask _sel "Disco destino (1-$_total)" ""
164        case "$_sel" in ''|*[!0-9]*) echo "  número inválido"; continue ;; esac
165        [ "$_sel" -ge 1 ] && [ "$_sel" -le "$_total" ] && break
166        echo "  fuera de rango"
167    done
168    eval "_line=\${$_sel}"
169    _name=$(printf '%s' "$_line" | cut -f1); _bytes=$(printf '%s' "$_line" | cut -f2)
170    DEV="/dev/$_name"
171    _disk_mb=$((_bytes/1048576))
172
173    # --- tamaños de partición ---
174    _esp=64; _slack=16; _avail=$((_disk_mb - _esp - _slack))
175    [ "$_avail" -ge 600 ] || { echo "Disco demasiado chico ($(_human "$_bytes")); se necesitan ~700 MiB."; exit 1; }
176    _defr=4096; [ "$_defr" -gt $((_avail*6/10)) ] && _defr=$((_avail*6/10))
177    _defs=1024; [ "$_defs" -gt $((_avail/5)) ] && _defs=$((_avail/5))
178    while :; do
179        ask ROOT_MB  "Tamaño de / en MB"      "$_defr"
180        ask STORE_MB "Tamaño de /store en MB" "$_defs"
181        case "$ROOT_MB$STORE_MB" in *[!0-9]*) echo "  usá sólo números"; continue ;; esac
182        if [ $((ROOT_MB + STORE_MB + _esp + _slack)) -le "$_disk_mb" ]; then break; fi
183        echo "  no entra en el disco ($_disk_mb MiB) — / + /store + ESP deben sumar menos"
184    done
185
186    # --- identidad ---
187    ask CFG_HOSTNAME "Hostname" "${CFG_HOSTNAME:-hammer}"
188    echo "Credencial de root:"
189    echo "  1) contraseña"
190    echo "  2) clave SSH (authorized_keys)"
191    echo "  3) omitir"
192    ask _cred "Opción" "1"
193    case "$_cred" in
194        1)  if have_cryptpw; then
195                while :; do
196                    read_secret _pw1 "Contraseña de root"
197                    read_secret _pw2 "Repetir"
198                    [ "$_pw1" = "$_pw2" ] && [ -n "$_pw1" ] && break
199                    echo "  no coinciden (o vacía) — reintentá"
200                done
201                CFG_ROOT_HASH=$(printf '%s' "$_pw1" | bb cryptpw -m sha512 2>/dev/null || true)
202                [ -n "$CFG_ROOT_HASH" ] || echo "  ⚠ no pude generar el hash; root queda como está"
203            else
204                echo "  (cryptpw no disponible en este busybox — usá la opción de clave SSH)"
205                ask CFG_ROOT_AUTHKEYS "Pegá una línea authorized_keys" ""
206            fi ;;
207        2)  ask CFG_ROOT_AUTHKEYS "Pegá una línea authorized_keys (o ruta a un fichero .pub)" ""
208            if [ -n "$CFG_ROOT_AUTHKEYS" ] && [ -f "$CFG_ROOT_AUTHKEYS" ]; then
209                CFG_ROOT_AUTHKEYS=$(cat "$CFG_ROOT_AUTHKEYS")
210            fi ;;
211        *)  echo "  (root sin credencial nueva)" ;;
212    esac
213
214    # --- locale (best-effort) ---
215    _zi="${ZONEINFO:-/usr/share/zoneinfo}"
216    if [ -d "$_zi" ]; then
217        ask CFG_TZ "Zona horaria (ej. America/La_Paz; vacío = UTC)" "${CFG_TZ:-}"
218        if [ -n "$CFG_TZ" ] && [ ! -e "$_zi/$CFG_TZ" ]; then
219            echo "  ⚠ zona desconocida, se ignora"; CFG_TZ=""
220        fi
221    else
222        echo "(tzdata no instalado — la zona horaria se omite)"; CFG_TZ=""
223    fi
224    ask CFG_KEYMAP "Layout de teclado" "${CFG_KEYMAP:-us}"
225
226    # --- resumen + confirmación fuerte ---
227    _cd="sin cambios"; [ -n "$CFG_ROOT_HASH" ] && _cd="contraseña"; [ -n "$CFG_ROOT_AUTHKEYS" ] && _cd="clave SSH"
228    echo
229    echo "Resumen de instalación:"
230    echo "  destino : $DEV   ($(_human "$_bytes"))"
231    echo "  / = ${ROOT_MB} MiB    /store = ${STORE_MB} MiB    /var/lib/hammer = resto"
232    echo "  hostname: $CFG_HOSTNAME"
233    echo "  root    : $_cd"
234    echo "  zona    : ${CFG_TZ:-UTC}    teclado: $CFG_KEYMAP"
235    echo
236    echo "  ⚠  ESTO BORRA TODO EN $DEV."
237    ask _ok "Escribí el nombre del disco ($DEV) para confirmar, o Enter para cancelar" ""
238    [ "$_ok" = "$DEV" ] || { echo "Cancelado — no se tocó ningún disco."; exit 1; }
239}
240
241# --- resolución del modo: interactivo (sin device + TTY) vs desatendido (device dado) ---
242if [ -z "$DEV" ]; then
243    if [ -t 0 ] || [ "${HAMMER_INSTALL_INTERACTIVE:-}" = 1 ]; then
244        interactive_setup
245    else
246        echo "uso: hammer-install <device> [ROOT_MB] [STORE_MB]   (o sin args con un TTY para el modo interactivo)" >&2
247        exit 2
248    fi
249fi
250ROOT_MB="${ROOT_MB:-1500}"
251STORE_MB="${STORE_MB:-400}"
252# En modo desatendido con contraseña por env, derivar el hash acá (interactivo ya lo hizo).
253if [ -z "$CFG_ROOT_HASH" ] && [ -n "${HAMMER_ROOT_PW:-}" ] && have_cryptpw; then
254    CFG_ROOT_HASH=$(printf '%s' "$HAMMER_ROOT_PW" | bb cryptpw -m sha512 2>/dev/null || true)
255fi
256
257# --- gancho de prueba: valida TUI + config sin tocar disco (HAMMER_INSTALL_DRYRUN=1) ---
258if [ "${HAMMER_INSTALL_DRYRUN:-}" = 1 ]; then
259    echo "== DRYRUN: plan de instalación =="
260    echo "  DEV=$DEV  ROOT_MB=$ROOT_MB  STORE_MB=$STORE_MB"
261    echo "  HOSTNAME=$CFG_HOSTNAME  TZ=${CFG_TZ:-UTC}  KEYMAP=$CFG_KEYMAP"
262    echo "  ROOT_HASH=$([ -n "$CFG_ROOT_HASH" ] && echo set || echo -)  AUTHKEYS=$([ -n "$CFG_ROOT_AUTHKEYS" ] && echo set || echo -)"
263    if [ -n "${HAMMER_INSTALL_TESTROOT:-}" ]; then
264        apply_post_install_config "$HAMMER_INSTALL_TESTROOT"
265        echo "  config aplicada a $HAMMER_INSTALL_TESTROOT"
266    fi
267    exit 0
268fi
269
270[ -b "$DEV" ] || { echo "hammer-install: $DEV no es un block device" >&2; exit 1; }
271[ -d "$PAYLOAD" ] || { echo "hammer-install: falta el payload $PAYLOAD (¿ISO sin INSTALLER=1?)" >&2; exit 1; }
272
273# --- Detección de firmware: UEFI ⇒ rama EFI-stub SOBERANA (ADR 0010 paso 5); BIOS ⇒ MBR+GRUB (abajo) ---
274# La rama EFI usa una ESP tipo 0xEF en tabla MBR (UEFI arranca \EFI\BOOT\BOOTX64.EFI de una ESP MBR igual
275# que de GPT) ⇒ alcanza con busybox fdisk/mkfs.vfat/mount, sin GPT-tool ni mtools. El bzImage metal ES el
276# binario EFI (EFI-stub, cmdline horneada carga el initrd); un initramfs mínimo pivota por LABEL. Mismos
277# artefactos que scripts/install-image-efi.sh (validado en OVMF), armados desde dentro del live.
278if [ -d /sys/firmware/efi ]; then
279    [ -r "$PAYLOAD/kernel/bzImage-efi" ] || { echo "hammer-install: live en UEFI pero falta $PAYLOAD/kernel/bzImage-efi (ISO sin kernel metal)" >&2; exit 1; }
280    ESP_MB="${ESP_MB:-64}"
281    echo "==> hammer-install (UEFI): EFI-stub soberano en $DEV (ESP ${ESP_MB}M, root ${ROOT_MB}M, store ${STORE_MB}M, estado=resto)"
282    echo "    ¡esto BORRA $DEV!"
283
284    # MBR, 4 primarias: p1=ESP(0xEF) p2=root p3=store p4=estado. Sectores explícitos (como la rama BIOS).
285    SPM=2048
286    P1S=2048;            P1E=$(( P1S + ESP_MB  * SPM - 1 ))
287    P2S=$(( P1E + 1 ));  P2E=$(( P2S + ROOT_MB * SPM - 1 ))
288    P3S=$(( P2E + 1 ));  P3E=$(( P3S + STORE_MB* SPM - 1 ))
289    P4S=$(( P3E + 1 ))   # estado = resto del disco
290    echo "==> particionando $DEV (MBR: ESP ${P1S}-${P1E} tipo ef, root ${P2S}-${P2E}, store ${P3S}-${P3E}, estado ${P4S}-fin)"
291    "$BB" fdisk "$DEV" >/dev/null 2>&1 <<FDISK || true
292o
293n
294p
2951
296$P1S
297$P1E
298n
299p
3002
301$P2S
302$P2E
303n
304p
3053
306$P3S
307$P3E
308n
309p
3104
311$P4S
312
313t
3141
315ef
316a
3171
318w
319FDISK
320    "$BB" partprobe "$DEV" 2>/dev/null || true
321    "$BB" sync; sleep 1
322    P1="${DEV}1"; P2="${DEV}2"; P3="${DEV}3"; P4="${DEV}4"
323    for p in "$P1" "$P2" "$P3" "$P4"; do
324        [ -b "$p" ] || { echo "hammer-install: no apareció la partición $p tras particionar" >&2; exit 1; }
325    done
326
327    echo "==> formateando (ESP FAT32 + 3 ext2 etiquetadas para el pivote por LABEL)"
328    "$BB" mkfs.vfat -F 32 -n HAMMER "$P1" >/dev/null 2>&1
329    "$BB" mke2fs -F -L hammer-root  "$P2" >/dev/null 2>&1
330    "$BB" mke2fs -F -L hammer-store "$P3" >/dev/null 2>&1
331    "$BB" mke2fs -F -L hammer-state "$P4" >/dev/null 2>&1
332
333    # initramfs de pivote (busybox estático del live + /init: findfs LABEL=hammer-root → switch_root).
334    echo "==> armando el initramfs de pivote (busybox + /init switch_root a hammer-root)"
335    IRD_TREE=/run/hammer-efi-ird
336    "$BB" rm -rf "$IRD_TREE"
337    "$BB" mkdir -p "$IRD_TREE/bin" "$IRD_TREE/dev" "$IRD_TREE/proc" "$IRD_TREE/sys" "$IRD_TREE/newroot"
338    cp "$BB" "$IRD_TREE/bin/busybox"; "$BB" chmod 0755 "$IRD_TREE/bin/busybox"
339    for a in sh mount umount findfs switch_root mkdir echo sleep; do "$BB" ln -sf busybox "$IRD_TREE/bin/$a"; done
340    cat > "$IRD_TREE/init" <<'INIT'
341#!/bin/busybox sh
342export PATH=/bin
343mount -t proc     proc /proc 2>/dev/null || true
344mount -t sysfs    sys  /sys  2>/dev/null || true
345mount -t devtmpfs dev  /dev  2>/dev/null || true
346log() { echo "$*"; echo "$*" > /dev/ttyS0 2>/dev/null || true; }
347log "HAMMER-EFI: initramfs de pivote — resolviendo hammer-root por LABEL"
348ROOTDEV=""
349for _try in 1 2 3 4 5; do
350    ROOTDEV="$(findfs LABEL=hammer-root 2>/dev/null || true)"
351    [ -n "$ROOTDEV" ] && break
352    log "HAMMER-EFI: hammer-root aún no visible, reintento $_try…"; sleep 1
353done
354[ -n "$ROOTDEV" ] || { log "HAMMER-EFI-FALLO: no encuentro LABEL=hammer-root"; exec sh; }
355log "HAMMER-EFI: hammer-root = $ROOTDEV → montando en /newroot"
356mount -t ext4 "$ROOTDEV" /newroot || { log "HAMMER-EFI-FALLO: no pude montar $ROOTDEV"; exec sh; }
357STOREDEV="$(findfs LABEL=hammer-store 2>/dev/null || true)"
358STATEDEV="$(findfs LABEL=hammer-state 2>/dev/null || true)"
359[ -n "$STOREDEV" ] && mount -t ext4 "$STOREDEV" /newroot/store          2>/dev/null || true
360[ -n "$STATEDEV" ] && mount -t ext4 "$STATEDEV" /newroot/var/lib/hammer  2>/dev/null || true
361log "HAMMER-EFI-DISK-PIVOT-OK: switch_root → /sbin/init"
362exec switch_root /newroot /sbin/init
363INIT
364    "$BB" chmod +x "$IRD_TREE/init"
365    ( cd "$IRD_TREE" && "$BB" find . | "$BB" cpio -o -H newc 2>/dev/null | "$BB" gzip -1 ) > /run/hammer-efi-ird.cpio.gz
366
367    # Poblar la ESP (FAT32, montable por el live): BOOTX64.EFI = bzImage metal + el initramfs de pivote.
368    echo "==> poblando la ESP (\\EFI\\BOOT\\BOOTX64.EFI = kernel metal + \\initramfs.cpio.gz)"
369    ESPMNT=/run/hammer-esp
370    "$BB" mkdir -p "$ESPMNT"
371    "$BB" mount -t vfat "$P1" "$ESPMNT"
372    "$BB" mkdir -p "$ESPMNT/EFI/BOOT"
373    cp "$PAYLOAD/kernel/bzImage-efi" "$ESPMNT/EFI/BOOT/BOOTX64.EFI"
374    cp /run/hammer-efi-ird.cpio.gz   "$ESPMNT/initramfs.cpio.gz"
375    "$BB" sync; "$BB" umount "$ESPMNT"
376
377    # Poblar la root (copia del live) — sin wrapper que monte particiones (el pivote ya montó store/estado).
378    echo "==> copiando la raíz del live → $P2 (excluye virtuales/efímeros, /store, /var/lib/hammer, payload)"
379    MNT=/run/hammer-install
380    "$BB" mkdir -p "$MNT"
381    "$BB" mount -t ext4 "$P2" "$MNT"
382    for entry in /* /.[!.]*; do
383        [ -e "$entry" ] || continue
384        name="${entry##*/}"
385        case "$name" in
386            proc|sys|dev|run|tmp|store|init) continue ;;
387            *) cp -a "$entry" "$MNT/" 2>/dev/null || true ;;
388        esac
389    done
390    "$BB" rm -rf "$MNT/var/lib/hammer" 2>/dev/null || true
391    "$BB" rm -rf "$MNT/usr/lib/hammer/install" 2>/dev/null || true
392    "$BB" mkdir -p "$MNT/store" "$MNT/var/lib/hammer" "$MNT/proc" "$MNT/sys" "$MNT/dev" "$MNT/run" "$MNT/tmp"
393    # /sbin/init: wrapper que auto-sana un upgrade interrumpido y arranca arje-zero (el pivote ya montó
394    # store/estado por LABEL, así que acá NO hace falta montar nada — sólo hammer-recover + exec).
395    if [ -x "$PAYLOAD/hammer-recover" ]; then
396        "$BB" mkdir -p "$MNT/usr/sbin"
397        cp "$PAYLOAD/hammer-recover" "$MNT/usr/sbin/hammer-recover"; "$BB" chmod 0755 "$MNT/usr/sbin/hammer-recover"
398    fi
399    # CLI hammer (static musl) para el menú de arranque por grafo (ADR 0010): lo copia al disco desde el
400    # payload; el wrapper lo invoca como `hammer boot menu`.
401    if [ -x "$PAYLOAD/hammer" ]; then
402        cp "$PAYLOAD/hammer" "$MNT/usr/bin/hammer"; "$BB" chmod 0755 "$MNT/usr/bin/hammer"
403    fi
404    "$BB" rm -f "$MNT/sbin/init"
405    cat > "$MNT/sbin/init" <<'INIT'
406#!/bin/sh
407# Wrapper PID1 (rama UEFI): el initramfs de pivote ya montó / /store /var/lib/hammer por LABEL antes del
408# switch_root; sólo auto-sanamos un upgrade interrumpido y arrancamos el init real. El marcador a
409# /dev/ttyS0 sobrevive `quiet` (que suprime el printk kernel-side) ⇒ prueba serie de que llegó a PID1.
410# busybox switch_root NO mueve /dev ⇒ montamos devtmpfs antes (si no, /dev/ttyS0 aún no existe).
411/bin/busybox mount -t devtmpfs dev /dev 2>/dev/null || true
412echo "HAMMER-EFI-INIT-OK: arje-zero PID1" > /dev/ttyS0 2>/dev/null || true
413[ -x /usr/sbin/hammer-recover ] && /usr/sbin/hammer-recover || true
414# Menú de arranque por grafo (ADR 0010): emite /run/hammer/boot-graph.json y, si hay compositor (mirada),
415# lo pinta sobre KMS. Graceful (sin compositor sigue) y al serial (no pinta tty0 ⇒ cero-parpadeo).
416[ -x /usr/bin/hammer ] && /usr/bin/hammer boot menu > /dev/ttyS0 2>&1 || true
417exec /usr/bin/arje-zero
418INIT
419    "$BB" chmod +x "$MNT/sbin/init"
420    # config del usuario (hostname / root / zona / teclado) recogida al inicio
421    apply_post_install_config "$MNT"
422    "$BB" sync
423    "$BB" umount "$MNT"
424
425    echo "✓ hammer-install (UEFI): $DEV instalado con EFI-stub SOBERANO (sin GRUB ni systemd-boot). Reiniciá sin el medio live."
426    exit 0
427fi
428
429# ===================== rama BIOS (MBR + GRUB) — el firmware NO es UEFI ==============================
430[ -r "$PAYLOAD/grub/boot.img" ] && [ -r "$PAYLOAD/grub/core.img" ] || { echo "hammer-install: payload GRUB incompleto" >&2; exit 1; }
431[ -r "$PAYLOAD/kernel/bzImage" ] || { echo "hammer-install: falta el kernel en el payload" >&2; exit 1; }
432
433echo "==> hammer-install: instalando el sistema live en $DEV (root ${ROOT_MB}M, store ${STORE_MB}M, estado=resto)"
434echo "    ¡esto BORRA $DEV!"
435
436# --- particionar MBR con busybox fdisk (3 primarias; p1 bootable) ---
437# Pasamos sectores de inicio/fin EXPLÍCITOS para las tres: busybox fdisk, al pedir el inicio por
438# defecto, ofrece el sector LIBRE MÁS BAJO (= el hueco 63..2047 que dejamos antes de p1) ⇒ con <enter>
439# colocaría p2 en ese hueco. Por eso computamos los sectores y los tecleamos.
440#   p1 ARRANCA EN 2048 (1 MiB) A PROPÓSITO: deja un hueco post-MBR de 2047 sectores para el core.img de
441#   GRUB (~281 sectores). El default CHS de busybox (sector 63 ⇒ hueco de 62) lo DESBORDA, pisando el
442#   filesystem de p1 ⇒ GRUB cae a `grub>`.
443SPM=2048
444P1S=2048;                  P1E=$(( P1S + ROOT_MB  * SPM - 1 ))
445P2S=$(( P1E + 1 ));        P2E=$(( P2S + STORE_MB * SPM - 1 ))
446P3S=$(( P2E + 1 ))         # p3 toma hasta el final del disco (último sector = default)
447echo "==> particionando $DEV (MBR: p1 ${P1S}-${P1E}, p2 ${P2S}-${P2E}, p3 ${P3S}-fin)"
448"$BB" fdisk "$DEV" >/dev/null 2>&1 <<FDISK || true
449o
450n
451p
4521
453$P1S
454$P1E
455n
456p
4572
458$P2S
459$P2E
460n
461p
4623
463$P3S
464
465a
4661
467w
468FDISK
469"$BB" partprobe "$DEV" 2>/dev/null || true
470"$BB" sync; sleep 1
471
472P1="${DEV}1"; P2="${DEV}2"; P3="${DEV}3"
473for p in "$P1" "$P2" "$P3"; do
474    [ -b "$p" ] || { echo "hammer-install: no apareció la partición $p tras particionar" >&2; exit 1; }
475done
476
477# --- formatear (busybox mke2fs = ext2; el driver ext4 del kernel lo monta) ---
478echo "==> formateando particiones (ext2, montables como ext4)"
479"$BB" mke2fs -F -L hammer-root  "$P1" >/dev/null 2>&1
480"$BB" mke2fs -F -L hammer-store "$P2" >/dev/null 2>&1
481"$BB" mke2fs -F -L hammer-state "$P3" >/dev/null 2>&1
482
483# --- copiar la raíz del live a la partición root, excluyendo virtuales + el payload ---
484MNT=/run/hammer-install
485"$BB" mkdir -p "$MNT"
486"$BB" mount -t ext4 "$P1" "$MNT"
487echo "==> copiando la raíz del live → $P1 (excluye virtuales/efímeros, /store, /var/lib/hammer y el payload)"
488# Enumeramos TODO el top-level de / y copiamos salvo lo virtual/efímero — así no se nos escapa ningún
489# dir del producto (p.ej. /ente con la seed.card, /linuxrc). uutils cp -a preserva modos/symlinks.
490for entry in /* /.[!.]*; do
491    [ -e "$entry" ] || continue
492    name="${entry##*/}"
493    case "$name" in
494        proc|sys|dev|run|tmp|store|init) continue ;;  # virtuales/efímeros + el /init marcador del live
495        *) cp -a "$entry" "$MNT/" 2>/dev/null || true ;;
496    esac
497done
498# /var sin /var/lib/hammer (estado) — se recrea vacío como mountpoint.
499"$BB" rm -rf "$MNT/var/lib/hammer" 2>/dev/null || true
500# Quitar el payload del disco instalado (sólo sirve en el live) y recrear mountpoints.
501"$BB" rm -rf "$MNT/usr/lib/hammer/install" 2>/dev/null || true
502"$BB" mkdir -p "$MNT/store" "$MNT/var/lib/hammer" "$MNT/proc" "$MNT/sys" "$MNT/dev" "$MNT/run" "$MNT/tmp" "$MNT/boot/grub/i386-pc"
503
504# --- /boot: kernel + módulos GRUB + grub.cfg, y wrapper /sbin/init (monta las particiones dedicadas) ---
505echo "==> poblando /boot (kernel + GRUB) y wrapper /sbin/init"
506cp "$PAYLOAD/kernel/bzImage" "$MNT/boot/bzImage"; "$BB" chmod 0644 "$MNT/boot/bzImage"
507cp "$PAYLOAD"/grub/i386-pc/*.mod "$MNT/boot/grub/i386-pc/" 2>/dev/null || true
508cp "$PAYLOAD"/grub/i386-pc/*.lst "$MNT/boot/grub/i386-pc/" 2>/dev/null || true
509ROOTDEV="${P1##*/}"   # p.ej. vda1 cuando el disco instalado sea el único
510cat > "$MNT/boot/grub/grub.cfg" <<CFG
511set timeout=2
512set default=0
513serial --unit=0 --speed=115200
514terminal_input serial console
515terminal_output serial console
516insmod part_msdos
517insmod ext2
518menuentry "hammer" {
519    linux /boot/bzImage console=ttyS0 root=/dev/vda1 rw rdinit=/sbin/init
520}
521CFG
522# hammer-recover: auto-sana un upgrade interrumpido al arranque (E4 #4b). Lo dejamos en /usr/sbin del
523# disco; el wrapper lo corre tras montar /store y /var/lib/hammer (que necesita) y antes de incarnar.
524if [ -x "$PAYLOAD/hammer-recover" ]; then
525    "$BB" mkdir -p "$MNT/usr/sbin"
526    cp "$PAYLOAD/hammer-recover" "$MNT/usr/sbin/hammer-recover"; "$BB" chmod 0755 "$MNT/usr/sbin/hammer-recover"
527fi
528"$BB" rm -f "$MNT/sbin/init"
529cat > "$MNT/sbin/init" <<'INIT'
530#!/bin/sh
531# Wrapper PID1: el kernel monta la partición root; montamos las dedicadas, auto-sanamos un upgrade
532# interrumpido (si lo hay) y arrancamos el init real.
533/bin/busybox mount -t ext4 /dev/vda2 /store          || echo "init: no pude montar /store (/dev/vda2)"
534/bin/busybox mount -t ext4 /dev/vda3 /var/lib/hammer  || echo "init: no pude montar /var/lib/hammer (/dev/vda3)"
535[ -x /usr/sbin/hammer-recover ] && /usr/sbin/hammer-recover || true
536exec /usr/bin/arje-zero
537INIT
538"$BB" chmod +x "$MNT/sbin/init"
539# config del usuario (hostname / root / zona / teclado) recogida al inicio
540apply_post_install_config "$MNT"
541"$BB" sync
542"$BB" umount "$MNT"
543
544# --- instalar GRUB: boot.img→MBR (440 B, sin pisar la tabla de particiones) + core.img→hueco post-MBR.
545#     Con install contiguo MBR los punteros por defecto de GRUB (kernel_sector=1, blocklist=2) ya valen
546#     ⇒ NO hace falta el parcheo binario que sí pide el caso GPT de install-image.sh.
547echo "==> instalando GRUB (boot.img→MBR + core.img→hueco post-MBR)"
548"$BB" dd if="$PAYLOAD/grub/boot.img"  of="$DEV" bs=1 count=440 conv=notrunc 2>/dev/null
549"$BB" dd if="$PAYLOAD/grub/core.img"  of="$DEV" bs=512 seek=1 conv=notrunc 2>/dev/null
550"$BB" sync
551
552echo "✓ hammer-install: $DEV instalado. Reiniciá sin el medio live para arrancar del disco."