File:  [NetBSD Developer Wiki] / wikisrc / rumpkernel.mdwn
Revision 1.4: download - view: text, annotated - select for diffs
Mon Feb 10 15:25:04 2014 UTC (7 years, 4 months ago) by pooka
Branches: MAIN
CVS tags: HEAD
link this years fosdem presentation

    1: **Contents**
    3: [[!toc levels=2]]
    5: # The Anykernel and Rump Kernels
    7: ## About
    9: A driver abstracts an underlying entity. For example, a TCP/IP driver
   10: abstracts the details required to perform networking, the Fast File
   11: System (FFS) driver abstracts how the file system blocks are laid out on
   12: the storage medium, and a PCI network card driver abstracts how to
   13: access device registers to send and receive packets. The kernel
   14: architecture controls how kernel drivers run with respect to other
   15: system components. Some examples of kernel architectures are the
   16: monolithic kernel, microkernel and exokernel. In contrast to the above
   17: architectures, NetBSD is an *anykernel*. This means that some kernel
   18: drivers can be run according to any kernel architecture instead of being
   19: limited to a single one.
   21: <!--
   22:     TODO
   23:     ![](rumparch.png)
   24: -->
   26: When a driver is not run as part of the monolithic kernel, e.g. when it
   27: is run as a microkernel style server, the driver is hosted in a *rump
   28: kernel*. A rump kernel is an ultralightweight virtualized kernel running
   29: on top of high-level hypercall interface. Instead of a low-level
   30: hypercall API typically seen with operating systems with operations such
   31: as "modify page table", the rump kernel hypercall API provides
   32: high-level operations such as "run this code in a thread".
   34: Currently, three implementations of the rump kernel hypercall interface
   35: exist.
   37: -   The POSIX implementation is included in the NetBSD tree and allows
   38:     rump kernels to run as userspace processes on most operating systems
   39:     such as NetBSD, Linux and Solaris.
   40: -   The Xen implementation allows running rump kernels directly as Xen
   41:     DomU's without an intermediate operating system.
   42: -   The Linux kernel hypervisor allows rump kernels to run inside the
   43:     Linux kernel.
   45: Rump kernels are radically different from OS virtualization technologies
   46: such as KVM, containers and usermode operating systems. A rump kernel
   47: does not support hosting application processes because a rump kernel is
   48: aimed at virtualizing kernel drivers and application virtualization
   49: would be pure overhead. Instead, existing entities such as processes
   50: from a hosting OS are used as clients for the rump kernel ("application"
   51: in the figure).
   53: As a result of the above design choices, rump kernels are extremely
   54: lightweight. The bootstrap time for rump kernels on POSIX hosts is
   55: measured in milliseconds and memory footprint in 100kB's. This means
   56: that a rump kernel can be bootstrapped for example as part of a command
   57: line tool for virtually no cost or user impact. Rump kernels also
   58: mandate very little from the hypercall implementation meaning that
   59: rump kernels, and by extension NetBSD kernel drivers, can be hosted in
   60: virtually any environment -- for example, rump kernels do not require
   61: a platform with an MMU.
   63: Use cases for rump kernels include:
   65: -   **Code reuse**: kernel drivers can be reused without having to run a
   66:     whole OS. For example, a full-featured TCP/IP stack (IPv6, IPSec,
   67:     etc.) can be included in an embedded appliance without having to
   68:     write the stack from scratch or waste resources on running an entire
   69:     OS.
   70: -   **Kernel driver virtualization**: every rump kernel has its own
   71:     state. Furthermore, the functionality offered by multiple rump
   72:     kernels running on the same host does not need to be equal. For
   73:     example, multiple different networking stacks optimized for
   74:     different purposes are possible.
   75: -   **Security**: when hosted on a POSIX system, a rump kernel runs in
   76:     its own instance of a userspace process. For example, it is widely
   77:     published that file system drivers are vulnerable to untrusted file
   78:     system images. Unlike on other general purpose operating systems, on
   79:     NetBSD it is possible to mount untrusted file systems, such as those
   80:     on a USB stick, in an isolated server with the kernel file system
   81:     driver. This isolates attacks and prevents kernel compromises while
   82:     not requiring to maintain separate userspace implementations of the
   83:     file system drivers or use other resource-intensive approaches such
   84:     as virtual machines.
   85: -   **Easy prototyping and development**: kernel code can be developed
   86:     as a normal userspace application. Once development is finished, the
   87:     code can simply be complied into the kernel. This is a much more
   88:     convenient and straightforward approach to kernel development than
   89:     the use of virtual machines.
   90: -   **Safe testing**: kernel code can be tested in userspace on any host
   91:     without risk of the test host being affected. Again, virtual
   92:     machines are not required.
   94: ## Further Reading
   96: ### Book
   98: The following book is the definitive guide to the anykernel and rump
   99: kernels and supercedes all earlier publications and terminology on
  100: the subject.
  102: -   [Flexible Operating System Internals: The Design and Implementation
  103:     of the Anykernel and Rump
  104:     Kernels](
  106: Note that the book was finalized in summer 2012, so while the fundamentals
  107: are still accurate, some of the problems described in "Future Work"
  108: have already been solved.  Check out the links below.
  111: ### Software using rump kernels
  113: While the NetBSD source tree hosts the base kernel drivers and hypercall
  114: implementation, more I/O drivers, infrastructure scripts and hypercall
  115: implementations are hosted elsewhere.  Most of the code is hosted
  116: under the [rump kernels]( organization
  117: on github.  Some highlights include:
  119: -   [Scripts for building rump kernels for POSIX
  120:     systems](
  121: -   The [rumprun]( package
  122:     allows portable building and running of unmodified NetBSD userspace
  123:     applications -- extremely useful for configuring rump kernels (e.g.
  124:     network interfaces and routing tables)
  125: -   [Rump kernel hypercall implementation for Xen; rump kernels as Xen
  126:     DomU's](
  127: -   [fs-utils: File system image access
  128:     utilities](
  129: -   Fast userspace packet processing: TCP/IP stack for use with
  130:     [DPDK](, 
  131:     [netmap]( or
  132:     [Snabb Switch](
  134: ### Articles, Tutorials & Howtos
  136: -   [Running rump kernels and applications on Xen without a full
  137:     OS](
  138: -   [PCI device driver support in rump kernels on
  139:     Xen](
  140: -   [Experiment with a rump kernel hypervisor for the Linux
  141:     kernel](
  142:     (allows rump kernels to run *in* the Linux kernel)
  143: -   [Experiment on compiling rump kernels to javascript and running them
  144:     in the
  145:     browser](
  146: -   [Kernel Servers using
  147:     Rump](
  148: -   [Tutorial On Rump Kernel Servers and
  149:     Clients](
  150: -   [Revolutionizing Kernel Development: Testing With
  151:     Rump](
  153: ### Conference publications and talks
  155: -   "Rump Kernels, Just Components" talks about rump kernels as reusable
  156:     and platform-agnostic drivers.  The intended audience is developers.  The
  157:     [video](
  158:     and [slides]( are available.
  159:     Presented at FOSDEM 2014 (Microkernel devroom).
  160: -   "The Anykernel and Rump Kernels" gives a general overview and
  161:     demonstrates rump kernels on Windows and in Firefox. The
  162:     [video](,
  163:     [slides](
  164:     and an
  165:     [interview](
  166:     are available. Presented at FOSDEM 2013 (Operating Systems track).
  167: -   "Rump Device Drivers: Shine On You Kernel Diamond" describes device
  168:     driver and USB. The
  169:     [paper](
  170:     and [video presentation](
  171:     are available. Presented at AsiaBSDCon 2010.
  172: -   "Fs-utils: File Systems Access Tools for Userland" describes
  173:     fs-utils, an mtools-like utility kit which uses rump kernel file
  174:     systems as a backend. The
  175:     [paper](
  176:     is available. Presented at EuroBSDCon 2009.
  177: -   "Rump File Systems: Kernel Code Reborn" describes kernel file system
  178:     code and its uses in userspace. The
  179:     [paper](
  180:     and
  181:     [slides](
  182:     are available. Presented at the 2009 USENIX Annual Technical
  183:     Conference.
  184: -   "Kernel Development in Userspace - The Rump Approach" describes
  185:     doing kernel development with rump kernels. The
  186:     [paper](
  187:     and
  188:     [slides](
  189:     are available. Presented at BSDCan 2009.
  190: -   "Environmental Independence: BSD Kernel TCP/IP in Userspace"
  191:     describes networking in rump kernels. The
  192:     [paper]( and
  193:     [video presentation]( are
  194:     available. Presented at AsiaBSDCon 2009.
  196: ### Manual pages
  198: The manpages provide the usual type of information. Start from
  199: [rump.3]( and
  200: follow the cross-references in "SEE ALSO".
  202: ## Discuss
  204: Any topic related to rump kernels can be discussed on the
  205: [rumpkernel-users mailing
  206: list](
  207: Alternatively, you can use a NetBSD mailing which is related to a
  208: specific subtopic.
  210: The IRC channel for rump kernels is **\#rumpkernel** on
  211: ****.
  213: ## Availability
  215: The anykernel and rump kernels were first introduced as a prototype in
  216: NetBSD 5.0. A stable version with numerous new features and improvements
  217: was shipped with NetBSD 6.0.
  219: ## Source Code
  221: All of the source code is available from the NetBSD source tree and can
  222: be obtained with the usual methods.
  224: You can also [browse]( the
  225: source code history online. Code is found from all areas of the source
  226: tree. Some examples of where to look include
  227: [src/lib](,
  228: [src/usr.bin]( and
  229: [src/sys/rump](

CVSweb for NetBSD wikisrc <> software: FreeBSD-CVSweb