1. Encendido del hardware
2. POST (Power-On Self Test) del BIOS/UEFI
3. BIOS/UEFI localiza el disco de arranque
4. GRUB (bootloader) carga desde MBR/ESP
5. GRUB carga el kernel y el initramfs
6. El kernel inicializa hardware y monta initramfs
7. initramfs monta el sistema de archivos raíz real
8. systemd (PID 1) se ejecuta desde el sistema de archivos raíz
9. systemd activa targets y servicios
10. Login prompt

# Analizar el tiempo de arranque completo
systemd-analyze

# Ver cada fase del arranque
systemd-analyze time

# Ver cuánto tardó cada servicio
systemd-analyze blame | head -20

# Ver la cadena crítica del arranque (ruta más lenta)
systemd-analyze critical-chain

# Verificar si el sistema usa UEFI o BIOS Legacy
ls /sys/firmware/efi 2>/dev/null && echo "UEFI" || echo "BIOS Legacy"

# En UEFI, ver la partición ESP (EFI System Partition)
fdisk -l | grep -i efi
lsblk -f | grep -i vfat

# Montar la partición ESP para inspeccionarla
mount /dev/sda1 /mnt/efi  # Ajustar el dispositivo según corresponda
ls /mnt/efi/EFI/

# Ver tabla de particiones (GPT para UEFI, MBR para BIOS)
fdisk -l /dev/sda
parted /dev/sda print

# Verificar la partición de arranque
blkid /dev/sda1

# Para UEFI: verificar entradas de arranque
efibootmgr -v  # Listar entradas de arranque EFI

# Archivos de configuración de GRUB
cat /etc/default/grub  # Configuración principal

# Aplicar cambios de configuración
update-grub           # Ubuntu/Debian
grub2-mkconfig -o /boot/grub2/grub.cfg  # CentOS/Rocky

# Instalar GRUB en el MBR (BIOS Legacy)
grub-install /dev/sda        # Ubuntu/Debian
grub2-install /dev/sda       # CentOS/Rocky

# Instalar GRUB para UEFI
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=ubuntu

# Ver y modificar las opciones principales
cat /etc/default/grub

# Opciones importantes:
# GRUB_DEFAULT=0                    # Entrada de menú por defecto (0 = primera)
# GRUB_TIMEOUT=5                    # Segundos a mostrar el menú
# GRUB_CMDLINE_LINUX=""             # Parámetros del kernel para todas las entradas
# GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"  # Parámetros solo para la entrada por defecto

# Ejemplo: habilitar consola serie para servidores sin monitor
sed -i 's/GRUB_CMDLINE_LINUX=""/GRUB_CMDLINE_LINUX="console=ttyS0,115200n8 console=tty0"/' \
    /etc/default/grub

# Aumentar timeout para servidores remotos (más tiempo para intervenir)
sed -i 's/GRUB_TIMEOUT=.*/GRUB_TIMEOUT=10/' /etc/default/grub

update-grub

# Listar kernels instalados
dpkg -l 'linux-image-*' | grep ^ii  # Ubuntu/Debian
rpm -qa | grep kernel                # CentOS/Rocky

# Ver las entradas en el menú de GRUB
grep -E "^menuentry|submenu" /boot/grub/grub.cfg | head -20

# Establecer un kernel específico como defecto
# Número de entrada en el menú (empieza en 0) o nombre completo
grub-set-default 2
grub-set-default "Ubuntu, with Linux 5.15.0-78-generic"

# Arrancar con un kernel diferente una sola vez
grub-reboot 1  # Número de entrada del menú
reboot

# Ver el kernel actualmente en uso
uname -r

# Ver información del kernel actual
uname -a
uname -r  # Solo la versión

# Archivos del kernel en /boot
ls -lh /boot/
# vmlinuz-* = imagen del kernel comprimida
# initrd.img-* = imagen initramfs
# System.map-* = tabla de símbolos del kernel
# config-* = configuración con la que se compiló el kernel

# Ver parámetros actuales con los que arrancó el kernel
cat /proc/cmdline

# Ver el contenido de un initramfs
mkdir /tmp/initrd-contents
cd /tmp/initrd-contents
# Descomprimir initramfs (puede ser gzip, lz4, o zstd)
file /boot/initrd.img-$(uname -r)
unmkinitramfs /boot/initrd.img-$(uname -r) /tmp/initrd-contents
ls /tmp/initrd-contents

# Regenerar initramfs (necesario tras cambios en módulos del kernel)
update-initramfs -u                    # Ubuntu/Debian (kernel actual)
update-initramfs -u -k $(uname -r)    # Ubuntu/Debian (kernel específico)
update-initramfs -u -k all            # Ubuntu/Debian (todos los kernels)

dracut --force                         # CentOS/Rocky
dracut --force /boot/initramfs-$(uname -r).img $(uname -r)  # Kernel específico

# Ver el target por defecto al que arranca el sistema
systemctl get-default

# Ver el estado actual del sistema (targets activos)
systemctl list-units --type=target --state=active

# Ver la secuencia de activación de targets
systemctl list-dependencies multi-user.target --no-pager | head -30

# Ver logs del proceso de arranque
journalctl -b          # Logs del arranque actual
journalctl -b -1       # Logs del arranque anterior
journalctl -b -p err   # Solo errores del arranque actual

# Arranques anteriores
journalctl --list-boots  # Ver lista de arranques disponibles

# Ver parámetros actuales del kernel
cat /proc/cmdline

# Parámetros útiles para depuración:
# rd.break            = Pausar en initramfs antes de montar rootfs
# init=/bin/bash      = Iniciar bash directamente (sin systemd)
# systemd.unit=rescue.target = Arrancar en modo rescate
# single              = Modo de usuario único
# nomodeset           = Deshabilitar KMS (útil para problemas de GPU)
# console=ttyS0,115200 = Activar consola serie
# debug               = Mensajes de depuración del kernel

# Añadir parámetro temporal (solo para un arranque):
# En el menú de GRUB, pulsar 'e' para editar
# Buscar la línea con 'linux' y añadir el parámetro al final
# Pulsar Ctrl+X o F10 para arrancar con esos parámetros

# Parámetros de sysctl en tiempo de ejecución
sysctl -a | head -30                        # Ver todos los parámetros
sysctl kernel.hostname                       # Ver parámetro específico
sysctl -w net.ipv4.ip_forward=1             # Cambiar temporalmente
echo "net.ipv4.ip_forward=1" >> /etc/sysctl.conf  # Cambio permanente
sysctl -p                                    # Aplicar cambios del archivo

# Opción 1: Cambiar target al vuelo (si el sistema está iniciando)
# En el menú GRUB, editar la línea 'linux' y añadir:
# systemd.unit=rescue.target
# O para emergencia completa (solo rootfs montado):
# systemd.unit=emergency.target

# Opción 2: Desde un sistema en ejecución (cauteloso en producción)
systemctl rescue
# O para emergencia
systemctl emergency

# Arrancar desde USB/CD de recuperación
# Montar el sistema de archivos raíz del servidor dañado

# Identificar la partición raíz
fdisk -l
lsblk

# Montar el sistema raíz (ajustar dispositivo)
mount /dev/sda2 /mnt

# Montar sistemas de archivos virtuales necesarios
mount --bind /dev /mnt/dev
mount --bind /proc /mnt/proc
mount --bind /sys /mnt/sys
mount --bind /run /mnt/run

# Si el sistema usa EFI, montar la partición ESP
mount /dev/sda1 /mnt/boot/efi

# Entrar en el sistema como chroot
chroot /mnt

# Desde aquí puedes:
# Reinstalar GRUB
grub-install /dev/sda
update-grub

# Regenerar initramfs
update-initramfs -u -k all

# Cambiar contraseña de root
passwd root

# Verificar el sistema de archivos
# exit  (salir del chroot primero)
# fsck -y /dev/sda2

# Desmontar todo y reiniciar
exit
umount -R /mnt
reboot

# En el menú GRUB, editar la entrada del kernel
# Añadir al final de la línea 'linux':
# init=/bin/bash rw

# El sistema arrancará en bash como root
# Cambiar la contraseña
passwd root

# Si el sistema tiene SELinux, relabelar
# touch /.autorelabel

# Sincronizar y reiniciar
sync
exec /sbin/reboot -f

# Arrancar con parámetros de depuración en GRUB:
# Quitar 'quiet splash' de la línea linux
# Añadir: debug systemd.log_level=debug
# Ver los logs del arranque fallido en el arranque siguiente
journalctl -b -1 -p err

# Verificar que la partición EFI existe
fdisk -l | grep EFI
# Regenerar entradas en /etc/fstab
blkid /dev/sda1  # Obtener UUID
# Añadir línea al fstab:
# UUID=XXXX /boot/efi vfat defaults 0 2

# El kernel no puede montar el sistema de archivos raíz
# Causas: UUID cambiado, disco dañado, initramfs corrupto
# Solución: Arrancar desde USB, hacer chroot y regenerar initramfs
update-initramfs -u -k all   # En el chroot
# Verificar /etc/fstab tiene el UUID correcto
blkid /dev/sda2
cat /etc/fstab

journalctl -b -u servicio-fallido.service
# Buscar dependencias no satisfechas
systemctl list-dependencies servicio-fallido.service
# Verificar si hay errores de permisos o configuración