Detailed explanation of the bootloader execution process and ARM Linux boot process analysis

This article explores the ARM Linux boot process, focusing on how embedded Linux operates across various electronic devices. Due to its portability, Linux is widely used in different architectures, and the boot process varies depending on the processor type.

The S3C2410 ARM processor serves as a case study to analyze the bootloader execution flow and the startup sequence of ARM Linux after system power-on.

1. Introduction

Linux was initially developed by Linus Torvalds in 1991 at the University of Helsinki in Sweden. With the support of the GNU project, Linux has grown into a powerful open-source operating system. While it may not be as popular as Windows on desktops, Linux has gained significant traction in the embedded world, offering new opportunities for developers.

An embedded Linux system typically consists of four main components from a software perspective: the bootloader, the Linux kernel, the root file system, and the application layer.

The bootloader is the first program executed after the system starts or resets. It initializes the hardware and then loads the Linux kernel into memory. Once the kernel is loaded, it mounts the root file system, which contains essential configuration files, libraries, and tools needed for applications.

Applications are the core of an embedded system, defining its purpose and functionality. Without proper application support, even the best-designed hardware lacks practical value. Understanding the roles of the bootloader and the kernel is crucial for effective embedded development.

Bootloaders play a key role in initializing the system and launching the kernel. Their primary function is to load and execute the Linux kernel. In embedded development, a significant amount of effort goes into developing and porting both the bootloader and the kernel.

A clear understanding of the bootloader and kernel boot processes can greatly improve the efficiency of embedded system development. This article provides an in-depth look at these processes.

2. Bootloader

(1) Definition and Role of Bootloader

A bootloader is the first program that runs when an embedded system powers on. It is similar to BIOS on a PC. After initializing the system, it copies the Linux kernel from non-volatile memory (such as Flash) into RAM and then jumps to the kernel’s entry point to start it. Understanding the bootloader is essential for grasping the full boot sequence of an embedded system.

(2) Bootloader Execution Process

Different processors have different starting addresses. For an ARM processor, this address is 0x00000000. Flash memory is usually mapped to this address, and the bootloader is located at the beginning of the memory. Depending on the type of Flash used, the bootloader’s execution process may vary.

Flash is divided into NOR and NAND types. NOR Flash supports in-place execution (XIP), allowing code to run directly from Flash without copying to RAM. NAND Flash requires code to be copied to RAM before execution.

Bootloaders can be simple or complex, depending on their intended functions. They often include tasks like initializing RAM, setting up the serial port for debugging, detecting the processor type, and passing boot parameters to the kernel.

To call the Linux kernel, the bootloader must initialize RAM, set up the serial port, detect the processor type, and pass the necessary boot parameters. These steps ensure the kernel can start properly.

3. Linux Kernel Startup Process

After the bootloader copies the kernel to RAM, it calls the Linux kernel using the function call_linux(0, machine_type, kernel_params_base). The machine_type is detected by the bootloader, and kernel_params_base is the address of the boot parameters in RAM.

The Linux kernel comes in two forms: an uncompressed Image and a compressed zImage. zImage is smaller but requires decompression before execution. Most embedded systems use zImage due to storage constraints.

For ARM processors, the zImage entry is located in arch/arm/boot/compressed/head.S, which handles MMU setup, decompression, and kernel execution.

(1) Kernel Entry Point

The entry point for an uncompressed kernel is in /arch/arm/kernel/head-armv.S. The bootloader jumps to this location after copying the kernel to RAM. The kernel performs architecture-specific initialization, builds the page table, and calls start_kernel() to begin the initialization process.

(2) start_kernel() Function

start_kernel() is the main initialization function for the Linux kernel. It sets up the architecture-specific environment, initializes memory management, creates the exception vector table, and starts the scheduler.

It also initializes the serial console, memory management, and inter-process communication mechanisms. Finally, it spawns the init process, which mounts the root file system and executes user-defined commands.

When all initialization is complete, the system enters an idle state with the cpu_idle() function, waiting for user processes to run. At this point, the Linux kernel is fully booted.

4. Conclusion

Linux is a large and complex project that has evolved significantly over the years. While understanding every detail is challenging, embedded developers don’t need to know everything about the kernel. By modifying hardware-related parts, Linux can be successfully ported to new platforms.

Analyzing the boot process helps identify hardware dependencies and internal kernel functions, making the porting process more efficient. The modular design of Linux further simplifies this task.