Manual de Rescate — chroot Linux

01 Requisitos previos

Para realizar un chroot de rescate necesitas arrancar el equipo desde un medio externo con Linux. A continuación se detallan los requisitos mínimos.

Medio de arranque

Una USB o DVD live de cualquier distribución Linux (Ubuntu, Arch, Debian, Fedora…).
El medio debe poder arrancar en el mismo modo que el sistema dañado: BIOS/Legacy o UEFI.
En sistemas UEFI, el live debe tener soporte UEFI (la mayoría de ISOs modernas lo tienen).

Privilegios

Acceso como root en el entorno live (o mediante sudo).

Herramientas necesarias

Están disponibles en cualquier entorno live moderno:

Herramienta	Uso
`lsblk` / `fdisk -l`	Identificar discos y particiones
`mount` / `umount`	Montar/desmontar sistemas de archivos
`chroot`	Cambiar la raíz del sistema
`arch-chroot` (opcional)	Wrapper conveniente (Arch Linux live)
`blkid`	Ver UUIDs y tipos de partición

💡 Conecta la red antes de entrar al chroot

Si vas a instalar paquetes desde dentro del chroot, asegúrate de que el entorno live tiene conexión a internet antes de entrar. El chroot hereda la red del sistema anfitrión.

02 Compatibilidad de distros

La pregunta habitual: ¿necesito usar una live de la misma distribución que el sistema dañado?

✔ Respuesta corta: No es obligatorio

El comando chroot es una función del kernel de Linux y funciona de forma agnóstica. Puedes usar cualquier distribución como live para entrar en chroot de otra diferente.

Sin embargo, existen matices importantes:

Situación	Recomendación
Reinstalar GRUB, reparar initramfs	Funciona con cualquier live. Los comandos (`grub-install`, `update-grub`, `mkinitcpio`, etc.) son del sistema chrooteado.
Instalar/actualizar paquetes (`apt`, `pacman`, `dnf`…)	El gestor de paquetes es del sistema dañado, no del live. Funciona perfectamente.
Editar archivos de configuración	Sin restricciones.
Arquitectura diferente (x86_64 vs ARM)	Requiere `qemu-user-static` y configurar binfmt. Para rescate estándar, usa la misma arquitectura.
Versión del kernel del live muy antigua	En casos raros con características de kernel muy recientes puede haber incompatibilidad. Usa un live actualizado.

⚠ Recomendación práctica

Aunque no es obligatorio, si tienes a mano una live de la misma familia (ej: Ubuntu para rescatar Ubuntu, Fedora para Fedora), úsala. Simplifica el debugging si algo falla durante el proceso.

03 Identificar discos y particiones

Antes de montar nada, identifica la estructura del disco del sistema dañado.

Terminal (live)

lsblk # Vista en árbol: discos, particiones y tamaños
lsblk -f         # Incluye tipo de sistema de archivos y UUID
blkid            # UUID y tipo de todas las particiones
fdisk -l         # Vista detallada con tipo de tabla (GPT/MBR)

Ejemplo de salida de lsblk -f que nos ayuda a identificar qué es cada partición:

Ejemplo — sistema UEFI con /boot/efi separado

NAME   FSTYPE   LABEL   UUID          MOUNTPOINT
sda
├─sda1 vfat             XXXX-XXXX     /boot/efi   ← partición EFI (ESP)
├─sda2 ext4             xxxxxxxx-xx   /boot       ← /boot (opcional)
└─sda3 ext4             yyyyyyyy-yy   /           ← raíz del sistema

Ejemplo — sistema BIOS/MBR clásico

NAME   FSTYPE   LABEL   UUID          MOUNTPOINT
sda
├─sda1 ext4             xxxxxxxx-xx   /           ← raíz del sistema
└─sda2 swap             zzzzzzzz-zz   ← swap (ignorar para chroot)

💡 Nota

En los ejemplos siguientes se usará /dev/sda como disco y /mnt como punto de montaje temporal. Adapta los nombres de dispositivo a los de tu sistema.

04 Chroot en sistema BIOS/MBR

En sistemas con BIOS tradicional, la partición de arranque está en el MBR del disco. No hay partición EFI.

Paso 1 — Montar la partición raíz

Terminal (como root)

mount /dev/sda1 /mnt   # Sustituye sda1 por tu partición raíz

Si tienes una partición /boot separada:

mount /dev/sda2 /mnt/boot   # Si /boot es una partición aparte

Paso 2 — Montar sistemas de archivos virtuales

Estos sistemas de archivos son necesarios para que el chroot tenga acceso a dispositivos, procesos y el kernel del sistema anfitrión:

Montar /proc, /sys, /dev

mount --types proc  proc    /mnt/proc
mount --rbind       /sys    /mnt/sys
mount --make-rslave         /mnt/sys
mount --rbind       /dev    /mnt/dev
mount --make-rslave         /mnt/dev

⚠ Importante: --rbind y --make-rslave

Usar --rbind en lugar de --bind asegura que los submounts (como /dev/pts o /sys/firmware/efi) también se propaguen al chroot. El flag --make-rslave evita que desmontes dentro del chroot afecten al sistema live.

Paso 3 — Entrar al chroot

chroot /mnt /bin/bash

Si el sistema usa dash como shell o /bin/bash no existe, prueba:

chroot /mnt /bin/sh

Paso 4 — Configurar el entorno dentro del chroot

Dentro del chroot

source /etc/profile            # Cargar variables del sistema
export PS1="(chroot) \u:\w\$ "  # Prompt visual para recordar que estás en chroot

✔ ¡Listo!

Ya estás dentro del sistema dañado. Todos los comandos que ejecutes ahora afectan al sistema del disco, no al live.

Reinstalar GRUB (BIOS/MBR)

Dentro del chroot — Debian/Ubuntu

grub-install /dev/sda   # El disco, no la partición
update-grub

Dentro del chroot — Arch Linux

grub-install --target=i386-pc /dev/sda
grub-mkconfig -o /boot/grub/grub.cfg

Dentro del chroot — Fedora/RHEL

grub2-install /dev/sda
grub2-mkconfig -o /boot/grub2/grub.cfg

05 Chroot en sistema UEFI

Los sistemas UEFI usan una partición EFI (ESP) formateada en FAT32, habitualmente en /boot/efi. Es imprescindible montarla para poder reinstalar o reparar el bootloader.

Paso 1 — Identificar la partición EFI

fdisk -l | grep -i efi     # Busca "EFI System" en el tipo de partición
# o bien:
lsblk -f | grep vfat       # La ESP siempre es FAT32 (vfat)

Paso 2 — Montar la partición raíz

mount /dev/sda3 /mnt   # Partición raíz del sistema dañado

Paso 3 — Montar la partición EFI

# Crear el mountpoint si no existe:
mkdir -p /mnt/boot/efi

# Montar la ESP (sda1 en este ejemplo):
mount /dev/sda1 /mnt/boot/efi

Si tienes /boot como partición separada (distinto de /boot/efi):

mkdir -p /mnt/boot
mount /dev/sda2 /mnt/boot   # Solo si /boot es partición aparte

Paso 4 — Montar sistemas de archivos virtuales

Igual que en BIOS, pero en UEFI el montaje de /sys es especialmente importante para acceder a las variables EFI:

mount --types proc  proc    /mnt/proc
mount --rbind       /sys    /mnt/sys
mount --make-rslave         /mnt/sys
mount --rbind       /dev    /mnt/dev
mount --make-rslave         /mnt/dev

# Verificar que efivars está accesible (necesario para grub-install UEFI):
ls /mnt/sys/firmware/efi/efivars/

✖ Si efivars está vacío

Si el live arrancó en modo BIOS/Legacy aunque el sistema dañado sea UEFI, efivars estará vacío y no podrás reinstalar GRUB en modo UEFI. Debes reiniciar el live en modo UEFI desde la BIOS/firmware del equipo.

Paso 5 — Entrar al chroot

chroot /mnt /bin/bash
source /etc/profile
export PS1="(chroot-uefi) \u:\w\$ "

Reinstalar GRUB (UEFI)

Dentro del chroot — Debian/Ubuntu

grub-install --target=x86_64-efi \
             --efi-directory=/boot/efi \
             --bootloader-id=ubuntu \
             --recheck
update-grub

Dentro del chroot — Arch Linux

grub-install --target=x86_64-efi \
             --efi-directory=/boot/efi \
             --bootloader-id=ARCH \
             --recheck
grub-mkconfig -o /boot/grub/grub.cfg

Dentro del chroot — Fedora/RHEL

dnf reinstall grub2-efi grub2-efi-modules shim
grub2-mkconfig -o /boot/efi/EFI/fedora/grub.cfg

💡 Consejo — Arch Linux y arch-chroot

Si arrancas desde una live de Arch Linux, puedes usar arch-chroot /mnt en lugar del proceso manual. Este script automatiza todos los montajes de proc, sys, dev y también monta la ESP si detecta /etc/fstab.

06 Comandos de rescate frecuentes

Una vez dentro del chroot, estos son los comandos más habituales según el problema:

Regenerar initramfs / initrd

Debian / Ubuntu

update-initramfs -u -k all

Arch Linux

mkinitcpio -P

Fedora / RHEL

dracut --force

Reparar paquetes dañados

Debian / Ubuntu

apt update
apt --fix-broken install
dpkg --configure -a

Arch Linux

pacman -Syyu
pacman -S linux linux-headers  # reinstalar kernel

Fedora / RHEL

dnf check
dnf reinstall <paquete>

Cambiar contraseña de root

passwd root
# o para otro usuario:
passwd nombre_usuario

Editar fstab para corregir montajes

nano /etc/fstab
# Verificar la sintaxis antes de reiniciar:
findmnt --verify --verbose

Verificar y reparar sistema de archivos (desde fuera del chroot)

⚠ Esto debe hacerse ANTES de montar, no desde dentro del chroot

El sistema de archivos debe estar desmontado para poder ejecutar fsck.

Desde el live, sin montar la partición

fsck -f /dev/sda1   # Forzar comprobación aunque parezca limpia
fsck -y /dev/sda1   # Responder "sí" automáticamente a reparaciones

07 Salir limpiamente del chroot

Es importante desmontar todo en orden correcto para no dejar el sistema en estado inconsistente.

Salir del chroot

exit
# o Ctrl+D

Desmontar en orden inverso — UEFI

umount -l /mnt/dev
umount -l /mnt/sys
umount    /mnt/proc
umount    /mnt/boot/efi   # Solo si tienes ESP
umount    /mnt/boot        # Solo si /boot era partición aparte
umount    /mnt

Desmontar en orden inverso — BIOS/MBR

umount -l /mnt/dev
umount -l /mnt/sys
umount    /mnt/proc
umount    /mnt/boot   # Solo si /boot era partición aparte
umount    /mnt

Verificar que no quedan mounts

lsblk   # No debe aparecer nada montado en /mnt

Reiniciar retirando el medio live

reboot

💡 El flag -l en umount

La opción -l (lazy unmount) es útil si algún proceso retiene el dispositivo. Desvincula el sistema de archivos del árbol inmediatamente y lo libera en cuanto deja de estar en uso.

08 Referencia rápida

Script todo-en-uno — BIOS/MBR

Copiar y ejecutar como root desde el live

#!/bin/bash
# Ajusta ROOT y BOOT según tu partición:
ROOT=/dev/sda1
# BOOT=/dev/sda2   # Descomenta si /boot es partición aparte

mount $ROOT /mnt
# [ -n "$BOOT" ] && mount $BOOT /mnt/boot

mount --types proc proc /mnt/proc
mount --rbind /sys /mnt/sys && mount --make-rslave /mnt/sys
mount --rbind /dev /mnt/dev && mount --make-rslave /mnt/dev

chroot /mnt /bin/bash --login

Script todo-en-uno — UEFI

#!/bin/bash
ROOT=/dev/sda3
EFI=/dev/sda1
# BOOT=/dev/sda2   # Descomenta si /boot es partición aparte

mount $ROOT /mnt
mkdir -p /mnt/boot/efi
mount $EFI  /mnt/boot/efi
# [ -n "$BOOT" ] && mount $BOOT /mnt/boot

mount --types proc proc /mnt/proc
mount --rbind /sys /mnt/sys && mount --make-rslave /mnt/sys
mount --rbind /dev /mnt/dev && mount --make-rslave /mnt/dev

chroot /mnt /bin/bash --login

Resumen comparativo

Aspecto	BIOS/MBR	UEFI/GPT
Partición extra necesaria	No	Sí — ESP (FAT32)
Mountpoint ESP	—	`/mnt/boot/efi`
Target de grub-install	`i386-pc`	`x86_64-efi`
Requiere live en modo UEFI	No	Sí (para reinstalar bootloader)
efivars necesario	No	Sí