> 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…
kernel kexec: el reboot suave por kexec_file_load, sin kexec-tools
ADR 0017 §1. Se usa kexec_file_load, no el kexec_load viejo, y la
diferencia es de orden de magnitud: kexec_load recibe los segmentos YA
armados y el purgatory —el código que corre entre los dos kernels—, o
sea que usarlo obliga a reimplementar kexec-tools entero.
kexec_file_load recibe los DESCRIPTORES del kernel y del initrd y hace
el trabajo adentro. Son ~50 líneas.
El syscall va con asm! en vez de agregar la crate libc al workspace: es
UN syscall, su número y su ABI son contrato estable de Linux, y la
alternativa era arrastrar una dependencia a un workspace que comparten
dos frentes.
El cmdline viaja CON su NUL: el kernel cuenta cmdline_len incluyendo el
terminador, y sin él lee un byte de más. Es el error clásico de esta
llamada.
recipes/linux-metal-kexec.toml — variante cuya ÚNICA diferencia es
CONFIG_KEXEC_FILE=y. Variante y no flag en la canónica porque el .config
ES la identidad del artefacto (SDD 22 §1): tocar linux-metal re-hashea
el kernel que arranca las imágenes y el que reproduce bit a bit, y el
ADR deja esa decisión al usuario. Comprobado que la canónica no se
mueve: sigue en b3:2ed8f54a…, el que ya está sellado.
Y un diagnóstico que corregí a los dos minutos de escribirlo, porque
mandaba al lugar OPUESTO: decía "falta CONFIG_KEXEC_FILE" para EPERM.
Medido en este hub — el kernel de Artix trae CONFIG_KEXEC_FILE=y y aun
así devolvió EPERM, por no ser root. EPERM es falta de CAP_SYS_BOOT (o
lockdown si ya sos root); ENOSYS es el flag que falta. Confundirlos
manda a recompilar un kernel que estaba bien.
La ayuda del comando dice con todas las letras que esto NO es
"actualizar sin rebootear": el userspace muere igual. Ahorra los 20-30 s
de POST/UEFI, que es la mitad del downtime en un servidor remoto y nada
en un portátil.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HHAKWoBqof9XvsYCvDicEj
diff --git a/crates/takana-cli/src/kernel_ab.rs b/crates/takana-cli/src/kernel_ab.rs
index 646903d1..37453443 100644
--- a/crates/takana-cli/src/kernel_ab.rs
+++ b/crates/takana-cli/src/kernel_ab.rs
@@ -162,6 +162,147 @@ pub fn instalar_candidato(bzimage: &Path, esp: &Path, ruta_efi: &str) -> Result<
Ok(n)
}
+// ══ kexec: el reboot suave (ADR 0017 §1) ═══════════════════════════════════════════════════════
+//
+// Se usa **`kexec_file_load`**, no el `kexec_load` viejo, y la diferencia es de orden de magnitud:
+// `kexec_load` recibe los segmentos YA armados y el *purgatory* —el código que corre entre los dos
+// kernels—, o sea que usarlo obliga a reimplementar kexec-tools. `kexec_file_load` recibe los
+// **descriptores** del kernel y del initrd y hace el trabajo dentro del kernel.
+//
+// Se hace con `asm!` en vez de agregar la crate `libc` al workspace: es **un** syscall, su número y
+// su ABI son contrato estable de Linux, y la alternativa era arrastrar una dependencia a un
+// workspace compartido por dos frentes.
+//
+// ⚠ **Esto no es «actualizar sin rebootear».** El userspace muere igual: es un reboot que se salta
+// el firmware. Lo que ahorra son los 20-30 s de POST/UEFI — la mitad del downtime en un servidor
+// remoto, y nada en un portátil. La ayuda del comando lo dice con esas palabras a propósito.
+#[cfg(target_arch = "x86_64")]
+mod sys {
+ /// `kexec_file_load` en x86_64. Contrato: `include/uapi/asm-generic/unistd.h`.
+ pub const NR_KEXEC_FILE_LOAD: u64 = 320;
+ /// `reboot`.
+ pub const NR_REBOOT: u64 = 169;
+
+ pub const LINUX_REBOOT_MAGIC1: u64 = 0xfee1_dead;
+ pub const LINUX_REBOOT_MAGIC2: u64 = 672_274_793;
+ pub const LINUX_REBOOT_CMD_KEXEC: u64 = 0x4558_4543;
+ /// Cargar sin initramfs (el fd de initrd se ignora).
+ pub const KEXEC_FILE_NO_INITRAMFS: u64 = 0x4;
+
+ /// # Safety
+ /// Invoca un syscall crudo. Los argumentos tienen que respetar la ABI del syscall llamado.
+ pub unsafe fn syscall5(n: u64, a: u64, b: u64, c: u64, d: u64, e: u64) -> i64 {
+ let ret: i64;
+ unsafe {
+ std::arch::asm!(
+ "syscall",
+ inlateout("rax") n => ret,
+ in("rdi") a,
+ in("rsi") b,
+ in("rdx") c,
+ in("r10") d,
+ in("r8") e,
+ lateout("rcx") _,
+ lateout("r11") _,
+ options(nostack)
+ );
+ }
+ ret
+ }
+}
+
+/// Carga un kernel para el próximo `reboot -f kexec`. NO salta todavía.
+#[cfg(target_arch = "x86_64")]
+pub fn kexec_cargar(kernel: &Path, initrd: Option<&Path>, cmdline: &str) -> Result<()> {
+ use std::os::fd::AsRawFd;
+ let fk = std::fs::File::open(kernel)
+ .with_context(|| format!("abriendo el kernel {}", kernel.display()))?;
+ // El cmdline viaja con su NUL: el kernel cuenta `cmdline_len` INCLUYENDO el terminador, y sin él
+ // lee un byte de más. Es el error clásico de esta llamada.
+ let mut cl: Vec<u8> = cmdline.as_bytes().to_vec();
+ cl.push(0);
+
+ let (fd_i, flags) = match initrd {
+ Some(p) => {
+ let fi = std::fs::File::open(p)
+ .with_context(|| format!("abriendo el initrd {}", p.display()))?;
+ (Some(fi), 0u64)
+ }
+ None => (None, sys::KEXEC_FILE_NO_INITRAMFS),
+ };
+ let raw_i = fd_i.as_ref().map(|f| f.as_raw_fd()).unwrap_or(-1);
+
+ let r = unsafe {
+ sys::syscall5(
+ sys::NR_KEXEC_FILE_LOAD,
+ fk.as_raw_fd() as u64,
+ raw_i as u64,
+ cl.len() as u64,
+ cl.as_ptr() as u64,
+ flags,
+ )
+ };
+ if r < 0 {
+ let e = -r;
+ // Traducir los tres errores que de verdad pasan, porque «Permission denied» a secas manda a
+ // buscar permisos de fichero cuando el problema es otro.
+ // ⚠ EPERM y ENOSYS se confunden fácil y mandan a lugares OPUESTOS. Medido en este mismo hub:
+ // el kernel de Artix trae `CONFIG_KEXEC_FILE=y` y aun así devolvió EPERM — por no ser root.
+ // El primer texto de este match decía «falta CONFIG_KEXEC_FILE» para EPERM, que es
+ // exactamente el diagnóstico equivocado: manda a recompilar un kernel que estaba bien.
+ let pista = match e {
+ 1 => " ⇒ falta CAP_SYS_BOOT: hay que ser root (y si YA sos root, es lockdown: Secure Boot no deja cargar un kernel sin firmar)",
+ 38 => " ⇒ el kernel que CORRE no implementa kexec_file_load: le falta CONFIG_KEXEC_FILE",
+ 13 => " ⇒ no puedo leer el fichero del kernel o del initrd",
+ 22 => " ⇒ la imagen no le gustó al kernel (¿es un bzImage x86_64 válido?)",
+ _ => "",
+ };
+ bail!("kexec_file_load falló: errno {e}{pista}");
+ }
+ Ok(())
+}
+
+/// Salta al kernel ya cargado. **No vuelve.**
+#[cfg(target_arch = "x86_64")]
+pub fn kexec_saltar() -> Result<()> {
+ let r = unsafe {
+ sys::syscall5(
+ sys::NR_REBOOT,
+ sys::LINUX_REBOOT_MAGIC1,
+ sys::LINUX_REBOOT_MAGIC2,
+ sys::LINUX_REBOOT_CMD_KEXEC,
+ 0,
+ 0,
+ )
+ };
+ bail!("reboot(KEXEC) volvió con {r}: no había kernel cargado, o no somos root")
+}
+
+#[cfg(not(target_arch = "x86_64"))]
+pub fn kexec_cargar(_: &Path, _: Option<&Path>, _: &str) -> Result<()> {
+ bail!("kexec: sólo implementado para x86_64")
+}
+#[cfg(not(target_arch = "x86_64"))]
+pub fn kexec_saltar() -> Result<()> {
+ bail!("kexec: sólo implementado para x86_64")
+}
+
+/// ¿El kernel que corre soporta `kexec_file_load`? Se responde **preguntándole al kernel**, no
+/// leyendo un `.config` que puede no ser el suyo.
+pub fn kexec_file_disponible() -> bool {
+ // Un `kexec_file_load` con fd inválido devuelve EBADF (9) si el syscall EXISTE, y ENOSYS (38)
+ // si no está compilado. Distinguir los dos es toda la prueba, y no carga nada.
+ #[cfg(target_arch = "x86_64")]
+ {
+ let r = unsafe { sys::syscall5(sys::NR_KEXEC_FILE_LOAD, u64::MAX, u64::MAX, 0, 0, sys::KEXEC_FILE_NO_INITRAMFS) };
+ -r != 38
+ }
+ #[cfg(not(target_arch = "x86_64"))]
+ {
+ false
+ }
+}
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/crates/takana-cli/src/kernel_cmd.rs b/crates/takana-cli/src/kernel_cmd.rs
index c1d3a74c..cbee9d16 100644
--- a/crates/takana-cli/src/kernel_cmd.rs
+++ b/crates/takana-cli/src/kernel_cmd.rs
@@ -227,6 +227,28 @@ pub enum KernelCmd {
#[arg(long)]
dry_run: bool,
},
+ /// Soft reboot into a kernel: skip firmware and bootloader (ADR 0017 §1).
+ ///
+ /// ⚠ **NO es «actualizar sin rebootear».** El userspace muere igual — es un reboot que se salta
+ /// el firmware. Ahorra los 20-30 s de POST/UEFI, que en un servidor remoto es la mitad del
+ /// downtime y en un portátil no es nada. Se dice acá porque media industria vende esto como
+ /// «live kernel update» y no lo es.
+ Kexec {
+ /// Artefacto del kernel en el store (nombre de directorio o ruta).
+ artefacto: String,
+ /// initramfs a cargar con él.
+ #[arg(long)]
+ initrd: Option<PathBuf>,
+ /// Kernel command line for the new kernel.
+ #[arg(long, default_value = "console=tty0 console=ttyS0,115200")]
+ cmdline: String,
+ /// Load it and stop there: the jump needs `--jump`.
+ #[arg(long)]
+ load_only: bool,
+ /// Actually jump. Without this it only loads and reports.
+ #[arg(long)]
+ jump: bool,
+ },
/// Say where this boot came from and what is on trial.
BootStatus {
#[arg(long, default_value = crate::efi_boot::EFIVARS)]
@@ -266,6 +288,8 @@ pub fn run(cmd: KernelCmd, store: &str) -> Result<()> {
match cmd {
KernelCmd::Stage { artefacto, esp, efivars, tries, state, dry_run } =>
ab_stage(&artefacto, store, &esp, &efivars, tries, &state, dry_run),
+ KernelCmd::Kexec { artefacto, initrd, cmdline, load_only, jump } =>
+ kexec_cmd(&artefacto, store, initrd.as_deref(), &cmdline, load_only, jump),
KernelCmd::BootStatus { efivars, state } => ab_status(&efivars, &state),
KernelCmd::Confirm { esp, efivars, state } => ab_confirm(&esp, &efivars, &state),
KernelCmd::Rollback { esp, efivars, state } => ab_rollback(&esp, &efivars, &state),
@@ -2120,3 +2144,42 @@ fn ab_rollback(esp: &Path, efivars: &Path, state: &Path) -> Result<()> {
println!("el kernel estable sigue siendo el que estaba. No se tocó.");
Ok(())
}
+
+fn kexec_cmd(
+ artefacto: &str,
+ store: &str,
+ initrd: Option<&Path>,
+ cmdline: &str,
+ load_only: bool,
+ jump: bool,
+) -> Result<()> {
+ let (bz, nombre) = bzimage_de(artefacto, store)?;
+ println!("kexec: {nombre}");
+ println!(" kernel: {}", bz.display());
+ match initrd {
+ Some(p) => println!(" initrd: {}", p.display()),
+ None => println!(" initrd: (ninguno)"),
+ }
+ println!(" cmdline: {cmdline}");
+
+ // Ojo: esto detecta si el SYSCALL existe, no si podemos usarlo. Un kernel con el flag puesto y
+ // un usuario sin privilegios pasa esta puerta y falla después con EPERM, que es lo correcto:
+ // mejor el error real del syscall que una sospecha nuestra.
+ if !kernel_ab::kexec_file_disponible() {
+ bail!(
+ "este kernel no implementa kexec_file_load (falta CONFIG_KEXEC_FILE).\n \
+ Los kernels del corpus traen CONFIG_KEXEC —el syscall viejo— que exige armar los \
+ segmentos y el purgatory a mano, o sea kexec-tools entero.\n \
+ La variante `recipes/linux-metal-kexec.toml` lo trae encendido."
+ );
+ }
+
+ kernel_ab::kexec_cargar(&bz, initrd, cmdline)?;
+ println!("✓ kernel cargado en memoria");
+ if load_only || !jump {
+ println!(" (no se salta: pasá --jump. El kernel queda cargado hasta el próximo reboot.)");
+ return Ok(());
+ }
+ println!("⚡ saltando — el userspace muere ACÁ. Esto no vuelve.");
+ kernel_ab::kexec_saltar()
+}
diff --git a/recipes/linux-metal-kexec.toml b/recipes/linux-metal-kexec.toml
new file mode 100644
index 00000000..5fca2fdd
--- /dev/null
+++ b/recipes/linux-metal-kexec.toml
@@ -0,0 +1,93 @@
+# linux-metal-kexec — VARIANTE de `linux-metal` cuya única diferencia es `CONFIG_KEXEC_FILE=y`.
+#
+# ── POR QUÉ UNA VARIANTE Y NO UN FLAG EN LA CANÓNICA ────────────────────────────────────────────
+# El `.config` ES la identidad del artefacto (SDD 22 §1): tocar `linux-metal` re-hashea el kernel
+# que hoy arranca las imágenes y el que reproduce bit a bit. El ADR 0017 deja esa decisión al
+# usuario, así que acá se paga el precio honesto —un artefacto más— en vez de mover el de todos.
+#
+# ── QUÉ DESTRABA ───────────────────────────────────────────────────────────────────────────────
+# Los seis kernels sellados traen `CONFIG_KEXEC=y`, que es el syscall VIEJO (`kexec_load`): recibe
+# los segmentos ya armados y el *purgatory* —el código que corre ENTRE los dos kernels—, o sea que
+# usarlo obliga a reimplementar kexec-tools entero.
+#
+# `kexec_file_load` invierte el reparto: se le pasan los **descriptores** del kernel y del initrd y
+# el trabajo lo hace el kernel. Son ~50 líneas en vez de miles, sin dependencias ajenas.
+#
+# Y de paso desata el nudo entre el ADR 0017 y el 0018: bajo *lockdown* —lo que trae Secure Boot—
+# el kernel RECHAZA `kexec_load` y sólo acepta `kexec_file_load`. Sin este flag, kexec y Secure Boot
+# no pueden coexistir.
+#
+# `-e CRYPTO_SHA256` va explícito porque `KEXEC_FILE` lo necesita para verificar la imagen y «al
+# azar del defconfig» no es un contrato.
+
+name = "linux-metal-kexec"
+version = "6.16.12"
+license = "GPL-2.0-only WITH Linux-syscall-note"
+
+[source]
+tarball = "https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-6.16.12.tar.gz"
+sha256 = "ffc6af80b014ddebd55e116aa29a9f7a5256c87a29a8a9dd97270b6d49625109"
+
+[build]
+compiler = "zig-cc"
+target = "x86_64-linux-musl"
+link = "dynamic"
+
+[deps]
+build = ["flex", "bison", "m4", "openssl", "elfutils", "make"]
+
+# SDD 25 §7-H1: `-e MEMCG -e PSI`. Sin MEMCG el fichero `memory.max` NO EXISTE y
+# `arje-incarnate::cgroup` sólo emite un `warn!` ⇒ la Card corre SIN tope de memoria. Va en la
+# fase configure porque el .config ES la identidad del artefacto (SDD 22 §1): esto re-hashea el
+# kernel a propósito. Comprobable con `takana kernel contract` sobre el config YA PRODUCIDO.
+[build.phases]
+configure = """
+make ARCH=x86_64 defconfig && \
+scripts/config -e KEXEC_FILE -e CRYPTO_SHA256 \
+ -d MODULE_SIG -d MODULE_SIG_ALL -d DEBUG_INFO_BTF -d DEBUG_INFO -d MODULES \
+ -d UNWINDER_ORC -e UNWINDER_FRAME_POINTER \
+ -e BLK_DEV_INITRD -e DEVTMPFS -e DEVTMPFS_MOUNT -e TMPFS \
+ -e OVERLAY_FS -e USER_NS -e NAMESPACES \
+ -e FANOTIFY -e FANOTIFY_ACCESS_PERMISSIONS \
+ -e OVERLAY_FS_REDIRECT_DIR -e OVERLAY_FS_INDEX -e OVERLAY_FS_XINO_AUTO -e OVERLAY_FS_METACOPY \
+ -e SECURITY -e SECURITY_LANDLOCK -e AUDIT -e IO_URING -e BPF_SYSCALL \
+ -e MEMCG -e PSI -d PSI_DEFAULT_DISABLED \
+ -e NTSYNC -d PREEMPT_VOLUNTARY -e PREEMPT -e HZ_1000 -e LRU_GEN -e LRU_GEN_ENABLED \
+ -e ZRAM -e ZSMALLOC -e EROFS_FS -e FS_VERITY \
+ -e VIRTIO -e VIRTIO_PCI -e VIRTIO_BLK -e VIRTIO_NET -e EXT4_FS \
+ -e PCI -e PCIEPORTBUS -e ACPI \
+ -e SATA_AHCI -e ATA -e ATA_PIIX -e SCSI -e BLK_DEV_SD -e BLK_DEV_LOOP \
+ -e NVME_CORE -e BLK_DEV_NVME \
+ -e USB_SUPPORT -e USB -e USB_PCI -e USB_XHCI_HCD -e USB_XHCI_PCI \
+ -e USB_EHCI_HCD -e USB_EHCI_PCI -e USB_OHCI_HCD -e USB_UHCI_HCD -e USB_STORAGE \
+ -e HID -e HID_GENERIC -e USB_HID -e INPUT_EVDEV \
+ -e INPUT_KEYBOARD -e KEYBOARD_ATKBD -e INPUT_MOUSE -e MOUSE_PS2 \
+ -e SERIO -e SERIO_I8042 -e VT -e VT_CONSOLE \
+ -e DRM -e DRM_SIMPLEDRM -e SYSFB_SIMPLEFB -e FB -e FB_EFI \
+ -e DRM_I915 -e DRM_FBDEV_EMULATION \
+ -e FRAMEBUFFER_CONSOLE -e FRAMEBUFFER_CONSOLE_DETECT_PRIMARY \
+ -e FRAMEBUFFER_CONSOLE_DEFERRED_TAKEOVER \
+ -e EFI -e EFI_STUB -e EFI_PARTITION -e EFIVAR_FS -e CMDLINE_BOOL \
+ -e VFAT_FS -e FAT_FS -e MSDOS_FS -e NLS_CODEPAGE_437 -e NLS_ISO8859_1 -e NLS_UTF8 \
+ -e ISO9660_FS -e JOLIET \
+ -e WLAN -e WIRELESS -e CFG80211 -e MAC80211 -e RFKILL \
+ -e WLAN_VENDOR_INTEL -e IWLWIFI -e IWLMVM \
+ -e ETHERNET -e NET_VENDOR_INTEL -e E1000 -e E1000E -e IGB -e IGC \
+ -e NET_VENDOR_REALTEK -e R8169 -e NET_VENDOR_BROADCOM -e TG3 \
+ -e USB_NET_DRIVERS -e USB_USBNET -e USB_NET_CDCETHER -e USB_NET_CDC_NCM -e USB_NET_RNDIS_HOST \
+ -d DRM_AMDGPU -d DRM_NOUVEAU -d DRM_RADEON -d AGP \
+ -e SOUND -e SND -e SND_PCM -e SND_TIMER -e SND_HRTIMER -e SND_DYNAMIC_MINORS \
+ -e SND_PCI -e SND_HDA -e SND_HDA_INTEL -e SND_HDA_GENERIC -e SND_HDA_PATCH_LOADER \
+ -e SND_HDA_CODEC_REALTEK -e SND_HDA_CODEC_HDMI -e SND_HDA_CODEC_GENERIC \
+ -e SND_INTEL_DSP_CONFIG -e SND_SOC -e SND_SOC_INTEL_SOF_PCI_DEV \
+ -e SND_SOC_SOF_TOPLEVEL -e SND_SOC_SOF_PCI -e SND_SOC_SOF_INTEL_TOPLEVEL \
+ -e SND_SOC_SOF_TIGERLAKE -e SND_SOC_SOF_HDA_AUDIO_CODEC -e SND_SOC_SOF_HDA_LINK \
+ -e SND_USB -e SND_USB_AUDIO \
+ -d MEDIA_SUPPORT -d INFINIBAND -d BT -d NFC -d CAN \
+ -d WATCHDOG -d USB4 -d FIREWIRE -d DEBUG_WX \
+ -d XFS_FS -d BTRFS_FS -d F2FS_FS -d JFS_FS -d GFS2_FS -d NTFS3_FS && \
+scripts/config --set-str CMDLINE "console=tty0 console=ttyS0,115200 quiet loglevel=3 vt.global_cursor_default=0 efi=novamap split_lock_detect=off initrd=/initramfs.cpio.gz rdinit=/init" && \
+make ARCH=x86_64 olddefconfig
+"""
+compile = "make ARCH=x86_64 CC=gcc HOSTCC=gcc -j\"$(nproc)\" bzImage"
+install = "mkdir -p /out/boot && cp arch/x86/boot/bzImage /out/boot/bzImage && cp .config /out/boot/config-6.16.12-metal-kexec"