Tutorial speakers

The topic is interesting enough even for people who did not have much
exposure to the BSDs yet and covers all the BSDs in general as Ansible
mostly abstracts the OS-specifics away. Basic Unix command line skills
(editing a file, navigating the directory tree, copying files, etc.) is
sufficient to participate.

I will start the tutorial with why and how Ansible is helpful
(infrastructure as code). Then, I will go into setting up clients
(receiving updates) and server (pushing configuration changes to
clients) with SSH. We will then start running basic ad-hoc commands from
the command line so that attendees get a feel for the power of this
tool. Next, attendees will learn how to run and write playbooks for
bigger tasks comprising multiple steps to execute on the target host.
Variables, loops, gathering facts from clients, as well as the basics of
YAML are part of the tutorial, which concludes with a complete example
about setting up and configuring a webserver.
Sysadmins and users alike can benefit from the tutorial by learning how
to automate dull, repetitive tasks and deploy configuration changes in
parallel.

In this tutorial we will cover the basics of DTrace, including basic and
advanced uses, and then, using a set of worked examples, add tracing to
user space and kernel space systems. The tutorial includes a set of
short labs, carried out on virtual machines, that give the students
hands on experience working with DTrace.

Students are expected to have a laptop computer which can run Virtual
Machine software such as VMWare (preferred), Virtual Box or QEMU.

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

Course Text

Marshall Kirk McKusick, George Neville-Neil, and Robert N. M. Watson,
The Design and Implementation of the FreeBSD Operating System,
Second Edition, Pearson Education, Boston, MA September 2014,
ISBN-13: 978-0-321-96897-5, ISBN-10: 0-321-96897-2.

Course text

In his spare time, he enjoys swimming, scuba diving, and
wine collecting. The wine is stored in a specially
constructed wine cellar (accessible from the Web at
http://www.mckusick.com/~mckusick/) in the basement of the
house that he shares with Eric Allman, his partner of
38-and-some-odd years and husband since 2013.

• how copy on write changes everything
• choosing and configuring hardware for your ZFS system
• customizing ZFS installs
• ZFS space usage
• dataset repair
• storage expansion
• compression vs deduplication
• creating and managing snapshots
• cloning datasets
• boot environments
• dataset delegation
• jailing ZFS
• replication
• managing large storage arrays
• NVMe
• bottlenecks
• cache management

and whatever other topics we have time for, which we probably won’t.

Based on the books by Allan Jude & myself, “FreeBSD Mastery: ZFS” and “FreeBSD Mastery: Advanced ZFS”