Install Arch Linux on ZFS (Italiano)

From ArchWiki

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:

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 zfsbootmenuAUR 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/sdx
(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/sdx 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, zectlAUR (systemd-boot), o zedenvAUR (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.[broken link: invalid section]

# 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
# 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.
  • 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-zfsAUR 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.

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 zectlAUR, 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

Attenzione: Per compilare ZFSBootMenu in queto momento non è possibile usare un helper AUR come ad esempio: paruAUR o yayAUR, 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-booleanAUR, 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
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

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

Adesso sarà possibile installare zfsbootmenuAUR

Attenzione: Per compilare ZFSBootMenu in queto momento non è possibile usare un helper AUR come ad esempio: paruAUR o yayAUR, 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-booleanAUR, 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 Avviarezfs-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

Guarda anche