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
This commit is contained in:
Sergio
@@ -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::*;
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user