Embedded Linux Systems Guide — Buildroot, Yocto & Kernel Configuration for Embedded Devices
In this tutorial, you'll learn about Embedded Linux Systems Guide. We cover key concepts, practical examples, and best practices to help you understand and apply this topic effectively.
Embedded Linux adapts the Linux kernel and userspace to resource-constrained devices like routers, IoT sensors, smart cameras, and industrial controllers, balancing functionality against limited CPU, memory, and storage.
What You'll Learn & Why It Matters
In this tutorial, you'll learn how to build embedded Linux systems: setting up cross-compilation toolchains, using Buildroot and Yocto to generate complete firmware images, configuring the kernel for specific hardware, writing device tree files for ARM/RISC-V boards, bootloaders like U-Boot, and optimizing for flash storage and real-time requirements.
Real-world use: A smart thermostat runs Linux on an ARM Cortex-A processor with 256 MB RAM and 512 MB flash. The kernel is stripped of unused drivers. The filesystem uses UBIFS for reliability on NAND flash. The web server is lighttpd, not Apache. Durga Antivirus Pro's hardware security module runs an embedded Linux variant optimized for real-time packet inspection.
graph TD
subgraph "Host Build Machine"
TC[Cross-Compiler
arm-linux-gnueabihf-]
BR[Buildroot / Yocto]
KERN[Kernel Build]
DT[Device Tree
.dts -> .dtb]
end
subgraph "Target Device"
BL[Bootloader
U-Boot]
KERN_T[Kernel zImage]
DT_T[Device Tree Blob]
ROOTFS[Root Filesystem
SquashFS / UBIFS]
APP[Application]
end
TC --> KERN
TC --> BR
DT --> DT_T
KERN --> KERN_T
BR --> ROOTFS
KERN_T --> BL --> DT_T --> ROOTFS --> APP
Cross-Compilation Setup
Embedded targets typically cannot compile software themselves (too slow, no compiler). You build on a powerful x86 host for an ARM/AArch64/RISC-V target.
# Install cross-compilation toolchain (ARM 32-bit)
sudo apt install gcc-arm-linux-gnueabihf binutils-arm-linux-gnueabihf
# Verify
arm-linux-gnueabihf-gcc --version
arm-linux-gnueabihf-objdump --version
# Cross-compile a simple C program
cat > hello_embedded.c << 'EOF'
#include <stdio.h>
#include <unistd.h>
int main() {
printf("Hello from Embedded Linux!\n");
printf("Running on: ");
fflush(stdout);
/* Print machine info */
FILE *cpuinfo = fopen("/proc/cpuinfo", "r");
if (cpuinfo) {
char line[256];
while (fgets(line, sizeof(line), cpuinfo)) {
if (strstr(line, "model name") || strstr(line, "Hardware")) {
printf("%s", line);
break;
}
}
fclose(cpuinfo);
}
printf("Uptime: %ld seconds\n", sysconf(_SC_CLK_TCK));
return 0;
}
EOF
arm-linux-gnueabihf-gcc -static -o hello_embedded hello_embedded.c
# Check the resulting binary
file hello_embedded
Expected output:
hello_embedded: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, not stripped
Buildroot Minimal System
Buildroot generates a complete embedded Linux system (kernel, rootfs, bootloader) from source.
import os
import textwrap
class BuildrootConfig:
"""Simulate Buildroot system configuration"""
def __init__(self, target_arch='arm', board_name='raspberrypi3'):
self.target_arch = target_arch
self.board_name = board_name
self.config = {}
self.packages = []
self._set_defaults()
def _set_defaults(self):
self.config = {
'BR2_arm': 'y' if self.target_arch == 'arm' else '',
'BR2_cortex_a7': 'y',
'BR2_TOOLCHAIN_EXTERNAL': 'y',
'BR2_TARGET_GENERIC_HOSTNAME': f'embedded-{self.board_name}',
'BR2_TARGET_GENERIC_ISSUE': 'Welcome to Embedded Linux',
'BR2_ROOTFS_OVERLAY': 'board/overlay',
'BR2_ROOTFS_POST_BUILD_SCRIPT': 'board/post-build.sh',
'BR2_LINUX_KERNEL': 'y',
'BR2_LINUX_KERNEL_VERSION': '6.1.30',
'BR2_LINUX_KERNEL_DEFCONFIG': 'bcm2709',
'BR2_PACKAGE_BUSYBOX': 'y',
'BR2_TARGET_ROOTFS_SQUASHFS': 'y',
'BR2_TARGET_ROOTFS_EXT2': 'y',
'BR2_TARGET_ROOTFS_EXT2_SIZE': '256M',
'BR2_PACKAGE_DROPBEAR': 'y', # SSH server
'BR2_PACKAGE_LIGHTTPD': 'y', # Lightweight web server
}
def add_package(self, name, config_options=None):
package = {
'name': name,
'config_options': config_options or {},
'selected': True,
}
self.packages.append(package)
self.config[f'BR2_PACKAGE_{name.upper()}'] = 'y'
if config_options:
for key, value in config_options.items():
self.config[f'BR2_PACKAGE_{name.upper()}_{key.upper()}'] = value
def generate_config(self):
print(f'Buildroot Configuration for {self.board_name} ({self.target_arch})')
print('=' * 55)
print(f'Target options:')
print(f' Architecture: {self.target_arch}')
print(f' Board: {self.board_name}')
print(f' Hostname: {self.config["BR2_TARGET_GENERIC_HOSTNAME"]}')
print(f' Kernel version: {self.config["BR2_LINUX_KERNEL_VERSION"]}')
print(f'\nFilesystem:')
print(f' SquashFS: {self.config["BR2_TARGET_ROOTFS_SQUASHFS"]}')
print(f' ext2 size: {self.config["BR2_TARGET_ROOTFS_EXT2_SIZE"]}')
print(f'\nSelected packages ({len(self.packages)}):')
for pkg in self.packages:
print(f' - {pkg["name"]}')
print(f'\nRun: make -j$(nproc)')
return True
def build_summary(self):
print(f'\nBuild output:')
print(f' output/images/zImage — Kernel')
print(f' output/images/rootfs.squashfs — Root filesystem')
print(f' output/images/rootfs.ext2 — ext2 rootfs (debug)')
print(f' output/build/ — Built packages')
print(f' Total image size: ~32 MB')
br = BuildrootConfig('arm', 'raspberrypi3')
br.add_package('busybox')
br.add_package('dropbear', {'version': '2022.83'})
br.add_package('lighttpd')
br.add_package('libcurl')
br.add_package('openssl')
br.add_package('i2c-tools')
br.generate_config()
br.build_summary()
Expected output:
Buildroot Configuration for raspberrypi3 (arm)
=======================================================
Target options:
Architecture: arm
Board: raspberrypi3
Hostname: embedded-raspberrypi3
Kernel version: 6.1.30
Filesystem:
SquashFS: y
ext2 size: 256M
Selected packages (6):
- busybox
- dropbear
- lighttpd
- libcurl
- openssl
- i2c-tools
Run: make -j$(nproc)
Build output:
output/images/zImage — Kernel
output/images/rootfs.squashfs — Root filesystem
output/images/rootfs.ext2 — ext2 rootfs (debug)
output/build/ — Built packages
Total image size: ~32 MB
Device Tree
The device tree describes the hardware to the kernel — which devices exist, their memory addresses, interrupts, and configuration.
// minimal.dts — Minimal Device Tree for an ARM board
/dts-v1/;
/ {
compatible = "dodatech,embedded-board", "arm,vexpress";
model = "DodaTech Embedded Development Board";
#address-cells = <1>;
#size-cells = <1>;
/* Main memory: 256 MB */
memory@60000000 {
device_type = "memory";
reg = <0x60000000 0x10000000>;
};
/* CPU: ARM Cortex-A7 single core */
cpus {
#address-cells = <1>;
#size-cells = <0>;
cpu@0 {
compatible = "arm,cortex-a7";
device_type = "cpu";
reg = <0>;
clock-frequency = <800000000>;
};
};
/* UART serial port */
uart@1c090000 {
compatible = "arm,pl011", "arm,primecell";
reg = <0x1c090000 0x1000>;
interrupts = <0 37 4>;
clock-frequency = <24000000>;
status = "okay";
};
/* I2C controller */
i2c@1c0a0000 {
compatible = "arm,versatile-i2c";
reg = <0x1c0a0000 0x1000>;
#address-cells = <1>;
#size-cells = <0>;
clock-frequency = <100000>;
status = "okay";
/* Temperature sensor */
temperature@48 {
compatible = "lm75";
reg = <0x48>;
};
/* EEPROM */
eeprom@50 {
compatible = "at24,24c02";
reg = <0x50>;
pagesize = <8>;
size = <256>;
};
};
/* GPIO controller */
gpio@1c0b0000 {
compatible = "arm,pl061", "arm,primecell";
reg = <0x1c0b0000 0x1000>;
gpio-controller;
#gpio-cells = <2>;
interrupts = <0 38 4>;
status = "okay";
};
/* SPI flash */
spi@1c0c0000 {
compatible = "arm,pl022", "arm,primecell";
reg = <0x1c0c0000 0x1000>;
interrupts = <0 39 4>;
#address-cells = <1>;
#size-cells = <0>;
status = "okay";
flash@0 {
compatible = "jedec,spi-nor";
reg = <0>;
spi-max-frequency = <50000000>;
#address-cells = <1>;
#size-cells = <1>;
partition@0 {
label = "bootloader";
reg = <0x0 0x100000>; /* 1 MB for U-Boot */
};
partition@1 {
label = "kernel";
reg = <0x100000 0x400000>; /* 4 MB for kernel */
};
partition@2 {
label = "rootfs";
reg = <0x500000 0x1b00000>; /* ~27 MB for rootfs */
};
};
};
/* Watchdog timer */
watchdog@1c0d0000 {
compatible = "arm,sp805", "arm,primecell";
reg = <0x1c0d0000 0x1000>;
interrupts = <0 40 4>;
timeout-sec = <60>;
status = "okay";
};
/* LEDs */
leds {
compatible = "gpio-leds";
led-0 {
label = "status:green";
gpios = <&gpio 0 1>; /* GPIO0, active low */
linux,default-trigger = "heartbeat";
};
led-1 {
label = "error:red";
gpios = <&gpio 1 1>; /* GPIO1, active low */
linux,default-trigger = "none";
};
};
};
# Compile device tree source to binary blob
dtc -I dts -O dtb -o minimal.dtb minimal.dts
# Decompile an existing device tree blob back to source
dtc -I dtb -O dts -o decompiled.dts /sys/firmware/devicetree/base/fdt
# View the device tree on a running system
ls /sys/firmware/devicetree/base/
# Check which compatible strings the kernel uses
cat /proc/device-tree/compatible
strings /proc/device-tree/compatible | tr '\0' '\n'
Expected output:
model memory cpus uart i2c gpio spi watchdog leds
U-Boot Bootloader
Das U-Boot is the standard bootloader for embedded Linux devices.
# U-Boot commands (simulated on target console)
echo "U-Boot 2024.01 (embedded) console:"
# Inspect memory
md.l 0x60000000 10
# Load kernel from MMC
fatload mmc 0:1 0x60000000 zImage
fatload mmc 0:1 0x68000000 minimal.dtb
# Set kernel command line
setenv bootargs console=ttyAMA0,115200 root=/dev/mmcblk0p2 rw rootwait
# Boot
bootz 0x60000000 - 0x68000000
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Simulated U-Boot commands */
typedef struct {
unsigned long load_addr;
unsigned long dtb_addr;
char *kernel_file;
char *dtb_file;
char *bootargs;
} uboot_env_t;
void uboot_shell(uboot_env_t *env) {
printf("U-Boot 2024.01 (embedded)\n");
printf("Board: DodaTech Embedded Board\n");
printf("DRAM: 256 MiB\n");
printf("MMC: mmc@1c0e0000: 0, mmc@1c0f0000: 1\n");
printf("Flash: SPI NOR (32 MiB)\n");
printf("Net: eth@1c100000\n\n");
printf("=> mmc dev 0\n");
printf("switch to partitions #0, OK\n");
printf("mmc0 is current device\n");
printf("\n=> fatload mmc 0:1 0x60000000 %s\n", env->kernel_file);
printf("reading %s\n", env->kernel_file);
printf("7864320 bytes read in 245 ms (30.6 MiB/s)\n");
printf("\n=> fatload mmc 0:1 0x68000000 %s\n", env->dtb_file);
printf("reading %s\n", env->dtb_file);
printf("24576 bytes read in 5 ms (4.7 MiB/s)\n");
printf("\n=> setenv bootargs %s\n", env->bootargs);
printf("\n=> bootz 0x60000000 - 0x68000000\n");
printf("## Flattened Device Tree blob at 68000000\n");
printf(" Booting using the fdt blob at 0x68000000\n");
printf(" Loading Device Tree to 6fff2000, end 6fffffff ... OK\n");
printf("\nStarting kernel ...\n");
printf("[ 0.000000] Booting Linux on physical CPU 0x0\n");
}
uboot_env_t env = {
.load_addr = 0x60000000,
.dtb_addr = 0x68000000,
.kernel_file = "zImage",
.dtb_file = "minimal.dtb",
.bootargs = "console=ttyAMA0,115200 root=/dev/mmcblk0p2 rw rootwait",
};
uboot_shell(&env);
Expected output:
U-Boot 2024.01 (embedded)
Board: DodaTech Embedded Board
DRAM: 256 MiB
MMC: mmc@1c0e0000: 0, mmc@1c0f0000: 1
Flash: SPI NOR (32 MiB)
Net: eth@1c100000
=> mmc dev 0
switch to partitions #0, OK
mmc0 is current device
=> fatload mmc 0:1 0x60000000 zImage
reading zImage
7864320 bytes read in 245 ms (30.6 MiB/s)
=> fatload mmc 0:1 0x68000000 minimal.dtb
reading minimal.dtb
24576 bytes read in 5 ms (4.7 MiB/s)
=> setenv bootargs console=ttyAMA0,115200 root=/dev/mmcblk0p2 rw rootwait
=> bootz 0x60000000 - 0x68000000
## Flattened Device Tree blob at 68000000
Booting using the fdt blob at 0x68000000
Loading Device Tree to 6fff2000, end 6fffffff ... OK
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
Real-Time Linux (PREEMPT_RT)
Embedded Systems often require real-time guarantees. Linux's PREEMPT_RT patch set makes the kernel fully preemptible.
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sched.h>
#include <time.h>
#include <unistd.h>
#include <sys/mman.h>
/* Real-time task with PREEMPT_RT: measure jitter */
#define NSEC_PER_SEC 1000000000L
static inline long timespec_diff_ns(struct timespec *start,
struct timespec *end) {
return (end->tv_sec - start->tv_sec) * NSEC_PER_SEC +
(end->tv_nsec - start->tv_nsec);
}
void *rt_task(void *arg) {
struct sched_param param;
param.sched_priority = 80;
pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
/* Lock memory to prevent page faults */
mlockall(MCL_CURRENT | MCL_FUTURE);
struct timespec next, now;
long period_ns = 1000000; /* 1 ms period */
long max_jitter = 0;
long missed = 0;
clock_gettime(CLOCK_MONOTONIC, &next);
printf("[RT-Task] Started, period=%ld us\n", period_ns / 1000);
for (int i = 0; i < 1000; i++) {
/* Sleep until next period */
next.tv_nsec += period_ns;
if (next.tv_nsec >= NSEC_PER_SEC) {
next.tv_sec++;
next.tv_nsec -= NSEC_PER_SEC;
}
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL);
/* Measure jitter */
clock_gettime(CLOCK_MONOTONIC, &now);
long jitter = timespec_diff_ns(&next, &now);
if (jitter > max_jitter)
max_jitter = jitter;
if (jitter > period_ns / 2)
missed++;
/* Simulate work: read sensor, process data */
volatile int dummy = 0;
for (int j = 0; j < 100; j++)
dummy += j;
}
printf("[RT-Task] Completed: max_jitter=%ld ns, missed=%ld\n",
max_jitter, missed);
return NULL;
}
int main() {
pthread_t rt_thread;
printf("PREEMPT_RT real-time task test\n");
pthread_create(&rt_thread, NULL, rt_task, NULL);
pthread_join(rt_thread, NULL);
printf("Done.\n");
return 0;
}
Expected output:
PREEMPT_RT real-time task test
[RT-Task] Started, period=1000 us
[RT-Task] Completed: max_jitter=4532 ns, missed=0
Done.
Common Mistakes
1. Not Stripping the Kernel
A default kernel build includes all drivers and features. A generic x86 kernel is ~50 MB. An embedded kernel should be ~3-5 MB. Configure with make menuconfig and disable unused drivers.
2. Using ext4 on NAND Flash Without Wear Leveling
ext4 on raw NAND flash causes rapid wear (cells die after ~10K writes). Use UBIFS (UBI filesystem) on top of UBI (unsorted block images), which provides wear leveling and bad block management.
3. Forgetting to Set Console Parameters
Without console=ttyAMA0,115200 in bootargs, the kernel sends no output to the serial port. The system boots but appears dead. Always configure the correct console for your board.
4. Cross-Compiling with Wrong ABI
ARM has multiple ABIs: OABI (old), EABI, hard-float (gnueabihf), soft-float (gnueabi). A hard-float binary crashes on a soft-float kernel. Use readelf -A to check the binary's ABI.
5. Not Configuring initramfs for Storage Drivers
If the root filesystem is on MMC, but initramfs only includes SATA drivers, the kernel can't mount root. Include the correct MMC/SDIO drivers in initramfs or build them into the kernel.
6. Ignoring Flash Write Endurance
Logging to a JFFS2 filesystem on NOR flash writes the same blocks repeatedly. Use a RAM-backed tmpfs for logs and syncing to flash only periodically. On UBIFS, enable compression to reduce wear.
Practice Questions
1. What is the difference between Buildroot and Yocto? Buildroot is simpler — it generates a single root filesystem and kernel image with makefile-based configuration. Yocto is more complex but more flexible — it uses BitBake recipes and layers to build custom Linux distributions with package management (RPM/deb), SDK generation, and board support packages.
2. What problem does the device tree solve? Before device trees, ARM Linux used board files — C source files describing the hardware, compiled into the kernel. Each board required a kernel rebuild. Device trees separate hardware description from kernel code, allowing one kernel binary to boot many boards by loading the appropriate .dtb at boot.
3. Why do Embedded Systems often use SquashFS or UBIFS instead of ext4? SquashFS is a compressed, read-only filesystem — ideal for immutable rootfs on flash (smaller image, no writes). UBIFS provides wear leveling and bad block management for NAND flash. ext4 expects a block device with an FTL (like eMMC) and performs poorly on raw NAND.
4. Challenge: Create a minimal embedded Linux system for a simulated ARM device. Write a device tree with a CPU, UART, I2C temp sensor, and 3 SPI flash partitions (bootloader, kernel, rootfs). Describe the boot sequence in a U-Boot script.
5. Real-World Task: If you have a Raspberry Pi, install Buildroot and build a minimal system: make raspberrypi3_defconfig && make -j4. Flash the output to an SD card and boot. Measure the boot time. Then remove packages and optimize the kernel config to reduce boot time by 30%.
Mini Project: Embedded System Simulator
import time
import random
class EmbeddedSystemSimulator:
"""Simulate an embedded Linux device"""
def __init__(self, name='sensor-node', flash_mb=64, ram_mb=256):
self.name = name
self.flash_mb = flash_mb
self.ram_mb = ram_mb
self.cpu_freq_mhz = 800
self.temperature = 25.0
self.uptime = 0
self.services = {}
self.fs_usage = 0
def boot(self):
print(f'[{self.name}] Power on')
print(f'[{self.name}] U-Boot loading...', end=' ')
time.sleep(0.2)
print('OK')
print(f'[{self.name}] Kernel decompress...', end=' ')
time.sleep(0.3)
print('OK')
print(f'[{self.name}] Mount rootfs (SquashFS)...', end=' ')
time.sleep(0.1)
print('OK')
self.services = {
'system-logger': {'state': 'running', 'mem_kb': 512},
'sensor-reader': {'state': 'running', 'mem_kb': 256},
'web-server': {'state': 'running', 'mem_kb': 1024},
'watchdog': {'state': 'running', 'mem_kb': 128},
}
total_mem = sum(s['mem_kb'] for s in self.services.values())
self.fs_usage = 18 * 1024 # 18 MB
print(f'[{self.name}] Started {len(self.services)} services '
f'({total_mem} KB RAM)')
print(f'[{self.name}] Boot complete\n')
def read_temperature(self):
self.temperature += random.uniform(-0.5, 0.5)
self.temperature = max(15, min(85, self.temperature))
return round(self.temperature, 1)
def memory_stats(self):
used = sum(s['mem_kb'] for s in self.services.values())
free_kb = self.ram_mb * 1024 - used
return {
'total_kb': self.ram_mb * 1024,
'used_kb': used,
'free_kb': free_kb,
'util_pct': round(used / (self.ram_mb * 1024) * 100, 1),
}
def flash_stats(self):
total_kb = self.flash_mb * 1024
return {
'total_kb': total_kb,
'used_kb': self.fs_usage,
'free_kb': total_kb - self.fs_usage,
'util_pct': round(self.fs_usage / total_kb * 100, 1),
}
def tick(self, seconds=1):
self.uptime += seconds
mem = self.memory_stats()
print(f't={self.uptime:4d}s | '
f'temp={self.read_temperature():.1f}C | '
f'RAM {mem["util_pct"]:.0f}% | '
f'Flash {self.flash_stats()["util_pct"]:.0f}% | '
f'Services: {len(self.services)}')
sensor = EmbeddedSystemSimulator('temp-sensor-01')
sensor.boot()
print('Running (5 ticks):')
for _ in range(5):
sensor.tick(5)
time.sleep(0.2)
Expected output:
[temp-sensor-01] Power on
[temp-sensor-01] U-Boot loading... OK
[temp-sensor-01] Kernel decompress... OK
[temp-sensor-01] Mount rootfs (SquashFS)... OK
[temp-sensor-01] Started 4 services (1920 KB RAM)
[temp-sensor-01] Boot complete
Running (5 ticks):
t= 5s | temp=25.3C | RAM 1% | Flash 28% | Services: 4
t= 10s | temp=25.1C | RAM 1% | Flash 28% | Services: 4
t= 15s | temp=25.8C | RAM 1% | Flash 28% | Services: 4
...
FAQ
Related Concepts
What's Next
You now understand embedded Linux systems. Next, explore real-time operating systems for deterministic scheduling, or revisit Linux kernel modules to write drivers for embedded hardware.
- Practice daily — If you have a Raspberry Pi or similar board, compile a custom kernel and measure the size difference from the stock kernel.
- Build a project — Set up Buildroot for a QEMU ARM target and build a system that boots to a shell with networking.
- Explore related topics — Study Zephyr RTOS for MCU-based Embedded Systems that don't need Linux.
Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.
Built by the developers of DodaTech
Doda Browser, DodaZIP & Durga Antivirus Pro