Learn DragonFlyBSD - Build System & Kernel Customization

#Introduction

In episode 19 you designed production storage with multi-volume HAMMER2. Now we take full control of the system: building DragonFlyBSD from source. This is the moment when you're no longer just a user — you become a builder.

Remember in episode 2: the base system is one source tree that can be fully rebuilt. Episode 20 makes that a reality. You'll run make buildworld and make buildkernel, install the results, write a custom kernel config, and use binary updates for the faster path.

#The Build System

#Preparing the Source

It all starts with the source tree. If you don't have it yet, clone it from git:

Set up the source tree

git clone git://git.dragonflybsd.org/dragonfly /usr/src
cd /usr/src
git checkout DragonFly_RELEASE_6_4

#buildworld

buildworld builds the entire userland — shell, libraries, utilities — from source:

Build world

cd /usr/src
make buildworld -j4

The -j4 flag runs 4 parallel jobs — use as many as you have cores. This process takes a long time (minutes to hours depending on the machine), so run it in a session that won't easily disconnect (tmux/screen) and make sure you have enough disk space.

#buildkernel

buildkernel builds the kernel:

Build the kernel

make buildkernel -j4

By default it builds the GENERIC kernel. For a custom kernel, specify it with KERNCONF:

Build a custom kernel

make buildkernel KERNCONF=DRAGONFLY -j4

#Installing the Kernel and World

After a successful build, install the kernel first:

Install the kernel

make installkernel KERNCONF=DRAGONFLY

Then install world and reboot:

Install world

make installworld
shutdown -r now

Danger

Installing the kernel and world is an operation that changes the core system. Always back up the active kernel (cp /boot/kernel/kernel /boot/kernel.old or keep the previous kernel) and never install world before the kernel is proven to boot. One wrong step can produce a system that won't boot.

#Cleaning Up After the Build

Cleaning up build artifacts:

Clean build artifacts

make cleanworld
make cleankernel

#Binary Updates: dragonfly-update

Building from source gives full control but is slow. For fast updates, DragonFlyBSD provides dragonfly-update — a binary update that downloads a ready-made base system:

Binary update of the base system

dragonfly-update

This tool downloads the latest release, verifies integrity, and prepares the upgrade. It's the recommended path for production servers that just need an up-to-date base system without compilation.

#Custom Kernel Config

#Configuration File Location

Kernel configuration files live in /usr/src/sys/config:

List kernel configs

ls /usr/src/sys/config

Create a custom kernel by copying the default:

Create a custom kernel config

cd /usr/src/sys/config
cp GENERIC DRAGONFLY
vi DRAGONFLY

#Writing the Kernel Config

Inside the config file, you register devices and options. Here's a realistic snippet:

Snippet of a custom kernel config

ident		DRAGONFLY
options		SMP
options		INET6
 
device		em
device		igb
device		nvmm
device		hammer2

ident names the kernel, options enables kernel-wide features, device registers drivers. Remove unused devices for a leaner kernel and faster builds.

#Booting with a New Kernel

A new kernel is installed in /boot/kernel/. Select a kernel at boot via the loader:

Test a new kernel

uname -a
nextboot -k /boot/kernel/kernel
shutdown -r now

nextboot sets the kernel for the next boot only — ideal for testing. Once the new kernel is stable, loaderboot or the kernel setting in /boot/loader.conf makes it the default.

#Closing

In this episode 20 you mastered the DragonFlyBSD build system: building the userland with make buildworld, the kernel with make buildkernel, installing with make installkernel and make installworld, using binary updates with dragonfly-update, and writing a custom kernel config in /usr/src/sys/config.

Key takeaways:

make buildworld and make buildkernel -j4 build the base system from source in /usr/src.
Install in order: make installkernel then make installworld, with a backup kernel before upgrading.
dragonfly-update provides fast base system binary updates for production.
A custom kernel starts with cp GENERIC DRAGONFLY in /usr/src/sys/config.
nextboot -k tests a new kernel for one boot before making it the default.

In the next episode, episode 21, we look to the future: DragonFlyBSD 6.4 & roadmap. You'll explore the 6.4.2 features — NVMM improvements, experimental HAMMER2 remote mounting, amdgpu driver updates, and bug fixes — then look at the direction of the 7.0 release and binary update practices with dfupdate.