Install Arch Linux on ZFS (Italiano)

Related articles
ZFS
ZFS/Virtual disks
Questo articolo spiega i passaggi richiesti per installare Arch Linux su una root filesystem ZFS.
Attenzione
Se si copia ciecamente questa wiki non funzionerà. È necessario prendersi il tempo per capire il processo di boot, e cosa viene fatto durante la creazione dei pool e dei dataset. Eccoti i link utili:
FreeBSD ZFS Handbook
ZFSOnLinux wiki
OpenZFS wiki
Aaron Toponce Install ZFS on Debian GNU/Linux
OpenZFS documentation for Arch Linux
Installazione
Per installare Arch Linux su ZFS, sarà necessario avviare il sistema con il modulo ZFS.
Precauzioni
Il fatto che i moduli Kernel ZFS siano out-of-tree combinato alla natura rolling release come la distribuzione Arch, ci saranno spesso dei momenti (anche se brevi) in cui i pacchetti del kernel nel repository esterno non saranno allineati con quelli Arch, e occasionalmente i moduli ZFS (in versione dkms)  non verranno compilati affato con i kernel piu recenti. Se hai bisogno o vuoi utilizzare sempre i pacchetti Kernel piu recenti, installare Arch su ZFS potrebbe non essere una buona idea. Tuttavia, nella maggior parte dei casi è sensato inserire linux e i relativi linux-* (e linux-*-headers se si utilizza dkms) nel file IgnorePkg e aggiornarli solo manualmente e ripristinarli nel caso in cui ci siano problemi evidenti. In alternativa, si potrebbe usare il pacchetto LTS Kernel, che dovrebbe essere sempre utilizabile con dkms.
Installare il modulo ZFS sul sistema archiso
Esistono due modi per installare il modulo ZFS in archiso.
Uno di questi è tramite un semplice script che installa e carica il modulo ZFS sul sistema archiso avviato. Questo dovrebbe funzionare su tutte le versioni di archiso.
Vedi
eoli3n/archiso-zfs
.
Incorporamento del modulo ZFS in un archiso personalizzato.
per creare un archiso personalizzato, leggere questo articolo
ZFS
.
Partizionamento dell'unità di destinazione
Rivedersi
Partitioning
per informazioni su come determinare il tipo di tabella partizioni da utilizzare per ZFS. ZFS supporta le tabelle partizioni GPT e MBR.
ZFS gestise le proprie partizioni, quindì è richiesto solo uno schema di tabella partizioni di base. La partizione che conterrà il filesystem ZFS dovrà essere di tipo
bf00
, o "Solaris Root".
I dischi più grandi di 2TB richiedono la tabella partizioni GPT. La configurazione GRUB per BIOS/GPT richiede una partizione di tipo "BIOS GRUB" grande (1-2MiB) per contenere l'immagine del codice di avvio..
In base al firmware della macchina e alla modalità di avvio scelta, l'avvio potrà richiedere o meno una
EFI system partition
. Su una macchina BIOS (o una macchina UEFI avvio in modalità legacy), una partizione di sistema EFI non è richiesta. Consulta la pagina
Arch boot process#Boot loader
per maggiori informazioni.
Schema partizioni
Ecco un esempio di uno schema di partizioni base che potrebbe essere utilizzato per l'installazione root ZFS su una macchina con BIOS/MBR e GRUB:
Part     Size   Type
----     ----   -------------------------
   1     XXXG   Solaris Root (bf00)
Utilizzando GRUB con tipo di avvio della macchina BIOS (o una macchina UEFI in modalità avvio legacy) ma usando lo schema partizioni GPT:
Part     Size   Type
----     ----   -------------------------
   1       2M   BIOS boot partition (ef02)
   2     XXXG   Solaris Root (bf00)
Utilizzando
Syslinux
con
zfsbootmenu
AUR
su una macchina con modalità avvio BIOS e una tabella partizioni GPT o MBR:
The factual accuracy of this article or section is disputed.
Reason:
The "BIOS boot partition" is GRUB-specific. Syslinux does not use it. (Discuss in
Talk:Install Arch Linux on ZFS (Italiano)
)
Part     Size   Type
----     ----   -------------------------
   1     512M   BIOS boot partition (ef02)
   2     XXXG   Solaris Root (bf00)
Un altro esempio, questa volta usando un bootloader specifico UEFI (come
rEFInd
) con tabella partizioni GPT:
Part     Size   Type
----     ----   -------------------------
   1       1G   EFI system partition (ef00)
   2     XXXG   Solaris Root (bf00)
ZFS non suporta lo swap file. Se si necessita della partizione di swap, visitare
ZFS#Swap volume
per creare lo swap ZVOL.
Tip
I bootloaders con supporto per ZFS sono descritti in
#Installazione e configurazione del bootloader
.
Attenzione
Diversi bug di GRUB (
bug #42861
,
zfsonlinux/grub/issues/5
) complicate installing it on ZFS partitions, see
#Installazione e configurazione del bootloader
for a workaround
Esempi di comandi per parted
Ecco alcuni comandi di esempio per partizionare un'unità per il secondo scenario di cui sopra, ovvero utilizzando la modalità di avvio BIOS/legacy con una tabella delle partizioni GPT e una partizione di avvio del BIOS da 1 MB (poco più) per GRUB:
# parted /dev/sd
x
(parted)mklabel gpt
(parted)mkpart non-fs 0% 2
(parted)mkpart primary 2 100%
(parted)set 1 bios_grub on
(parted)set 2 boot on
(parted)quit
è possibile ottenere quanto sopra, in un singolo comando:
# parted --script /dev/sd
x
mklabel gpt mkpart non-fs 0% 2 mkpart primary 2 100% set 1 bios_grub on set 2 boot on
Se si sta creando un partizione di sistema EFI dovrà essere impostata sotto boot invece che root.
Formattazione del disco di destinazione
Se si ha optato per una partizione di avvio e per qualsiasi altra partizione di sistema non ZFS, formattala. Non fare nulla alla partizione Solaris né alla partizione alla partizione di avvio BIOS GRUB. ZFS gestirà la prima, mentre il bootloader la seconda.
Configurazione ZFS filesystem
Attenzione
Non usare il carattere '-' nel nome dei datasets. (
see this "feature"
)
Prima, assicurati che il modulo ZFS sia caricato:
# modprobe zfs
Creazione del pool di root
Creare il tuo pool e imposta tutte le opzioni del dataset predefinite. Tutti i dataset creati da zpool, erediteranno ciascuno l'opzione
-O
alla creazione. Le impostazioni di default sono spiegate in
Debian Buster Root on ZFS. Step 2: Disk Formatting
.
Note
Utilizzare
-o ashift=9
per dischi con una dimensione dei settori fisici di 512 byte o
-o ashift=12
per dischi con dimensione fisica dei settori a 4096 byte. Vedi
lsblk -S -o NAME,PHY-SEC
per verificare la dimensione fisica del settore per ogni disco SCSI/SATA. Rimuovere
-S
se si vuole lo stesso valore per tutti i dispositivi. Per dischi NVMe, usare
nvme id-ns /dev/nvmeXnY -H | grep "LBA Format"
per ottenere quale formato LBA è in uso. Molti dischi NVMe sono con dimensione dei settori fisica da 512-byte, Vedi
OpenZFS: NVMe low level formatting
per passare a settori di 4096-byte.
Attenzione
Tieni a presente che la maggior parte dei dispositivi moderni usa settori fisici da 4096 byte, anche se alcuni riportno 512 byte. Questo è specialmentevero per gli SSD. Selezionando
ashift=9
su una dimensione settori di 4096 byte (anche se viene riportato 512)
comporterà
una perdita di prestazioni. Selezionando
ashift=12
su settori da 512 byte potrebbe comportare ma incorrere in perdita di capacità, ma non in si avrà delle perdite di prestazioni. Se si è in dubbio, per i dischi moderni, sbagliare dalla parte
ashift=12
, o ricerca il valore appropriato al tuo dispositivo. Fare riferimento a
OpenZFS issue #967
for a related discussion, and
OpenZFS issue #2497
fper una conseguenza di un valore di spostamento più elevato.
# zpool create -f -o ashift=12         \
             -O acltype=posixacl       \
             -O relatime=on            \
             -O xattr=sa               \
             -O dnodesize=legacy       \
             -O normalization=formD    \
             -O mountpoint=none        \
             -O canmount=off           \
             -O devices=off            \
             -R /mnt                   \
             zroot /dev/disk/by-id/
id-to-partition-partx
Compressione e crittografia nativa
Questo abiliterà la compressione e la crittografia nativa per impostazione predefinita su tutti i dataset:
# zpool create -f -o ashift=12         \
             -O acltype=posixacl       \
             -O relatime=on            \
             -O xattr=sa               \
             -O dnodesize=legacy       \
             -O normalization=formD    \
             -O mountpoint=none        \
             -O canmount=off           \
             -O devices=off            \
             -R /mnt                   \
             -O compression=lz4        \
             -O encryption=aes-256-gcm \
             -O keyformat=passphrase   \
             -O keylocation=prompt     \
             zroot /dev/disk/by-id/
id-to-partition-partx
Attenzione
Utilizza sempre i nomi ID quando lavori con ZFS, altrimenti si verificheranno errori di importazione.
Invece di by-id, considera l'utilizzo di by-partuuid o by-uuid, poiché rimarranno coerenti anche se un'unità interna viene spostata in un contenitore USB o viceversa (questo è possibile solo se ZFS viene utilizzato con una partizione, non con un intero disco)
Gli utenti
GRUB
dovrebbero tenere a mente che il comando
zpool-create
normalmente abilita tutte le caratteristiche,
alcuni dei quali potrebbero non essere supportati da GRUB
. Vedi:
ZFS#GRUB-compatible pool creation
.
Creazione dei dataset
Invece di utilizzare le partizioni del disco convenzionali, ZFS utilizza il concetto di dataset per gestire il tuo spazio di archiviazione. A differenza delle partizioni del disco, i dataset non hanno dimensioni fisse e consentono di applicare attributi diversi, come la compressione, a ciascun dataset. I normali dataset ZFS vengono montati automaticamente da ZFS mentre i dataset legacy devono essere montati utilizzando fstab o con il tradizionale comando mount.
Una delle funzionalità più utili di ZFS sono gli ambienti di avvio. Gli ambienti di boot ti consentono di creare un'istantanea avviabile del tuo sistema a cui puoi ripristinare immediatamente in qualsiasi momento semplicemente riavviando e avviando da quell'ambiente di boot. Ciò può rendere gli aggiornamenti di sistema molto più sicuri ed è anche incredibilmente utile per lo sviluppo e il test del software. Per poter utilizzare un gestore dell'ambiente di boot come
beadm
,
zectl
AUR
(systemd-boot), o
zedenv
AUR
(GRUB) per gestire gli ambienti di boot, i dataset devono essere configurati correttamente. La chiave è che dividi le tue cartelle di dati (come
/home
) in dataset distinti dai dataset del tuo sistema e che non inserisci i dati nella radice del pool poiché questo non può essere spostato in seguito.
Dovresti sempre creare un dataset almeno per il tuo filesystem root e in quasi tutti i casi vorrai che anche
/home
sia in un dataset separato. Potresti decidere di desiderare che i tuoi registri persistano negli ambienti di avvio. Se stai utilizzando un software che memorizza dati al di fuori di
/home
(come nel caso dei server di database) dovresti strutturare i tuoi dataset in modo che le cartelle dei dati del software che desideri eseguire siano separate dal dataset root.
Con questi comandi di esempio, creeremo una configurazione compatibile con l'ambiente di boot di base comprendente solo i dataset root e
/home
. Eredita le opzioni predefinite da
zpool creation
.
# zfs create -o mountpoint=none zroot/data
# zfs create -o mountpoint=none zroot/ROOT
# zfs create -o mountpoint=/ -o canmount=noauto zroot/ROOT/default
# zfs create -o mountpoint=/home zroot/data/home
Puoi anche creare il tuo dataset ROOT senza dover specificare il punto di montaggio su / poiché GRUB lo monterà comunque su /. Ciò ti dà la possibilità di avviare alcune vecchie versioni di root semplicemente clonandole e inserendole come voce di menu di GRUB. In tal modo, puoi creare ROOT con il seguente comando:
# zfs create -o mountpoint=/roots/default zroot/ROOT/default
Puoi memorizzare
/root
nella tua
zroot/data/home
dataset.
# zfs create -o mountpoint=/root zroot/data/home/root
Dovrai abilitare alcune opzioni per i dataset che contengono directory specifiche:
Opzioni richieste da directory specifiche
Directory
Dataset option
Details
/
canmount=noauto
/var/log/journal
acltype=posixacl
systemd (Italiano)#systemd-tmpfiles-setup.service non si avvia al boot
Dataset di sistema
Per creare dataset per il sistema di cartelle, usa
canmount=off
.
Per alcuni esempi, puoi leggere
Debian-Buster-Root-on-ZFS#step-3-system-installation
.
Note
Considera 'utilizzo di
zfs-mount-generator
invece di
zfs-mount.service
se si monta un dataset, ad esempio
zroot/var/log
, su
/var/log
. Corregge l'ordine di montaggio del filesystem come descritto in
Step 5.7 of Debian Buster Root on ZFS
.
# zfs create -o mountpoint=/var -o canmount=off     zroot/var
# zfs create                                        zroot/var/log
# zfs create -o mountpoint=/var/lib -o canmount=off zroot/var/lib
# zfs create                                        zroot/var/lib/libvirt
# zfs create                                        zroot/var/lib/docker
Export/Import dei pool
Per validare la propria configurazine, esportare e reimportare i propri pool.
Attenzione
Non saltare questo passaggio, Do not skip this, altrimenti sarà richiesto l'utilizzo di
-f
quando si importa i pool. Questo scarica i pool importati.
Note
Questo potrebbe fallire se si ha aggiunto una partizione di swap. Si dovrà procedere con la disattivazione tramite il comando
swapoff
.
# zpool export zroot
# zpool import -d /dev/disk/by-id -R /mnt zroot -N
Note
-d
non è l'attuale ID del dispositivo, ma la cartella contenente i link simbolici.
Se questo comando fallisce e viene chiesto di importare i pool tramite il suo ID numerico, esegui
zpool import
per scoprire lo ID del tuo pool, quindi utilizza un comando come:
# zpool import 9876543212345678910 -R /mnt zroot
Se si sta usando la cifratura nativa, caricare la chiave zfs.
# zfs load-key zroot
Montare manualmente il proprio rootfs dataset perché questo ha l'opzione
canmount=noauto
, poi montare i rimanenti datasets creati.
# zfs mount zroot/ROOT/default
# zfs mount -a
Adesso lo ZFS filesystem è pronto ad essere utilizzato.
Configurazione del root filesystem
Se hai utilizzato i dataset legacy, saranno elencati in
/etc/fstab
.
Imposta la proprietà di bootfs sul filesystem di root, in modo che il boot loader sia in grado di trovare il sistema ooperativo.
# zpool set bootfs=zroot/ROOT/default zroot
Se non si ha
/etc/zfs/zpool.cache
, crearlo:
# zpool set cachefile=/etc/zfs/zpool.cache zroot
Assicurati di portare il file
zpool.cache
nel ptoprio sistema. Questo sarà necessario successivamente per l'avvio del demone ZFS.
# mkdir -p /mnt/etc/zfs
# cp /etc/zfs/zpool.cache /mnt/etc/zfs/zpool.cache
Installazione e configurazione Arch Linux
Segui i passaggi seguenti usando la
Installation guide (Italiano)
. Verrà specificato dove sarà necessario prestare più attenzione per ZFSonLinux.
Per prima cosa montare tutte le partizioni di avvio o di sistema legacy o non-ZFS, usando il comando mount.
Installa il sistema di base.
La procedura descritta in
Installation guide (Italiano)#Fstab
di solito è eccessivo per ZFS. Solitamente ZFS monta automaticamente le proprie partizioni, quindi non abbiamo bisogno delle partizioni ZFS nel file
fstab
, a meno che l'utente non abbia creato i dataset legacy delle cartelle di sistema. Per generare
fstab
per i filesystem, usare:
# genfstab -U -p /mnt >> /mnt/etc/fstab
Cambiare root nel nuovo sistema, per
Installation guide (Italiano)#Chroot
:
# arch-chroot /mnt
Modificare il file
/etc/fstab
:
Note
Se hai scelto di creare dataset legacy per le cartelle di sistema, mantienili nel file
fstab
!
Commentare tutti i non-legacy dataset al di fuori di swap file e la partizione di sistema EFI. Questa è una convenzione per sostituire lo UUID dello swap con
/dev/zvol/zroot/swap
.
Sarà necessario aggiungere
Arch ZFS
repository in
/etc/pacman.conf
,
firmarne la chiave
e
installare
zfs-linux
AUR
(o
zfs-linux-lts
AUR
se si sta usando il kernel LTS) all'interno di arch-chroot prima di poter aggiornare il ramdisk con il supporto ZFS.
Quando si crea lo initial ramdisk, prima modificare
/etc/mkinitcpio.conf
. Aggiungere
zfs
a
MODULES
:
MODULES=(zfs)
Poi in
HOOKS
, aggiungere
zfs
prima di filesystems. Poi, spostare
keyboard
hook prima di
zfs
quindi puoi digitare in console se qualcosa va storto. Sarà necessario anche rimuovere fsck (se non si sta usando Ext3 or Ext4). La tua linea di
HOOKS
dovrà essere simile alla seguente:
HOOKS=(base udev autodetect microcode modconf kms keyboard keymap consolefont block zfs filesystems)
Quando si utilizza systemd nello initrd, è necessario installare
mkinitcpio-sd-zfs
AUR
e aggiungere lo hook
sd-zfs
dopo lo hook
systemd
invece dello hook
zfs
. Tieni presente che questo hook utilizza parametri del kernel diversi rispetto allo hook predefinito
zfs
, maggiori informazioni possono essere trovate su
project page
.
Note
sd-zfs
non supporta ancora la crittografia nativa
dasJ/sd-zfs/issues/4
.
Se si sta utilizzando un dataset separato per
/usr
e si ha seguito le istruzioni riportate di seguito, bisognerà assicurarsi di avere lo hook
usr
abilitato dopo
zfs
, o il sistema non si avvierà.
Quando si genera lo initramfs, il file
zpool.cache
viene copiato nello initrd. Se non lo hai generato prima o hai bisogno di rigenerarlo, ricordati di rigenerare nuovamente lo initramfs.
Puoi anche utilizzare il muontpoint
legacy
per consentire a fstab di montarlo.
Regenerate the initramfs
.
Installazione e configurazione del bootloader
In linea di principio, la configurazione del bootloader non differisce molto se il kernel e initrd risiedono in una partizione non-ZFS. Una volta che il kernel ha il modulo zfs e initrd che sono stati compilati con lo hook, e la riga cmd del kernel ha il parametro kernel
zfs
, il sistema può avviarsi. Ad esempio,
zfs=zroot/ROOT/default rw
o anche solo
zfs=zroot rw
(nel caso in cui il parametro bootfs sia stato impostato correttamente come fatto precedentemente) dovrebbe funzionano per la maggior parte dei casi. Non è necessario un parametro
root
poiché zfs monterà la root. Consulta la documentazione del bootloader su come impostare i parametri del kernel.
Tuttavia, se è necessario caricare l'immagine del kernel e/o initrd da zfs, è necessario utilizzare un bootloader in grado di leggere zfs e configurare correttamente il bootloader.
Considerando quanto sopra, configurare il tuo bootloader dovrebbe essere abbastanza semplice. Ecco alcuni esempi, ma l’elenco non è affatto completo.
Utilizzando EFISTUB
Per
EFISTUB
, sarà possibile aggiungere una voce al menu di avvio UEFI:
# efibootmgr --create --disk
il_tuo_disco_esp
--part
il_tuo_numero_di_partizione_esp
--label "Arch Linux (ZFS)" --loader /vmlinuz-linux --unicode 'zfs=zroot/ROOT/default rw initrd=\initramfs-linux.img'
Utilizzando Unified kernel image
Utilizzando una
Unified kernel image
(UKI) è abbastanza semplice. Assicurati solo di avere il parametro zfs da qualche parte in
/etc/cmdline.d
. Configura manualmente mkinitcpio (moduli e hooks) come fatto in precedenza in questa pagina, o altrimnenti come faresti per una normale UKI. Per esempio:
/etc/cmdline.d/root.conf
zfs=zroot/ROOT/default rw
Forse zfs=zroot è sufficiente (non testato), poiché zfs dovrebbe montare automaticamente root. Ricorda solo di rieseguire mkinitcpio ogni volta che si apportato modifiche.
Utilizzando GRUB
Se si usa GRUB, sarà possibile inserire il proprio
/boot
in uno zpool. Leggere
Debian-Buster-Root-on-ZFS#step-3-system-installation
.
Installa GRUB sul disco come indicato qui:
GRUB#BIOS systems
o
GRUB#UEFI systems
. GRUB
manual
fornisce informazioni dettagliate sulla configurazione manuale del software che è possibile integrare con
GRUB
e
GRUB/Tips and tricks
.
bug: rilevamento del pool root danneggiato
A causa di un
bug
,
grub-mkconfig
non riuscirà a rilevare il pool root e ometterà
/boot/grub/grub.cfg
. Fino a quando il problema non viene risolto, ci sono due possibili soluzioni alternative:
Soluzione A: Modifica il codice per il rilevamento rpool in
/etc/grub.d/10_linux
. Sostituisci
rpool=`${grub_probe} --device ${GRUB_DEVICE} --target=fs_label 2>/dev/null || true`
con
rpool=`zdb -l ${GRUB_DEVICE} | grep " name:" | cut -d\' -f2`
Questo di solito è in grado di rilevare il nome corretto del pool root e scrivere il percorso di lavoro su
/boot/grub/grub.cfg
ogni volta che viene utilizzato
grub-mkconfig
.
Soluzione B:  Se la soluzione di cui sopra non riesce a rilevare il percorso corretto, puoi codificarlo in
/etc/grub.d/10_linux
. Sostituendo
linux   ${rel_dirname}/${basename} root=${linux_root_device_thisversion} rw ${args}
con
linux   ${rel_dirname}/${basename} root=ZFS=zroot/ROOT/default rw ${args}
errore: impossibile ottenere il percorso canonico di
grub-mkconfig
non riesce a generare correttamente le voci per i sistemi su ZFS.
# grub-mkconfig -o /boot/grub/grub.cfg
/usr/bin/grub-probe: error: failed to get canonical path of `/dev/bus-Your_Disk_ID-part#'
grub-install: error: failed to get canonical path of `/dev/bus-Your_Disk_ID-part#'
Per risolvere questo problema è necessario impostare questa variabile di ambiente:
ZPOOL_VDEV_NAME_PATH=1
. Per esempio:
# ZPOOL_VDEV_NAME_PATH=1 grub-mkconfig -o /boot/grub/grub.cfg
errore: filesystem sconosciuto
Gli strumenti GRUB come
grub-probe
o
grub-install
potrebbero fallire con l'errore
unknown filesystem
quando il rilevamento del filesystem fallisce. Ciò può accadere perché il filesystem non è supportato da GRUB o, nel caso di ZFS, potrebbero essere presenti funzionalità non supportate (fare riferimento
ZFS#GRUB-compatible pool creation
per le funzionalità appropriate da includere in uno zpool di avvio.)
Per risolvere l'errore, capire quale filesystem non riesce a identificare (ad esempio, eseguire
grub-probe
sui sospetti, come
grub-probe /
o
grub-probe /boot
). Segue un esempio di interazione:
# grub-probe /boot
zfs

# grub-probe /
grub-probe: error: unknown filesystem.
Dopo aver identificato il filesystem problematico, esegui
grub-probe -vvvv /
e scansiona lo output per il filesystem che avrebbe dovuto identificare. In questo caso era previsto ZFS, ma è stato generato il seguente output:
grub-probe -vvvv /
(...)
grub-core/kern/fs.c:56: Detecting zfs...
grub-core/osdep/hostdisk.c:420: opening the device `/dev/sda4' in open_device()
grub-core/fs/zfs/zfs.c:1199: label ok 0
grub-core/osdep/hostdisk.c:399: reusing open device `/dev/sda4'
grub-core/fs/zfs/zfs.c:1014: check 2 passed
grub-core/fs/zfs/zfs.c:1025: check 3 passed
grub-core/fs/zfs/zfs.c:1032: check 4 passed
grub-core/fs/zfs/zfs.c:1042: check 6 passed
grub-core/fs/zfs/zfs.c:1050: check 7 passed
grub-core/fs/zfs/zfs.c:1061: check 8 passed
grub-core/fs/zfs/zfs.c:1071: check 9 passed
grub-core/fs/zfs/zfs.c:1093: check 11 passed
grub-core/fs/zfs/zfs.c:1119: check 10 passed
grub-core/fs/zfs/zfs.c:1135: str=com.delphix:hole_birth
grub-core/fs/zfs/zfs.c:1135: str=com.delphix:embedded_data
grub-core/fs/zfs/zfs.c:1144: check 12 passed (feature flags)
grub-core/fs/zfs/zfs.c:1884: zio_read: E 0: size 4096/4096
(...)
grub-core/osdep/hostdisk.c:399: reusing open device `/dev/sda4'
grub-core/fs/zfs/zfs.c:2117: zap: name = com.delphix:extensible_dataset, value = 18, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = com.datto:bookmark_v2, value = 0, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = com.datto:encryption, value = c, cd = 0 # <------------------
grub-core/kern/fs.c:78: zfs detection failed.  # <----------------------------------------------------
grub-core/kern/fs.c:56: Detecting xfs...
grub-core/fs/xfs.c:931: Reading sb
grub-core/fs/xfs.c:270: Validating superblock
grub-core/kern/fs.c:78: xfs detection failed.
grub-core/kern/fs.c:56: Detecting ufs2...
(...)
grub-core/kern/fs.c:56: Detecting affs...
grub-core/kern/fs.c:78: affs detection failed.
grub-probe: error: unknown filesystem.
Ciò dimostra che il rilevamento ZFS è andato bene finché non è stata rilevata la funzionalità
com.datto:encryption
. Poiché la crittografia nativa ZFS non è supportata da GRUB (a partire da agosto 2021), il rilevamento di ZFS non è riuscirà. Un secondo zpool compatibile con GRUB potrebbe essere appropriato per l'avvio in un sistema crittografato: a partire da agosto 2021, questo è l'approccio consigliato (fare riferimento a
relevant OpenZFS project page
).
Un'esecuzione riuscita
grub-probe
su uno zpool compatibile con GRUB assomiglia a questo:
grub-probe -vvvv /boot
(...)
grub-core/osdep/hostdisk.c:399: reusing open device `/dev/sda3'
grub-core/fs/zfs/zfs.c:2117: zap: name = com.delphix:extensible_dataset, value = 0, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = com.delphix:embedded_data, value = 1, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = com.delphix:hole_birth, value = 1, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = org.open-zfs:large_blocks, value = 0, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = org.illumos:lz4_compress, value = 1, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = , value = 0, cd = 0
grub-core/fs/zfs/zfs.c:2117: zap: name = , value = 0, cd = 0
grub-core/fs/zfs/zfs.c:3285: alive
(...)
grub-core/fs/zfs/zfs.c:1906: endian = 1
grub-core/fs/zfs/zfs.c:597: dva=8, 20008
grub-core/fs/zfs/zfs.c:2697: alive
zfs
Avvio del kernel e initrd da ZFS
Puoi saltare questa sezione se hai il kernel e initrd su una partizione
/boot
separata utilizzando qualcosa come ext4 o vfat.
Altrimenti grub deve caricare il kernel e initrd provenienti da un dataset ZFS, i percorsi del kernel e initrd devono essere nel seguente formato:
/dataset/@/actual/path
Esempio con Arch installato sul dataset root:
/boot/grub/grub.cfg
set timeout=5
set default=0

menuentry "Arch Linux" {
    search -u UUID
    linux /@/boot/vmlinuz-linux zfs=zroot rw
    initrd /@/boot/initramfs-linux.img
}
Esempio con Arch installato su un dataset nidificato:
/boot/grub/grub.cfg
set timeout=5
set default=0

menuentry "Arch Linux" {
    search -u UUID
    linux /ROOT/default/@/boot/vmlinuz-linux zfs=zroot/ROOT/default rw
    initrd /ROOT/default/@/boot/initramfs-linux.img
}
Avvio del kernel e initrd da una partizione di avvio separata
Esempio con una partizione /boot separata non ZFS e Arch installato su un set di dati nidificato:
/boot/grub/grub.cfg
set timeout=5
set default=0

menuentry "Arch Linux" {
    search -u UUID
    linux /vmlinuz-linux zfs=zroot/ROOT/default rw
    initrd /initramfs-linux.img
}
Utilizzo di systemd-boot (solo per EFI)
systemd-boot non riesce ad aprire
/boot
se risiede all'interno di uno zpool, quindi sarà necessario far risiedere
/boot
in una partizione VFAT o ext4 separata.
Note
Per poter gestire i tuoi ambienti di avvio con
zectl
AUR
, segui
zectl/docs/plugins/systemdboot.md
.
Installare systemd-boot sulla propria partizione di sistema EFI seguendo
systemd-boot#Installing the UEFI boot manager
.
Creare una boot entry:
esp
/loader/entries/arch.conf
title   Arch Linux
linux   /vmlinuz-linux
initrd  /initramfs-linux.img
options zfs=zroot/ROOT/default rw
Utilizzando rEFInd per UEFI
Usare
EFISTUB
e
rEFInd
per il UEFI boot loader. I parametri kernel in
refind_linux.conf
per ZFS dovrebbero essere
zfs=bootfs
o
zfs=zroot
in modo che il sistema possa avviarsi da ZFS. I parametri
root
e
rootfstype
non sono richiesti.
Using ZFSBootMenu for UEFI
Quando si utilizza ZFSBootMenu si deve avere la directory
/boot
posizionata sul tuo filesystem root (ZFS). Vedi
Boot Environments and You: A Primer
per ulteriori informazioni.
Sarà possibile scegliere tra usare
#Generazione immagine ZFSBootMenu
o usare
#Binari EFI ZFSBootMenu
precostruito.
Generazione immagine ZFSBootMenu
Montare la propria partizione
ESP
Installare
zfsbootmenu
AUR
e
efibootmgr
Attenzione
Per compilare ZFSBootMenu in queto momento non è possibile usare un helper AUR come ad esempio:
paru
AUR
o
yay
AUR
, Ma sarà possibile compilare il pacchetto manualmente seguendo questa soluzione
Come descritto qui
e spostare manualmente, nelle ripsettive posizioni, tutti i file.
Le seguenti dipendenze sono richieste per il funzionamento di ZFSBootMenu:
perl-boolean
AUR
,
perl-sort-versions
,
perl-yaml-pp
,
kexec-tools
,
fzf
.
Configurazione ZFSBootMenu:
/etc/zfsbootmenu/config.yaml
Global:
  ManageImages: true
  BootMountPoint:
percorso_del_tuo_ESP
DracutConfDir: /etc/zfsbootmenu/dracut.conf.d
  PreHooksDir: /etc/zfsbootmenu/generate-zbm.pre.d
  PostHooksDir: /etc/zfsbootmenu/generate-zbm.post.d
  InitCPIO: true
  InitCPIOConfig: /etc/zfsbootmenu/mkinitcpio.conf
Components:
  ImageDir:
percorso_del_tuo_ESP
/EFI/zbm
  Versions: 3
  Enabled: false
  syslinux:
    Config: /boot/syslinux/syslinux.cfg
    Enabled: false
EFI:
  ImageDir:
percorso_del_tuo_ESP
/EFI/zbm
  Versions: false
  Enabled: true
Kernel:
  CommandLine: ro quiet loglevel=0
Generazione immagini ZFSBootMenu:
# generate-zbm
Configurazione degli argomenti della riga di comando di avvio zfs:
# zfs set org.zfsbootmenu:commandline="rw" zroot/ROOT
Prima di aggiungere ZFSBootMenu dovrai montare lo UEFI variable filesystem:
# mount -t efivarfs efivarfs /sys/firmware/efi/efivars
Note
Secondo la guida:
Unified Extensible Firmware Interface#Mount efivarfs
Attenzione
Se questo passaggio viene saltato il sistema non si avvierà
Aggiunta della ZFSBootMenu entry allo EFI boot manager:
# efibootmgr -c -d
disco_esp
-p
numero_partizione_esp
-L "ZFSBootMenu" -l '\EFI\zbm\vmlinuz-linux.EFI'
Binari EFI ZFSBootMenu
Montare la propria partizione
ESP
Installare
zfsbootmenu-efi-bin
AUR
e
efibootmgr
Configurazione degli argomenti della riga di comando di avvio zfs:
# zfs set org.zfsbootmenu:commandline="rw" zroot/ROOT
Prima di aggiungere ZFSBootMenu dovrai montare lo UEFI variable filesystem:
# mount -t efivarfs efivarfs /sys/firmware/efi/efivars
Note
Secondo la guida:
Unified Extensible Firmware Interface#Mount efivarfs
Attenzione
Se questo passaggio viene saltato il sistema non si avvierà
Aggiunta della ZFSBootMenu entry allo EFI boot manager:
# efibootmgr -c -d
disco_esp
-p
numero_partizione_esp
-L "ZFSBootMenu" -l '\EFI\zbm\zfsbootmenu-release-vmlinuz-x86_64.EFI'
Utilizzando ZFSBootMenu per Legacy/CSM
Come per UEFI, se si utilizza ZFSBootMenu la directory
/boot
dovrà esser parte del pool
zroot
.
Ma a differnza della directory
efi
si avrà bisogno della directory
syslinux
.
Booting explaination ZFSBootMenu
Installing ZFSBootMenu on MBR
Complete guide for Syslinux
Montare la propria partizione
syslinux
.
Note
Per eseguire questo passaggio sarà necessario aver seguito lo
Schema Partizioni
relativo a Syslinux e ZFSBootMenu.
Installare il pacchetto
syslinux
e
gptfdisk
per supporto a dischi con tabelle partizioni GPT.
Copiare tutti i file
.c32
dentro la directory
syslinux
:
# cp /usr/lib/syslinux/bios/*.c32 /
la_tua_posizione
/syslinux
Adesso installare il bootloader:
# extlinux --install /
la_tua_posizione
/syslinux
Una volta fatto, procedere con l'installazione di Syslinux bootstrap code appropriato per la propria tabella partizioni:
mbr.bin
verrà installatio per una
#MBR partition table
or,
gptmbr.bin
verrà installatio per una
#GUID partition table
Adesso sarà possibile installare
zfsbootmenu
AUR
Attenzione
Per compilare ZFSBootMenu in queto momento non è possibile usare un helper AUR come ad esempio:
paru
AUR
o
yay
AUR
, Ma sarà ossibile compilare il pacchetto manualmente seguendo questa soluzione
Come descritto qui
e spostare manualmente, nelle ripsettive posizioni, tutti i file.
Le seguenti dipendenze sono richieste per il funzionamento di ZFSBootMenu:
perl-boolean
AUR
,
perl-sort-versions
,
perl-yaml-pp
,
kexec-tools
,
fzf
.
Configurazione degli argomenti della riga di comando di avvio zfs:
# zfs set org.zfsbootmenu:commandline="rw" zroot/ROOT
Impostazione della creazione di immagini di ZFSBootMenu mediante modifica di:
/etc/zfsbootmenu/config.yaml
Global:
  ManageImages: true
  BootMountPoint:
path_to_your_syslinux_folder
PreHooksDir: /etc/zfsbootmenu/generate-zbm.pre.d
  PostHooksDir: /etc/zfsbootmenu/generate-zbm.post.d
  InitCPIO: true
  InitCPIOConfig: /etc/zfsbootmenu/mkinitcpio.conf
Components:
  ImageDir:
percorso_della_tua_cartella_syslinux
/zfsbootmenu
  Versions: false
  Enabled: true
Kernel:
  CommandLine: ro quiet loglevel=0
Adesso generare l'immagine ZFSBootMenu:
# generate-zbm
Note
Se si intende avere una entry di backup su Syslinux, genereare l'immagine personalizzata due volte
Modificare il file sostiuendo il contenuto con:
/boot/syslinux/syslinux.cfg
UI menu.c32
PROMPT 0

MENU TITLE ZFSBootMenu
TIMEOUT 50

DEFAULT zfsbootmenu

LABEL zfsbootmenu
  MENU LABEL ZFSBootMenu
  KERNEL /zfsbootmenu/vmlinuz-linux-bootmenu
  INITRD /zfsbootmenu/initramfs-bootmenu.img
  APPEND zfsbootmenu quiet

# The following for the backup entry
LABEL zfsbootmenu-backup
  MENU LABEL ZFSBootMenu (Backup)
  KERNEL /zfsbootmenu/vmlinuz-linux-bootmenu-backup
  INITRD /zfsbootmenu/initramfs-bootmenu-backup.img
  APPEND zfsbootmenu quiet
Per concludere rigenerare mkinitcpio:
# mkinitcpio -P
Configurazione di systemd ZFS mounts
Affinché il tuo sistema possa riavviarsi senza problemi, devi abilitare
zfs.target
per montare automaticamente i pool e impostare lo hostid.
Note
L'istruzioni in questa sezione presuppongono che tu sia sempre in
arch-chroot
Per ogni pool che si desidera montare automaticamente eseguire:
# zpool set cachefile=/etc/zfs/zpool.cache
pool
Avviare
zfs.target
Per montare automaticamente i pool zfs all'avvio è necessario
Avviare
zfs-import-cache.service
,
zfs-mount.service
e
zfs-import.target
.
Quando si esegue ZFS su root, lo hostid della macchina non sarà disponibile al momento del montaggio del filesystem di root. Ci sono due soluzioni. Puoi inserire il tuo spl hostid nei
kernel parameters
del tuo boot loader. Per esempio, aggiungendo
spl.spl_hostid=0x00bab10c
, per ottenere il tuo numero di hostid digitare il comando
hostid
.
L'altra soluzione suggerita è assicurarsi che ci sia un hostid in
/etc/hostid
, quindi rigenerare l'immagine initramfs che copierà lo hostid nell'immagine initramfs. Per scrivere il file hostid in modo sicuro è necessario utilizzare il coamndo
zgenhostid
.
Per utilizzare lo hostid generato da libc (raccomandata):
# zgenhostid $(hostid)
Per utilizzare un hostid personalizzato (deve essere esadecimale e lungo 8 caratteri):
# zgenhostid deadbeef
Per consentire allo strumento di generare un hostid:
# zgenhostid
Non dimenticare di
regenerate the initramfs
.
Smontare e riavvio
Abbiamo quasi finito! Se disponi di una partizione di avvio legacy prima eseguire:
# umount /mnt/boot
poi:
# zfs umount -a
# zpool export zroot
Adesso riavviare.
Attenzione
Se non esporti correttamente zpool, il pool rifiuterà l'importazione nell'ambiente ramdisk e rimarrai bloccato sul terminale busybox.
Caricamento password da USB-Stick
È possibile memorizzare la password su una chiavetta USB e caricarla all'avvio:
Salva la password nei primi bytes della USB-Stick:
# dd if=
il_tuo_password_file
bs=32 count=1 of=/dev/disk/by-id/
usb_stick
Per creare la partizione zfs è possibile utilizzare il metodo descritto in precedenza con la richiesta della password o eseguire il pipe con
dd
:
# dd if=/dev/disk/by-id/
usb_stick
bs=32 count=1 | zfs create -o encryption=on -o keyformat=
passphrase
zroot/ROOT
Il prossimo passo è modificare lo hook zfs. Per impostazione predefinita zfs richiede la password. Devi cambiarlo per averlo collegato con dd dalla tua pendrive. Per fare ciò modifica
/usr/lib/initcpio/hooks/zfs
e cambia la seguente riga:
# ! eval zfs load-key "${encryptionroot}"; do
così:
# ! eval dd if=/dev/disk/by-id/
usb_stick
bs=32 count=1 | zfs load-key "${encryptionroot}"; do
Stai modificando il tuo hook zfs quindi non dimenticare di
regenerate the initramfs
. Ora zfs dovrebbe caricare la password dalla chiavetta USB all'avvio.
Troubleshooting
Il sistema non si avvia a causa di: impossibile importare zroot: nessun pool di questo tipo disponibile
Puoi provare i seguenti passaggi e vedere se possono essere d'aiuto.
Utilizza il modulo kernel da
archzfs repo
invece della versione dkms. Si potrà tornare alla versione dkms ad avvio completato.
Rimuovere il file
/etc/zfs/zpool.cache
e eseguire:
# zpool set cachefile=none zroot
Rimuovere il file
/etc/hostid
.
Regenerate the initramfs
.
Guarda anche
HOWTO install Ubuntu to a Native ZFS Root
ZFS cheatsheet
Funtoo:ZFS Install Guide
A reference guide to ZFS on Arch Linux
Arch Linux On Zfs
Youtube: Open-ZFS Bootcamp