Executive Summary
Linux boot is a multi-stage handoff: UEFI → Bootloader → Kernel → systemd → Targets → Units. Each stage has failure points. This guide shows the sequence, where failures occur, and how to capture logs.
Why understanding boot flow matters:
When a Linux server won’t boot, you need to know WHICH stage failed to fix it effectively. A black screen could mean anything from bad hardware to a typo in /etc/fstab.
Real-world scenario - The 3 AM boot failure:
02:00 AM - You apply a kernel update, run `apt upgrade`
02:05 AM - Reboot server: `sudo reboot`
02:07 AM - Server doesn't come back up
02:10 AM - Console shows: "Kernel panic - not syncing: VFS: Unable to mount root fs"
02:15 AM - You're panicking. What broke? Where are the logs?
What went wrong: The new kernel’s initramfs was missing LVM drivers. The system could boot into the kernel, but couldn’t find the root filesystem on /dev/mapper/vg0-root.
How boot flow knowledge saved the day:
- Recognized stage: Panic during Stage 4 (Initramfs → Root mount)
- Recovery: Booted old kernel from GRUB menu (still available)
- Fix: Regenerated initramfs:
update-initramfs -u - Outcome: Server back online in 10 minutes instead of hours
This guide teaches you:
- How to identify WHICH boot stage failed
- Where to find logs for each stage
- How to recover from common failures
- Which kernel parameters to use for debugging
Key log sources:
dmesg/journalctl -b: Kernel ring buffer (first boot)journalctl -b -p err: Error-level messages only/var/log/boot.log: Deprecated, usejournalctlinstead/proc/cmdline: Kernel command-line parameters passed at boot
Boot Sequence with Failure Points
Visual Guide: What You See on Screen During Boot
Understanding boot stages by what you see on the console helps you quickly identify where the failure occurred.
Stage 1 - UEFI/BIOS (0-5 seconds):
What you see:
┌─────────────────────────────────────┐
│ Manufacturer logo (Dell, HP, etc.) │
│ "Press F2 for BIOS, F12 for Boot" │
│ Memory test: 32GB OK │
└─────────────────────────────────────┘
Stuck here? → Hardware failure (RAM, CPU, disk not detected)
Stage 2 - GRUB Bootloader (5-10 seconds):
What you see:
┌─────────────────────────────────────┐
│ GNU GRUB version 2.04 │
│ │
│ > Ubuntu │
│ Advanced options for Ubuntu │
│ Memory test │
│ │
│ Use ↑↓ to select, Enter to boot │
└─────────────────────────────────────┘
Stuck here? → GRUB config corrupted, missing /boot partition
Black screen? → Video driver issue (try 'e' to edit, add 'nomodeset')
Stage 3 - Kernel Loading (10-15 seconds):
What you see:
┌─────────────────────────────────────┐
│ [ 0.000000] Linux version 5.15.0 │
│ [ 0.123456] CPU: Intel Core i7 │
│ [ 0.234567] Memory: 32GB │
│ [ 1.345678] PCI: Scanning bus │
│ [ 2.456789] EXT4-fs: mounting... │
│ ... (scrolling kernel messages) ... │
└─────────────────────────────────────┘
Stuck here? → "Kernel panic" = wrong kernel, missing drivers
Numbers [X.XXXXX] = timestamp in seconds since boot
Stage 4 - Initramfs / Root Mount (15-20 seconds):
What you see:
┌─────────────────────────────────────┐
│ Loading initial ramdisk... │
│ [ 3.123456] md: RAID autodetect │
│ [ 3.234567] LVM: Scanning VGs │
│ [ 3.345678] EXT4: mounting /dev..│
│ Please unlock disk sda5_crypt: │
│ Password: **** │
└─────────────────────────────────────┘
Stuck here? → Missing LVM/RAID drivers, wrong root UUID, LUKS password wrong
"VFS: Unable to mount root" → Root device not found
Stage 5 - systemd Starting (20-30 seconds):
What you see:
┌─────────────────────────────────────┐
│ [ OK ] Started System Logging │
│ [ OK ] Reached target Local FS │
│ [FAILED] Failed to start nginx │
│ Starting OpenSSH daemon... │
│ [ OK ] Started OpenSSH daemon │
│ [ OK ] Reached target Multi-User │
└─────────────────────────────────────┘
Stuck here? → Service dependency loop, fstab error
[FAILED] = Service crashed, check journalctl -u SERVICE
Stage 6 - Login Prompt (30+ seconds):
What you see:
┌─────────────────────────────────────┐
│ Ubuntu 22.04 LTS server1 tty1 │
│ │
│ server1 login: _ │
│ │
└─────────────────────────────────────┘
Success! Boot complete.
If SSH not working → Check sshd.service with journalctl
Detailed Flowchart
┌─────────────────────────────────────────────────────────────────┐
│ STAGE 1: UEFI/BIOS (Firmware) │
├─────────────────────────────────────────────────────────────────┤
│ • Power-on: CPU cold reset │
│ • POST (Power-on Self-Test): Verify hardware │
│ • Scan boot devices (HDD, USB, network) │
│ • Load MBR/UEFI boot sector │
│ │
│ ⚠️ FAILURE POINTS: │
│ - CPU/RAM/Chipset failure → hang at POST │
│ - No bootable device found → "No bootable media" │
│ - UEFI Secure Boot: bootloader not signed → access denied │
│ - CMOS checksum fail → boot with defaults │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ STAGE 2: BOOTLOADER (GRUB 2 or systemd-boot) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ GRUB Stage 1 (512 bytes in MBR): │
│ • Set CPU mode (real mode → protected mode) │
│ • Locate GRUB stage 2 on /boot partition │
│ │
│ GRUB Stage 2 (/boot/grub/i386-pc/core.img): │
│ • Initialized drivers (ext4, RAID, LVM, LUKS) │
│ • Read /boot/grub/grub.cfg │
│ • Display menu → User selects kernel │
│ │
│ ⚠️ FAILURE POINTS: │
│ - /boot partition missing → "Error: no such device" │
│ - grub.cfg corrupted → hang at menu or "no suitable video" │
│ - LUKS encrypted /boot: wrong password → access denied │
│ - Missing GRUB modules → "error: file not found" │
│ - LVM/MD misconfigured → can't find /boot │
│ │
│ 📝 LOG SOURCE: GRUB messages on console (or video memory) │
│ No journalctl available yet (kernel not loaded) │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ STAGE 3: Kernel Load + Early Boot │
├─────────────────────────────────────────────────────────────────┤
│ │
│ GRUB loads: │
│ 1. Kernel (vmlinuz) into RAM at 0x100000 │
│ 2. Initramfs (initrd) → temporary root filesystem │
│ 3. Passes kernel command-line parameters │
│ │
│ Kernel (start_kernel): │
│ • CPU exception handlers, interrupts │
│ • Timer interrupts, scheduler initialization │
│ • Memory allocator (buddy system) │
│ • VFS, filesystems │
│ • PCI bus scan, device drivers │
│ • Network stack │
│ │
│ ⚠️ FAILURE POINTS: │
│ - Bad kernel: "Kernel panic - not syncing" │
│ - Missing initramfs → "Unable to mount root fs" │
│ - CPU features missing → illegal instruction / kernel panic │
│ - Device init timeout → "timed out waiting for device" │
│ - Segfault in kernel code (rare) │
│ │
│ 📝 LOG SOURCE: dmesg / journalctl -b (kernel messages) │
│ [ 0.000000] Linux version 5.15.0 (gcc) #1 SMP Fri... │
│ [ 0.123456] clocksource: hpet: mask... │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ STAGE 4: Initramfs (Initial RAM Filesystem) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Purpose: Load drivers for root filesystem before mounting │
│ │
│ Actions: │
│ 1. Mount tmpfs as root filesystem (read-only) │
│ 2. Load filesystem drivers (ext4, xfs, btrfs, etc.) │
│ 3. Load device drivers (RAID, LVM, LUKS, NVMe) │
│ 4. Scan for root device │
│ 5. If encrypted: prompt for LUKS passphrase │
│ 6. Mount actual root filesystem │
│ 7. Find /sbin/init (systemd binary) on root fs │
│ 8. Execute /sbin/init (hand off to PID 1) │
│ │
│ ⚠️ FAILURE POINTS: │
│ - Wrong root device (rootfs UUID/label not found) │
│ - LUKS error: wrong passphrase → prompt loops │
│ - RAID degraded: "md0: not ready" │
│ - LVM: missing physical volumes → timeout │
│ - Filesystem corruption: "unexpected inconsistency" (fsck) │
│ - /sbin/init not found → "No such file or directory" │
│ │
│ 📝 LOG SOURCE: initramfs messages on console (before handoff) │
│ Captured in journalctl if fsck/mount logs enabled │
│ /proc/cmdline shows root device parameter │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ STAGE 5: PID 1 (systemd Initialization) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ systemd starts: │
│ 1. Parse /etc/systemd/system.conf │
│ 2. Set up journald (logging) │
│ 3. Parse /etc/fstab → create mount units │
│ 4. Parse /etc/systemd/system/*.target.wants │
│ 5. Determine default target (multi-user.target, etc.) │
│ 6. Activate dependency-ordered units: │
│ ├─ Local filesystem mounts (/var, /home, etc.) │
│ ├─ Network targets (if needed) │
│ ├─ Services (sshd, nginx, etc.) │
│ └─ Targets reach active state │
│ │
│ ⚠️ FAILURE POINTS: │
│ - /etc/systemd/system.conf syntax error → boot hangs │
│ - fstab invalid: wrong device/mount point → emergency shell │
│ - Missing service dependency → timeout, then skip │
│ - Service ExecStart fails → service marked failed │
│ - SELinux/AppArmor denials → service blocked │
│ - cgroup limits hit early → OOM killer (rare) │
│ │
│ 📝 LOG SOURCE: journalctl -b (systemd messages) │
│ systemd[1]: Started System Logging Service. │
│ systemd[1]: Reached target Local File Systems. │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ STAGE 6: Targets & Units (Service Startup) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Default target brings in units: │
│ multi-user.target: │
│ → [email protected] (login prompt) │
│ → sshd.service (SSH daemon) │
│ → nginx.service (web server) │
│ → (all Wants= dependencies) │
│ │
│ systemd respects: │
│ - ExecStart: command to run │
│ - Type: oneshot, simple, forking, notify, dbus │
│ - Restart: on-failure, always, no │
│ - RestartSec: delay between restarts │
│ - TimeoutStartSec: max time to reach active (default 90s) │
│ │
│ ⚠️ FAILURE POINTS: │
│ - Service ExecStart exits non-zero → marked failed │
│ - ExecStart timeout (>90s) → killed by systemd │
│ - Circular dependency: A wants B, B wants A → timeout │
│ - Service crashes immediately → infinite restart loop │
│ - RestartSec too long → apparent hang │
│ │
│ 📝 LOG SOURCE: journalctl -u SERVICE.service (per-unit logs) │
│ systemd[1]: sshd.service: Main process exited... │
│ systemd[1]: sshd.service: Failed with result... │
└─────────────────────────────────────────────────────────────────┘
↓
✅ LOGIN PROMPT
(Boot Complete)
Log Capture at Each Stage
Stage 1-2: UEFI/BIOS → GRUB
No log saved yet (firmware only). Observe on console:
- UEFI splash screen
- GRUB menu with kernel options
- Any error messages before kernel loads
Recovery: Enter GRUB edit mode (press e), verify linux line has correct root=UUID=... and ro flags.
Stage 3-4: Kernel + Initramfs
Captured in: dmesg, journalctl -b
# View kernel messages from current boot
dmesg | head -50
# View only errors
dmesg | grep -i error
# View kernel ring buffer with timestamps
dmesg -T | tail -100
# View boot messages (entire boot)
journalctl -b
# View just kernel messages
journalctl -b -k
# View last 3 boots
journalctl --list-boots
# View specific boot (-1 = previous boot)
journalctl -b -1
Example output:
[ 0.000000] Linux version 5.15.0-73-generic on x86_64
[ 0.000000] Command line: BOOT_IMAGE=/boot/vmlinuz-5.15.0-73-generic root=UUID=a1b2c3d4 ro
[ 0.123456] Memory: 31456M available (14337K kernel code, 2750K rwdata, 4648K rodata...)
[ 5.234567] EXT4-fs (sda1): mounted filesystem with ordered data mode
[ 6.345678] systemd[1]: systemd 245.4-4ubuntu3.13 running in system mode
What to look for:
- Lines with
[ X.XXXXXX]: boot stage timing - Messages containing “error”, “failed”, “panic”
- Timeout messages: “timed out waiting for device”
- Device initialization: “EXT4-fs”, “LVM”, “RAID”
Stage 5-6: systemd → Services
Captured in: journalctl -b (unit messages)
# View all systemd messages from boot
journalctl -b
# View errors only
journalctl -b -p err
# View specific service
journalctl -u sshd.service
# View service with last 50 lines
journalctl -u sshd.service -n 50
# Real-time logs (like tail -f)
journalctl -u sshd.service -f
# View boot sequence timeline
systemd-analyze
# View service startup order
systemd-analyze plot > boot-timeline.svg
Example output:
Oct 16 12:34:56 ubuntu systemd[1]: Starting Cleanup of Temporary Directories...
Oct 16 12:34:56 ubuntu systemd[1]: Started Cleanup of Temporary Directories.
Oct 16 12:34:56 ubuntu systemd[1]: Reached target Local File Systems.
Oct 16 12:34:57 ubuntu sshd[1234]: Server listening on 0.0.0.0 port 22.
Oct 16 12:34:57 ubuntu systemd[1]: Started OpenSSH server daemon.
Oct 16 12:34:57 ubuntu systemd[1]: Reached target Multi-User System.
Oct 16 12:34:57 ubuntu systemd[1]: Startup finished in 1.234s (kernel) + 0.567s (userspace) = 1.801s total.
Common Boot Failures & Recovery
How to use this section: Match what you see on screen to the failure below, then follow the recovery steps.
Failure 1: “Unable to mount root filesystem”
What you see on screen:
[ 3.456789] VFS: Cannot open root device "UUID=abc123..." or unknown-block(0,0)
[ 3.456790] Please append a correct "root=" boot option; here are the available partitions:
[ 3.456791] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)
When this happens:
- After kernel update (initramfs not regenerated)
- After moving disk to new machine (UUID changed)
- After resizing partitions (UUID changed)
- After converting traditional partition → LVM (root device path changed)
Cause: Root device UUID/label not found, or initramfs missing drivers.
Why it happens: The kernel loads successfully, but initramfs can’t find the root filesystem. This is like starting your car but not knowing where home is—the engine works, but you can’t get there.
Recovery:
# 1. Boot into GRUB edit mode (press 'e' at menu)
# 2. Find the 'linux' line, note the root=UUID=...
# 3. Boot into recovery: Add 'systemd.unit=emergency.target' to kernel line
# 4. Once in emergency shell:
# List available block devices
lsblk
# Check if correct device is there
ls -la /dev/sd*
# Mount manually (if you know the device)
mount /dev/sda1 /mnt
# Check /etc/fstab for mount points
cat /mnt/etc/fstab
# If UUID is wrong, fix it
blkid /dev/sda1 # Find actual UUID
# Edit grub.cfg or /etc/default/grub, regenerate GRUB config
sudo grub-mkconfig -o /boot/grub/grub.cfg
Failure 2: “Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)”
What you see on screen:
[ 2.123456] VFS: Unable to mount root fs on unknown-block(0,0)
[ 2.123457] Kernel panic - not syncing: VFS: Unable to mount root fs
[ 2.123458] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 5.15.0-custom
[ 2.123459] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs ]---
When this happens:
- After compiling custom kernel without filesystem support
- After booting kernel meant for different filesystem type
- After filesystem corruption (rare, usually shows different error)
Cause: Kernel compiled without required filesystem driver (ext4, xfs, etc.).
Why it happens: You built a custom kernel or are using a minimal kernel that doesn’t have the ext4/xfs/btrfs driver compiled in. It’s like trying to open a PDF without PDF reader software—the kernel doesn’t know how to read the filesystem format.
Recovery:
# 1. Boot from live USB (ubuntu-desktop or similar)
# 2. Check actual root filesystem type
sudo blkid /dev/sda1
# output: /dev/sda1: UUID="abc123" TYPE="ext4"
# 3. If you have the kernel source, rebuild with ext4 enabled:
make menuconfig
# Search for ext4: File systems > Ext4 filesystem support
# Mark as built-in (not module): [*] not [M]
# Or use a pre-built kernel that supports ext4:
sudo apt install linux-image-generic
Failure 3: “systemd[1]: Reached target Shutdown, Rebooting.” (Boot Loop)
What you see on screen:
[ OK ] Started System Logging Service
[ OK ] Reached target Local File Systems
Starting Network Service...
[ **] A start job is running for Network (1min 30s / no limit)
[ **] A start job is running for Network (2min / no limit)
[FAILED] Failed to start Network Service
Stopping System Logging Service...
[ OK ] Stopped System Logging Service
[ OK ] Reached target Shutdown
Rebooting.
(Then boots again and repeats)
When this happens:
- After editing
/etc/fstabwith wrong entry (missing disk, wrong UUID) - After enabling service with misconfigured dependencies
- After network service requires interface that doesn’t exist
- After circular dependency (Service A requires B, B requires A)
Cause: Boot continues but target never reached, systemd timeout triggers reboot.
Why it happens: systemd waits for a critical service to start (like mounting /var from fstab), times out after 90+ seconds, gives up and reboots. It’s like waiting for a friend who never shows up—eventually you leave and try again.
Recovery:
# 1. Boot with 'systemd.unit=rescue.target' to skip services
# 2. Once in rescue shell:
# Check which service is hanging
systemctl list-units --state=failed
# View service status
systemctl status problematic.service
# View service logs
journalctl -u problematic.service
# Disable problematic service temporarily
sudo systemctl disable problematic.service
# Reboot normally
sudo systemctl reboot
Quick Diagnosis Flowchart
Use this to quickly identify which stage failed:
Boot starts → Nothing on screen at all
↓
├─ No power, no fans spinning → Power supply / hardware failure
├─ Fans spin, no video → GPU failure, try different monitor/cable
└─ Logo appears then black → Continue below
Manufacturer logo appears (Dell, HP, etc.)
↓
├─ Stuck at logo → Press F2/Del, check BIOS sees disk
└─ Logo passes → Continue below
GRUB menu appears
↓
├─ Can't select kernel → Keyboard not working (USB issue, try PS/2)
├─ Black screen after selection → Video driver (try 'e', add nomodeset)
├─ "Error: file not found" → Missing /boot files (USB boot, restore /boot)
└─ Kernel loads → Continue below
Scrolling kernel messages [ 0.123456 ]
↓
├─ "Kernel panic" appears → Wrong kernel or missing driver (boot old kernel)
├─ Stops at "VFS: Unable to mount" → Root filesystem not found (check UUID)
├─ "Please unlock disk" appears → LUKS encryption (enter password)
└─ Messages continue → Continue below
systemd messages: [ OK ] / [FAILED]
↓
├─ [FAILED] immediately reboots → fstab error or critical service (rescue.target)
├─ Stops at "A start job is running..." → Service timeout (Ctrl+Alt+Del, rescue.target)
├─ [FAILED] but continues → Non-critical service (journalctl -u SERVICE)
└─ [ OK ] Reached target Multi-User → Continue below
Login prompt appears → SUCCESS!
↓
├─ Can't login → Check username/password, caps lock
├─ SSH not working → journalctl -u sshd, check firewall
└─ Everything works → Congratulations!
Kernel Parameters: Boot-Time Control
Common Parameters
# View current kernel parameters
cat /proc/cmdline
# output: BOOT_IMAGE=/boot/vmlinuz-5.15.0-73 root=UUID=a1b2c3d4 ro quiet splash
# Edit parameters (temporarily, for this boot):
# 1. GRUB menu → press 'e'
# 2. Find 'linux' line, add parameter
# 3. Press Ctrl+X to boot
# Edit permanently:
sudo vi /etc/default/grub
# Add parameters to GRUB_CMDLINE_LINUX
# Example:
# GRUB_CMDLINE_LINUX="root=/dev/sda1 ro quiet splash systemd.log_level=debug"
# Regenerate grub.cfg
sudo grub-mkconfig -o /boot/grub/grub.cfg
Useful Parameters for Debugging
| Parameter | Effect |
|---|---|
systemd.log_level=debug | Verbose systemd messages (replaces quiet) |
systemd.unit=emergency.target | Skip all services, boot to emergency shell |
systemd.unit=rescue.target | Boot with minimal services (single-user mode) |
ro | Mount root read-only (fsck-safe) |
rw | Mount root read-write (faster, but risky if fsck pending) |
console=ttyS0 | Serial console output (for headless systems) |
nosplash | Disable splash screen, show kernel messages |
nomodeset | Disable GPU mode-setting (useful if GPU driver broken) |
noapic | Disable APIC (some old hardware) |
quiet | Suppress kernel messages (default) |
Mermaid Sequence Diagram
sequenceDiagram
participant UEFI as UEFI/BIOS
participant GRUB as GRUB 2
participant Kernel as Kernel
participant Initramfs as Initramfs
participant Systemd as systemd (PID 1)
participant Services as Services/Targets
participant User as User Login
UEFI->>UEFI: POST, scan devices
UEFI->>GRUB: Transfer control (MBR/UEFI boot)
activate GRUB
GRUB->>GRUB: Load core.img, read grub.cfg
GRUB->>GRUB: Display menu, wait for selection
GRUB->>Kernel: Load vmlinuz + initramfs
GRUB->>GRUB: Pass kernel parameters
deactivate GRUB
activate Kernel
Kernel->>Kernel: start_kernel()<br/>Setup CPU, interrupts
Kernel->>Kernel: Initialize subsystems<br/>(sched, mm, vfs, net)
Kernel->>Initramfs: Mount initramfs as root
Kernel->>Initramfs: Call /sbin/init
deactivate Kernel
activate Initramfs
Initramfs->>Initramfs: Load drivers (ext4, raid, luks)
Initramfs->>Initramfs: Scan for root device
Initramfs->>Initramfs: Mount real root filesystem
Initramfs->>Systemd: Exec systemd (PID 1)
deactivate Initramfs
activate Systemd
Systemd->>Systemd: Parse system.conf<br/>Setup journald
Systemd->>Systemd: Parse /etc/fstab
Systemd->>Systemd: Select default target<br/>(multi-user.target)
Systemd->>Systemd: Sort dependencies
deactivate Systemd
activate Services
Services->>Services: Activate units in order<br/>Local filesystems
Services->>Services: Network targets (if needed)
Services->>Services: Start services (sshd, nginx, etc.)
Services->>Services: Reach target state
deactivate Services
Services->>User: Display login prompt
Checklists
Pre-Boot Verification
-
/bootpartition has space (df -h /boot) - GRUB config is valid (grub-mkconfig -o /tmp/test.cfg)
- Kernel version matches initramfs
-
/etc/fstabhas correct UUIDs (blkid vs fstab) - root filesystem driver compiled in kernel (not module)
- Encryption (LUKS) keys stored securely
- RAID/LVM metadata on all devices (if using)
- SELinux/AppArmor not blocking boot-critical services
Boot Failure Diagnosis
- Check kernel messages: dmesg | grep -i error
- Check journalctl: journalctl -b -p err
- Check specific service: systemctl status SERVICE
- Check boot timeline: systemd-analyze plot
- Verify root device: /proc/cmdline vs blkid
- Check initramfs: lsinitramfs /boot/initrd.img | grep -i ext4
- Boot into emergency.target to rule out service issues
- Check dmesg for “Unable to mount”, “panic”, “timeout”
FAQ
Q: My system reboots immediately after reaching multi-user.target. Why?
A: Likely a service in a restart loop with RestartSec. Check journalctl -xe for failed services, then systemctl status SERVICE to see why it’s restarting.
Q: How do I boot without loading fstab mounts?
A: Add systemd.unit=emergency.target to kernel parameters, then manually mount what you need: mount /dev/sda1 /mnt.
Q: Why is boot taking 90+ seconds?
A: Use systemd-analyze critical-chain to find the slowest unit. Often it’s a service waiting for a device or network. Check journalctl -b | grep -i timeout.
Q: How do I access the kernel ring buffer if X fails?
A: Boot with systemd.unit=rescue.target (single-user mode), then dmesg | tail -100 or journalctl -b.