Publications on Microkernels

• User-level Management of Kernel Memory. Andreas Haeberlen and Kevin Elphinstone. 8th Asia-Pacific Computer Systems Architecture Conference (ACSAC '03), Aizu-Wakamatsu City, Japan, Sep 2003.
  
  × @inproceedings{haeberlen-2003-kmem,
    author = {Andreas Haeberlen and Kevin Elphinstone},
    title = {User-level Management of Kernel Memory},
    booktitle = {8th Asia-Pacific Computer Systems Architecture Conference (ACSAC '03)},
    location = {Aizu-Wakamatsu City, Japan},
    month = sep,
    year = 2003
  }
  ×

  Kernel memory is a resource that must be managed carefully in order to ensure the efficiency and safety of the system. The useof an inappropriate management policy can weaken the isolation between subsystems, lead to suboptimal performance, and even make the kernel vulnerable to denial-of-service attacks. Yet, many existing kernels use only a single built-in policy, which is always a compromise between performance and generality.

  In this paper, we address this problem by exporting control over kernel memory to user-level pagers. Thus, subsystems can implement their own application-specific management policies while independent subsystems can still be isolated from each other.

  The pagers have full control over the memory resources they manage; they can even preempt and later restore individual pages of kernel memory. Still, protection is not compromised because the kernel converts its metadata into a safe representation before exporting it. Therefore, pagers need only be trusted by their respective clients.

  We describe the model we use to page kernel memory and various techniques for obtaining a safe external representation for kernel metadata. We also report experiences with an experimental kernel that implements our scheme and outline our plans to further develop the approach.

  PDF BibTeX Abstract
• Managing Kernel Memory Resources from User Level. Andreas Haeberlen. Diplomarbeit, University of Karlsruhe, Germany, Apr 2003.
  
  × @misc{haeberlen-2003-thesis,
    author = {Andreas Haeberlen},
    title = {Managing Kernel Memory Resources from User Level},
    note = {Diplomarbeit, University of Karlsruhe, Germany},
    month = apr,
    year = 2003
  }
  ×

  In order to implement abstractions like threads or address spaces, operating system kernels need to maintain the corresponding metadata. This metadata is usually stored in kernel memory, i.e. in a region of physical memory that is reserved for kernel use. As the amount of available kernel memory is limited, its allocation must be controlled carefully; otherwise, applications can run a denial-of-service attack against the kernel by consuming all of its resources.

  Some operating system kernels have addressed this problem by providing powerful management policies. However, with a single global policy,it is difficult to accommodate multiple domains with different requirements at the same time. Also, existing solutions allow only limited control over kernel memory; for example, it is often not possible to reduce an allocation, except by killing the task that currently holds it. This makes it difficult to respond to changing load situations or suspected denial-of-service attacks.

  In this thesis, we present a new scheme which uses paged virtual memory to control kernel memory resources from user level. Memory can be preempted from the kernel and restored later; any kernel metadata affected by this is converted into an external representation, which can be safely exported. To demonstrate our approach, we apply it to an existing kernel, the L4 microkernel. We also present an experimental implementation.

  PDF BibTeX Abstract
• Using Platform-Specific Optimizations in Stub-Code Generation. Andreas Haeberlen. Study Thesis, University of Karlsruhe, Germany, Jul 2002.
  
  × @misc{haeberlen-2002-idl4,
    author = {Andreas Haeberlen},
    title = {Using Platform-Specific Optimizations in Stub-Code Generation},
    note = {Study Thesis, University of Karlsruhe, Germany},
    month = jul,
    year = 2002
  }
  ×

  The use of a stub code generator can greatly reduce the effort required to implement a multi-server system on top of a microkernel. However, stub code has traditionally been highly generic and therefore rather slow, which has prevented it from being used in performance-critical applications.

  In this work, we show that this restriction can be eliminated by specialization for the underlying platform, i.e. by exploiting specific properties of the kernel, compiler, or hardware platform that are being used. We demonstrate our approach for an example platform, the L4 microkernel, and present a variety of optimization techniques that can be used to improve stub code performance on this platform.

  Our techniques are implemented and validated in IDL⁴, our optimizing stub code generator. A comparison with traditional stub code generators shows that IDL⁴ stubs can perform up to an order of magnitude better, and that they can in-crease application performance by more than 10 percent.

  PDF BibTeX Abstract Software
• Performance of Address-Space Multiplexing on the Pentium. Volkmar Uhlig, Uwe Dannowski, Espen Skoglund, Andreas Haeberlen, and Gernot Heiser. Technical report 2002-1, Department of Computer Science, University of Karlsruhe, May 2002.
  
  × @techreport{uhlig-2002-smallspaces,
    author = {Volkmar Uhlig and Uwe Dannowski and Espen Skoglund and Andreas Haeberlen and Gernot Heiser},
    title = {Performance of Address-Space Multiplexing on the Pentium},
    institution = {Department of Computer Science, University of Karlsruhe},
    number = {2002-1},
    month = may,
    year = 2002
  }
  ×

  This paper presents an analysis of the performance potential and limitation of the so-called small-space scheme, where several logical address spaces are securely multiplexed onto a single hardware address space. This can be achieved on the IA-32 architecture by using the segment registers to relocate address spaces transparently to the applications.

  Our results show that the scheme can provide significant performance improvements in cases where processes with small working sets interact frequently, as is often the case in client-server applications, and particularly in microkernel-based systems. We also investigate how potentially costly revocation of mappings can be prevented by clustering communicating processes.

  PDF BibTeX Abstract Software
• User-Level Management of L4 Kernel Memory. Andreas Haeberlen. 2th International Workshop on Microkernel-Based Systems, Lake Louise, Canada, Oct 2001.
  
  × @inproceedings{haeberlen-2001-kpages,
    author = {Andreas Haeberlen},
    title = {User-Level Management of {L4} Kernel Memory},
    booktitle = {2th International Workshop on Microkernel-Based Systems},
    location = {Lake Louise, Canada},
    month = oct,
    year = 2001
  }
  ×

  In the Hazelnut microkernel, kernel memory is a limited resource. This allows malicious applications to run denial-of-service attacks against the kernel, because there is no way to restrict the amount of kernel memory they may use. I suggest to integrate kernel memory into the normal memory management concept, which permits to control its allocation entirely from user level.

  PDF BibTeX Abstract
• The L4Ka Vision. Jochen Liedtke, Uwe Dannowski, Kevin Elphinstone, Gerd Liefländer, Espen Skoglund, Volkmar Uhlig, Christian Ceelen, Andreas Haeberlen, and Marcus Völp. White Paper, University of Karlsruhe, Germany, Apr 2001.
  
  × @misc{liedtke-2001-l4kavision,
    author = {Jochen Liedtke and Uwe Dannowski and Kevin Elphinstone and Gerd Liefl\"ander and Espen Skoglund and Volkmar Uhlig and Christian Ceelen and Andreas Haeberlen and Marcus V\"olp},
    title = {The {L4Ka} Vision},
    note = {White Paper, University of Karlsruhe, Germany},
    month = apr,
    year = 2001
  }
  ×

  Microkernels are minimal but highly flexible kernels. Both conventional and non-classical operating systems can be built on top or adapted to run on top of them. Microkernel-based architectures should particularly support extensibility and customizability, robustness including reliability and fault tolerance, protection and security.

  After desastrous results in the early 90’s, the microkernel approach now seems to be promising, although it still bears a lot of research risks. Currently, University of Karlsruhe's system architecture group is defining the state of the art in microkernel research.

  The L4Ka research project aims at substantiating and establishing a new methodology for system construction that helps to manage ever-increasing OS complexity and minimizes legacy dependence. Our vision is a microkernel technology that can be and is used advantageously for constructing any general or customized operating system including pervasive systems, deep-computing systems, and huge servers.

  The technology should help to manage ever-increasing OS complexity, enable stepwise innovations in OS technology while preserving legacy compatibility, and lead to a widely-accepted foundation of system architecture.

  PDF BibTeX Abstract Software
• Stub-Code Performance is Becoming Important. Andreas Haeberlen, Jochen Liedtke, Yoonho Park, Lars Reuther, and Volkmar Uhlig. 1st Workshop on Industrial Experiences with Systems Software (WIESS '00), San Diego, CA, Oct 2000.
  
  × @inproceedings{haeberlen-2000-idl4,
    author = {Andreas Haeberlen and Jochen Liedtke and Yoonho Park and Lars Reuther and Volkmar Uhlig},
    title = {Stub-Code Performance is Becoming Important},
    booktitle = {1st Workshop on Industrial Experiences with Systems Software (WIESS '00)},
    location = {San Diego, CA},
    month = oct,
    year = 2000
  }
  ×

  As IPC mechanisms become faster, stub-code efficiency becomes a performance issue for local client/server RPCs and inter-component communication. Inefficient and unnecessary complex marshalling code can almost double communication costs. We have developed an experimental new IDL compiler that produces near-optimal stub code for gcc and the L4 microkernel. The current experimental IDL4 compiler cooperates with the gcc compiler and its x86 code generator. Other compilers or target machines would require different optimizations. In most cases, the generated stub code is approximately 3 times faster (and shorter) than the code generated by a commonly used portable IDL compiler. Benchmarks have shown that efficient stubs can increase application performance by more than 10 percent. The results are applied within IBM’s SawMill project that aims at technology for constructing multi-server operating systems.

  PDF BibTeX Abstract

Show all publications