sergio/takana
> Una distribución Linux construida con un laboratorio funcional y hermético en el > sótano, y una terminal mutable, clásica y anárquica en el piso de arriba — diseñada > desde el suelo para que una IA programadora entienda, modifique y co…
⎇ f06d943f9365bd17dd8db1b79f17862e559a8ff8
crates/takana-cli/src/metal.rs
Historia
Quién tocó qué
crudo
1//! `takana metal` — instalar takana EN ESTA MÁQUINA, con UN verbo.
2//!
3//! ══ POR QUÉ EXISTE ════════════════════════════════════════════════════════════════════════════
4//! El instalador funcionaba y no se podía usar. La forma de invocarlo era ésta:
5//!
6//! ```text
7//! sudo ./takana kernel kexec ./kernel --initrd ./takana-instalador.cpio.gz \
8//! --cmdline 'console=ttyS0,115200 console=tty0' --jump
9//! ```
10//!
11//! Eso no es un instalador: es el motor con la tapa abierta. Quien lo teclea tiene que saber que
12//! existe `kexec`, que el payload va por `--initrd`, que sin `--jump` sólo se carga, y qué consola
13//! pedirle al kernel nuevo. Ninguna de esas cuatro cosas es una decisión del que instala.
14//!
15//! `takana metal` es la tapa. Tres verbos, y el orden en que se usan es el orden en que se leen:
16//!
17//! ```text
18//! takana metal check ¿puede esta máquina instalarse sin USB? (no toca nada)
19//! takana metal survey ¿qué hay en los discos y qué se puede usar? (no toca nada)
20//! takana metal install el viaje entero: comprueba, avisa y salta
21//! ```
22//!
23//! ── UN MOTOR, VARIAS CARAS (SDD 28 §8) ────────────────────────────────────────────────────────
24//! `survey` **no reimplementa el censo**: llama al mismo `takana-install-partition.sh --survey` que
25//! corre dentro del instalador. Con `--json` emite el contrato que consume una cara gráfica
26//! (churay). El riesgo que esto evita está medido en otro frente: dos censos divergen, y el que se
27//! equivoca no muestra de menos — formatea de más.
28//!
29//! ── EL CONTRATO, VERSIÓN 2 (2026-09-25) ───────────────────────────────────────────────────────
30//! La v1 alcanzaba para una LISTA y no para un DIBUJO: sin saber a qué disco pertenece cada fila ni
31//! en qué byte empieza, no se sabe qué va al lado de qué ni qué hueco queda entre dos. La v2 agrega
32//! lo que hace falta para pintar el terreno, y **ni un campo de decisión**: `veredicto` y `usable`
33//! siguen siendo los únicos que deciden, y siguen saliendo de acá.
34//!
35//! Por fila: `clase` (`particion` · `hueco` · `disco`), `disco`, `inicio_bytes`, `tamano_bytes`,
36//! `tipo_guid`. Y un array `discos` con el APARATO: `modelo`, `removible`, `tamano_bytes`,
37//! `sector_bytes`, `tabla`.
38//!
39//! ⚠ **`tamano_bytes` existe además de `mib` porque `mib` está redondeado**: una barra proporcional
40//! construida con MiB acumula error a lo largo del disco y el hueco final sale corrido.
41//!
42//! ⚠ **Un `hueco` NO tiene `dev` propio**: su `dev` es el del disco, y dos huecos del mismo disco
43//! traen el MISMO `dev`. Su identidad es `disco` + `inicio_bytes`. Una cara que los indexe por
44//! `dev` se queda con uno solo y pierde el otro sin que nada falle.
45//!
46//! ⚠ El aparato va en un array propio y **no repetido en cada fila**: un dato del disco copiado en
47//! cada partición se puede contradecir entre filas, y entonces hay que decidir a cuál creerle.
48//!
49//! ── LO QUE ESTE VERBO NO HACE ─────────────────────────────────────────────────────────────────
50//! No elige partición, no formatea y no escribe la NVRAM. Todo eso pasa DESPUÉS del salto, dentro
51//! del instalador, que es donde el disco destino puede estar desmontado. Acá sólo se comprueba, se
52//! avisa y se salta.
53
54use std::path::{Path, PathBuf};
55
56use anyhow::{bail, Context, Result};
57use clap::Subcommand;
58
59use crate::kernel_ab;
60
61/// Nombres con los que viaja el payload. Se buscan en ese orden dentro del directorio del paquete.
62const INITRD: &[&str] = &["takana-instalador.cpio.gz", "instalador.cpio.gz", "initramfs.cpio.gz"];
63const KERNEL: &[&str] = &["kernel/boot/bzImage", "bzImage", "boot/bzImage", "kernel"];
64const GUION: &[&str] = &[
65 "scripts/takana-install-partition.sh",
66 "takana-install-partition.sh",
67 "instalador/takana-install-partition.sh",
68];
69/// La consola por defecto pide las DOS: `ttyS0` es la única forma de ver por qué murió cuando no
70/// llega a pintar nada, y `tty0` es la pantalla del que instala.
71///
72/// ⚠ **El ORDEN no es cosmético: el kernel hace `/dev/console` = la ÚLTIMA `console=`.** Con `tty0`
73/// primero, `/dev/console` queda en el SERIAL — y el instalador interactivo, que lee y escribe por
74/// ahí, sale por un puerto que un portátil no tiene. La pantalla se queda en el último printk y el
75/// arranque parece colgado. `tty0` va ÚLTIMO.
76const CONSOLA: &str = "console=ttyS0,115200 console=tty0";
77
78#[derive(Subcommand)]
79pub enum MetalCmd {
80 /// ¿Puede esta máquina instalarse sin USB? Diagnóstico, no toca nada.
81 Check,
82 /// El terreno de esta máquina: qué hay en cada disco y qué se puede usar. No toca nada.
83 Survey {
84 /// Emitir el censo en JSON (el contrato que consume una cara gráfica).
85 #[arg(long)]
86 json: bool,
87 /// Directorio del paquete (por defecto, el del propio binario).
88 #[arg(long)]
89 payload: Option<PathBuf>,
90 },
91 /// Instalar takana en esta máquina: comprueba, avisa y salta al instalador.
92 Install {
93 /// Directorio del paquete (por defecto, el del propio binario).
94 #[arg(long)]
95 payload: Option<PathBuf>,
96 /// Partición destino, ya elegida. Sin esto, el instalador muestra el censo y pregunta.
97 /// **Usá `PARTUUID=…`**: los nombres `/dev/nvme…` no son estables entre arranques.
98 #[arg(long)]
99 root: Option<String>,
100 /// ESP a poblar. Sin esto se deduce del disco del destino.
101 #[arg(long)]
102 esp: Option<String>,
103 /// No formatear nada: instalar en el espacio SIN ASIGNAR más grande.
104 #[arg(long)]
105 free: bool,
106 /// Disco sobre el que buscar el hueco de `--free`.
107 #[arg(long)]
108 disk: Option<String>,
109 /// No preguntar antes de saltar. **No** hace desatendido al instalador: eso es `--unattended`.
110 #[arg(long, short = 'y')]
111 yes: bool,
112 /// Desatendido de punta a punta: el instalador tampoco pregunta. Exige `--root` o `--free`.
113 #[arg(long)]
114 unattended: bool,
115 /// Cargar el instalador en memoria y NO saltar. Ensayo: no se pierde la sesión.
116 #[arg(long)]
117 load_only: bool,
118 /// Saltar aunque no haga falta. Normalmente el salto sólo ocurre si el destino es la raíz
119 /// viva; esto lo fuerza (arneses, y para probar el salto a propósito).
120 #[arg(long)]
121 jump: bool,
122 /// Consolas para el kernel del instalador.
123 #[arg(long, default_value = CONSOLA)]
124 console: String,
125 },
126}
127
128pub fn run(cmd: MetalCmd) -> Result<()> {
129 match cmd {
130 MetalCmd::Check => check(),
131 MetalCmd::Survey { json, payload } => survey(json, payload.as_deref()),
132 MetalCmd::Install {
133 payload, root, esp, free, disk, yes, unattended, load_only, jump, console,
134 } => install(Instalacion {
135 payload, root, esp, free, disk, yes, unattended, load_only, jump, console,
136 }),
137 }
138}
139
140struct Instalacion {
141 payload: Option<PathBuf>,
142 root: Option<String>,
143 esp: Option<String>,
144 free: bool,
145 disk: Option<String>,
146 yes: bool,
147 unattended: bool,
148 load_only: bool,
149 jump: bool,
150 console: String,
151}
152
153// ── dónde está el paquete ─────────────────────────────────────────────────────────────────────
154// Por defecto, JUNTO AL BINARIO y no en el directorio actual: el paquete se copia entero a un pen
155// drive o a `~/Descargas` y se corre con `sudo ./takana …`, muchas veces desde otro sitio. Buscar
156// en el cwd manda a «no encuentro el instalador» a alguien que lo tiene al lado.
157fn dir_del_binario() -> Option<PathBuf> {
158 std::env::current_exe().ok()?.parent().map(|p| p.to_path_buf())
159}
160
161fn buscar(dirs: &[PathBuf], nombres: &[&str]) -> Option<PathBuf> {
162 for d in dirs {
163 for n in nombres {
164 let p = d.join(n);
165 if p.is_file() {
166 return Some(p);
167 }
168 }
169 }
170 None
171}
172
173fn candidatos(payload: Option<&Path>) -> Vec<PathBuf> {
174 let mut v = Vec::new();
175 if let Some(p) = payload {
176 v.push(p.to_path_buf());
177 } else {
178 if let Some(d) = dir_del_binario() {
179 v.push(d);
180 }
181 v.push(PathBuf::from("."));
182 // El árbol del repo, para el que trabaja desde adentro.
183 v.push(PathBuf::from("work/instalador-salida"));
184 // ⚠ Y las rutas de un takana INSTALADO. Sin esto, `takana metal survey` sólo funcionaba
185 // con el paquete recién copiado: llamado desde una cara gráfica que encontró `takana` en
186 // el `PATH` —que es exactamente como lo va a encontrar churay— el binario está en
187 // `/usr/bin` y el censo no está al lado, así que el censo moría con «no encuentro
188 // takana-install-partition.sh». Medido el 2026-09-23 desde `churay-cli metal`.
189 for d in ["/usr/libexec/takana", "/usr/lib/takana", "/usr/share/takana"] {
190 v.push(PathBuf::from(d));
191 }
192 }
193 v
194}
195
196// ── check ─────────────────────────────────────────────────────────────────────────────────────
197fn check() -> Result<()> {
198 let (puede, motivos) = crate::kernel_cmd::kexec_probe();
199 if puede {
200 println!("✓ esta máquina puede instalarse SIN USB: el salto al instalador está disponible.");
201 println!(" Seguí con: takana metal survey (mirar el terreno, no toca nada)");
202 println!(" sudo takana metal install");
203 return Ok(());
204 }
205 println!("✗ esta máquina NO puede saltar al instalador desde el sistema que corre:");
206 for m in &motivos {
207 println!(" · {m}");
208 }
209 println!();
210 // ⚠ Sin root el diagnóstico NO es concluyente —el kernel contesta EPERM antes de decir si
211 // implementa el syscall— así que mandar al USB acá sería mandar a la solución cara por un
212 // problema que se arregla con `sudo`. Medido en esta misma caja: como uid 1001 el motivo es
213 // «falta root»; como root aparece el de verdad, que es otro.
214 if !crate::kernel_cmd::soy_root() {
215 println!("Antes de nada: repetilo con `sudo`. Sin privilegios este diagnóstico no distingue");
216 println!("«te falta ser root» de «tu kernel no lo trae», y son cosas distintas.");
217 std::process::exit(1);
218 }
219 println!("Eso NO quiere decir que no se pueda instalar: quiere decir que hay que arrancar el");
220 println!("instalador desde otro medio. La imagen USB hace exactamente lo mismo que el salto —el");
221 println!("instalador es el mismo— y no depende de lo que traiga el kernel de esta máquina.");
222 std::process::exit(1);
223}
224
225// ── survey ────────────────────────────────────────────────────────────────────────────────────
226fn survey(json: bool, payload: Option<&Path>) -> Result<()> {
227 let guion = buscar(&candidatos(payload), GUION)
228 .ok_or_else(|| {
229 anyhow::anyhow!(
230 "no encuentro `takana-install-partition.sh` junto al binario ni en el directorio actual.\n \
231 Pasá --payload <directorio del paquete>."
232 )
233 })?;
234 let mut c = std::process::Command::new("sh");
235 c.arg(&guion).arg("--survey");
236 if json {
237 c.arg("--json");
238 }
239 let st = c
240 .status()
241 .with_context(|| format!("no puedo ejecutar {}", guion.display()))?;
242 if !st.success() {
243 bail!("el censo falló ({st})");
244 }
245 Ok(())
246}
247
248// ── install ───────────────────────────────────────────────────────────────────────────────────
249fn install(i: Instalacion) -> Result<()> {
250 if i.unattended && i.root.is_none() && !i.free {
251 bail!(
252 "--unattended sin destino: nadie va a estar ahí para elegirlo.\n \
253 Dale --root PARTUUID=… (mirá `takana metal survey`) o --free."
254 );
255 }
256 let dirs = candidatos(i.payload.as_deref());
257 let initrd = buscar(&dirs, INITRD).ok_or_else(|| {
258 anyhow::anyhow!(
259 "no encuentro el instalador ({}) en:\n {}\n Pasá --payload <directorio del paquete>.",
260 INITRD.join(" / "),
261 dirs.iter().map(|d| d.display().to_string()).collect::<Vec<_>>().join("\n ")
262 )
263 })?;
264 let bz = buscar(&dirs, KERNEL).ok_or_else(|| {
265 anyhow::anyhow!(
266 "encontré el instalador ({}) pero no su kernel ({}).\n \
267 El paquete va entero: el instalador corre sobre SU kernel, no sobre el de esta máquina.",
268 initrd.display(),
269 KERNEL.join(" / ")
270 )
271 })?;
272 let guion = buscar(&dirs, GUION);
273
274 // ── 1) PRIMERO SE ELIGE, Y SE ELIGE ACÁ ───────────────────────────────────────────────────
275 //
276 // ⚠ **Esto era al revés y costó un cuelgue en metal.** El orden viejo era «saltá primero,
277 // elegí después»: toda la conversación pasaba DESPUÉS del kexec, en una máquina cuyo panel
278 // puede no volver a encenderse tras el salto. El usuario dijo que sí, la pantalla se fue a
279 // negro y se quedó así hasta apagar con el botón — el instalador estaba vivo del otro lado,
280 // pidiendo una tecla que nadie podía ver que estaba pidiendo.
281 //
282 // Ahora se elige en el sistema que TODAVÍA FUNCIONA, y lo de después va con la respuesta
283 // puesta. Un panel muerto pasa de ser un cuelgue a ser un detalle estético.
284 let mut destino = i.root.clone();
285 let mut usar_hueco = i.free;
286 let mut disco = i.disk.clone();
287 if destino.is_none() && !usar_hueco {
288 let g = guion.as_ref().ok_or_else(|| {
289 anyhow::anyhow!(
290 "no encuentro el censo (`takana-install-partition.sh`) junto al paquete, así que no \
291 puedo preguntarte acá.\n Pasá --root PARTUUID=… o --payload <dir del paquete>."
292 )
293 })?;
294 let elec = elegir(g)?;
295 match elec {
296 None => {
297 println!("nada hecho.");
298 return Ok(());
299 }
300 Some(e) => {
301 destino = e.dest;
302 usar_hueco = e.free;
303 if e.disk.is_some() {
304 disco = e.disk;
305 }
306 }
307 }
308 }
309
310 // ── 2) ¿HACE FALTA SALTAR? ────────────────────────────────────────────────────────────────
311 // Sólo si el destino es la raíz VIVA: es la única partición que no se puede formatear desde
312 // adentro. Para cualquier otra, el salto sería matar la sesión del usuario sin necesidad.
313 let censo = censo_de(guion.as_deref());
314 let sobre_la_raiz = destino
315 .as_deref()
316 .map(|d| es_raiz_viva(&censo, d))
317 .unwrap_or(false);
318
319 let inst = Instalacion { root: destino.clone(), free: usar_hueco, disk: disco.clone(), ..i };
320
321 if !sobre_la_raiz && !inst.load_only && !inst.jump {
322 // El destino está libre: se instala DESDE ACÁ y esta sesión no se muere.
323 if let Some(g) = guion.as_ref() {
324 return instalar_aqui(g, &dirs, &inst);
325 }
326 println!("⚠ el destino no es la raíz viva, así que no haría falta saltar — pero no encuentro");
327 println!(" el censo junto al paquete para instalar desde acá. Sigo por el salto.");
328 }
329
330 // ── 3) EL SALTO: sólo acá, y explicando qué implica ───────────────────────────────────────
331 let (puede, motivos) = crate::kernel_cmd::kexec_probe();
332 if !puede {
333 println!("✗ el destino es la raíz que está corriendo AHORA, así que hay que soltarla antes");
334 println!(" de formatearla — y esta máquina no puede saltar:");
335 for m in &motivos {
336 println!(" · {m}");
337 }
338 println!();
339 if !crate::kernel_cmd::soy_root() {
340 println!("Repetilo con `sudo`: sin privilegios esto no es concluyente.");
341 } else {
342 println!("Quedan dos caminos, los dos sin tocar tu sistema actual:");
343 println!(" · instalar AL LADO, en espacio sin asignar: takana metal install --free --disk /dev/…");
344 println!(" · la imagen USB, que hace exactamente lo mismo desde otro medio.");
345 }
346 std::process::exit(1);
347 }
348
349 let cmdline = cmdline_de(&inst);
350 println!();
351 println!("── el salto ──────────────────────────────────────────────────────────────────");
352 if sobre_la_raiz {
353 println!(" El destino es la raíz que estás usando: no se puede formatear desde adentro.");
354 println!(" Para soltarla, esta máquina salta a un instalador que corre en RAM.");
355 } else {
356 println!(" El destino NO es la raíz viva, así que este salto no haría falta: lo pediste");
357 println!(" a mano con --jump. El instalador corre igual, en RAM.");
358 }
359 println!();
360 println!(" destino: {}", inst.root.as_deref().unwrap_or("el espacio sin asignar"));
361 println!(" instalador: {} ({})", initrd.display(), tam(&initrd));
362 println!(" su kernel: {} ({})", bz.display(), tam(&bz));
363 println!();
364 println!(" Qué implica, en orden:");
365 println!(" 1. TODO lo que está corriendo muere en el acto. Guardá antes.");
366 println!(" 2. La pantalla puede quedarse en negro un rato, o no volver hasta el reinicio:");
367 println!(" un kexec no reinicia el hardware de vídeo. **No es un cuelgue** — ya no hay");
368 println!(" nada que preguntarte: la elección ya está hecha y el instalador la lleva puesta.");
369 println!(" 3. Al terminar, la máquina reinicia sola.");
370 if en_sesion_grafica() {
371 println!();
372 println!(" ⚠ Esto parece una sesión GRÁFICA. El salto es mucho más sano desde una consola de");
373 println!(" texto: pasá a una con Ctrl+Alt+F2, entrá, y corré esto ahí.");
374 }
375 println!("──────────────────────────────────────────────────────────────────────────────");
376
377 if !inst.yes && !inst.load_only && !confirmar()? {
378 println!("nada hecho.");
379 return Ok(());
380 }
381
382 kernel_ab::kexec_cargar(&bz, Some(&initrd), &cmdline)?;
383 println!("✓ instalador cargado en memoria");
384 if inst.load_only {
385 println!(" (--load-only: no se salta. Queda cargado hasta el próximo reinicio.)");
386 return Ok(());
387 }
388 println!("⚡ saltando — a partir de acá no hace falta mirar nada.");
389 kernel_ab::kexec_saltar()
390}
391
392/// Lo que devolvió el menú.
393struct Eleccion {
394 dest: Option<String>,
395 free: bool,
396 disk: Option<String>,
397}
398
399/// Corre el censo en modo `--pick`: muestra el terreno, deja elegir y **no toca nada**.
400fn elegir(guion: &Path) -> Result<Option<Eleccion>> {
401 let tmp = std::env::temp_dir().join(format!("takana-eleccion.{}", std::process::id()));
402 let st = std::process::Command::new("sh")
403 .arg(guion)
404 .arg("--pick")
405 .arg(&tmp)
406 .status()
407 .with_context(|| format!("no puedo ejecutar {}", guion.display()))?;
408 if !st.success() {
409 let _ = std::fs::remove_file(&tmp);
410 return Ok(None);
411 }
412 let txt = std::fs::read_to_string(&tmp).unwrap_or_default();
413 let _ = std::fs::remove_file(&tmp);
414 let mut e = Eleccion { dest: None, free: false, disk: None };
415 for l in txt.lines() {
416 match l.split_once('=') {
417 Some(("DEST", v)) => e.dest = Some(v.to_string()),
418 Some(("DISK", v)) => e.disk = Some(v.to_string()),
419 Some(("FREE", _)) => e.free = true,
420 _ => {}
421 }
422 }
423 if e.dest.is_none() && !e.free {
424 return Ok(None);
425 }
426 Ok(Some(e))
427}
428
429/// El censo en JSON, o vacío si no se pudo. **Vacío no es «no hay discos»**: acá sólo se usa para
430/// una pregunta concreta —¿el destino es la raíz viva?— y no saberlo se trata como «no».
431fn censo_de(guion: Option<&Path>) -> String {
432 let Some(g) = guion else { return String::new() };
433 std::process::Command::new("sh")
434 .arg(g)
435 .args(["--survey", "--json"])
436 .output()
437 .ok()
438 .filter(|o| o.status.success())
439 .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
440 .unwrap_or_default()
441}
442
443/// ¿El destino elegido es la raíz viva? Se lee del censo, que es quien lo decide.
444///
445/// Sin parsear JSON de verdad: se busca el bloque de esa partición y se mira si su veredicto es
446/// `RAIZ_VIVA`. Un formato de una línea por partición hace que esto sea exacto; si el censo
447/// cambiara de forma, esto deja de encontrar nada y el resultado es «no es la raíz» ⇒ se instala
448/// sin saltar y el instalador aborta con su propia guarda. Se equivoca del lado que no destruye.
449fn es_raiz_viva(censo_json: &str, destino: &str) -> bool {
450 let clave = destino.trim_start_matches("PARTUUID=").trim_start_matches("partuuid=");
451 for linea in censo_json.lines() {
452 let l = linea.trim();
453 if !l.starts_with('{') {
454 continue;
455 }
456 let casa = l.contains(&format!("\"partuuid\": \"{clave}\""))
457 || l.contains(&format!("\"dev\": \"{destino}\""));
458 if casa {
459 return l.contains("\"veredicto\": \"RAIZ_VIVA\"");
460 }
461 }
462 false
463}
464
465/// ¿Estamos dentro de una sesión gráfica? Sólo para AVISAR, nunca para decidir.
466///
467/// Un kexec no reinicia el hardware de vídeo, y saltar desde un compositor con la GPU tomada es la
468/// forma más fácil de quedarse con el panel apagado del otro lado. Desde una VT de texto el salto
469/// es mucho más sano. No se bloquea: se avisa, porque también hay quien sabe lo que hace.
470fn en_sesion_grafica() -> bool {
471 ["WAYLAND_DISPLAY", "DISPLAY", "XDG_SESSION_TYPE"]
472 .iter()
473 .any(|v| std::env::var(v).map(|x| !x.is_empty() && x != "tty").unwrap_or(false))
474}
475
476/// Instala **desde esta máquina**, sin saltar. Es el camino normal cuando el destino no es la raíz
477/// viva: no hay ninguna razón para matar la sesión del usuario.
478///
479/// El árbol que se copia vive comprimido dentro del initramfs del instalador, así que se
480/// desempaqueta primero — con el `busybox` que viaja en el paquete y no con el del host, que puede
481/// no existir (en las tres máquinas de este proyecto no hay `cpio`).
482fn instalar_aqui(guion: &Path, dirs: &[PathBuf], i: &Instalacion) -> Result<()> {
483 let bb = buscar(dirs, &["busybox", "bin/busybox"]).ok_or_else(|| {
484 anyhow::anyhow!(
485 "el paquete no trae `busybox`, que es con lo que se desempaqueta el árbol a instalar.\n \
486 Rearmá el paquete con scripts/instalador-paquete.sh."
487 )
488 })?;
489 let initrd = buscar(dirs, INITRD).expect("ya se resolvió antes");
490
491 println!();
492 println!("── instalar desde acá, SIN saltar ────────────────────────────────────────────");
493 println!(" El destino no es la raíz que estás usando, así que no hace falta soltarla:");
494 println!(" esta sesión sigue viva y al terminar reiniciás cuando quieras.");
495 println!(" destino: {}", i.root.as_deref().unwrap_or("el espacio sin asignar"));
496 println!("──────────────────────────────────────────────────────────────────────────────");
497 if !i.yes && !confirmar()? {
498 println!("nada hecho.");
499 return Ok(());
500 }
501
502 let tmp = std::env::temp_dir().join(format!("takana-arbol.{}", std::process::id()));
503 std::fs::create_dir_all(&tmp)?;
504 println!("==> desempaquetando el árbol a instalar en {}", tmp.display());
505 let sh = format!(
506 "{bb} gzip -d -c {ird} | ( cd {d} && {bb} cpio -i -d --quiet )",
507 bb = bb.display(),
508 ird = initrd.display(),
509 d = tmp.display()
510 );
511 let st = std::process::Command::new("sh").arg("-c").arg(&sh).status()?;
512 if !st.success() {
513 bail!("no pude desempaquetar {}", initrd.display());
514 }
515
516 let mut c = std::process::Command::new("sh");
517 c.arg(guion);
518 if let Some(r) = &i.root {
519 c.arg("--root-part").arg(r);
520 }
521 if i.free {
522 c.arg("--use-free-space");
523 }
524 if let Some(d) = &i.disk {
525 c.arg("--disk").arg(d);
526 }
527 c.arg("--yes");
528 // Las herramientas y el árbol salen del paquete: acá no hay store del que resolverlas por hash.
529 for (v, rel) in [
530 ("TOOL_mke2fs", "bin/mke2fs"),
531 ("TOOL_sfdisk", "bin/sfdisk"),
532 ("TOOL_mmd", "bin/mmd"),
533 ("TOOL_mcopy", "bin/mcopy"),
534 ("TOOL_mdir", "bin/mdir"),
535 ] {
536 c.env(v, tmp.join(rel));
537 }
538 c.env("STAGE", tmp.join("payload/stage"))
539 .env("STAGE_LISTO", "1")
540 .env("KERNEL", tmp.join("payload/bzImage"))
541 .env("HAMMER", tmp.join("bin/takana"));
542 let st = c.status()?;
543 let _ = std::process::Command::new("rm").arg("-rf").arg(&tmp).status();
544 if !st.success() {
545 bail!("el instalador falló ({st})");
546 }
547 println!();
548 println!("✓ listo. Reiniciá cuando quieras y elegí takana en el firmware.");
549 Ok(())
550}
551
552/// La cmdline del instalador: las respuestas que ya se dieron viajan por acá, y las que no, no.
553/// Es el mismo canal que lee el `/init` del initramfs, así que **no hay nada horneado por máquina**.
554fn cmdline_de(i: &Instalacion) -> String {
555 let mut s = i.console.clone();
556 if let Some(r) = &i.root {
557 s.push_str(&format!(" takana.root={r}"));
558 }
559 if let Some(e) = &i.esp {
560 s.push_str(&format!(" takana.esp={e}"));
561 }
562 if let Some(d) = &i.disk {
563 s.push_str(&format!(" takana.disk={d}"));
564 }
565 if i.free {
566 s.push_str(" takana.free");
567 }
568 if i.unattended {
569 s.push_str(" takana.yes");
570 }
571 s
572}
573
574fn tam(p: &Path) -> String {
575 match std::fs::metadata(p).map(|m| m.len()) {
576 Ok(b) if b >= 1 << 20 => format!("{} M", b >> 20),
577 Ok(b) => format!("{} K", b >> 10),
578 Err(_) => "?".to_string(),
579 }
580}
581
582/// Confirmación explícita. **No** acepta un `enter` pelado: el enter es lo que se aprieta sin leer,
583/// y lo que sigue mata la sesión.
584fn confirmar() -> Result<bool> {
585 use std::io::{BufRead, Write};
586 print!("¿Saltar al instalador? Escribí «si» para seguir: ");
587 std::io::stdout().flush().ok();
588 let mut l = String::new();
589 if std::io::stdin().lock().read_line(&mut l).is_err() {
590 return Ok(false);
591 }
592 let l = l.trim().to_lowercase();
593 Ok(l == "si" || l == "sí")
594}
595
596#[cfg(test)]
597mod tests {
598 use super::*;
599
600 fn base() -> Instalacion {
601 Instalacion {
602 payload: None, root: None, esp: None, free: false, disk: None,
603 yes: false, unattended: false, load_only: false, jump: false,
604 console: CONSOLA.to_string(),
605 }
606 }
607
608 #[test]
609 fn sin_respuestas_la_cmdline_no_lleva_ninguna_maquina_adentro() {
610 // El punto entero de la generalización: un paquete sirve en cualquier máquina porque no
611 // trae respuestas horneadas. Si esto empieza a fallar, alguien volvió a hornear.
612 assert_eq!(cmdline_de(&base()), CONSOLA);
613 }
614
615 #[test]
616 fn las_respuestas_dadas_viajan_por_la_cmdline() {
617 let i = Instalacion {
618 root: Some("PARTUUID=55b5-0de7".into()),
619 esp: Some("PARTUUID=aaaa-bbbb".into()),
620 unattended: true,
621 ..base()
622 };
623 let c = cmdline_de(&i);
624 assert!(c.contains("takana.root=PARTUUID=55b5-0de7"), "{c}");
625 assert!(c.contains("takana.esp=PARTUUID=aaaa-bbbb"), "{c}");
626 assert!(c.contains("takana.yes"), "{c}");
627 assert!(!c.contains("takana.free"), "{c}");
628 }
629
630 #[test]
631 fn free_y_disk_viajan_juntos_y_sin_destino() {
632 let i = Instalacion { free: true, disk: Some("/dev/nvme0n1".into()), ..base() };
633 let c = cmdline_de(&i);
634 assert!(c.contains("takana.free"), "{c}");
635 assert!(c.contains("takana.disk=/dev/nvme0n1"), "{c}");
636 assert!(!c.contains("takana.root="), "{c}");
637 }
638
639 const CENSO: &str = r#"{
640 "version": 1,
641 "raiz_viva": "8:2",
642 "particiones": [
643 {"dev": "/dev/sda2", "partuuid": "AAAA", "mib": 6144, "veredicto": "RAIZ_VIVA", "usable": true},
644 {"dev": "/dev/sda5", "partuuid": "BBBB", "mib": 40960, "veredicto": "CANDIDATA", "usable": true}
645 ]
646}"#;
647
648 #[test]
649 fn el_salto_hace_falta_solo_para_la_raiz_viva() {
650 // Es la decisión que reordenó todo: saltar cuando no hace falta es matar la sesión del
651 // usuario por nada, y el cuelgue que lo destapó pasó justamente ahí.
652 assert!(es_raiz_viva(CENSO, "PARTUUID=AAAA"));
653 assert!(!es_raiz_viva(CENSO, "PARTUUID=BBBB"));
654 assert!(es_raiz_viva(CENSO, "/dev/sda2"));
655 assert!(!es_raiz_viva(CENSO, "/dev/sda5"));
656 }
657
658 #[test]
659 fn un_destino_que_el_censo_no_conoce_no_se_toma_por_la_raiz_viva() {
660 // Se equivoca del lado que NO destruye: si esto diera «sí», se saltaría sin necesidad; si
661 // da «no», se instala desde acá y la guarda del propio instalador aborta si el destino
662 // resulta ser la raíz. Un error de más contra un error que mata la sesión.
663 assert!(!es_raiz_viva(CENSO, "PARTUUID=ZZZZ"));
664 assert!(!es_raiz_viva("", "PARTUUID=AAAA"));
665 assert!(!es_raiz_viva("esto no es json", "PARTUUID=AAAA"));
666 }
667
668 #[test]
669 fn buscar_respeta_el_orden_de_los_nombres_y_de_los_directorios() {
670 let d = std::env::temp_dir().join(format!("metal-test-{}", std::process::id()));
671 let a = d.join("a");
672 let b = d.join("b");
673 std::fs::create_dir_all(&a).unwrap();
674 std::fs::create_dir_all(&b).unwrap();
675 std::fs::write(b.join("initramfs.cpio.gz"), b"x").unwrap();
676 std::fs::write(b.join("takana-instalador.cpio.gz"), b"x").unwrap();
677 // El directorio gana sobre el nombre: `a` no lo tiene, así que se cae a `b`.
678 let v = vec![a.clone(), b.clone()];
679 assert_eq!(buscar(&v, INITRD).unwrap(), b.join("takana-instalador.cpio.gz"));
680 std::fs::write(a.join("initramfs.cpio.gz"), b"x").unwrap();
681 // Y ahora `a` gana aunque su nombre sea el último de la lista: primero el directorio.
682 assert_eq!(buscar(&v, INITRD).unwrap(), a.join("initramfs.cpio.gz"));
683 std::fs::remove_dir_all(&d).ok();
684 }
685}