OSKit Roadmap to Components
Here's a brief look at each of the libraries in the OSKit. For
more detail go to each chapter. For context for this excerpt from
the documentation, jump into the main document.
"Function" libraries in the OSKit,
along with the chapter numbers in which each is described:
- 12
- liboskit_c:
A simple, minimal C library
which minimizes dependencies with the environment and between modules,
to provide common C library services in a restricted OS environment.
For example, this library provides
many standard string, memory, and other utility functions,
as well as a formatted I/O facility (e.g., printf)
designed for easy use in restricted environments such as
kernels. In situations where a more complete, POSIX-like, C
library is desired, the FreeBSD C library (in
Chapter 18) may be used instead of the minimal
C library.
- 13
- liboskit_kern:
Kernel support code for setting up a basic OS kernel environment,
including providing default handlers for traps and interrupts and such.
This library includes many general utilities useful in kernel code,
such as functions to access special processor registers,
set up and manipulate page tables, and switch between processor modes
(e.g., between real and protected mode on the x86).
Also includes facilities for convenient source-level remote debugging
of OS kernels under development.
- 14
- liboskit_smp:
More kernel support code, this library deals with setting up
a multiprocessor system to the point where it can be used by
the operating system.
Also (to be) included are message-passing routines and
synchronization primitives, which are necessary to flush
remote TLBs.
- 4
- liboskit_com:
Utility functions for handling COM interfaces, and a suite
of generic wrapper components. These wrappers map one OSKit COM
interface to another, or implement simple functionality such as
synchronization by creating proxy COM objects that wrap the
COM objects provided by more primitive components.
- 8
- liboskit_dev:
This library provides default implementations
of the ``glue'' functions required by device drivers
and other ``large'' encapsulated components (networking, filesystems)
imported from other operating systems,
running in the OSKit Device Driver (née ``fdev'') framework.
(The framework's current name reveals its heritage; today,
a more accurate name would be the ``OS Environment'' framework.)
The default implementations of these functions
are designed for simple kernels using liboskit_kern;
for more elaborate kernel (or user-mode) environments,
the client OS will have to override
some or all of the functions in this library.
More formal
"component" libraries that are currently provided by the OSKit
along with the chapter numbers in which each is described:
- POSIX emulation and libraries
- 17
- liboskit_posix:
Adds support for what a POSIX conformant system would typically
implement as system calls. For example, open, read, and
write. These POSIX operations are mapped to the
corresponding OSKit COM interfaces. Both the minimal C library
and the FreeBSD C library rely on the POSIX library to
provide the necessary system level operations.
- 18
- liboskit_freebsd_c:
Complete POSIX-like C library derived from FreeBSD,
providing both single- and multithreaded configurations.
This library is an alternative to the minimal C library
liboskit_c (above), intended for programs that use
substantial POSIX-like functionality or need thread-safety.
The FreeBSD ``system call'' layer is supplied by the POSIX
library liboskit_posix, while the higher-level code
is mostly unchanged from that found in FreeBSD.
- 19
- liboskit_freebsd_m:
Complete standard math library (taken from FreeBSD's libm).
The functions in this library will commonly be needed by programs
that use floating point.
- 20
- liboskit_fsnamespace:
The Filesystem Namespace library provides ``namei'' style
translation for the application, as well as high level mount and
unmount capabilities. Multi component absolute and relative
pathnames (names with ``slashes'') are converted to
oskit_file and oskit_dir COM objects.
- 21
- liboskit_rtld:
The Runtime Linker/Loader library allows ELF compiled
OSKit kernels to load shared libraries (.so files).
- Memory management
- 22
- liboskit_lmm:
A flexible memory management library
that can be used to manage either physical or virtual memory.
This library supports many special features needed by OS-level code,
such as multiple memory types, allocation priorities,
and arbitrary alignment and placement constraints for allocated blocks.
- 23
- liboskit_amm:
The Address Map Manager library manages collections of resources
where each element of a collection has a name (address) and some set of
attributes.
Examples of resources that might be managed by address maps include
swap space and process virtual address space.
- 24
- liboskit_svm:
The Simple Virtual Memory library uses the AMM library
to define a simple virtual-memory interface for a single
address space that can provide memory protection and paging
to a block device such as a disk partition.
(unsupported/redzone.c provides a stack redzone
for single-threaded kernels, without all of SVM.)
- Threads, synchronization, and scheduling
- 25
- liboskit_threads:
This library provides support for multithreaded kernels,
including POSIX threads, synchronization, scheduling,
and stack guards.
Scheduling policies are the standard POSIX Round-Robin
and FIFO.
Experimental support for CPU inheritance scheduling, a hierarchical
framework for arbitrary scheduling policies, is also provided,
although not integrated or robust. Provided policies include
rate-monotonic, stride (WFQ), and lottery scheduling.
- Development aids
- 26
- liboskit_memdebug:
This library provides debugging versions of malloc et al that
check for a variety of bugs related to memory-allocation (overruns,
use of freed blocks, etc).
- 27
- liboskit_gprof:
Run-time support code for an OSKit kernel to collect profiling
data about itself and report it at the end of a run. Profiling
data can be collected for kernel code compiled with the ``-pg''
option (as for use with Unix gprof),
and profiled ``_p'' versions of all OSKit libraries are provided
to profile OSKit code used by the application kernel.
- Simple disk/file reading and loading
- 28
- liboskit_diskpart:
A generic library
that recognizes various common disk partitioning schemes
and produces a complete ``map'' of the organization of any disk.
This library provides a simple way for the OS
to find relevant or ``interesting'' disk partitions,
as well as to easily provide high-level access
to arbitrary disk partitions through various naming schemes;
BSD- and Linux-compatible naming mechanisms are provided as defaults.
- 29
- liboskit_fsread:
A simple read-only file system interpretation library
supporting various common types of file systems
including BSD FFS, Linux ext2fs, and MINIX file systems.
This library is typically used
in conjunction with the partition library
to provide a convenient way for the OS
to read programs and data off of hard disks or floppies.
Again, this functionality is often needed at boot time
even in operating systems that otherwise would not require it.
This code is also extremely useful in constructing boot loaders.
- 30
- liboskit_exec:
A generic executable interpreter and loader
that supports popular executable formats such as a.out and ELF,
either during bootstrap or during general operation.
(Even microkernel systems,
which normally don't load executables,
generally
must have a way to load the first user-level program;
the OSKit's small, simple executable interpreter
is ideally suited to this purpose.)
- Filesystem implementations
- 31
- liboskit_linux_fs:
Encapsulated Linux 2.0.29 filesystem code.
Includes the Linux VFS layer supporting
ext2fs, the primary Linux filesystem,
as well as numerous other PC filesystems supported under Linux.
- 32
- liboskit_netbsd_fs:
Encapsulated NetBSD 1.2 filesystem code.
Includes the BSD VFS layer supporting the local FFS
filesystem.
- 33
- liboskit_memfs:
An implementation of a trivial memory-based filesystem, exporting
the standard OSKit filesystem interfaces.
- Networking implementations
- 34
- liboskit_freebsd_net:
Encapsulated FreeBSD 2.1.7.1 networking code.
Includes socket layer and protocol support
wrapped to use the OSKit's framework.
- 35
- liboskit_bootp:
This library provides a simple interface for performing the BOOTP
protocol (RFC 1048/1533) on Ethernet devices to retrieve a
canonical set of parameters from a server, based on the client's
Ethernet hardware address.
- 36
- liboskit_hpfq:
This library provides hierarchical proportional-share control
of outgoing network link bandwidth, described in the Bennet/Zhang
SIGCOMM'96 paper.
- Device driver implementations
- 37
- liboskit_linux_dev:
Encapsulated Linux 2.0.29 device driver set.
Currently includes over 50 block (SCSI, IDE) and network drivers
wrapped to use the OSKit's device driver framework.
See the source file linux/dev/README for a list of devices and
their status.
- 38
- liboskit_freebsd_dev:
Encapsulated FreeBSD 2.1.7.1 device driver set.
Currently includes eight TTY
(virtual console and serial line, including mouse) drivers
wrapped to use the OSKit's device driver framework.
- Video and window manager implementations
- 39
- liboskit_wimpi:
Simple hierarchical windowing system based on MGR, with only simple
drawing and window management operations.
- 40
- liboskit_*video*:
Basic video support, with two implementations: one encapsulating
all of SVGALIB 1.3.0, and one based on XFree86 3.3.1, but with only the
S3 driver currently supported.
We also provide support for X11 clients.
The following four libraries are provided mainly for convenience;
they are not as general or as well documented as the other libraries but
are still useful. See the source directories and READMEs for details.
-
- liboskit_startup:
Contains functions to start up and initialize
various OSKit components,
making it easier to write OSKit programs.
-
- liboskit_unsupp:
Contains various unsupported hacks and utilities.
-
- liboskit_unix:
Provides the necessary support to debug and run certain
OSKit components on FreeBSD and Linux in user-mode.
-
- liboskit_fudp:
Provides a ``Fake UDP'' implementation:
a restricted send-only no-fragmenting version of UDP. This can
be useful with the hpfq library (in Chapter 36).
University of Utah Flux Research Group