mount FreeBSD Cifrado ZFS desde liveCD y encontrar partición root

Fuente:

https://klarasystems.com/articles/manipulating-a-pool-from-the-rescue-system/

 mkdir /tmp/mountado
 geli attach /dev/nda0p4
 zpool import -f -R /tmp/montado zroot

 zfs list zroot
 NAME                            USED  AVAIL  REFER  MOUNTPOINT
zroot                            223G   211G    96K  /zroot
zroot/ROOT                      82.9G   211G    96K  none
zroot/ROOT/14.3-RELEASE-p8         8K   211G  21.1G  /
zroot/ROOT/default              82.9G   211G  21.3G  /
zroot/cache                     3.04G   211G    96K  /zroot/cache
zroot/cache/ccache              3.04G   211G  3.04G  /var/cache/ccache
zroot/home                      75.3G   211G    96K  /home
zroot/home/carlos               75.3G   211G  67.4G  /home/carlos
zroot/reserved                  50.0G   261G    96K  /zroot/reserved
zroot/tmp                        320K   211G   180K  /tmp
zroot/usr                       9.89G   211G    96K  /usr
zroot/usr/ports                 6.99G   211G  2.91G  /usr/ports
zroot/usr/src                   2.90G   211G  2.63G  /usr/src
zroot/var                       1.61G   211G    96K  /var
zroot/var/audit                   96K   211G    96K  /var/audit
zroot/var/crash                 1.60G   211G  1.60G  /var/crash
zroot/var/log                   3.11M   211G  2.00M  /var/log
zroot/var/mail                   356K   211G   260K

Propiedad canmount de zroot/ROOT/default

zfs get mountpoint,canmount,mounted zroot/ROOT/default
NAME                PROPERTY    VALUE       SOURCE
zroot/ROOT/default  mountpoint  /           local
zroot/ROOT/default  canmount    noauto      local
zroot/ROOT/default  mounted     yes         -

¿Qué hace canmount=noauto?

La propiedad canmount en ZFS controla si un dataset puede ser montado. Tiene tres valores posibles:

on - El dataset se monta automáticamente cuando es necesario (por ejemplo, al importar el pool o al ejecutar zfs mount -a).

off - El dataset no puede ser montado en absoluto.

noauto - El dataset no se monta automáticamente por operaciones generales del sistema (como zfs mount -a o la importación del pool), pero puede ser montado manualmente con zfs mount. Es un estado intermedio que lo hace "disponible pero no automático".

Montar zroot/ROOT/default con el comando mount

 zfs mount zroot/ROOT/default

Despues de finalizar los cambios exportar el zpool

zpool export zroot

Reiniciar y arrancar desde el disco duro NVMe (nda0)

 shutdown -r now

FreeBSD es genial!.

Migración de SSD a disco de mayor capacidad en FreeBSD 14.3 send receive vía USB

Estado actual del sistema

zpool status
zpool list 
zpool list -t all

Identificar discos

geom disk list
camcomtrol devlist

Anotar el disco actual (ada0) y el nuevo disco USB (da0)

Limpiar el disco nuevo completamente

gpart destroy -F da0
dd -if=/dev/zero of=/dev/da0 bs=1M count=100

Crear tabla de particiones GPT

gpart create -s gpt da0

Partición de arranque EFI (si el sistema usa UEFI)

gpart add -t efi -s 260M -l efiboot-new da0

Partición de arranque BIOS/GPT (para compatibilidad legacy)

gpart add -t freebsd-boot -s 512k -l gptboot-new da0

Partición swap

gpart add -t freebsd-swap -s 8G -a 1M -l swap0 da0

Particion ZFS (el resto del disco)

gpart add -t freebsd-zfs -a 1M -l zroot-new da0

Para sistemas UEFI

Montar partición EFI del disco nuevo

newfs_msdos -F 32 -c 1 /dev/da0p1
mount -t msdosfs /dev/da0p1 /mnt

Copiar EFI loader desde el actual disco

mkdir -p /mnt/EFI/BOOT
cp -r /boot/efi/EFI/BOOT /mnt/EFI/

umount /mnt

Crear pool temporal en el nuevo disco

Crear pool temporal con nombre diferente para evitar conflictos
zpool create -o altroot=/mnt \
             -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O acltype=posix \
             -m none \
             zroot-new /dev/da0p3

Verificar

zpool status zroot-new

Listar todos los datasets a migrar

zfs list -H -o name -t filesystem,volume

Tomar snapshot recursivo de todo el pool (Shell zsh)

sudo zfs snapshot -r zroot@migracion

Verificar snapshot creado

zfs list -t snapshot -o name | grep "$migracion" 
zroot@migracion
zroot/ROOT@migracion
zroot/ROOT/14.3-RELEASE-filebrowser-tailscale-serve-certs-https@migracion
zroot/ROOT/14.3-RELEASE_2026-02-14_193200@migracion
zroot/ROOT/default@2026-02-14-19:32:00-0
zroot/ROOT/default@2026-02-17-17:48:09-0
zroot/ROOT/default@migracion
zroot/home@migracion
zroot/home/carlos@migracion
zroot/tmp@migracion
zroot/usr@migracion
zroot/usr/ports@migracion
zroot/usr/src@migracion
zroot/var@migracion
zroot/var/audit@migracion
zroot/var/crash@migracion
zroot/var/log@migracion
zroot/var/mail@migracion
zroot/var/tmp@migracion

Enviar snapshot raíz primero

zfs send -Lec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Enviar recursivamente todos los datasets hijos

zfs send -RLec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Banderas (flags)

-R Recursivo (todos los datasets hijos)
-L Incluye large blocks
-e Embed data (bloques pequeños inline)
-c Comprime el stream
-F En receive: fuerza rollback si es necesario
-u No monta los datasets al recibirlos
-v Verbose

Comprobar la replicación

Comparar conjuntos de datos entre pools

zfs list -r zroot
zfs list -r zroot-new

Verificar propiedades

zfs get all zroot
zfs get all zroot-new

Cantidad de instantáneas

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zroot-new | wc -l

Configurar bootfs en el nuevo pool

zpool set bootfs=zroot-new/ROOT/default zroot-new

Verificar

zpool get bootfs zroot-new

Ajustar cachefile y otros parámetros del pool

zpool set cachefile=/boot/zfs/zpool.cache zroot-new

Ver propiedades del pool original para replicarlas

zpool get all zroot

Montar el dataset raíz del nuevo disco

zfs set mountpoint=/mnt zroot-new/ROOT/default
zfs mount zroot-new/ROOT/default

Verificar /boot/loader.conf

cat /mnt/boot/loader.conf

Debe contener algo como:

zfs_load="YES"
vfs.root.mountfrom="zfs:zroot/ROOT/default"

Si el nombre del pool cambió, actualizar:

sed -i '' 's/zroot-new/zroot/g' /mnt/boot/loader.conf

También verificar /etc/fstab (en ZFS puro suele estar sin referencias a ada0)

cat /mnt/etc/fstab

Cambiar el disco y primer arranque

Apagar el sistema

shutdown -p now

Desconectar el disco viejo Conectar el nuevo disco en el slot interno (ya no como USB) Comprobar en BIOS/UEFI que el nuevo disco sea el primero en el orden de arranque Arrancar

Verificación después del arranque

Comprobar salud del pool

zpool status
zpool list

Verificar que todos los datasets montaron

zfs list -t filesystem

Verificar espacio disponible (debe reflejar el disco nuevo mayor)

df -h

Verificar que el sistema arrancó desde el disco correcto

geom disk list
camcontrol devlist

Limpiar snapshots de migración

zfs destroy -r zroot@migracion

Problemas y posibles soluciones después del primer arranque

Renombrar zpool zroot-new a zroot

zpool import -f zroot-new zroot

Error

zpool export zroot-new Cannot unmount /

Es el error clásico: el dataset raíz (/) está montado desde zroot-new, así que ZFS no puede desmontarlo en caliente

Solución Desde loader prompt o LiveCD

Desde el LiveCD

zpool import -f zroot-new zroot
zpool set bootfs=zroot/ROOT/default zroot
zpool export zroot

zpool import -f zroot-new zroot
   zpool set bootfs=zroot/ROOT/default zroot
   zpool export zroot hecho.

Reiniciar

shutdown -r now

FreeBSD al arrancar y no encontrar zroot buscará pools disponibles. Si el disco nuevo ya está interno, lo encontrará como zroot-new y podrás importarlo con el nombre correcto.

Después de reiniciar sin el LiveCD el sistema arranca desde el nuevo disco duro.

Estos dos errores son normales y esperables en este proceso.

1. swapon: /dev/da0p3: No such file or directory, 
2. Import of zpool cache /etc/zfs/zpool.cache failed

El archivo /etc/fstab del sistema nuevo todavía referencia el dispositivo del disco USB (da0) que ya no existe. Ahora el disco está interno, probablemente como ada0 o nvme0ns1.

Montar el sistema de ficheros rw

mount -u -o rw /

Averiguar cómo se llama el disco ahora geom disk list o camcontrol devlist.

geom disk list                                    
Geom name: ada0
Providers:
1. Name: ada0
   Mediasize: 250059350016 (233G)
   Sectorsize: 512
   Mode: r3w3e7
   descr: WDC WDS250G2B0A-00SM50
   lunid: 5001b448b8a2a91f
   ident: 192686806761
   rotationrate: 0
   fwsectors: 63
   fwheads: 16

Cambiar la línea de swap, por ejemplo

/dev/da0p3  none   swap  sw   0   0
 por
/dev/ada0p3  none   swap  sw   0   0

Mejor aún, usar la etiqueta (label) GPT que es independiente del nombre del dispositivo

gpart show -l ada0
=>       40  488397088  ada0  GPT  (233G)
         40     532480     1  efiboot0  (260M)
     532520       1024     2  gptboot0  (512K)
     533544        984        - free -  (492K)
     534528   16777216     3  swap0  (8.0G)
   17311744  471085056     4  zroot-new  (225G)
  488396800        328        - free -  (164K)

ls /dev/gpt/
efiboot0 gptboot0 swap0

En el archivo /etc/fstab usar la etiqueta en lugar del dispositivo

...
/dev/gpt/swap0	  none	  swap	  sw	 0	0
...

Error 2

Import of zpool cache /etc/zfs/zpool.cache failed

El zpool.cache fue generado cuando el pool se llamaba zroot-new y estaba en da0. Ahora el pool se llama zroot y el dispositivo cambió. El caché está obsoleto.

Sencillamente borrarlo, ZFS lo regenera automáticamente

rm /etc/zfs/zpool.cache

Antes de reiniciar para verificar el nombre correcto del dispositivo

swapinfo -h
Device              Size     Used    Avail Capacity
/dev/gpt/swap0      8.0G       0B     8.0G     0%

Si el sistema arrancó pero con errores no críticos Ambos errores no impiden el funcionamiento del sistema. El swap simplemente no está activo hasta que corrijas el fstab, y el zpool.cache se regenera solo. Si llegaste al prompt de login, la migración fue exitosa.

Reiniciar

shutdown -r now

Error 3.

Can't open /dev/gpt/efiboot0

Ese error indica que el bootloader está buscando la partición EFI por su label GPT (efiboot0) pero no la encuentra, probablemente porque el label en el disco nuevo es diferente o no se asignó correctamente

ls /dev/gpt
efiboot0 gptboot0 swap0

Montar el sistema de ficheros rw

mount -u -o rw /

Solución. Renombrar el label al esperado

...
/dev/gpt/efiboot0    /boot/efi	  msdosfs    rw	   2	2
...

Corregir el label

gpart modify -i 1 -l efiboot0 ada0

Si la partición EFI estaba vacía, reinstalar loader

newfs_msdos -F 32 -c 1 /dev/ada0p1
mount -t msdosfs /dev/ada0p1 /mnt
mkdir -p /mnt/EFI/BOOT
cp /boot/loader.efi /mnt/EFI/BOOT/BOOTX64.EFI

umount /mnt

 

FreeBSD es genial!.

Replicar, Recuperar Pool Root FreeBSD ZFS

NFS Sistema de Archivos en Red FreeBSD
Montaje de Sistema de Archivos NFS Usando Autofs
Replicar, Recuperar Pool Root ZFS FreeBSD

Contruir o reconstruir un sistema a partir de instantáneas (snapshot)

Replicar instantáneas en otro sistema es una característica de OpenZFS que mejora la administración de datos, proporciona un mecanismo para manejar una falla de hardware con una pérdida de datos y un tiempo de inactividad mínimos. La replicación también es una forma conveniente de transferir una copia de un sistema existente a otro, por ejemplo, implementar un laboratorio completo de sistemas similares.

Escenario

Servidor: tormenta FreeBSD 13.1 NUC 11 Essential DDR4-2933 CPU 4 \
          32GB RAM M.2 NVMe PCIe 3.0
Cliente: solaris FreeBSD 13.1 Dell Latitude 7390 DDR4-2400 CPU 8 \
          16GB RAM M.2 NVMe PCIe 3.0

Enviar una copia de seguridad al servidor vía ssh utilizando zfs send receive

% cat /etc/hosts | grep tormenta
...
192.168.88.160          tormenta
...

Configurar acceso SSH

OpenZFS utiliza SSH para cifrar la replicación durante la transferencia de red.

Puede generar un par de claves con ssh-keygen y luego enviar una copia de la clave pública al servidor. Presione enter en todas las indicaciones para aceptar los valores predeterminados y no solicitar una frase de contraseña.

Dado que root enviará la replica, cambie esta línea en el archivo de configuración del demonio SSH /etc/ssh/sshd_config

#PermitRootLogin no

a

PermitRootLogin yes

Recargar la configuración del demonio SSH

service sshd reload

Enviar una copia de la clave pública al sistema recector (tormenta)

cat ~/.ssh/id_rsa.pub | ssh 192.168.88.160 'cat >>.ssh/authorized_keys' 
Password for root@192.168.88.160: 
exit

Crear un conjunto de datos para almacenar las instatáneas replicadas /usr/backup/poolrecovery.

tormenta # zfs create -p zroot/usr/backup/poolrecovery

Creamos la instantánea recursiva del conjunto de datos del pool zroot que incluye los sistemas de archivos secundarios

solaris # zfs snapshot -r zroot@zroot.snap1_dell

Comprobar los recursos compartidos por el servidor tormenta

solaris % showmount -e tormenta
Exports list on tormenta:
...
/usr/backup/poolrecovery        192.168.88.0 
...

Montar el recurso compartido

# mount -o soft,intr,rw tormenta:/usr/backup/poolrecovery /mnt

Enviar la instantánea de forma recursiva, redirigimos (como archivo comprimido .gz) a la ubicación compartida para poder acceder a esta ubicación al construir el cliente

# zfs send -Rv zroot@snap1_dell | gzip > /mnt/zroot.snap1.gz

Enviar a un sistema que se encuentra en otra ubicación geografica a través de una conexión ssh

zfs send -Rv zroot@snap-20241125 | ssh root@185.166.84.138 "gzip > \ 
/export/recovery/solaris/zroot@snap-solaris-20241125.gz"

Enviar al servidor de la red local a través de una conexión ssh

zfs send -Rv zroot@snap-20241125 | ssh root@192.168.88.160 "gzip > \ 
/export/recovery/solaris/zroot@snap-solaris-20241125.gz"

Proceso de recuperación

Asumimos que ha realizado una instalación limpia en el sistema a restaurar eligiendo el particionado auto ZFS en el instalador FreeBSD.

Iniciar con una memoria usb que contenga una img de FreeBSD 13.1 (misma RELEASE usada en la instalación del sistema a recuperar)

En la pantalla de instalacion

Install Shell Live cd

Elegir (live cd)

login: root

Intro (no necesita contrasena)

Iniciar la red con el comando

dhclient em0

Ver información de la conexión

# ifconfig

Comprobar conectividad

# ping freebsd.org

Configurar ssh

configurar un sshd único para esta sesión.

# mkdir /tmp/etc
# mount_unionfs /tmp/etc /etc
# edit /etc/ssh/sshd_config

editar /etc/ssh/sshd_config y cambiar la configuración de PermitRootLogin de no a sí y eliminar el comentario, puede utilizar Ctrl-Y para buscar "root".

Establecer una contrasena para el usuario root (no teclee root directamente, utilice passwd root)

# passwd root

Importar el zpool

# mkdir /tmp/zroot
# zpool import -fR /tmp/zroot zroot

Incluir la direccion IP en el archivo /etc/exports del servidor nfs tormenta

Agregar en el archivo /etc/rc.conf la línea

nfs_client_enable

# service nfsclient start
NFS access cache time=60

Montar recurso compartido NFS

# mount -o soft,intr,rw 192.168.88.51:/usr/backup/poolrecovery /mnt

ls /mnt/
zroot.snap1.gz 

Ya tenemos el archivo que utilizaremos

Lanzamos el comando, gzcat descomprime el archivo, lee el archivo y la operacion de lectura redirige al comando receive, para recibir el sistema de archivos en el pool zroot

# gzcat /mnt/zroot.snap1.gz | zfs receive -Fv zroot

Establecer el sistema de archivos de arranque

zpool set bootfs=zroot/ROOT/default zroot

Exportar zroot

# zpool export zroot

Reiniciar el sistema

# reboot

Sí, ha funcionado

En este punto tenemos todo tal y como estaba en el momento en que se crearon las instantáneas

Utilizar el usuario no privilegiado carlos para el envío y recepción de instantáneas

Permisos para el envío de instantáneas

 zfs allow -u carlos create,destroy,hold,mount,receive,send,snapshot zroot

Permisos para la recepción de instantáneas

 zfs allow -u carlos create,destroy,mount,mountpoint,quota,receive,send,\
 snapdir zroot

FreeBSD es genial!.

Crear particiones e instalar FreeBSD 13.0 zfs UEFI

A diferencia del valor predeterminado de bsdinstall para ZFS, no establece puntos de montaje explícitos para conjuntos de datos, sino que se basa en la herencia.

Este conjunto de instrucciones configura partición freebsd-boot, una particion ESP para la instalacion UEFI, intercambio cifrado con GELI y un grupo raíz.  

Iniciar el instalador de FreeBSD

Elegir shell para el particionado manual

Limpiar disco - Esta es una operación destructiva

# gpart destroy -F ada0
ada0 destroyed

Configurar nueva tabla de partición GPT.

Antes de poder crear particiones de disco, se debe marcar el disco con el tipo de esquema de partición que utilizará, gpart create con la marca -s y el esquema, como gpt o mbr. Aquí, el disco usa el esquema GPT

# gpart create -s gpt ada0
ada0 created

Añadir particiones con etiquetas (label -l) para acceder a ellas por su nombre.

Crear partición boot para arranque Legacy (aunque no será utilizada). No puede ser mayor de 545k.

 # gpart add -t freebsd-boot -s 512k -l boot0 ada0
ada0p1 added

UEFI ESP arranque UEFI.

# gpart add -t efi -s 200M -l efi0 ada0 
ada0p2 added

ESP debe ser vfat/fat32:

# newfs_msdos -F 32 -c 1 /dev/ada0p2
/dev/gpt/efi0: 2003 sectors in 2003 FAT12 clusters (512 bytes/cluster)
BytesPerSec=512 SecPerClust=1 ResSectors=1 FATs=2 RootDirEnts=512 Sectors=2048 \
Media=0xf0 FATsecs=6 SecPerTrack=63 Heads=255 HiddenSecs=0

Partición swap

# gpart add -t freebsd-swap -l swap0 -a 1m -s 2048m ada0

Resto del disco

# gpart add -t freebsd-zfs -l zroot0 -a 1m ada0

Crear el root pool

.

# zpool create -R /mnt -o cachefile=/tmp/zpool.cache -O mountpoint=/ \
    -O atime=off -O canmount=off -O compression=on \
    zroot gpt/zroot0
# zfs create -o canmount=off -o mountpoint=none zroot/ROOT
# zfs create -o mountpoint=/ zroot/ROOT/default

Definir el conjunto de datos de arranque predeterminado para este zpool

# zpool set bootfs=zroot/ROOT/default zroot

Crear el resto de los sistemas de archivos

# zfs create -o canmount=off zroot/usr
# zfs create zroot/usr/home
# zfs create zroot/usr/local
# zfs create zroot/usr/obj
# zfs create zroot/usr/src
# zfs create zroot/usr/ports
# zfs create -o canmount=off zroot/var
# zfs create zroot/var/jail
# zfs create zroot/var/log
# zfs create zroot/var/tmp
# zfs create zroot/tmp
# zfs set setuid=off zroot/tmp
# zfs set setuid=off zroot/var
# zfs set exec=off zroot/var
# zfs set setuid=off zroot/usr/src 
# zfs set exec=off zroot/usr/src
# zfs set setuid=off zroot/usr/ports
# zfs set exec=on zroot/var/tmp

Copiar el caché de zpool

# mkdir -p /mnt/boot/zfs
# cp /tmp/zpool.cache /mnt/boot/zfs

No olvide elegir la opción shell para terminar la configuración al final de la instalación.

# exit

Elegir

 Install  

Keymap Selection

Set Hostname

Distribution Select 

Partitioning

En este punto elegir la opción:

open a shell and partition by hand

# exit

Fetching Distribution

Comprobing checksum

Archive Extraction 

New Password

Retype New Password

Network Configuration

Would you like to configure
IPv6..? No

Resolver Configuration

Select local or UTC (Greenwich Mean Time) clock

System Configuration 

System Hardening

Add User Accounts (Yes)

Final Configuration 

Exit (Apply configuration and exit installer) OK

Manual Configuration Yes

Elegir Yes para seguir con la configuración

# cat >> /boot/loader.conf<<EOF
zfs_load="YES"

zpool_cache_load="YES"
zpool_cache_name="/boot/zfs/zpool.cache"
zpool_cache_type="/boot/zfs/zpool.cache"

vfs.root.mountfrom="zfs:zroot/ROOT/default"
EOF

# cat >> /etc/rc.conf<<EOF
zfs_enable="YES"
zfsd_enable="YES"
EOF

# cat >> /etc/fstab<<EOF
/dev/gpt/efi0 /boot/efi0 msdosfs rw,late 0 0
/dev/swap.eli none swap sw 0 0
EOF

# mount -t devfs devfs /dev
# rm /dev/null

Crear punto de montaje y montar ESP

# mkdir /boot/efi0 
# mount -t msdosfs /dev/gpt/efi0 /boot/efi0 

UEFI con nomenclatura de reserva:

mkdir -p /boot/efi0/efi/boot
cp /boot/loader.efi /boot/efi0/efi/boot/bootx64.efi

Llegados a este punto debería estar listo.

# exit

# Reboot

# zfs create zroot/usr/home/carlos

Enlace simbólico y permisos.

# ln -s /usr/home /home
# chmod 1777 /var/tmp
# chmod 1777 /tmp

Usar git para obtener el código fuente de FreeBSD 13.0

(Si necesita construir módulos del kernel)

# pkg install git
# git clone -b releng/13.0 https://git.freebsd.org/src.git /usr/src

Clonar colección de puertos con git

# git clone https://git.freebsd.org/ports.git /usr/ports

Crear Directorios de usuario

# pkg install xdg-user-dirs
$ xdg-user-dirs-update

# cat /etc/fstab
/dev/gpt/efi0 /boot/efi0 msdosfs rw,late 2 2
/dev/swap.eli none swap sw 0 0

# cat /boot/loader.conf
security.bsd.allow_destructive_dtrace=0
cryptodev_load="YES"
zfs_load="YES"
zpool_cache_load="YES"
zpool_cache_name="/boot/zfs/zpool.cache"
zpool_cache_type="/boot/zfs/zpool.cache"

vfs.root.mountfrom="zfs:zroot/ROOT/default"

# cat /etc/rc.conf
clear_tmp_enable="YES"
syslogd_flags="-ss"
sendmail_enable="NONE"
hostname="bsdzfs"
ifconfig_ue0="DHCP"
sshd_enable="YES"
ntpd_enable="YES"
# Set dumpdev to "AUTO" to enable crash dumps, "NO" to disable
dumpdev="NO"
zfs_enable="YES"
zfsd_enable="YES"

# gpart show
=>       40  976773088  ada0  GPT  (466G)
         40       1088     1  freebsd-boot  (544K)
       1128       2048     2  efi  (1.0M)
       3176        920        - free -  (460K)
       4096    4194304     3  freebsd-swap  (2.0G)
    4198400  972574720     4  freebsd-zfs  (464G)
  976773120          8        - free -  (4.0K)

# zfs list
NAME                        USED  AVAIL     REFER  MOUNTPOINT
zroot                      1.83G   444G       96K  /
zroot/ROOT                 1011M   444G       96K  none
zroot/ROOT/default         1011M   444G     1011M  /
zroot/tmp                   104K   444G      104K  /tmp
zroot/usr                   863M   444G       96K  /usr
zroot/usr/home               96K   444G       96K  /usr/home
zroot/usr/local             191M   444G      191M  /usr/local
zroot/usr/obj                96K   444G       96K  /usr/obj
zroot/usr/ports             192K   444G       96K  /usr/ports
zroot/usr/ports/distfiles    96K   444G       96K  /usr/ports/distfiles
zroot/usr/src               672M   444G      672M  /usr/src
zroot/var                   432K   444G       96K  /var
zroot/var/jail               96K   444G       96K  /var/jail
zroot/var/log               144K   444G      144K  /var/log
zroot/var/tmp                96K   444G       96K  /var/tmp

https://wiki.freebsd.org/MasonLoringBliss/ZFSandGELIbyHAND

FreeBSD es genial!.

Actualizar zpool en FreeBSD 13.0 UEFI partition

Después de actualizar el pool el código de inicio del disco duro también se debe actualizar, de manera que se pueda iniciar el sistema sin problemas.

El instalador de FreeBSD 13.0 con zfs elige una partición de arranque BIOS tradicional freebsd-boot y una partición UEFI efi .

gpart show
=>        40  1953525088  ada0  GPT  (932G)
          40      532480    1   efi  (260M)
      532520        1024    2   freebsd-boot  (512K)
      533544         984        - free -  (492K)
      534528     4194304    3   freebsd-swap  (2.0G)
     4728832  1948794880    4   freebsd-zfs  (929G)
  1953523712        1416        - free -  (708K)

# zpool upgrade -a
This system supports ZFS pool feature flags.

Enabled the following features on 'zroot':
  allocation_classes

If you boot from pool 'zroot', don't forget to update boot code.
Assuming you use GPT partitioning and da0 is your boot disk
the following command will do it:

        gpart bootcode -b /boot/pmbr -p /boot/gptzfsboot -i 2 da0

Si el arranque de su sistema es UEFI al ejecutar el código anterior y hacer un reboot el sistema no se iniciará.
    
Para actualizar una partición EFI:

# mount -t msdosfs /dev/ada0p1 /mnt
# mv /mnt/boot/efi0/efi/boot/bootx64.efi /mnt/efi/boot/bootx64.efi-old
# cp /boot/loader.efi /mnt/boot/efi0/efi/boot/bootx64.efi
# umount /mnt

# reboot

FreeBSD es genial!.