L4Re and Google Summer of Code

L4Re participates in GSoC 2018 under the umbrella of the Microkernel devroom. This page contains the list of possible project ideas with prospective mentors. If you are a student and would like to work on one of these projects, please contact the suggested mentors by sending an e-mail to gsoc@l4re.org.

Benchmark suite for L4Re

The goal of this project is to provide means to easily benchmark programs and functions. Either by providing hooks inside Ned to start the time keeping until program termination; or by providing wrappers, doing the time keeping for a specific function; or by providing a library maintaining internal state and providing functions like start(), stop(), elapsed() to use in your own program. Furthermore, all these solutions shall use high-precision timers (HPT) provided by the hardware. Hence, a HPT library must provide tailoring to the specific hardware (x86, ARM, ...). Usage of HW Performance Counters is to be explored.

In the second half of the project, the benchmarks suite shall be applied to different use cases (e.g. gtest) to provide performance data on different parts of the operating system and on different hardware. Including visualization of the gained data and comparison between different data sets. In this context gprof might be of interest. Ideally, the benchmarks are executed regularly and integrated into the CI infrastructure.

Philipp Eppelt
Required Skills:
C++, basic x86/arm assembly, low-level system programming, using GNU tools such as binutils, make, GCC
Intel SDM, ARM Manual, GNU gprof

Nested virtualization with uvmm on x86

The scientist gave a superior smile before replying, “What is the tortoise standing on?” “You’re very clever, young man, very clever”, said the old lady. “But it’s turtles all the way down!”

Nested virtualization is a technology where a hypervisor can run multiple other hypervisors and their associated guest virtual machines. This is useful in cloud computing scenarios to enable users to run their own hypervisors or for testing and debugging hypervisors. This project aims at implementing this feature for the L4Re hypervisor and its VMM counterpart called uvmm. The project should focus on Intel VT-x.

Matthias Lange, Steffen Liebergeld
Required skills:
x86 architecture incl. VT-x, C++, using GNU tools such as binutils, make, GCC, kernel programming
L4Re internals:
Microkernel course at TU Dresden
Intel Architecture Manual:
KVM nested virtualization:
The Turtles Project:
paper, presentation

Port Fiasco.OC/L4Re to RISC-V

This project aims to port L4Re to the RISC-V Instruction Set Architecture (ISA). As there is currently no hardware available that allows to run L4Re, simulators will be used (e.g. Spike or QEMU). Porting to a new architecture is a rather large effort and can thus be accomplished in multiple incremental steps. A port of L4Re starts by porting a base set of user-level components so that the L4Re bootstrap component can be run. This is followed by porting the L4Re microkernel. When the microkernel itself has matured enough, the user-level components can be completed. Advanced features, such as multi-processor support, can follow after that.

Adam Lackorzynski, Jakub Jermář
Required skills:
RISC-V assembly & architecture, C++, using GNU tools such as binutils, make, GCC, kernel programming
L4Re internals:
Microkernel course at TU Dresden
specifications, toolchains, simulators

Library fuzzing

The goal of this project is to fuzz one or several L4Re specific libraries. To get going, the project shall first focus on generic L4Re libraries that can also be compiled under Linux. If successful, the project should then move to libraries that can only run on top of the Fiasco.OC microkernel (for instance inside QEMU).

Hendrik Tews, Marius Melzer, Steffen Liebergeld
See also
A gentle introduction to fuzzing...
Required skills:
C, C++, GNU tools such as binutils, make, gcc, some fuzzing tool (for instance libFuzzer)