Before you can build the kernel for ARM, you need a special compiler — one that runs on your x86 machine but produces code for an ARM processor. This is called a cross-compiler toolchain.

A toolchain is not just one tool. It is a collection of programs that work together: the C compiler (gcc), the linker (ld), the assembler (as), the object dump utility (objdump), and several others. In a cross toolchain, all of these produce output for your target architecture — not your host.

Method 1 — Quick Install via apt (Recommended)

The simplest way to get a working ARM cross-compiler on Ubuntu or Debian is through the package manager. For ARM 32-bit targets (like Raspberry Pi running a 32-bit OS):

sudo apt install crossbuild-essential-armhf

This installs the complete ARM hard-float toolchain. The tools land in /usr/bin/, which is already in your PATH — so you can use them immediately.

To verify the installation, check where the compiler lives and what version it is:

which arm-linux-gnueabihf-gcc
arm-linux-gnueabihf-gcc --version | head -n1

Method 2 — Building or Cloning a Toolchain from Source

In some situations — especially when you need a very specific GCC version or need to target a vendor-specific SoC — the packaged toolchain may not be enough. You can obtain pre-built toolchains from the ARM Developer website or build one using crosstool-NG.

When you use a toolchain that is not in your system’s default PATH, you have to tell your shell where to find it. You do this by updating the PATH variable:

# Example: adding a custom toolchain directory to PATH
export PATH=/opt/arm-toolchain/bin:$PATH

The Linux kernel build system is controlled through its Makefile. When you cross-compile, you must pass two critical variables to make. These are not optional — without them, the kernel will compile for your host machine, not your target.

How ARCH Works

The value you set for ARCH must match a directory name inside the arch/ folder of the kernel source tree. Go into any Linux kernel source and run ls arch/ — you will see directories like arm, arm64, x86, riscv, mips, etc. Each one contains architecture-specific code for that platform.

How CROSS_COMPILE Works

CROSS_COMPILE is a string prefix. The kernel’s Makefile appends tool names to this prefix when it needs to invoke compiler tools. So if you set CROSS_COMPILE=arm-linux-gnueabihf-, the build system will call:

arm-linux-gnueabihf-gcc     # C compiler
arm-linux-gnueabihf-ld      # Linker
arm-linux-gnueabihf-objcopy # Object copy tool
arm-linux-gnueabihf-strip   # Strip tool

This is why you need the toolchain directory in your PATH — the Makefile calls these tools by name, and the shell needs to be able to find them.

Before you can build, you need to configure the kernel — telling it which features to enable or disable. The Linux kernel has thousands of configurable options. Fortunately, you do not have to set all of them manually. You start from a default configuration that already works for your target board.

What is a defconfig?

A defconfig (default configuration) file is a pre-set collection of configuration options maintained by kernel developers for a specific board or SoC family. These files live inside arch/<ARCH>/configs/ in the kernel source.

When you run make <board>_defconfig, the build system reads the matching file from that directory and generates your .config file — which is the actual kernel configuration used during the build.

Cleaning Before a Fresh Build

Before configuring a new kernel, it is good practice to clean out any leftover files from a previous build. The mrproper target does a thorough clean:

make mrproper

This removes all generated files including your .config. Use it when you are starting completely fresh or switching to a different target board.

Configuring for ARM 32-bit (Raspberry Pi 2 / 3 style)

# Set ARCH and CROSS_COMPILE for ARM 32-bit
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-

# Apply a board-appropriate defconfig
make bcm2709_defconfig

Configuring for ARM 64-bit (Raspberry Pi 4 / 5 and modern boards)

# Set ARCH and CROSS_COMPILE for ARM 64-bit
export ARCH=arm64
export CROSS_COMPILE=aarch64-linux-gnu-

# Apply the generic ARM64 defconfig (works for most boards)
make defconfig

Optional: Fine-Tuning with menuconfig

After applying a defconfig, you can optionally open the interactive menu-based configurator to adjust individual settings. This is useful when you need to add a specific driver or tweak kernel parameters:

make ARCH=arm menuconfig

For most beginners, skipping this step and using the defconfig directly is perfectly fine.

With configuration done, you are ready to actually compile. The make command takes the .config you generated and builds everything.

What Are DTBs?

A Device Tree Blob (DTB) is a file that describes the hardware layout of your board to the kernel — things like where the memory is, what peripherals are connected, which interrupt lines they use, and so on. ARM boards rely heavily on device tree because the hardware is not self-describing (unlike x86 PCI). Without the correct DTB, the kernel cannot talk to your board’s hardware correctly.

Building for ARM 32-bit

make -j$(nproc) ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- zImage modules dtbs

Building for ARM 64-bit (Kernel 6.x — modern boards)

make -j$(nproc) ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- Image modules dtbs

Building the kernel is only half the job. You also need to get it onto your target device. The general process involves copying the kernel image, the DTB files, and the kernel modules to the right locations on your target’s storage.

Installing Kernel Modules

Kernel modules must be installed into the target’s root filesystem, not your host’s. This is critically important. If you install modules without specifying a path, they will overwrite your host system’s modules — which can break your host machine.

Always use the INSTALL_MOD_PATH variable to point to the target’s root filesystem mount point:

# INSTALL_MOD_PATH points to where your target's root filesystem is mounted
sudo make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- \
     INSTALL_MOD_PATH=/mnt/target-rootfs \
     modules_install

Copying DTB Files

# Copy all DTB files for your platform to the target's boot partition
sudo cp arch/arm/boot/dts/*.dtb /mnt/target-boot/

# Copy device tree overlays as well
sudo cp arch/arm/boot/dts/overlays/*.dtb* /mnt/target-boot/overlays/

sync

These questions are commonly asked in embedded Linux / kernel development interviews.