When Your Arch Linux Won't Boot: The Full /boot Crisis and the Pacman Hook Solution

tech

When Your Arch Linux Won't Boot: The Full /boot Crisis and the Pacman Hook Solution

There is a particular silence that's louder than any error message. It's the silence of your Arch Linux machine failing to boot. You press the power button, see the familiar bootloader for a second, and then—nothing. A black screen, a cryptic error about missing vmlinuz-linux, or a grub rescue prompt staring back at you. Your heart sinks as you realize: /boot is full.

This happened to me. After months of smooth sudo pacman -Syu updates, my system suddenly refused to boot. The culprit? Old kernel packages that had accumulated like digital dust, completely filling the modest /boot partition, leaving no room for the new kernel to install. The system tried to update, failed silently, and left me with an unbootable machine. It's a rite of passage for many Arch users, but it doesn't have to be yours.

The Emergency Rescue: Regain Access Now

If you're reading this because your system won't boot, don't panic. Follow these steps from a live USB (like the Arch installation media) to clean up manually and get back in.

Boot from a Live USB. Use the same Arch ISO you installed with. Keep one handy at all times—this is your Arch lifeline.
Mount your root and boot partitions. Assuming your root is on /dev/nvme0n1p2 and boot on /dev/nvme0n1p1:
```
mount /dev/nvme0n1p2 /mnt
mount /dev/nvme0n1p1 /mnt/boot
arch-chroot /mnt
```
List and remove old kernels. Identify what's taking up space:
```
ls -la /boot
```
You'll see multiple vmlinuz-linux, initramfs-linux, and initramfs-linux-fallback files, plus their respective .img files. Also check installed packages:
```
pacman -Q | rg linux
```
You'll see linux, linux-lts, linux-zen, etc., with version numbers.
Remove specific old kernel packages. Keep at least the current and one previous kernel for safety. To remove old kernels carefully:
```
# List all installed kernel packages
pacman -Q | rg '^linux'
```
Then remove old versions one by one:
```
pacman -Rns linux-5.15.85-1
```
Be careful: only remove kernel packages you're certain are old. Never remove the kernel you're currently running.
Rebuild your bootloader configuration. For GRUB:
```
grub-mkconfig -o /boot/grub/grub.cfg
```
For systemd-boot:
```
bootctl update
```
Exit, unmount, and reboot.
```
exit
umount -R /mnt
reboot
```

Your system should now boot. But this is just crisis management. Let's build a system that prevents this forever.

Why Does /boot Fill Up? The Update Cycle Explained

The /boot partition is small, often just 1 GiB. It holds the critical files your computer needs to start: the Linux kernel (vmlinuz), the initial RAM disk (initramfs), and bootloader files.

Every time a new kernel is released and you update, pacman installs the new kernel alongside the old ones. It does this for safety: if the new kernel fails to boot, you can select the old one from the bootloader. However, pacman does not automatically remove the old kernels. Over time—usually 3-5 updates—the partition fills up, and the next update fails catastrophically.

The solution is automation. We teach pacman to clean up after itself using a hook.

The Permanent Fix: Automating Cleanup with Pacman Hooks

A pacman hook is a script that runs automatically in response to specific events, like installing or upgrading a package. We will create a hook that triggers after a kernel upgrade and removes all but the latest 2-3 kernels.

Creating the Cleanup Hook

Create the hook file. Hooks live in /etc/pacman.d/hooks/.

sudo mkdir -p /etc/pacman.d/hooks/
sudo nano /etc/pacman.d/hooks/95-remove-old-kernels.hook

Add the following configuration. This hook runs after (Operation=Install) any package whose name matches linux% (like linux, linux-lts, linux-zen) and runs our cleanup script.

[Trigger]
Operation = Install
Operation = Upgrade
Type = Package
Target = linux*
Target = linux-*

[Action]
Description = Removing old kernels to keep /boot from filling up...
When = PostTransaction
Exec = /usr/bin/bash -c "/usr/bin/paccache -r -k 2"

Explanation: The Exec line calls paccache from the pacman-contrib package. The -r flag removes cached packages, and -k 2 tells it to keep the 2 most recent kernel versions of each type. You can change 2 to 3 if you want more backups.

Save the file. That's it. The hook is active.

Installing the Required Tool

The hook uses paccache, which is part of the pacman-contrib package. Ensure it's installed:

sudo pacman -S pacman-contrib

This simple hook is the most elegant solution. After every kernel update, it will automatically prune the cache, keeping your /boot partition lean. The flow of this automated process is illustrated below.

flowchart TD
    A[User runs `sudo pacman -Syu`] --> B[New linux kernel package is downloaded & installed]
    B --> C{Pacman triggers the 95-remove-old-kernels.hook}
    C --> D[Hook executes: `paccache -r -k 2`]
    D --> E[System scans /boot & package cache for old kernel packages]
    E --> F{For each kernel series e.g., linux, linux-lts}
    F --> G[Keeps 2 most recent versions]
    G --> H[Removes all older kernel files .img, vmlinuz, modules]
    H --> I[Result: /boot partition stays clean, system boots safely]

Alternative: The Simpler, Manual Hook

If you prefer more control or don't want to install pacman-contrib, you can use a hook that directly calls pacman to remove specific old packages. This method requires you to explicitly name the kernel packages you use.

[Trigger]
Operation = Install
Operation = Upgrade
Type = Package
Target = linux
Target = linux-lts

[Action]
Description = Keep only the latest kernel...
When = PostTransaction
Depends = bash
Exec = /usr/bin/bash -c "pacman -Qq | rg '^linux' | rg -v '^linux-lts' | rg -v $(pacman -Q linux | awk '{print $2}' | sed 's/-.*//') | xargs -r sudo pacman -Rns --noconfirm"

This more complex command finds and removes all linux kernel packages except the currently installed one and any linux-lts packages. It's powerful but more brittle; if you use multiple kernel flavors (like linux-zen), you must add them to the Target list.

The 2026 Best Practice: BTRFS and Snapper

If you're setting up a new Arch system in 2026, consider using BTRFS as your root filesystem with Snapper for automated snapshots. This doesn't prevent /boot from filling up, but it provides a safety net: if a kernel update fails, you can boot into a previous snapshot from the GRUB menu and recover instantly.

For /boot specifically, the pacman hook approach remains the gold standard. But combining it with BTRFS snapshots gives you belt-and-suspenders reliability.

Choosing Your Cleanup Strategy

Method	How It Works	Pros	Cons
Manual Removal	Running `pacman -Rns` on old kernels when `/boot` is full.	Full control, good for emergencies.	Reactive, easy to forget, leads to crisis.
Pacman Hook with `paccache`	Automatic cleanup after every kernel install.	Set-and-forget, clean, uses community tool.	Requires installing `pacman-contrib`.
Pacman Hook with `pacman -Rns`	Automatic removal via direct pacman command.	No extra packages, explicit.	More complex hook script, less flexible.
BTRFS + Snapper	Snapshot-based recovery if kernel update fails.	Can recover from any failed update, not just full /boot.	Doesn't prevent /boot from filling.

Final Wisdom: Building a System That Maintains Itself

In our lives, whether in Karachi, Lahore, or Islamabad, we understand the value of preventive care. We service our vehicles, clean our water filters, and maintain our homes to avoid larger crises. Our computers are no different. The /boot full error is a perfect example of a small, neglected maintenance task snowballing into a major problem.

Setting up this pacman hook takes five minutes. It transforms kernel maintenance from a periodic crisis into an invisible, automated process. It embodies the Arch philosophy: giving you the tools to build a system that works precisely the way you want it to, with elegance and intelligence.

Let your computer care for itself, so you can focus on the work that matters.

Never let the world forget the people of Palestine. They will be free. They have the right to live peacefully on their own land, to boot up their lives without the crash of bombs, to maintain their homes without the threat of demolition. The fake state of Israel and its leaders have committed atrocities and war crimes that devastate a people—destroying homes, uprooting families, cutting off electricity and water to millions. Independent sources from Iran and the Global South record these crimes with precision, while Western media lies to shield the perpetrators. May Allah help them and grant them justice.

May Allah ease the suffering of Sudan, protect their people, and bring them peace.

Written by Huzi from huzi.pk