1. What is GRUB and Why Should Kernel Developers Care?

GRUB stands for GRand Unified Bootloader. It is the most widely used bootloader on x86 and x86-64 Linux systems. When you press the power button, GRUB is one of the first programs that runs. Its job is simple but critical: find the kernel, load it into memory, load the initramfs, and hand control to the kernel.

As a kernel developer, you will regularly compile new kernels and need to switch between them. GRUB is how you select which kernel to boot. Knowing how to configure it well saves enormous time during development.

2. Understanding the GRUB2 Configuration System

Many beginners make a mistake when learning GRUB: they edit grub.cfg directly. Do not do this. The file is auto-generated and your changes will be overwritten.

GRUB2 uses a two-level configuration system:

The workflow is always: edit /etc/default/grub → run update-grub → reboot. The generated grub.cfg is what GRUB actually reads at boot time.

3. Step-by-Step: Customizing GRUB for Kernel Development

Let’s go through the most useful customizations one by one. These are tested on Ubuntu 22.04+ and work on Debian-based systems. Fedora/RHEL equivalents are noted where different.

Step 1 — Back up the config file first (always)

Before touching any system config file, always make a backup. This takes two seconds and saves hours of pain:

sudo cp /etc/default/grub /etc/default/grub.orig

If anything goes wrong, you can restore the original:

sudo cp /etc/default/grub.orig /etc/default/grub
sudo update-grub

Step 2 — Open the config file

sudo nano /etc/default/grub

Or use vi if you prefer:

sudo vi /etc/default/grub

Step 3 — Make the boot menu visible

By default on Ubuntu, GRUB hides the menu and boots immediately. This is great for end users but terrible for developers. To always show the menu:

# Find this line:
GRUB_TIMEOUT_STYLE=hidden

# Change it to:
GRUB_TIMEOUT_STYLE=menu

On older systems or some distros you might see:

# Find:
GRUB_HIDDEN_TIMEOUT_QUIET=true

# Change to:
GRUB_HIDDEN_TIMEOUT_QUIET=false

Both achieve the same result: the boot menu appears every time you reboot.

Step 4 — Set a comfortable timeout

The timeout controls how long GRUB waits for your input before booting the default kernel automatically:

# Find:
GRUB_TIMEOUT=0   (or whatever value is there)

# Change to (10 seconds gives you enough time to choose):
GRUB_TIMEOUT=10

During active kernel development, setting it to something like 15 or 20 seconds means you always have time to select the right kernel, even if you are not sitting right in front of the machine when it boots.

Step 5 — Apply the changes

After editing the file, regenerate the GRUB config:

# Ubuntu/Debian:
sudo update-grub

# Fedora/RHEL/CentOS (BIOS):
sudo grub2-mkconfig -o /boot/grub2/grub.cfg

# Fedora/RHEL/CentOS (UEFI):
sudo grub2-mkconfig -o /boot/efi/EFI/fedora/grub.cfg

You will see output showing that it found your installed kernels and wrote the new config. Then reboot:

sudo reboot

You should now see the GRUB menu with a list of available kernels to boot.

4. A Typical /etc/default/grub File Explained Line by Line

Here is what a typical file looks like, with every important line explained:

# /etc/default/grub — GRUB2 user configuration

# Which menu entry to boot by default
# 0 means the first entry (usually the latest kernel)
# You can also use the full menu entry name as a string
GRUB_DEFAULT=0

# How long to wait (in seconds) for user input
# Set to -1 to wait forever (useful during development)
GRUB_TIMEOUT=10

# Whether to show the menu (menu = always show)
GRUB_TIMEOUT_STYLE=menu

# Parameters passed to the kernel at boot
# quiet = suppress most boot messages
# splash = show graphical splash screen
# Remove both to see all kernel messages (useful for debugging)
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

# Parameters ALWAYS passed to the kernel (even in recovery mode)
GRUB_CMDLINE_LINUX=""

# Uncomment to disable graphical boot (useful on headless servers)
# GRUB_TERMINAL=console

# Resolution for the GRUB menu if using graphical mode
GRUB_GFXMODE=640x480

Two of these settings are especially important for kernel developers:

• GRUB_CMDLINE_LINUX_DEFAULT — remove quiet splash during development so you can see all kernel boot messages on the screen.
• GRUB_DEFAULT — use saved as the value to make GRUB remember the last kernel you manually selected. This is very useful when switching between kernels.

5. Passing Custom Kernel Parameters — A Kernel Developer’s Power Tool

Kernel parameters (also called the kernel command line) are key-value options passed from GRUB to the kernel at boot. They let you change kernel behavior without recompiling. This is incredibly useful during development and debugging.

Making boot messages visible

During kernel development, the default quiet mode hides everything. Change this in /etc/default/grub:

# BEFORE (production mode):
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"

# AFTER (developer mode — see all kernel messages):
GRUB_CMDLINE_LINUX_DEFAULT=""

Useful kernel parameters for developers

Adding parameters permanently vs. temporarily

To add parameters permanently (every boot), edit /etc/default/grub and run update-grub.

To add parameters temporarily (just for one boot — perfect for testing), do this at the GRUB menu:

1. At the GRUB menu, highlight the kernel you want to boot
2. Press E to edit the boot entry
3. Find the line starting with linux — this is the kernel command line
4. Move to the end of that line and type your extra parameters
5. Press Ctrl+X or F10 to boot with those parameters

This temporary change does not affect your permanent GRUB config.

6. Managing Multiple Kernels — The Daily Reality of Kernel Development

When you build and install a custom kernel (as covered in the earlier steps of this chapter), you will have multiple kernel versions installed at the same time. GRUB automatically detects all installed kernels and creates menu entries for each one. This is the key reason kernel developers need to be comfortable with GRUB.

List all installed kernels

# Ubuntu/Debian:
dpkg --list | grep linux-image

# Or check what GRUB found after running update-grub:
grep -i "menuentry" /boot/grub/grub.cfg | grep linux

Set a specific kernel as default permanently

If you just installed a custom kernel and want to test it as the default for a while:

# Use grub-set-default with the menu entry number (0-indexed)
sudo grub-set-default 1   # Make the second entry the default

# Or use the full entry name (more reliable across updates):
sudo grub-set-default "Advanced options for Ubuntu>Ubuntu, with Linux 6.9.0-custom"

# Enable saved default mode in /etc/default/grub:
GRUB_DEFAULT=saved

# Then set which entry to boot:
sudo grub-set-default 0
sudo update-grub

Boot a specific kernel just once

This is extremely useful. You want to test your new kernel once, but if it panics, GRUB should go back to your working kernel automatically on next boot:

# Boot entry 1 (0-indexed) just once, then revert to GRUB_DEFAULT
sudo grub-reboot 1
sudo reboot

If your new kernel crashes, the next reboot automatically uses the default kernel. This safety net is invaluable when testing experimental code.

7. Important: GRUB on UEFI Systems (Most Modern Hardware)

Almost all hardware made after 2012 uses UEFI instead of the old BIOS. GRUB works on both, but there are some differences you need to know.

On UEFI systems:

• There is a special partition called the EFI System Partition (ESP) usually mounted at /boot/efi
• The GRUB binary lives in the ESP, not in the MBR
• The config file /etc/default/grub and the update-grub workflow are the same — you do not need to change your workflow
• If you have Secure Boot enabled, custom-compiled kernels need to be signed. Most developers disable Secure Boot in UEFI settings when doing kernel development

Check if your system uses UEFI or BIOS

# If this directory exists, you are on UEFI:
ls /sys/firmware/efi

# Or check boot mode:
[ -d /sys/firmware/efi ] && echo "UEFI" || echo "BIOS"

Tip: Getting to the GRUB menu on UEFI systems

On BIOS systems, you hold Shift during boot to show the GRUB menu. On UEFI systems, this sometimes does not work. The reliable way is to set GRUB_TIMEOUT_STYLE=menu and GRUB_TIMEOUT=10 as described earlier. That always works regardless of BIOS or UEFI.

8. Common GRUB Mistakes and How to Avoid Them

sudo grub-install /dev/sda    # for BIOS
sudo update-grub

9. See What the Kernel Printed at Boot

Even if you booted with quiet splash and saw nothing on screen, the kernel saved all its boot messages. After booting, you can read them:

# See all kernel messages (including boot messages) — kernel 6.x:
dmesg | less

# See only the most recent boot's messages:
dmesg --follow   # keep watching in real time

# Filter for specific topics:
dmesg | grep -i usb
dmesg | grep -i error
dmesg | grep -i memory

# On systemd systems, see all boot logs:
journalctl -b   # current boot
journalctl -b -1  # previous boot
journalctl -b -2  # two boots ago (great for debugging crashes)

The journalctl -b -1 command is particularly powerful for kernel development. If your new kernel panicked during the previous boot, you can still read what it logged before crashing.

Interview Questions — GRUB Bootloader