Antti Kantee

The talk will be a thought-provoking exploration of operating systems and the software/hardware stack. It will be a high-flying tale of low-level gore, and is intended for everyone with an understanding of programming and/or software systems.

The focus of the talk is in core operating system architecture. While that is sometimes seen as a highly technical topic, the talk will put the subject into common terms to disband the illusion of magic, and to give the audience an idea of what the purpose of the OS is in 2015 and why they should care beyond just having one installed.

Some of the subjects that the talk will graze upon include:

• the need for an operating system (or lack thereof)
• historical perspective and what has actually changed since time immemorial
• hardware/software interface
• userspace is the new kernelspace (or is it?)
• why actually good ideas fail

Every discussed subject will not be backed by experimental evidence, nor does the presenter claim that all insights are original. The intent is to raise awareness of good ideas so that they can be implemented more widely, and to raise awareness of bad ideas so that they can be unimplemented more widely.

The talk will concentrate more on anecdotes from the "drivers first" development approach. Technical details for how rump kernels work will be provided as links.

Rump kernels are NetBSD kernel drivers running on top of a set of high-level hypercalls. The term "drivers" is used in the broad sense, and includes for example file system, TCP/IP and system call drivers. The hypercall interface makes virtually no assumptions about the host, apart from it being able to execute code and access I/O functions required by the drivers (e.g. NIC-like devices for the networking stack). The original motivation for rump kernels was being able to debug NetBSD kernel drivers in a nice, non-monolithic kernel environment (i.e. userspace processes). This motivation dictated that drivers running in the non-monolithic environment had to be unmodified with respect to the NetBSD kernel version under the hammer. The implication was that instead of modifying drivers to work in userspace, NetBSD was modified to allow the drivers to run anywhere. The result of work begun in 2007 is that NetBSD kernel drivers from any snapshot or release of NetBSD now run more or less anywhere: in userspace on most operating systems, in a web browser, on top of the Xen hypervisor, or in the Linux kernel. The only component required for running NetBSD kernel drivers in a given environment is the rump kernel hypercall implementation. This implementation generally speaking 1000 lines of code (figure includes comments and whitespace and rudimentary I/O access routines).

This talk will introduce the concepts of the anykernel and rump kernels, motivate their existence, and show a few cool tricks that are unique benefits. We will not go deep into technical detail -- basic knowledge of operating systems is enough to follow the talk.

The anykernel is a new way of looking at kernel architecture. Conventional models such as the monolithic kernel, microkernel and exokernel dictate the execution model for kernel drivers. In contrast, the anykernel states that any of these should be possible as a runtime choice.

A rump kernel is a lightweight virtualized driver execution environment. Typically, OS virtualization means that the application execution environment is virtualized. In contrast, the rump kernel is designed for ultralightweight kernel driver virtualization. Benefits of using rump kernels include millisecond bootstrap times and a small memory footprint.

A production quality implementation of the concepts is available in NetBSD 6. The implementation lends itself to various use cases, such as isolating kernel drivers into separate servers on an on-demand basis and reusing kernel drivers in a library fashion such as for accessing file system images.

In addition to providing a basic overview of the concepts and benefits, the talk will introduce recent developments. An example of such is a script for building rump kernels for non-NetBSD platforms which allows NetBSD kernel drivers such as the TCP/IP stack to be leveraged on platforms beyond NetBSD.

As a demonstration, the NetBSD kernel FFS driver will be run in a browser. This is accomplished by compiling the driver with a C-to-javascript compiler and running a rump kernel on top of a hypervisor provided by the javascript environment.

Existing virtualization solutions such as Xen, QEMU and usermode operating systems virtualize the entire OS. While this is useful in a machine room type of use case, it is unnecessarily heavyweight when the interest is in virtualizing only one kernel driver or one kernel service. This talk introduces the anykernel architecture and rump kernels, which allow to safely virtualize individual drivers and subsystems from a monolithic kernel. Rump kernels can be used in a variety of different configurations, such as an application library, a microkernel style server, or as a server over the Internet. We will go over a number of real world use cases and present results which show that in their application domain rump kernels are faster, smaller and more agile than full OS virtualization technologies.

The implementation is available in production quality code as part of NetBSD. A key point of the project is the use of existing drivers from a real OS, i.e. real-world hardened code.