Porting the Genode OS Framework to a new hardware platform

Recently, more and more companies have shown interest in microkernel operating systems. These systems from the academic category begin to turn into the category of OS for use in real products. For example, the recently introduced Samsung Knox platform is built using the OKL4 Microvisor. It is very likely that there are many more such solutions, but not all manufacturers advertise the technologies used, since at the moment microkernel systems are mainly used in the field of information security.

A brief history of microkernel OS and a description of the most famous projects were recently described by my colleague sartakov in the article " Microkernels and FOSDEM'13 ". I want to talk more about the Genode OS Frameworkand the process of porting it to a new hardware platform based on an ARM architecture processor. I used Fiasco.OC as a kernel for Genode .



So what is the Genode OS Framework? This is a framework for building an operating system based on a microkernel. Genode provides a single API that allows you to use various microkernels to build the OS. The following microkernels are currently supported: Codezero, Fiasco, Fiasco.OC, Nova, OKL4, Pistachio. Linux kernel support is also supported. In addition, it is possible to run without the use of third-party cores (base-hw) on some platforms based on the ARM architecture.
These cores support different processor architectures and may use some hardware features. For example, the Fiasco.OC kernel can work on a large number of architectures, such as: x86, amd64, ARM (other architectures are available, but their support is not used in Genode at the moment), and the Nova core is a micro hypervisor for the x86 architecture and allows you to use hardware virtualization. Thanks to the use of the Genode framework, we can compile the application for use on any of the supported kernels without changing the source code.
More detailed information about Genode can be obtained from the documentation posted on the project website, as well as from materials read by Norman Feske for the " Ksys labs Summer School of System Programming "

Currently, Genode + Fiasco.OC for ARM architecture supports the following platforms: Realview PBXA9, Versatile Express A9X4, Pandaboard (TI OMAP4), Freescale iMX53, Arndale (Samsung Exynos 5). All these debug boards are quite expensive, and some are generally very difficult to acquire. Now there are many single-board PCs with a price of less than $ 100, which are used by enthusiasts both as debug boards for studying the OS, and as a basis for prototyping and manufacturing their devices. Linux is usually ported to these devices and some even have open source documentation. A good article with an overview of available devices " Choosing a mini computer for home creativity (DIY) ". Some platforms of the described boards are already supported by the Fiasco.OC kernel and do not require porting.

As you probably already guessed from the photo at the beginning of the post, I used the Cubieboard mini-PC based on the Allwinner A10 SoC as a porting platform .
This platform is interesting for a number of reasons:
- not too outdated Cortex-A8 architecture;
- the presence of the source code of the U-Boot loader, the Linux kernel, and the presence of “leaked” documentation into the network in the form of a user manual;
- A large set of peripherals (SATA, HDMI, etc.);
- the presence of a large number of inexpensive "hackable" devices on this chip (Cubieboard, Mele A1000 / A2000, and others).

Consider this SoC in more detail.

CPU: ARM Cortex-A8 with a frequency of up to 1Ghz with support for NEON, VFPv3, Trustzone
GPU: Mali 400 MP with support for Open GL ES 2.0
VPU: CedarX with support for FullHD video.
Peripherals: 4xUSB Host, USB OTG, 4xSD / MMC, 8xUART, 4xSPI, 3xI2C, GPIO, SATA, HDMI, LCD-interface and others.

Fiasco.OC core supports Cortex-A8 processor architecture. This means that to port it to a new platform you only need to add platform support, the so-called Board Support Package (BSP). The source code for the BSP is located in the directory kernel / fiasco / src / kern / arm / bsp.
The BSP for the ARM architecture in Fiasco.OC includes:
- an interrupt controller driver;
- timer driver;
- UART driver;
- implementation of the reset.
In addition, the BSP includes a memory allocation configuration.
The memory in A10, according to the user manual, is distributed as follows:

In order for the OS to use memory, it must know the physical addresses. These parameters are set in the Mem_layout class, mem_layout-arm-sun4i.cpp file:

EXTENSION class Mem_layout
{
public:
  enum Virt_layout_sun4i : Address {
    Timer_map_base       = Devices1_map_base + 0x020C00,
    Intc_map_base        = Devices1_map_base + 0x020400,
    Uart_base            = Devices1_map_base + 0x028000,
    Watchdog_map_base    = Timer_map_base    + 0x90,
  };
  enum Phys_layout_sun4i : Address {
    Devices1_phys_base   = 0x01c00000,
    Sdram_phys_base      = 0x40000000,
    Flush_area_phys_base = 0xe0000000,
  };
};

An interrupt controller is needed to handle events from various sources. The driver of the interrupt controller is used to control the controller, performing operations such as: controller configuration, masking interrupts, processing function. Driver code in pic-arm-sun4i.cpp file.

A timer is needed to generate events, such as the end of a time slot or the IPC timeout. The A10 has 6 timers. The timer Timer0 is used as a timer for interruptions. In addition to general timers, SoC also includes Watchdog and RTC with an alarm clock. To use the timer in system mode, it must generate an interrupt every 1 ms. Timer initialization and necessary functions are implemented in the timer-arm-sun4i.cpp file.

The UART driver is used by the kernel to output debugging messages and access the JDB kernel debugger. There is no initialization of the UART module in Fiasco.OC; it is believed that the bootloader has already configured it, in our case, U-Boot. The UART driver code is located in the files uart-arm-sun4i.cpp and kernel / fiasco / src / lib / uart / uart_sun4i.cc.

To perform a complete reset of the processor, a Watchdog timer is used, the purpose of which is to reset the system when the code loops. The implementation is in the reset-arm-sun4i.cpp file.

After performing these steps, we get the BSP for the selected processor. But the kernel still needs to be loaded. Consider the boot process of Genode + Fiasco.OC on the ARM architecture:

1. At startup, ROM-boot looks for a bootloader on an SD card or boots from NAND if there is no SD card.
2. U-Boot, executing the startup scripts, loads the Genode image as ELF or u-boot-image.
3. The loaded module contains the Fiasco.OC kernel and all other executable files, such as: sigma0, root task (in Genode it is the core module) and user programs.
4. Bootstrap is the first to start, which performs part of the operations necessary to start the kernel, such as:
- scanning available memory (not for all architectures; on ARM, the available memory is set in the configuration on the platform);
- moving modules in memory (sigma0 and root task must be located in certain regions so that the kernel can start them at startup);
- and directly launch the kernel.
7. The kernel performs the necessary initialization of the system, starts sigma0 and root task.
8. The core module (which is the root task) starts, which initializes the Genode services and allows you to run the applications we need using the configuration file.

Accordingly, to run bootstrap on Cubieboard, he must know about this platform, so we add the necessary configuration l4 / mk / platforms / cubieboard.conf and l4 / pkg / bootstrap / server / src / platform / sun4i.cc. In addition, you must implement the UART driver to display information about the download to the console.

The final step in porting is to add the necessary configuration files to the Genode build system. The process is simple, I will not describe it, you can see the changes in the corresponding commit in the repository. A good description of the build system was discussed in the " Genode OS Framework Programming Environment " lecture .

The source code is on Github https://github.com/Ksys-labs/genode in the tutorials branch. A modified version of Fiasco.OC in the https://github.com/Ksys-labs/foc repository in the r47-sun4i branch, these source codes already contain the necessary patches and are downloaded using the Genode build system.

To build, you must clone the source code:

git clone git://github.com/Ksys-labs/genode.git
git checkout tutorials
cd genode

Build toolchain for ARM:

./tools/tool_chain arm

And download the Fiasco.OC kernel:

make prepare -C base-foc

Now everything is ready to run.
1. Create a directory for the assembly using the command:

./tools/create_builddir foc_cubieboard BUILD_DIR=_build.foc_cubieboard
cd _build.foc_cubieboard

2. Add the hello_tutorial repository to cope with the simplest scenario, which does not require drivers that are not yet available.

echo 'REPOSITORIES += $(GENODE_DIR)/hello_tutorial' >> etc/build.conf

3. Turn on u-boot-image file generation

echo 'SPECS += uboot' >> etc/spec.conf

4. Collect the image

make run/hello

After a short build, we get the image in the form: ELF (hello.elf) and u-boot-image (uImage) in the var / run / hello directory.
After starting on the device, in the connected console, you can see the boot process and running applications from the hello tutorial:

As you can see, porting the microkernel to the new architecture is not at all difficult. Of course, as I wrote above, to use micronuclei in real projects, everything depends on the support of the platform hardware. For example, when making prototypes of devices based on Pandaboard and Gumstix Overo, we had to add a lot of drivers, such as: GPIO, UART, SPI, I2C. These interfaces were required to work with the LCD, touchscreen and smartcard reader. To use Cubieboard as a mini-PC with Genode, at least you need to write (or port) drivers: Framebuffer, USB, Ethernet.

Genode Labs plans to build a modern OS based on its framework and they are confidently moving in this direction. This is a very interesting open source project related to alternative OSs. Genode is not very demanding on resources, and in my opinion, single-board PCs based on ARM architecture may well be used as one of the cheapest platforms for this OS.

In addition, Genode is great for studying in the field of Computer Science, and if you are a student and you are interested, you can join us. To do this, you need to look at the first three lectures ( 1 , 2 , 3 ) and complete the tasks from them. You need to post the solution on Github and send a link to edu@ksyslabs.org.