Install Arch Linux on ZFS (Italiano)
Questo articolo spiega i passaggi richiesti per installare Arch Linux su una root filesystem ZFS.
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:
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.
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
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.
-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.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
- 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.
# 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:
| 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.
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.
-f quando si importa i pool. Questo scarica i pool importati.# zpool export zroot # zpool import -d /dev/disk/by-id -R /mnt zroot -N
-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 generarefstabper 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:
- 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-linuxAUR (o zfs-linux-ltsAUR 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. AggiungerezfsaMODULES:
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-zfsdopo lo hooksystemdinvece dello hookzfs. Tieni presente che questo hook utilizza parametri del kernel diversi rispetto allo hook predefinitozfs, maggiori informazioni possono essere trovate su project page.
-
sd-zfsnon supporta ancora la crittografia nativa dasJ/sd-zfs/issues/4. - Se si sta utilizzando un dataset separato per
/usre si ha seguito le istruzioni riportate di seguito, bisognerà assicurarsi di avere lo hookusrabilitato dopozfs, o il sistema non si avvierà. - Quando si genera lo initramfs, il file
zpool.cacheviene 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
legacyper 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.cfgogni 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.
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 zfsbootmenuAUR e efibootmgr
- 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
- 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-binAUR 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
- 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
Montare la propria partizione syslinux.
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.binverrà installatio per una #MBR partition table or, -
gptmbr.binverrà installatio per una #GUID partition table
Adesso sarà possibile installare zfsbootmenuAUR
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
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.
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.
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.cachee eseguire:
# zpool set cachefile=none zroot
- Rimuovere il file
/etc/hostid. - Regenerate the initramfs.