(no commit message)

[ikiwiki.git] / docs / handbook / Installation / index.mdwn

This document describes the installation of DragonFly BSD. This process uses a bootable DragonFly CD or USB disk image, usually referred to as a 'live CD' or 'USB disk image'.  These are available at one of the current mirrors, which distribute the images by various protocols.

It is recommended to install DragonFly with USB because USB is faster and more flexible.


[[!toc  levels=3]]


----


# Installation from CD or USB


## Downloading DragonFly BSD

Choose the closest [mirror](/mirrors/) site and go to `iso-images/` directory. Then choose installation image:

[[!table  data="""
|<tablestyle="width:100%"> |
 **dfly-x86_64-X.X.X_REL.iso** | uncompressed image for CD and VM.
 **dfly-x86_64-X.X.X_REL.iso.bz2** | compressed image for CD and VM.
 **dfly-x86_64-X.X.X_REL.img.bz2** | compressed image for USB.
"""]]

Then download `md5.txt` and verify image:

    % md5 -C md5.txt dfly-x86_64-X.X.X_REL.*
    (MD5) dfly-x86_64-X.X.X_REL.img.bz2: OK
    (MD5) dfly-x86_64-X.X.X_REL.iso: OK
    (MD5) dfly-x86_64-X.X.X_REL.iso.bz2: OK



## Creating install media

Decompress downloaded image if it is compressed:

    % bzip2 -d dfly-x86_64-X.X.X_REL.iso.bz2


### Flash drives

A bootable USB flash drive can be created by attaching the target device and copying over the image with [dd(1)](https://leaf.dragonflybsd.org/cgi/web-man?command=dd&section=1).

Using DragonFly BSD, assuming device was recognized as sd8:

    # dd if=dfly-x86_64-*_REL.img of=/dev/sd8 bs=1m


### CD

DragonFly's image is too big to fit on CD-ROM, however, it fits on DVD.

You can create a bootable CD on DragonFly BSD by using [cdrecord(1)](https://leaf.dragonflybsd.org/cgi/web-man?command=cdrecord&section=1)

    # cdrecord -tao dfly-x86_64-*_REL.iso



## Performing a simple install

The installer is designed to install DragonFly BSD with a minimum of user intervention.  In fact, you can often just hit [Enter] to get a good DragonFly BSD install, moving your hands to the rest of the keyboard only to make choises.

After [dmesg(8)](https://leaf.dragonflybsd.org/cgi/web-man?command=dmesg&section=8) is shown, you will see the first installer question:

    ...
    Welcome to DragonFly!

    To start the installer, login as 'installer'. To just get a shell prompt, login as 'root'

    DragonFly/x86_64 (Amnesiac) (ttyv0)

    login: 

Type `installer` and press [Enter] and follow the instructions.


# Manual Installation (all types) (assumes whole disk)

WARNING! These instructions assume that 'da0' is the drive you are installing to and that you booted from somewhere else.  'da0' in these instructions must not contain anything you used to boot the system from.  Normally you will have booted from some other media, such as a USB stick, CD, or the network.  

WARNING! These instructions assume that you are not sharing the drive with any other operating system and have no data on the drive that you wish to keep.  Generally speaking, my recommendation is to not have multi-OS boot setups (its too easy to mistakenly wipe them when messing around with other installations).  Instead, invest in a hot-swap drive bay and put each OS on its own SSD.

To do a manual installation you need to initialize the disk.  DragonFlyBSD uses a modified fdisk which works on any-sized disk by having the kernel recognize the maximum size fdisk supports and translate that to the whole disk's actual size.  You need to install the boot sector and also setup a bootable DragonFlyBSD disklabel.

    # fdisk -IB /dev/da0

    # disklabel -r -w -B /dev/da0s1 auto

Edit the label and create three partitions: a, b, and d.  The 'a' partition is going to be /boot and needs to be a 1GB UFS partition.  'b' is your swap and should be roughly 2x main memory (we recommend at least 4GB or more, particularly if you will be running browsers).  'd' is your root partition.

    # disklabel -e da0s1

    a: 1G 0 4.2BSD
    b: 8G * swap
    d: * * HAMMER

One can simply use HAMMER2 instead of HAMMER on the d: line if the HAMMER2 filesystem is going to be used.


# Manual Non-Crypto Installation

Format the filesystems and mount them:

    # newfs /dev/da0s1a
    # newfs_hammer -L ROOT /dev/da0s1d # Use newfs_hammer2 for HAMMER2
    # mount /dev/da0s1d /mnt
    # mkdir /mnt/boot
    # mount /dev/da0s1a /mnt/boot

Once you have them mounted, copy from a working DragonFly installation.  This can be from installation media or via NFS if you have setup the network and have a server somewhere.  Two cpdup commands are needed since we have two partitions.  If the source of your image is broken up into additional partitions, you may have to cpdup each one (cpdup nominally stops at mount boundaries on the source):

    # cpdup /boot /mnt/boot
    # cpdup / /mnt

Finally, edit "/mnt/boot/loader.conf", "/mnt/etc/fstab", and "/mnt/etc/rc.conf" to point to your disk.  At a minimum you will need this line in your "/mnt/boot/loader.conf" (we recommend configuring by serial number, which you can get from the dmesg output, but if you don't want to then use the drive name which might be something like 'da0s1d'):

    vfs.root.mountfrom="hammer:serno/SERIALNUMOFDISK.s1d" # Use vfs.root.mountfrom="hammer2:serno/SERIALNUMOFDISK.s1d" for HAMMER2

Your "/etc/fstab" file should contain something like the below:

    serno/SERIALNUMOFDISK.s1a    /boot           ufs     rw              1 1
    serno/SERIALNUMOFDISK.s1b    none            swap    sw              0 0
    serno/SERIALNUMOFDISK.s1d    /               hammer  rw              1 1
    #following line for HAMMER2
    #serno/SERIALNUMOFDISK.s1d    /               hammer2  rw              1 1

Finally, unmount the partitions and reboot the machine.  Once the machine is in reset, before it hits the BIOS, unplug your installation media:

    # umount /mnt/boot
    # umount /mnt
    # reboot



# Manual Crypto Installation

To setup a crypto system follow the generic non-crypto steps above.  Make sure that your boot drive has a "/boot/kernel/initrd.img.gz" file in as the system will need to bootstrap through MD0 in order to mount an encrypted root.  In this example I am also encrypting swap.

If your drive partitions previously contained unencrypted data and you want to wipe it, you can dd /dev/urandom to the target partitions.  It can take many hours to do this so you might decide to skip this optional step:

    # dd if=/dev/urandom of=/dev/da0s1b bs=32k
    # dd if=/dev/urandom of=/dev/da0s1d bs=32k

Setup an encrypted swap and root partition as shown below (be careful of the password you type as the keyboard will be in qwerty when you decrypt, that can be changed by modifying the initrd later):

    # kldload dm
    # cryptsetup --key-size 256 --hash sha512 -y luksFormat /dev/da0s1b
    # cryptsetup --key-size 256 --hash sha512 -y luksFormat /dev/da0s1d
    # cryptsetup luksOpen /dev/da0s1b swap
    # cryptsetup luksOpen /dev/da0s1d root # Use rootd instead of root for HAMMER2

Format the filesystems and mount them.  Note that the boot partition is not encrypted.

    # newfs /dev/da0s1a
    # newfs_hammer -L ROOT /dev/mapper/root # newfs_hammer2 /dev/mapper/rootd for HAMMER2
    # mount /dev/mapper/root /mnt           # mount_hammer2 /dev/mapper/rootd /mnt for HAMMER2
    # mkdir /mnt/boot
    # mount /dev/da0s1a /mnt/boot

Once you have them mounted, copy from a working DragonFly installation.  This can be from installation media or via NFS if you have setup the network and have a server somewhere.  Two cpdup commands are needed since we have two partitions.  If the source of your image is broken up into additional partitions, you may have to cpdup each one (cpdup nominally stops at mount boundaries on the source):

    # cpdup /boot /mnt/boot
    # cpdup / /mnt

Finally, edit "/mnt/boot/loader.conf", "/mnt/etc/fstab", and "/mnt/etc/rc.conf" to point to your disk.  At a minimum you will need this line in your "/mnt/boot/loader.conf" (we recommend configuring by serial number, which you can get from the dmesg output, but if you don't want to then use the drive name which might be something like 'da0s1d').

    initrd.img_load="YES"
    initrd.img_type="md_image"
    vfs.root.mountfrom="ufs:md0s0"
    vfs.root.realroot="crypt:hammer:serno/SERIALNUMOFDISK.s1d:root" # vfs.root.realroot="crypt:hammer2:serno/SERIALNUMOFDISK.s1d:rootd" for HAMMER2
    dm_load="YES"
    dm_target_crypt_load="YES"

You can note that we are using rootd in the case of HAMMER2, that's because it's not possible to pass a HAMMER2 label to the rcmount_crypt script in the initrd, and so the mapping name has to end in d so that mount_hammer2 will automatically use the ROOT label for mounting

Your "/etc/fstab" file should contain something like the below:

    serno/SERIALNUMOFDISK.s1a    /boot           ufs     rw              1 1
    /dev/mapper/root              /               hammer  rw              1 1
    #following line for HAMMER2
    #/dev/mapper/rootd              /               hammer2  rw              1 1

You can setup the encrypted swap via the "/etc/rc.local" file with the following lines:

    # cryptsetup luksOpen /dev/serno/SERIALNUMOFDISK.s1b swap
    #swapon /dev/mapper/swap

Finally, unmount the partitions and reboot the machine.  Once the machine is in reset, before it hits the BIOS, unplug your installation media:

    # umount /mnt/boot
    # umount /mnt
    # reboot


# Installation to a Disk Slice in a Multiboot Set-up with rEFInd

Currently, the DragonFly BSD Installer only supports a full-disk installation. Obviously, this
set-up is not appropriate for multibooting with other operating systems (OSs), because each OS
resides on its own hard drive slice. Therefore, for multiboot you have to install DragonFly to a hard
drive slice. For this, you have to do a manual installation. 

[rEFInd](http://www.rodsbooks.com/refind) is a powerful boot manager for machines with Unified
Extensible Firmware Interface (UEFI), which are prevalent today. Prior to starting the DragonFly installation,
please download the latest rEFInd version as a [binary zip file](http://www.rodsbooks.com/refind/getting.html),
unzip it and write it to a USB stick.

After booting DragonFly with the install medium, login as root. To see how your hard drive is
recognised, issue:

        # camcontrol devlist

to list your IDE/SCSI devices

or, if you have a Solid State Drive (SSD),

        # nvmectl info

An IDE/SCSI drive will be recognised as ad0/da0 (see [Disk Slices, Partitions and local UNIX file systems](https://www.dragonflybsd.org/docs/handbook/UnixBasics/#index9h2)) and a modern SSD as nvme0. For simplicity, hereafter an nvme device is
assumed. If you have an IDE/SCSI drive, you can simply substitute nvme0 with ad0/da0 in the following
instructions.

## Partition the hard drive

To be safe, first clean up the starting sectors of the disk drive from remnants of any previous
partitioning:

        # dd if=/dev/zero of=/dev/nvme0 count=1024 bs=1m

Here, we assume GUID Partition Table (GPT) partitioning (see the gpt manual page).

Destroy any existing GPT partition table:

        # gpt destroy nvme0

Create a new partition table:

        # gpt create -f nvme0

In between, to view the current partition table, you can issue:

        # gpt -v show -l nvme0

Before you start adding the slices, note that slice sizes are specified in number of disk drive
sectors. Normally, a sector has 512 bytes. To check that, you can run:

        # dmesg | grep blksize

The output will look something like this:

nvme0: Disk nvme0 ns=1 blksize=512 lbacnt=1000215216 cap=476GB serno=S33UNB0J606162-1

in which case it confirms that the sector size is 512 bytes. So, if you need a slice of size S bytes,
you have to specify S/512 number of sectors for it. 

First, you have to create the EFI system partition (ESP) of 512 MiB. The ESP will be your first
slice and hence it will get a slice number of 0. The corresponding number of sectors is 
(512 * 1024 ** 2) / 512 = 1048576:

        # gpt add -i 0 -s 1048576 -t efi nvme0

In the above command, -i specifies slice number 0, -s the slice size in sectors, and -t specifies the
slice type.

Give the EFI slice a UTF-8 label:

        # gpt label -i 0 -l "EFI System" nvme0

Create the DragonFly slice of, say 200 GiB:

        # gpt -v show nvme0 gpt add -i 1 -s 419430400 -t dfly nvme0

Label the DragonFly slice:

        # gpt label -i 1 -l "DragonFly BSD" nvme0

Now you can create your disklabel partitions on the DragonFly slice. Normally, you want a disk
layout consisting of an "a" partition for /boot, a "b" partition for swap and a "d" partition for
the root file system.

Create a standard virgin disk label for the DragonFly slice:

        # disklabel64 -r -w nvme0s1 auto

Create the disklabel partitions on the DragonFly slice:

        # disklabel64 -e nvme0s1

The above command opens a text editor, where you can describe the partitions you want to add, with their
sizes and file system types. For the above layout, you can add the following three lines:

        a: 1G * 4.2BSD
        b: 16G * swap
        d: * * HAMMER2

to specify a partition "a" of 1 GiB that will carry a UFS file system, a partition "b" of 16 GiB for
swap, and a partition "d" encompassing the remaining space on the DragonFly slice for the root file
system. The [size of the swap space](https://itsfoss.com/swap-size) depends on the available RAM.

Now you can proceed adding slices for the rest of the OSs you plan to install. E.g., to add a 200
GiB OpenBSD slice:

        # gpt add -i 2 -s  419430400 -t "Unused" nvme0

Specifying -t "OpenBSD" in the above command is not supported. You will have to modify that partition type later when installing OpenBSD.

Label the OpenBSD slice:

        # gpt label -i 2 -l "OpenBSD" nvme0

To add a linux slice encompassing the remaining space on the disk drive:

        # gpt add -i 3 -t linux nvme0

Label the linux slice:

        # gpt label -i 3 -l "Linux"

## Install rEFInd to the ESP


Format the ESP slice with FAT file system:

        # newfs_msdos nvme0s0

Create a mount point for the ESP:

        # mkdir /efimnt

Mount the ESP:

        # mount_msdos /dev/nvme0s0 /efimnt

Create the required directory structure of the ESP:

        # mkdir -p /efimnt/EFI/BOOT

Create a mount point for the USB stick with the rEFInd executables:

        # mkdir /usb

Go to the EFI/BOOT directory of the ESP:

        # cd /efimnt/EFI/BOOT

Insert the USB stick with the rEFInd executables. On inserting the stick, the system reports the new
device. You can double-check how it is recognised by issuing:

        # camcontrol devlist

Assuming the USB stick is recognised as /dev/da9, mount the USB stick with the rEFInd executables: 

        # mount_msdos /dev/da9s1 /usb

Copy the rEFInd executables to the current directory (assuming you have rEFInd version x.y.z):

        # cp -r /usb/refind-bin-x.y.z/refind/* .

Unmount the USB stick with the rEFInd executables and delete its mount point:

        # umount /usb
        # rmdir /usb

Remove the unnecessary drivers, efi executables and tools. E.g, for an amd64 machine you have to
remove the *aa64* and *ia32* files and directories:

        # rm -rf *aa64* *ia32* 

Rename the rEFInd executable:

        # mv refind_x64.efi bootx64.efi

Copy the DragonFly BSD boot1.efi under a different name:

        # cp /boot/boot1.efi bootx64-dragonflybsd.efi

Rename the rEFInd configuration file:

        # mv refind.conf-sample refind.conf

Edit refind.conf:

        # vi refind.conf 

Add this section:

     menuentry "DragonFly BSD" {
           loader /EFI/BOOT/bootx64-dragonflybsd.efi
           icon /EFI/BOOT/icons/os_freebsd.png
     }

You may ask why the freebsd icon is provided above? Well, currently there is no os_dragonflybsd.png
icon. If you wish, you can create your own one and copy it to the ./icons directory; it has to be a
128 x 128 png. Of course, as you install other OSs at a later stage, you have to provide relevant
entries for them in the refind.conf file and copy the necessary booting executables to the ESP.
Information on this is usually provided by the OS or available as part of the rEFInd documentation.
Caveat: when installing the other OSs, make sure their installers do not overwrite the ESP you just
created. It would be best to not install rEFInd for the other OS using the OS's installer, but do
this manually: the process involves copying a few relevant files to the ESP and making a respective
entry in refind.conf. For example, with OpenBSD, after finishing the installation and before rebooting, 
copy the file /mnt/usr/mdec/BOOTX64.EFI to a USB stick; then boot into DragonFly, copy that
file to the ESP under EFI/BOOT, and rename it to bootx64-openbsd.efi; add a respective entry
in refind.conf, using again a different icon as an OpenBSD one is currently not available as well.
On your next reboot, the rEFInd menu should contain both DragonFly and OpenBSD as boot options.

Leave the ESP: 

        # cd

Unmount the ESP:

        # umount /efimnt

Delete the ESP's mount point:

        # rmdir /efimnt

Now you can proceed formatting the DragonFly disklabel partitions with the filesystems of your choice
and installing DragonFly as described above in the section on Manual Non-Crypto Installation. When you
reboot, you should see the rEFInd menu prompting you to select an OS to boot.


# Manual Installation with an Extended HAMMER2 Disk Layout

[HAMMER](https://leaf.dragonflybsd.org/cgi/web-man?command=hammer&section=ANY) is a file system
that allows creating pseudo file systems (PFSs) within it, which dynamically share a common storage
space. Oversimplified, you can think of HAMMER as of a logical volume manager (LVM) with logical
volumes (PFSs) that are not of fixed size. Each PFS obtains as much space from the HAMMER file
system as it needs. Here, we consider the
[HAMMER2](https://leaf.dragonflybsd.org/cgi/web-man?command=hammer2&section=ANY) file system, which
is the follower of HAMMER. 

This section shows how to create the following disk layout:

        # mount -p
        nvme0s1d                /               hammer2 rw                      1 1
        devfs                   /dev            devfs   rw,nosymfollow          0 0
        /dev/nvme0s1a           /boot           ufs     rw                      1 1
        @usr                    /usr            hammer2 rw                      0 0
        @usr.dports             /usr/dports     hammer2 rw                      0 0
        @usr.local              /usr/local      hammer2 rw                      0 0
        @usr.src                /usr/src        hammer2 rw                      0 0
        @var                    /var            hammer2 rw                      0 0
        @home                   /home           hammer2 rw,nosuid               0 0
        @build                  /build          hammer2 rw                      0 0
        /build/usr.distfiles    /usr/distfiles  null    rw                      0 0
        /build/usr.obj          /usr/obj        null    rw                      0 0
        /build/var.cache        /var/cache      null    rw                      0 0
        /build/var.crash        /var/crash      null    rw                      0 0
        /build/var.log          /var/log        null    rw                      0 0
        /build/var.run          /var/run        null    rw                      0 0
        /build/var.spool        /var/spool      null    rw                      0 0
        tmpfs                   /tmp            tmpfs   rw,noexec,nosuid,nodev  0 0
        tmpfs                   /var/tmp        tmpfs   rw,noexec,nosuid,nodev  0 0
        tmpfs                   /var/run/shm    tmpfs   rw                      0 0
        procfs                  /proc           procfs  rw                      0 0

The entries that start with a "@" in front are PFSs. This layout is relatively complicated, as it uses
separate PFSs for directories that are separately mounted in many UNIX installations. Furthermore,
file systems that do need backup are mounted under the /build PFS, which is something like scratch 
space in DragonFly. /tmp and /var/tmp are implemented as tmpfs.

In the following, it is assumed you have already booted the install medium, logged in as root,
sliced the hard drive and created your disklabel partitions "a" for /boot, formatted with UFS, "b"
for swap, and "d" for /, formatted with HAMMER2. It is furthermore assumed your disk drive is
recognised as nvme0.  If your drive is recognised as something else, e.g. da0, you can simply
replace nvme0 with da0 in the following commands.

Note:
When creating mount points and mounting disk partitions it is important to keep in mind that the
directory hierarchy determines the order of the commands. More specifically, if partition B is to be
mounted under a directory of partition A, then first partition A has to be mounted, then the mount
point for partition B created on A, and finally partition B mounted. If you proceed first creating the
mount points and then mounting the partitions without heeding the hierarchy you will get into
trouble :-). Be warned about that.

So, let's create the layout.

Mount the disklabel partitions (the swap partition is not mounted): 

        # mount_hammer2 nvme0s1d /mnt
        # mkdir /mnt/boot
        # mount nvme0s1a /mnt/boot

Note that first the / partition is mounted, then the mount point for /boot is created on the mounted
/, and finally the /boot partition is mounted. This sequence of commands is determined by the file
system hierarchy as discussed in the note above.  

Create the HAMMER2 PFSs. The path to the mounted HAMMER2 ROOT file system is specified via the -s
parameter:

        # hammer2 -s /mnt pfs-create usr
        # hammer2 -s /mnt pfs-create usr.dports
        # hammer2 -s /mnt pfs-create usr.local
        # hammer2 -s /mnt pfs-create usr.src
        # hammer2 -s /mnt pfs-create var
        # hammer2 -s /mnt pfs-create home
        # hammer2 -s /mnt pfs-create build

To view the created PFSs, you can in between issue:

        # hammer2 pfs-list /mnt

Create the mount points and mount the PFSs, taking care of the directory hierarchy (see the note
above on creating mount points and mounting partitions):

        # mkdir /mnt/usr
        # mount_hammer2 @usr /mnt/usr

        # mkdir /mnt/usr/dports
        # mkdir /mnt/usr/local
        # mkdir /mnt/usr/src
        # mkdir /mnt/var
        # mkdir /mnt/build
         
        # mount_hammer2 @usr.dports /mnt/usr/dports
        # mount_hammer2 @usr.local /mnt/usr/local
        # mount_hammer2 @usr.src /mnt/usr/src
        # mount_hammer2 @var /mnt/var
        # mount_hammer2 @build /mnt/build

Note that among these directories there are such with non-existent (/usr/dports and /usr/src) or
empty (/build and /home) counterparts on the install medium. You may ask why /usr/dports
and /usr/src are mounted although they will remain empty; the answer is, as cpdup does not cross mount
boundaries, this prevents cpdup from asking whether to delete them (because they do not exist on the
installation media) when copying /usr from the install medium at a later stage. There is no need to
mount /home, as it is an independent file system that will remain empty. On /build, we create
directories for file systems that do not normally need backup. At a later stage, we will null-mount
these directories to their respective mount points in the hierarchy.

Create directories for file systems that do not normally need backup:

        # mkdir /mnt/build/usr.distfiles
        # mkdir /mnt/build/usr.obj
        # mkdir /mnt/build/var.cache
        # mkdir /mnt/build/var.crash
        # mkdir /mnt/build/var.log
        # mkdir /mnt/build/var.run
        # mkdir /mnt/build/var.spool

Create the mount points for the /build null mounts that do not exist on the install medium:

        # mkdir /mnt/usr/distfiles

Create mount points for the non-empty /build null mounts:

        # mkdir /mnt/var/crash
        # mkdir /mnt/var/log
        # mkdir /mnt/var/run
        # mkdir /mnt/var/spool

There is no need to create mount points for the empty /build null mounts that exist on the install
medium (/usr/obj and /var/cache), as they will be copied by cpdup together with /usr and /var at a
later stage. 

Mount the non-empty /build null mounts:

        # mount_null /mnt/build/var.crash /mnt/var/crash
        # mount_null /mnt/build/var.log /mnt/var/log
        # mount_null /mnt/build/var.run /mnt/var/run
        # mount_null /mnt/build/var.spool /mnt/var/spool

Mount /usr/distfiles as it does not exist under /usr on the installation media (to prevent cpdup
from asking whether to delete it when copying /usr at a later stage):

        # mount_null /build/usr.distfiles /mnt/usr/distfiles

Install DragonFly by copying the non-empty file systems. Luckily, cpdup won't cross mount boundaries
on the source or destination, so it takes a few commands:

        # cpdup / /mnt
        # cpdup /boot /mnt/boot
        # cpdup /usr /mnt/usr
        # cpdup /usr/local /mnt/usr/local
        # cpdup /var /mnt/var

Copy the non-empty /build null mounts:

        # cpdup /var/crash /mnt/var/crash
        # cpdup /var/log /mnt/var/log
        # cpdup /var/run /mnt/var/run
        # cpdup /var/spool /mnt/var/spool

DragonFly BSD uses a different /etc from the one present on the install medium. The /etc on the
install medium is only used during installation. It is the /etc.hdd directory that is intended
for permanent use. You can delete /etc, but it is preferable to store it under the name /etc.live
instead:

        # mv /mnt/etc /mnt/etc.live
        # mv /mnt/etc.hdd /mnt/etc

There is no example fstab in /etc.hdd. The one from /etc.live has to be copied:

        # cp /mnt/etc.live/fstab.example /mnt/etc/fstab

Describe all mounts in fstab:

        # vi /mnt/etc/fstab

Enter the following content:

        /dev/nvme0s1a /boot ufs rw 1 1
        /dev/nvme0s1b none swap sw 0 0
        /dev/nvme0s1d / hammer2 rw 1 1
        @usr /usr hammer2 rw 0 0
        @usr.dports /usr/dports hammer2 rw 0 0
        @usr.local /usr/local hammer2 rw 0 0
        @usr.src /usr/src hammer2 rw 0 0
        @var /var hammer2 rw 0 0
        @home /home hammer2 rw,nosuid 0 0 @build
        /build hammer2 rw 0 0
        /build/usr.distfiles /usr/distfiles null rw 0 0
        /build/usr.obj /usr/obj null rw 0 0
        /build/var.cache /var/cache null rw 0 0
        /build/var.crash /var/crash null rw 0 0
        /build/var.log /var/log null rw 0 0
        /build/var.run /var/run null rw 0 0
        /build/var.spool /var/spool null rw 0 0
        tmpfs /tmp tmpfs rw,nosuid,noexec,nodev 0 0
        tmpfs /var/tmp tmpfs rw,nosuid,noexec,nodev 0 0
        proc /proc procfs rw 0 0
        
Now, specify the correct root file system:

        # vi /mnt/boot/loader.conf

Add the following content:

        vfs.root.mountfrom="hammer2:nvme0s1d"

Unmount mounted filesystems:

        # umount /mnt/boot
        # umount /mnt/usr/distfiles
        # umount /mnt/usr/dports
        # umount /mnt/usr/local
        # umount /mnt/usr/src
        # umount /mnt/var/crash
        # umount /mnt/var/log
        # umount /mnt/var/run
        # umount /mnt/var/spool
        # umount /mnt/usr
        # umount /mnt/var
        # umount /mnt/build
        # umount /mnt

Halt to give you time to remove the install medium:

        # halt

Wait for the system to halt, remove the installation medium after that, and finally press any key to
reboot.