An Introduction to the FreeBSD Open-Source Operating System

Who Should Take this Course
---------------------------
This course provides a broad overview of how the FreeBSD kernel
implements its basic services. It will be most useful to those who
need to learn how these services are provided.  Individuals involved in
technical and sales support can learn the capabilities and limitations
of the system; applications developers can learn how to effectively
and efficiently interface to the system; systems programmers without
direct experience with the FreeBSD kernel can learn how to maintain,
tune, and interface to such systems. This course is directed to
users who have had at least a year of experience using a UNIX-like
system. They should have an understanding of fundamental algorithms
(searching, sorting, and hashing) and data structures (lists, queues,
and arrays).

The course is divided into two days. Together they cover the entire
FreeBSD kernel but subjects have been arranged such that students can
also decide to attend only the first or the second day depending on
the subjects in which they are interested.

Description
-----------
This course will provide a firm background in the FreeBSD kernel.
The POSIX kernel interfaces will be used as examples where they are
defined. Where they are not defined, the FreeBSD interfaces will
be described. The course will cover basic kernel services, process
structure, locking, jails, scheduling, signal handling, and virtual
and physical memory management. The kernel I/O structure will be
described showing disk management, how I/O is multiplexed, and
the configuration of special devices. Next the organization of
the filesystem will be described showing how its buffer pool is
integrated with the virtual memory system. The course then covers the
implementation of the fast filesystem and its capabilities including
soft updates and snapshots. The filesystem interface will then be
generalized to show how to support multiple filesystem types. The
course also covers the socket-based network architecture, layering,
and implementation. The socket communications primitives and internal
layering will be discussed, with emphasis on the interfaces between
the layers; the TCP/IP implementation will be used as an example.
A discussion of routing issues will be included.  The presentations
will emphasize code organization, data structure navigation, and
algorithms. It will not cover the machine specific parts of the
system such as the implementation of device drivers.

Day 1 morning - Kernel Overview
	Process structure
	Locking
	Communications
	Process Groups and Sessions
	Jails
	Scheduling
	Signals and timers
	Virtual memory management

Day 1 afternoon - Kernel I/O structure
	I/O data structures
	Disk Management
	Multiplexing I/O
	Autoconfiguration strategy
	Configuration of a device driver

Day 2 morning - Filesystems Overview
	Filesystem organization
	Block I/O system (buffer cache)
	Filesystem implementation
	Soft Updates and Snapshots
	Support for multiple filesystems

Day 2 afternoon - Networking Implementation
	System layers and interfaces
	Internet Protocols
	Mbufs and control blocks
	Routing issues
	TCP algorithms