funwithlinux guide

From Source to Running Kernel: Compilation and Integration

The Linux kernel is the core of every Linux-based operating system, acting as the bridge between hardware and software. While most users rely on precompiled kernels provided by their distributions, compiling a kernel from source offers unparalleled control: customizing features, optimizing for specific hardware, enabling experimental drivers, or even contributing to kernel development. This blog takes you on a step-by-step journey from downloading the kernel source code to booting a fully functional, custom-compiled kernel. Whether you’re a developer, a system administrator, or an enthusiast eager to learn, this guide demystifies the process with detailed explanations and actionable steps.

Table of Contents

  1. Prerequisites
  2. Understanding the Kernel Source Code
  3. Preparing the Environment
  4. Configuring the Kernel
  5. Compiling the Kernel
  6. Installing the Kernel
  7. Integrating with the Bootloader
  8. Testing the New Kernel
  9. Troubleshooting Common Issues
  10. Conclusion
  11. References

1. Prerequisites

Before diving in, ensure your system meets these requirements:

Hardware & Software

  • Linux-based OS: Any distribution (Ubuntu, Fedora, Arch, etc.) with kernel headers installed.
  • Storage: At least 20GB free space (source code, compilation artifacts, and modules).
  • RAM: 8GB+ recommended (compilation is memory-intensive).
  • Internet: To download the kernel source and dependencies.

Required Tools

Install these packages (commands vary by distribution):

Debian/Ubuntu:

sudo apt update && sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev dwarves git

Fedora/RHEL:

sudo dnf groupinstall "Development Tools" && sudo dnf install ncurses-devel bison flex openssl-devel elfutils-libelf-devel dwarves git

Arch Linux:

sudo pacman -S base-devel ncurses bison flex openssl elfutils dwarves git

2. Understanding the Kernel Source Code

The Linux kernel source is hosted at kernel.org. Let’s break down its structure and key components:

Obtaining the Source

Download the latest stable kernel (e.g., 6.6.1) or a long-term support (LTS) version (e.g., 6.1.60) from kernel.org. Use wget or git:

# Using wget (replace with your desired version)
wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.1.tar.xz

# Or using git (for development versions)
git clone https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/
cd linux && git checkout v6.6.1  # Checkout a specific tag

Key Directory Structure

Extract the source (if downloaded via wget):

tar -xf linux-6.6.1.tar.xz && cd linux-6.6.1

Explore critical folders:

  • arch/: Architecture-specific code (e.g., x86/, arm64/).
  • drivers/: Hardware drivers (GPU, network, storage, etc.).
  • fs/: File system implementations (ext4, btrfs, NTFS).
  • init/: Initialization code (starts the kernel after boot).
  • kernel/: Core kernel subsystems (scheduling, process management).
  • net/: Networking stack (TCP/IP, Wi-Fi, Bluetooth).

3. Preparing the Environment

Clean Up Old Artifacts

If recompiling, clean previous builds to avoid conflicts:

make clean  # Removes most compiled files (keeps config)
make mrproper  # Removes all generated files (including config)

Verify the Source (Optional)

For security, verify the source tarball’s GPG signature:

wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.1.tar.sign
gpg --verify linux-6.6.1.tar.sign  # Ensure "Good signature"

4. Configuring the Kernel

The kernel configuration determines which features, drivers, and subsystems are included. This is the most critical step—misconfiguration can break boot or hardware support.

Start with a Base Config

Use your current kernel’s config as a template (safer for beginners):

zcat /proc/config.gz > .config  # For systems with /proc/config.gz
# OR (Debian/Ubuntu)
cp /boot/config-$(uname -r) .config

Customize the Config

Edit the config using an interactive tool:

make menuconfig (Text-Based)

The most common choice for CLI users:

make menuconfig
  • Navigate with arrow keys; press Enter to select submenus.
  • Use Space to toggle options (* = built-in, M = module, empty = disabled).
  • ? shows help for selected options.
  • Save with F6 (or Exit → Save).

make xconfig (Graphical, Qt)

For GUI users with Qt installed:

make xconfig

Key Configuration Tips

  • Drivers: Enable hardware-specific drivers (e.g., Device Drivers > Network device support > Ethernet driver support for your NIC).
  • Filesystems: Include your root FS (e.g., ext4, btrfs) as built-in (*), not a module (M), to avoid boot failures.
  • Security: Enable Security Options > SELinux or AppArmor if used.
  • Optimizations: Under Processor type and features, select your CPU architecture (e.g., x86-64-v3 for modern Intel/AMD CPUs).

5. Compiling the Kernel

Compilation converts source code into a bootable kernel and modules.

Build the Kernel

Use make with parallel jobs (replace N with CPU cores + 1 for speed):

make -j$(nproc)  # e.g., make -j8 for 8-core CPU

This generates:

  • vmlinuz-6.6.1: The compressed kernel image.
  • Kernel modules in drivers/ and net/, to be installed later.

Build and Install Modules

Modules are drivers/libraries loaded at runtime. Install them to /lib/modules/:

sudo make modules_install -j$(nproc)

This creates /lib/modules/6.6.1/ with all compiled modules.

6. Installing the Kernel

Copy the kernel image and initramfs to /boot, then update the initramfs.

Install Kernel Image and Headers

sudo make install

This does the following:

  • Copies vmlinuz-6.6.1 and System.map-6.6.1 to /boot/.
  • Generates an initramfs (initial RAM filesystem) with update-initramfs (Debian/Ubuntu) or mkinitcpio (Arch).

Verify Initramfs

Ensure the initramfs exists:

ls /boot/initrd.img-6.6.1  # Debian/Ubuntu
# OR (Fedora/Arch)
ls /boot/initramfs-6.6.1.img

7. Integrating with the Bootloader

The bootloader (e.g., GRUB) must detect the new kernel to list it at startup.

Update GRUB (Most Distributions)

GRUB is the default bootloader for most Linux systems. Update its config:

sudo update-grub  # Debian/Ubuntu
# OR (Fedora/RHEL)
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
# OR (Arch)
sudo grub-mkconfig -o /boot/grub/grub.cfg

GRUB will auto-detect vmlinuz-6.6.1 and add it to the boot menu.

8. Testing the New Kernel

Reboot and select the new kernel from the GRUB menu.

Verify the Kernel

After booting, confirm the new kernel is running:

uname -r  # Should output 6.6.1

Check for Issues

  • Hardware: Test network, sound, GPU, and storage.
  • Logs: Check dmesg for errors (e.g., missing drivers): 
    dmesg | grep -i error
  • Modules: Ensure critical modules load: 
    lsmod | grep <module-name>  # e.g., lsmod | grep nvidia

9. Troubleshooting Common Issues

Boot Failure

If the system hangs at boot:

  1. Reboot and select the old kernel from GRUB.
  2. Check /var/log/kern.log for errors.
  3. Recompile with a simpler config (e.g., use make defconfig for a minimal baseline).

Missing Modules

If hardware isn’t detected:

  • Reboot to the old kernel.
  • Re-run make menuconfig, enable the missing driver as a module (M).
  • Recompile and reinstall modules: make modules_install -j$(nproc).

Initramfs Errors

If initramfs fails to load:

  • Rebuild it manually: 
    sudo update-initramfs -c -k 6.6.1  # Debian/Ubuntu

10. Conclusion

Compiling a Linux kernel from source is a rewarding skill that unlocks customization, performance tuning, and deeper OS understanding. While the process requires patience, the steps—from configuring to testing—are straightforward with practice.

Whether you’re optimizing for a embedded device, enabling bleeding-edge hardware, or contributing to kernel development, this guide provides a foundation to experiment and learn.

11. References

Happy compiling! 🐧