Tutorial speakers

Managing BSD systems with Ansible
Benedict Reuschling

The tutorial was first held at AsiaBSDcon and it was well attended (14
people) and received. The feedback I got in the meantime has been worked
into the tutorial, so that attendees will get the updated and revised
version. The tutorial is laid out for 2.5 – 3 hours with breaks in
between and enough time for attendees to try out the examples on their
own machines.

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

Speaker biography:
Benedict Reuschling joined the FreeBSD Project in 2009. After receiving
his full documentation commit bit in 2010, he actively began mentoring
other people to become FreeBSD committers over the years. He is proctor
for the BSD Certification Group. Benedict has a Master of Science degree
in Computer Science and is teaching a UNIX for software developers class
at the University of Applied Sciences, Darmstadt, Germany. He is
managing the Big Data cluster for the computer science department using
Ansible since mid 2014. Benedict joined the FreeBSD Foundation Board of
Directors in 2015 and is currently serving as vice president.

DTrace for Developers: no more printfs
George Neville-Neil

One of the largest challenges to building complex software is a lack of
run time visibility into what the system is doing at any particular
time. Typical approaches to adding tracing and logging emphasize
sprinkling calls to printf() or similar statements throughout the source
code, and enabling these in debug builds. DTrace is a modern system that
gives software developers the ability to add, low overhead tracing that
is always available, coupled with an advanced scripting language, to
programs that they are creating, modifying and debugging.

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.

Speaker biography:
George Neville-Neil works on networking and operating system code for
fun and profit. He also teaches various courses on subjects related to
computer programming. His professional areas of interest include code
spelunking, operating systems, networking, time and security. He is the
co-author with Marshall Kirk McKusick and Robert Watson of The Design
and Implementation of the FreeBSD Operating System and is the columnist
behind ACM Queue’s “Kode Vicious.” Mr. Neville-Neil earned his
bachelor’s degree in computer science at Northeastern University in
Boston, Massachusetts, and is a member of the ACM, the Usenix
Association, the IEEE, and is one of the Directors of the FreeBSD
Foundation. He is an avid bicyclist and traveler who currently resides
in New York City.

An Introduction to the FreeBSD Open-Source Operating System
Kirk McKusick


An Introduction to the FreeBSD
Open-Source Operating System

Dr. Marshall Kirk McKusick
Author and Consultant

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.


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

Speaker biography:
Dr. Marshall Kirk McKusick writes books and articles, teaches
classes on UNIX- and BSD-related subjects, and provides
expert-witness testimony on software patent, trade secret,
and copyright issues particularly those related to operating
systems and filesystems. He has been a developer and commiter
to the FreeBSD Project since its founding in 1994. While
at the University of California at Berkeley, he implemented
the 4.2BSD fast filesystem and was the Research Computer
Scientist at the Berkeley Computer Systems Research Group
(CSRG) overseeing the development and release of 4.3BSD and
4.4BSD. He earned his undergraduate degree in electrical
engineering from Cornell University and did his graduate
work at the University of California at Berkeley, where he
received master’s degrees in computer science and business
administration and a doctoral degree in computer science.
He has twice been president of the board of the Usenix
Association, is currently a member of the FreeBSD Foundation
Board of Directors, a member of the editorial board of ACM’s
Queue magazine, a senior member of the IEEE, and a member of
the Usenix Association, ACM, and AAAS.

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.


Core concepts of ZFS
Michael W. Lucas

This half-day tutorial walks through the core concepts of ZFS. We’ll
discuss real life ZFS deployments, and troubleshoot bottlenecks.

Topics include:

  • 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”

Speaker biography:
Michael W Lucas is the author of many technical books, including
“Absolute FreeBSD,” “Absolute OpenBSD,” “PAM Mastery,” and the
brand-new “Relayd and Httpd Mastery.” He lives in Detroit, Michigan,
with his wife and an assortment of rats. Learn more at

BGP for developers and sysadmins
Peter Hessler

BGP is becoming more and more relevant outside of pure networking.
Developers need to understand TCP/IP for their own projects,
micro-services use networking for performance and redundancy. Virtual
Machines move from host to host, and need to have network traffic
delivered to them. BGP is the backbone protocol of the Internet, and as
a Data Center networking protocol for Facebook, Google, and Microsoft.

I will teach you the relevant basics of networking and how BGP is used
in the wild. At my day job, I run the 4th most connected network in
Germany, and are a developer with OpenBSD focusing on networking and OpenBGPD.

Attendees must bring a laptop capable of connecting to ethernet, and
running bird/openbgpd. Please pre-install the packages “sipcalc”, “bird”.

Knowledge of subnets or routing is not required.
Speaker biography:
Peter Hessler has been a developer with the OpenBSD project since 2008.

Originally from San Francisco he has an interest in how things work. An
OpenBSD user since 2000, he moved to Germany in 2008, to Switzerland in
2013, then back to Germany in 2015. In his spare time Peter enjoys
drinking beer, filling out Immigration documentation, and bad puns.

How to untangle your threads from a giant lock in a multiprocessor system
Taylor R Campbell

You’ve been living under a giant lock your whole life, but
Moore’s law has been moving in parallel rather than serial now
for over a decade, and it’s time to make your code scale to
many cores. How?

Your undergrad professor told you all about philosophers
fighting over dinner forks, which seems only philosophically
relevant when you stare at inscrutable kernel memory

In this tutorial, you’ll work through examples of drivers and
kernel subsystems in the context of NetBSD — though the
concepts will generalize to other BSDs, to userland, etc. — of
designing them to be MP-safe or even MP-scalable.
Speaker biography:
Taylor `Riastradh’ Campbell has been a NetBSD developer since
2011. His first major contribution was to fix the
synchronization of the rename system call, which has to juggle
four different objects, any pair of which might be the same,
and guarantee a local operation does not violate global
invariants of the file system. Since then, he has been
tweaking lock orders and synchronization protocols, including
writing passive references for cheaply parallelizing
read-mostly access to shared resources in the network stack.