1. Why Does the Linux Kernel Need to Be Configured?

The Linux kernel source tree contains over 30 million lines of code. It supports everything from tiny embedded microcontrollers to massive server machines with hundreds of CPU cores. Every driver, every protocol, every optional feature is present in the source. But you do not want all of it compiled into every kernel image — that would be enormous and impractical.

Configuration is how you tell the kbuild system what to include. If you are taking this free Linux kernel development course to build drivers for a specific piece of hardware, you need to know which config options enable your target subsystem. If you are on a free embedded Linux course, you need a lean kernel with only what your board needs. Configuration is the first step toward both goals.

Think of it like ordering a custom-built PC — you pick exactly which components go in, and everything else stays out. The output of this selection process is a file called .config.

2. The .config File — How the Kernel Knows What to Build

The .config file is a plain text file that lives in the root of the kernel source tree. It contains hundreds or thousands of lines, one for each configuration option. Every option is prefixed with CONFIG_ and assigned a value. Here is what a real snippet looks like:

#
# General setup
#
CONFIG_CC_IS_GCC=y
CONFIG_GCC_VERSION=130200
CONFIG_SYSVIPC=y
CONFIG_POSIX_MQUEUE=y
# CONFIG_AUDIT is not set
CONFIG_MODULES=y
CONFIG_MODULE_UNLOAD=y
CONFIG_USB_SERIAL=m

There are exactly three possible states for any kernel config option:

3. Start Clean — Preparing the Kernel Source Tree

Before generating a config, especially if you are working in a source tree that was previously built, you should start from a clean state. The kernel provides commands for this:

# Removes ALL generated files including .config
# Use when starting completely from scratch
make mrproper

# Even more thorough — also removes editor backup files
make distclean

# Lighter clean — keeps .config but removes compiled objects
make clean

cp .config ~/backup-kernel.config

4. Generating Your First Config with make localmodconfig

If you are building the kernel for your own development machine, the fastest and most practical way to generate a starting .config is make localmodconfig. This target looks at what kernel modules are currently loaded on your running system and generates a config that includes only those — nothing unnecessary.

Your running system already knows exactly what hardware it needs. localmodconfig captures that knowledge as a config file.

Step 1 — Capture the Currently Loaded Modules

# lsmod lists all currently loaded kernel modules
# Save this list to a file
lsmod > /tmp/lsmod.now

# Verify it captured something
wc -l /tmp/lsmod.now

Step 2 — Generate the Config from Your Module List

# Point kbuild at your module list and generate .config
make LSMOD=/tmp/lsmod.now localmodconfig

When you run this, kbuild reads the running kernel’s existing config (found at /boot/config-$(uname -r)) and trims it down to match your loaded modules. For any new options that did not exist in the old config, it prompts you with a (NEW) marker. Simply press Enter to accept the default.

Here is a representative sample of the output you will see. The full output is much longer — this shows the important patterns:

$ make LSMOD=/tmp/lsmod.now localmodconfig

*
* General setup
*
Compile also drivers which will not load (COMPILE_TEST) [N/y/?] n
Local version (LOCALVERSION) []
Kernel compression mode
  1. Gzip (KERNEL_GZIP)
  2. Bzip2 (KERNEL_BZIP2)
  3. XZ  (KERNEL_XZ)
  4. LZ4 (KERNEL_LZ4)
choice[1-4?]: 1
...
Enable userfaultfd() system call (USERFAULTFD) [Y/n/?] y
Enable rseq() system call (RSEQ) [Y/n/?] (NEW)   <-- press Enter
...
#
# configuration written to .config
#

$ ls -lh .config
-rw-r--r-- 1 user user 140K Jun 20 10:31 .config

Cross-Machine localmodconfig for Embedded Targets

A powerful feature for embedded Linux developers: you can generate a localmodconfig for a different target board. Run lsmod on the target, transfer the file to your build host, and generate a matching config there.

# On the target board:
lsmod > /tmp/target-modules.txt
scp /tmp/target-modules.txt buildhost:/tmp/

# On the build host (cross-compile scenario):
make LSMOD=/tmp/target-modules.txt localmodconfig

# Preserve specific subsystems even if not in the lsmod list:
make LSMOD=/tmp/target-modules.txt \
     LMC_KEEP="drivers/usb:drivers/gpu:fs" \
     localmodconfig

5. All Kernel Configuration Tools Compared

The kernel provides five different ways to view and edit the .config file. They all produce the same .config output — they just offer different user interfaces. As a student of this free Linux kernel development course, you should know all of them.

6. Fine-Tuning Kernel Config with make menuconfig

Once you have a starting .config from localmodconfig or another source, use make menuconfig to browse and modify it visually. This is the core workflow skill for anyone doing Linux kernel development or writing Linux device drivers.

Install the Required Dependency

# Debian / Ubuntu / Linux Mint:
sudo apt-get install libncurses-dev

# Fedora / RHEL / Rocky Linux:
sudo dnf install ncurses-devel

# Arch Linux:
sudo pacman -S ncurses

Launch menuconfig

# From the root of the kernel source tree:
make menuconfig

# For a specific architecture (cross-compile / embedded):
make ARCH=arm64 menuconfig
make ARCH=arm menuconfig

The first time you run this, kbuild compiles a helper C program called mconf inside the kernel tree. This only happens once:

UPD  scripts/kconfig/.mconf-cfg
HOSTCC scripts/kconfig/mconf.o
HOSTCC scripts/kconfig/lxdialog/checklist.o
HOSTCC scripts/kconfig/lxdialog/menubox.o
HOSTCC scripts/kconfig/lxdialog/inputbox.o
HOSTLD  scripts/kconfig/mconf
scripts/kconfig/mconf  Kconfig

After that, the colorful menu screen appears immediately. Here is a representation of what the top-level menu looks like:

Keyboard Navigation Reference

How to Search for a Config Option in menuconfig

This is one of the most useful skills in the entire free Linux kernel development course. When you know the name of a config symbol but not which submenu it lives under, use the built-in search:

# While inside menuconfig, press the / key
# Type your search term — example: USB_SERIAL
# menuconfig shows the option, its current value,
# its exact menu location, and all its dependencies

Search results show you the exact path through the menu tree where the option lives, so you can navigate directly to it. This saves enormous time when dealing with the thousands of options a real kernel has.

7. Other Important Config Targets Every Developer Should Know

Beyond localmodconfig and menuconfig, the kbuild system provides many more configuration targets essential for real-world free Linux device drivers development and embedded work.

# Start from the architecture's default configuration
make defconfig

# Like localmodconfig but sets all modules to built-in (=y)
# Ideal for embedded systems where you want everything baked in
make localyesconfig

# Update an existing .config for a new kernel version interactively
# Asks you about each NEW option added since your old config was made
make oldconfig

# Same as oldconfig but automatically accepts the default
# Best for automated CI builds or quick upgrades
make olddefconfig

# Produce the absolute smallest possible kernel (research/testing only)
make tinyconfig

# Add settings optimized for running Linux inside a KVM virtual machine
make kvm_guest.config

8. Common Mistakes Beginners Make in Kernel Configuration

9. Best Practices for Kernel Configuration

10. Under the Hood — How Kconfig Works Internally

Every directory in the kernel source tree contains a Kconfig file. These files define the configuration options for that subsystem, their names, types, descriptions, dependencies, and defaults. When you run make menuconfig, kbuild reads all these files recursively and assembles the menu tree you see on screen.

When you save and exit, your choices go into .config. Before compilation starts, the build system generates two intermediate files that the C compiler and Makefiles actually use:

include/generated/autoconf.h
# C header auto-included in every kernel C file.
# CONFIG_SYSVIPC=y in .config becomes:
#   #define CONFIG_SYSVIPC 1

include/config/auto.conf
# Makefile fragment used by the build system.
# CONFIG_USB_SERIAL=m expands to: obj-m += usb-serial.o

This is how kernel developers write conditionally compiled code:

#ifdef CONFIG_SYSVIPC
    ipc_init();   /* only compiled when CONFIG_SYSVIPC=y */
#endif

/* IS_ENABLED() works for both =y and =m */
if (IS_ENABLED(CONFIG_USB_SERIAL)) {
    /* runs when USB serial is configured */
}

11. Quick Command Reference Card

# CLEAN THE SOURCE TREE
make mrproper          # Full clean, removes .config too
make distclean         # mrproper + removes editor backup files
make clean             # Remove objects only, keep .config

# GENERATE A STARTING .config
lsmod > /tmp/lsmod.now
make LSMOD=/tmp/lsmod.now localmodconfig   # Based on running system
make defconfig                              # Architecture defaults
make tinyconfig                             # Absolute minimum kernel

# BROWSE AND EDIT THE .config
make menuconfig        # Text menus (ncurses) — recommended
make nconfig           # Enhanced text menus with F-key shortcuts
make xconfig           # Qt-based graphical UI
make gconfig           # GTK-based graphical UI

# UPDATE .config FOR A NEWER KERNEL VERSION
make oldconfig         # Interactive — asks about new options
make olddefconfig      # Auto-accept defaults for new options

# SPECIAL TARGETS
make localyesconfig    # Like localmodconfig but =y instead of =m
make kvm_guest.config  # Optimized for KVM guest kernel
make xen.config        # Optimized for Xen dom0 guest

12. Summary and Key Takeaways

Frequently Asked Questions — Linux Kernel Configuration