Page 36 - DCAP507_SYSTEM_SOFTWARE

System Software

Notes
Example: Direct user access to low-level facilities is not allowed, providing the operating
system with more control over the hardware and more knowledge of which resources each user
program is using. As a further example, consider the history of Windows NT. The first release
had a very layer-oriented organization. However, this version suffered low performance
compared to that of Windows 95. Windows NT 4.0 redressed some of these performance issues
by moving layers from user space to kernel space and more closely integrating them.

2.2.3 Exokernel

Exokernel is an operating system kernel developed by the MIT Parallel and Distributed Operating
Systems group, and also a class of similar operating systems.

The idea behind exokernel is to force as few abstractions as possible on developers, enabling
them to make as many decisions as possible about hardware abstractions.
Applications may request specific memory addresses, disk blocks, etc. The kernel only ensures
that the requested resource is free, and the application is allowed to access it. This low-level
hardware access allows the programmer to implement custom abstractions, and omit unnecessary
ones, most commonly to improve a program's performance. It also allows programmers to
choose what level of abstraction they want, high, or low.

Exokernels can be seen as an application of the end-to-end principle to operating systems, in that
they do not force an application program to layer its abstractions on top of other abstractions
that were designed with different requirements in mind.

Example: In the MIT Exokernel project, the Cheetah web server stores preformatted
Internet Protocol packets on the disk, the kernel provides safe access to the disk by preventing
unauthorized reading and writing, but how the disk is abstracted is up to the application or the
libraries the application uses.
Operating systems define the interface between applications and physical resources.
Unfortunately, this interface can significantly limit the performance and implementation freedom
of applications. Traditionally, operating systems hide information about machine resources
behind high-level abstractions such as processes, files, address spaces and interprocess
communication. These abstractions define a virtual machine on which applications execute;
their implementation cannot be replaced or modified by untrusted applications.
Hardcoding the implementations of these abstractions is inappropriate for three main reasons:
 it denies applications the advantages of domain-specific optimizations,
 it discourages changes to the implementations of existing abstractions, and

 it restricts the flexibility of application builders, since new abstractions can only be added
by awkward emulation on top of existing ones (if they can be added at all).
These problems can be solved through application level resource management in which
traditional operating system abstractions, such as Virtual Memory (VM) and interprocess
communication (IPC), are implemented entirely at application level by untrusted software.
In this architecture, a minimal kernel-called an exokernel-securely multiplexes available
hardware resources. Library operating systems, working above the exokernel interface,
implement higher-level abstractions.
Application writers select libraries or implement their own. New implementations of library
operating systems are incorporated by simply relinking application executables. Applications
can benefit greatly from having more control over how machine resources are used to implement

30 LOVELY PROFESSIONAL UNIVERSITY