Raspberry Pi Bare Bones: Difference between revisions

 

== Building a Cross-Compiler ==

 

The first thing you should do is set up a [[GCC Cross-Compiler]] for '''arm-none-eabi'''. You have not yet modified your compiler to know about the existence of your operating system, so we use a generic target called arm-none-eabi, which provides you with a toolchain targeting the [[System V ABI]].

 

The environment is set up and execution to _start transferred from [https://github.com/raspberrypi/tools/blob/master/armstubs/armstub.S#L35 armstub.s].

// AArch32 mode

 

wfe

b halt

 

The section ".text.boot" will be used in the linker script to place the boot.S as the very first thing in our kernel image. The code initializes a minimum C environment, which means having a stack and zeroing the BSS segment, before calling the kernel_main function. Note that the code avoids using r0-r2 so the remain valid for the kernel_main call.

You can then assemble boot.S using:

 

arm-none-eabi-gcc -mcpu=arm1176jzf-s -fpic -ffreestanding -c boot.S -o boot.o

 

===Pi 2===

 

The environment is set up and execution to _start transferred from [https://github.com/raspberrypi/tools/blob/master/armstubs/armstub7.S#L167 armstub7.s].

// AArch32 mode

 

wfe

b halt

 

You can assemble boot.S using:

 

arm-none-eabi-gcc -mcpu=cortex-a7 -fpic -ffreestanding -c boot.S -o boot.o

 

===Pi 3, 4===

 

The environment is set up and execution to _start transferred from [https://github.com/raspberrypi/tools/blob/master/armstubs/armstub8.S#L154 armstub8.s].

// AArch64 mode

 

ldr x5, =__bss_start

ldr w6, =__bss_size

str xzr, [x5], #8

sub w6, w6, #1

 

// jump to C code, should not return

 

Compile your code with:

 

aarch64-elf-as -c boot.S -o boot.o

 

== Implementing the Kernel ==

The following shows how to create a simple kernel in C. Please take a few moments to understand the code. To set the value for "int raspi" in run-time, see [[Detecting_Raspberry_Pi_Board|detecting the board type]].

 

#include <stddef.h>

#include <stdint.h>

};

 

{

// Disable UART0.

mmio_write(UART0_CR, 0x00000000);

#endif

{

uart_puts("Hello, kernel World!\r\n");

 

uart_putc(uart_getc());

}

 

The GPU bootloader passes arguments to the AArch32 kernel via r0-r2 and the boot.S makes sure to preserve those 3 registers. They are the first 3 arguments in a C function call. The argument r0 contains a code for the device the RPi was booted from. This is generally 0 but its actual value depends on the firmware of the board. r1 contains the 'ARM Linux Machine Type' which for the RPi is 3138 (0xc42) identifying the BCM2708 CPU. A full list of ARM Machine Types is available from [http://www.arm.linux.org.uk/developer/machines/ here]. r2 contains the address of the ATAGs.

Compile using:

 

arm-none-eabi-gcc -mcpu=arm1176jzf-s -fpic -ffreestanding -std=gnu99 -c kernel.c -o kernel.o -O2 -Wall -Wextra

 

or for 64 bit:

 

aarch64-elf-gcc -ffreestanding -c kernel.c -o kernel.o -O2 -Wall -Wextra

 

Note that the above code uses a few extensions and hence we build as the GNU version of C99.

The linker script for 64 bit mode looks exactly the same, except for the starting address.

 

ENTRY(_start)

 

__end = .;

}

 

There is a lot of text here but don't despair. The script is rather simple if you look at it bit by bit.

SECTIONS declares sections. It decides where the bits and pieces of our code and data go and also sets a few symbols that help us track the size of each section.

 

. = 0x8000;

__start = .;

 

The "." denotes the current address so the first line tells the linker to set the current address to 0x8000 (or 0x80000), where the kernel starts. The current address is automatically incremented when the linker adds data. The second line then creates a symbol "__start" and sets it to the current address.

After that sections are defined for text (code), read-only data, read-write data and BSS (0 initialized memory). Other than the name the sections are identical so lets just look at one of them:

 

__text_start = .;

.text : {

. = ALIGN(4096); /* align to page size */

__text_end = .;

 

The first line creates a __text_start symbol for the section. The second line opens a .text section for the output file which gets closed in the fifth line. Lines 3 and 4 declare what sections from the input files will be placed inside the output .text section. In our case ".text.boot" is to be placed first followed by the more general ".text". ".text.boot" is only used in boot.S and ensures that it ends up at the beginning of the kernel image. ".text" then contains all the remaining code. Any data added by the linker automatically increments the current address ("."). In line 6 we explicitly increment it so that it is aligned to a 4096 byte boundary (which is the page size for the RPi). And last line 7 creates a __text_end symbol so we know where the section ends.

What are the __text_start and __text_end for and why use page alignment? The 2 symbols can be used in the kernel source and the linker will then place the correct addresses into the binary. As an example the __bss_start and __bss_end are used in boot.S. But you can also use the symbols from C by declaring them extern first. While not required I made all sections aligned to page size. This later allows mapping them in the page tables with executable, read-only and read-write permissions without having to handle overlaps (2 sections in one page).

 

__end = .;

 

After all sections are declared the __end symbol is created. If you ever want to know how large your kernel is at runtime you can use __start and __end to find out.

You can then link your kernel using:

 

arm-none-eabi-gcc -T linker.ld -o myos.elf -ffreestanding -O2 -nostdlib boot.o kernel.o -lgcc

arm-none-eabi-objcopy myos.elf -O binary kernel7.img

 

or for 64 bit:

 

aarch64-elf-gcc -T linker.ld -o myos.elf -ffreestanding -O2 -nostdlib boot.o kernel.o -lgcc

aarch64-elf-objcopy myos.elf -O binary kernel8.img

 

== Booting the Kernel ==

Now mount the first partition from the SD card and look at it:

 

bootcode.bin fixup.dat kernel.img start.elf

cmdline.txt fixup_cd.dat kernel_cutdown.img start_cd.elf

config.txt issue.txt kernel_emergency.img

 

If you don't have a raspbian image, you can create a FAT32 partition, and [https://github.com/raspberrypi/firmware/tree/master/boot download the firmware files] from the official repository. You'll need only three files:

Your Minicom should then show the following:

 

Hello, kernel World!

 

=== Testing your operating system (QEMU) ===

With QEMU you do not need to objcopy the kernel into a plain binary; QEMU also supports ELF kernels:

 

$YOURINSTALLLOCATION/bin/qemu-system-arm -m 256 -M raspi2 -serial stdio -kernel kernel.elf

 

==== Updated Support for AArch64 (raspi2, raspi3) ====

As of QEMU 2.12 (April 2018), emulation for 64-bit ARM, ''qemu-system-aarch64'', now supports direct emulation of both Raspberry Pi 2 and 3 using the machine types '''raspi2''' and '''raspi3''', respectively. This should allow for testing of 64-bit system code.

 

qemu-system-aarch64 -M raspi3 -serial stdio -kernel kernel8.img

 

Note that in most cases, there will be few if any differences between 32-bit ARM code and 64-bit ARM, but there can be difference in the way the code behaves, in particular regarding kernel memory management. Also, some AArch64 implementations may support features not found on any of their 32-bit counterparts (e.g., cryptographic extensions, enhanced NEON SIMD support).

 

[[Category:ARM]]

[[Category:Bare bones tutorials]]

[[Category:C]]