ES: The Four Elements of Embedded Linux

Building an embedded Linux system is not a single task — it is the process of obtaining, customising, and deploying four distinct elements that work together to bring a device to life. Every embedded Linux project, regardless of complexity, revolves around these same four building blocks.

The Four Elements

+--------------------------------------------+
|  Root Filesystem                           |
|  +-----------+  +----------------------+   |
|  | Application|  | System Programs      |   |
|  +-----------+  +----------------------+   |
+--------------------------------------------+
|  Linux Kernel                              |
|  +------------------+  +--------------+   |
|  | System Call Interface|  | Device Drivers|  |
|  +------------------+  +--------------+   |
|  | Process Mgmt     |  | Memory Mgmt  |   |
|  +------------------+  +--------------+   |
+--------------------------------------------+
|  Bootloader         |  Device Tree         |
+--------------------------------------------+
|  Hardware                                  |
+--------------------------------------------+

The four elements are:

1. Toolchain — the compiler and build tools
2. Bootloader — initialises hardware and loads the kernel
3. Linux Kernel — manages hardware resources and provides services
4. Root Filesystem — contains programs, configurations, and the application

Everything else depends on having all four correctly assembled.

1. Toolchain

The toolchain is the set of tools that compiles source code into executables for the target device. It is the first thing you need — without it, nothing else can be built.

A toolchain consists of:

• Compiler (GCC or Clang) — translates C/C++ source into machine code
• Linker — combines object files into executables
• Run-time libraries — C library (glibc, musl, uClibc)
• Binutils — assembler, objdump, readelf, strip

Host Machine (x86_64)
        |
        | Cross-compiler (e.g. aarch64-none-linux-gnu-gcc)
        v
Target Binary (ARM64 executable)

The toolchain is also called a cross-toolchain when the build machine (host) differs from the target architecture — which is always the case in embedded development.

2. Bootloader

The bootloader is the software executed at power-up. Its job is to initialise the hardware and load the operating system into memory.

Key responsibilities:

• Set up the CPU and memory controller
• Copy the kernel, device tree, and root filesystem into RAM
• Pass control to the first kernel instruction

Power-Up Sequence:
+------------------+
| Reset Vector     |  CPU starts here (Boot Flash)
+------------------+
        |
        v
+------------------+
| Bootloader       |  Initialises RAM, loads software
+------------------+
        |
        v
+------------------+
| Linux Kernel     |  Takes over, sets up the system
+------------------+
        |
        v
+------------------+
| Init / Application|  User space starts
+------------------+

Device Tree

The device tree is closely associated with the bootloader. It is a binary data structure that describes the physical hardware to the kernel — what peripherals exist, their memory addresses, and how they connect.

The bootloader passes the device tree blob (DTB) to the kernel at boot time, so the kernel can initialise device drivers correctly.

3. Linux Kernel

The Linux kernel is the operating system core. It manages all hardware resources and provides services to user-space programs through the system call interface.

Kernel services include:

• Process management — creating, scheduling, and terminating processes
• Memory management — virtual memory, paging, allocation
• Device drivers — hardware abstraction for I/O devices
• Filesystem — virtual filesystem layer (VFS)
• Networking — protocol stacks and network drivers
• Inter-process communication — sockets, shared memory, pipes

+----------------------------------+
|  User Space                      |
|  (Applications, System Programs) |
+----------------------------------+
         | System Calls
         v
+----------------------------------+
|  Kernel Space                    |
|  Monolithic Kernel               |
|  + Loadable Modules              |
+----------------------------------+
         | Hardware Access
         v
+----------------------------------+
|  Hardware                        |
+----------------------------------+

4. Root Filesystem

The root filesystem is the container that holds everything the running system needs after the kernel starts:

• Configuration files — how the system behaves at startup
• System programs — utilities like ls, cat, sh, daemons
• Application — the software delivering the device's end-user function
• Shared libraries — runtime dependencies
• Device nodes — entries in /dev for hardware access

System Programs

System programs provide a convenient environment for development and execution. They are the utilities in /bin, /sbin, and /usr/bin — tools like ls, chmod, cat, mount, and shell interpreters.

In embedded Linux, these are often provided by BusyBox — a single binary that implements hundreds of standard Unix utilities with a minimal footprint.

Application

The application is the reason the embedded system exists. It is the software that delivers the user-facing function — whether that is a network router managing traffic, a NAS serving files, or an in-vehicle infotainment system playing media.

Interaction Between the Four Elements

Build Time:
Toolchain --> Bootloader binary
Toolchain --> Kernel binary + DTB
Toolchain --> Root Filesystem contents

Runtime:
Bootloader --> loads Kernel + DTB
Kernel      --> mounts Root Filesystem
Root FS     --> starts init --> starts Application

Final Thoughts

Every embedded Linux project goal is the same: obtain, customise, and deploy these four elements for a target platform. Whether you are using Buildroot, Yocto, or assembling components manually, you are always working with the same four building blocks.

Mastering each element — and understanding how they interact — is the foundation of all embedded Linux engineering.