Jump to content

# Install Arch Linux on ZFS (Italiano)

From ArchWiki

Related articles

- ZFS
- Experimenting with ZFS

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 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.

    # 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-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`. 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.

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

- Montare la propria partizione ESP
- Installare zfsbootmenuAUR e efibootmgr

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

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

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

Category:

- Installation process (Italiano)

Hidden category:

- Pages or sections flagged with Template:Accuracy

Install Arch Linux on ZFS (Italiano)
Add topic