Differenze tra le versioni di "Installare Arch Linux su ZFS"

Da GolemWiki.
Jump to navigation Jump to search
(Creata pagina con '= Requisiti = * Un sistema funzionante con Arch Linux x86_64 * Almeno 4 GB di RAM = Installation media = Dato che lo ZFS non è ufficialmente supportato da nessuna distribu...')
 
(Archiso)
 
(9 versioni intermedie di 2 utenti non mostrate)
Riga 6: Riga 6:
  
 
= Installation media =
 
= Installation media =
Dato che lo ZFS non è ufficialmente supportato da nessuna distribuzione Linux, tantomento da Arch, sarà necessario realizzare un'immagine live appositamente per questo scopo.
+
Dato che lo ZFS non è ufficialmente supportato da nessuna distribuzione Linux, tantomento da Arch, sarà necessario realizzare un'immagine live creata appositamente per questo scopo.
  
 
== Archiso ==
 
== Archiso ==
A tale scopo, Arch Linux mette a disposizione un pacchetto denominato '''Archiso''' che contiene una serie di script per realizzare supporti per l'installazione.
+
A tale scopo, Arch Linux mette a disposizione un pacchetto, denominato [https://wiki.archlinux.org/index.php/Archiso_(Italiano) Archiso], contenente una serie di script per la realizzazione di supporti per l'installazione.
  
 
  # pacman -S archiso
 
  # pacman -S archiso
  
Start the process:
+
Copiare il contenuto del pacchetto in una directory di lavoro, es.: ''/root/media''
# cp -r /usr/share/archiso/configs/releng /root/media
+
# cp -r /usr/share/archiso/configs/releng /root/media
  
Embed the archzfs packages into an archiso
+
Per aggiungere il supporto allo ZFS occorre:
It is a good idea make an installation media with the needed software included. Otherwise, the latest archiso installation media burned to a CD or a USB key is required.
 
To embed zfs in the archiso, from an existing install, download the archiso package.
 
  
# pacman -S archiso
+
* Modificare le seguenti righe al file '''pacman.conf''' di archiso
 +
[archzfs]
 +
SigLevel = Never
 +
Server = http://mirror.sum7.eu/archlinux/archzfs/$repo/$arch
  
Start the process:
+
* Aggiungere le seguenti righe al file ''packages.x86_64''
# cp -r /usr/share/archiso/configs/releng /root/media
+
spl-utils
 +
spl-dkms
 +
zfs-utils
 +
zfs-dkms
 +
net-tools
  
Edit the packages.x86_64 file adding those lines:
+
* Lanciare lo script
spl-utils
+
# ./build.sh -v
spl
+
L'immagine sarà generata nella directory /root/media/out
zfs-utils
 
zfs
 
net-tools
 
  
Edit the pacman.conf file adding those lines (TODO, correctly embed keys in the installation media?):
+
= Boot col nuovo supporto (CD/USB) =
[demz-repo-core]
+
Effettuare il boot e scegliere l'architettura x86_64, ZFS non è ben supportato su i686.
SigLevel = Never
 
Server = http://demizerone.com/$repo/$arch
 
  
 +
== SSH ==
 +
Si consiglia di abilitare il demone ssh ed effettuare il processo di installazione collegandosi da un altro computer così da poter effettuare copia ed incolla da questa o altre guide.
  
Add other packages in packages.both, packages.i686, or packages.x86_64 if needed and create the image.
+
# systemctl enable sshd.service
# ./build.sh -v
+
# systemctl start sshd.service
The image will be in the /root/media/out directory.
 
  
 +
== Preparazione del disco ==
 +
=== Schede madri BIOS ===
 +
==== Cenni di teoria ====
 +
Per fare a meno della tradizionale partizione di /boot ed utilizzare ZFS come unico filesystem si consiglia di partizionare il disco secondo il nuovo formato [https://wiki.archlinux.org/index.php/GUID_Partition_Table GPT].
  
Boot with the new media.
+
Sarà comunque necessario creare due partizioni: una per il Grub ed una per gli [http://it.wikipedia.org/wiki/ZFS_(file_system)#I_pool_dello_storage zpool].  
Choose x86_64, I suggest to set a root password, enable ssh daemon and do the install process from another computer so you can easily have paste and copy from this guide.
 
  
# systemctl enable sshd.service
+
La prima, denominata [http://en.wikipedia.org/wiki/BIOS_Boot_partition Bios Grub Partition], è concettualmente l'equivalente del MBR nei sistemi GPT. A differenza del MBR, la Bios Grub Partition può però essere sufficientemente grande da contenere il codice per il supporto allo ZFS.
# systemctl start sshd.service
+
Il vantaggio sta nel fatto che a differenza della tradizionale partizione /boot dove risiedono anche kernel e ramdisk, il contenuto di quest'ultima cambia esclusivamente nei rari casi di upgrade del Grub.
  
 +
==== Partizionamento ====
 +
Col seguente comando verrà creata la partizione di Grub (EF02) a partire dal 1MB, della grandezza di 64MB; il resto del disco resterà disponibile per lo i pool dello ZFS.
 +
Se avete più dischi da utilizzare in raid, questa operazione andrà ripetuta per ciascun disco.
  
# Create a bios_grub partition (type EF02) starting at 1MB with size 64MB.  The
+
  # sgdisk \
# 1MB offset is to ensure proper sector alignment for SSD's and other 4k sector drives.
+
--new=1:2048:133120 --typecode=1:EF02 --change-name=1:"grub" \
# After the utility partition, the rest of the drive is setup for ZFS. Repeat for all
+
--largest-new=2 --typecode=2:BF01 --change-name=2:"zfs" /dev/sda
# drives to be used in the pool.
 
 
 
  $ sgdisk \
 
    --new=1:2048:133120 --typecode=1:EF02 --change-name=1:"grub" \
 
    --largest-new=2 --typecode=2:BF01 --change-name=2:"zfs" \
 
    /dev/sda
 
  
 +
=== Schede madri UEFI ===
 +
==== Partizionamento ====
 +
'''NB: NON avendo un computer con scheda madre UEFI non ho potuto verificare questa procedura e non ne ho potuto testare il funzionamento'''
  
# Create a pool:
+
Col seguente comando verrà creata la partizione EFI (EF00) a partire dal 1MB, della grandezza di 512MB; il resto del disco resterà disponibile per lo i pool dello ZFS.
    $ zpool create rpool sda2
+
# sgdisk \
 +
--new=1:2048:1064960 --typecode=1:EF00 --change-name=1:"efi" \
 +
--largest-new=2 --typecode=2:BF01 --change-name=2:"zfs" /dev/sda
  
#The zpool will initially be mounted at /rpool, but we need to move it to /mnt/ to work on it
+
La partizione '''EFI''' dovrà poi essere formattata in FAT32
 +
# mkfs.vfat -T32 /dev/sda1
  
    $ zfs unmount rpool
+
== ZFS pool ==
    $ zfs set mountpoint=/mnt/ rpool
+
Creazione del pool principale
######################  $ zfs set canmount=off rpool
+
# zpool create rpool sda2
  
    $ zfs create -o mountpoint=legacy rpool/ROOT
+
Inizialmente il pool sarà montato in ''/rpool'', per i nostri scopi avremo bisogno di spostarlo in ''/mnt''
    $ zpool set bootfs=rpool/ROOT rpool
+
# zfs unmount rpool
 +
# zfs set mountpoint=/mnt/ rpool
 +
 
 +
Creazione del root dataset rpool/ROOT (necessario per il boot del sistema)
 +
# zfs create -o mountpoint=legacy rpool/ROOT
 +
# zpool set bootfs=rpool/ROOT rpool
 
      
 
      
#Now mount the root filesystem in the usual spot:
+
Montaggio del filesystem
 +
# mount -t zfs rpool/ROOT /mnt
  
    $ mount -t zfs rpool/ROOT /mnt
+
In aggiunta al root dataset è possibile crearne altri al fine di ottimizzare l'ordine del sistema, es.:
 +
# zfs create rpool/home
 +
# zfs create rpool/usr/src
 +
# zfs create rpool/var
 +
# zfs create rpool/srv
  
 +
'''NB:''' /bin, /boot, /sbin, /etc, /dev, /sys e /proc devono stare nel root dataset, non possono essere parte di sub-dataset.
  
# In addition to the root dataset, we'll create several other datasets to help keep things organized.
+
=== zpool cache ===
# Note that /bin, /boot, /sbin, /etc, /dev, /sys, and /proc must all be in the root dataset, not part of sub-datasets.
+
Configurare la cache degli zpool
 +
# zpool set cachefile=/etc/zfs/rpool.cache rpool
  
    $ zfs create rpool/home
+
Copiare il file di cache nel sistema dove dovremo eseguire il chroot per l'installazione.
    $ zfs create rpool/usr/src
+
# mkdir -p /mnt/etc/zfs
    $ zfs create rpool/var
+
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
    $ zfs create rpool/srv
 
  
 +
== Installazione ==
 +
=== Pacchetti base ===
 +
# pacstrap /mnt base base-devel net-tools
  
# zpool set cachefile=/etc/zfs/rpool.cache rpool
+
=== Chroot ===
 +
Effettuare il chroot nel nuovo sistama
 +
# arch-chroot /mnt
  
Copy zpool.cache
+
==== Configurazione del sistema di base ====
Now is also a good time to copy over the zpool cache so your initramfs will have access to it.
+
Aggiungere la seguente riga nel file '''/etc/fstab''' per il mountpoint del filesystem
 +
rpool/ROOT      /              zfs        noatime    0 0
  
    $ mkdir -p /mnt/etc/zfs
+
Editare il file '''/etc/mkinitcpio.conf''' aggiungendo ''zfs'' prima del ''filesystem'' e spostare ''keyboard'' prima di ''zfs'', in modo che il vostro HOOKS assomigli a qualcosa di questo tipo
    $ cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
+
HOOKS="base udev autodetect modconf block keyboard zfs filesystems"
  
 +
Aggiungere il repository per lo zfs nel ''pacman.conf'' del sistema Arch sotto chroot
 +
[demz-repo-core]
 +
Server = http://demizerone.com/$repo/$arch
 +
SigLevel = Never
  
 +
Installare il supporto per lo ZFS
 +
# pacman -Sy
 +
# pacman -S archzfs
  
# pacstrap /mnt base base-devel
+
In caso di necessità è possibile rigenerare il ramdisk col seguente comando
 +
# mkinitcpio -p linux
  
 +
Impostare il fuso orario
 +
# ln -s /usr/share/zoneinfo/Europe/Rome /etc/localtime
  
 +
Impostare la mappatura della tastiera
 +
# echo KEYMAP=it > /etc/vconsole.conf
 +
 +
=== Installazione Grub ===
 +
==== Sistema con BIOS ====
 +
# pacman -S grub
 +
# grub-mkconfig -o /boot/grub/grub.cfg
 +
# grub-install /dev/sda
  
#####################
+
==== Sistema UEFI ====
#                   #
+
'''NB: NON avendo un computer con scheda madre UEFI non ho potuto verificare questa procedura e non ne ho potuto testare il funzionamento'''
#     CHROOT      #
+
# pacman -S grub
#                   #
+
# mkdir /boot/EFI
#####################
+
# mount /dev/sda1 /boot/EFI
 +
# grub-install --target=x86_64-efi --efi-directory=$esp --bootloader-id=grub --recheck --debug
 +
# grub-mkconfig -o /boot/grub/grub.cfg
  
# arch-chroot /mnt
+
==== Modifiche a Grub ====
 +
Per permettere il caricamento del sistema è necessario aggiungere ''zfs_force=1 zfs=bootfs'' alla riga di caricamento del kernel nel file ''/boot/grub/grub.cfg''.
  
 +
Esempio di configurazione
  
# zpool set cachefile=/etc/zfs/rpool.cache rpool
+
set timeout=2
 +
set default=0
 +
menuentry 'Arch Linux'{
 +
        insmod gzio
 +
        insmod part_gpt
 +
        insmod zfs
 +
        set root='hd0,gpt2'
 +
        linux  /ROOT@/boot/vmlinuz-linux zfs_force=1 zfs=bootfs root=ZFS=rpool/ROOT rw  quiet
 +
        initrd  /ROOT@/boot/initramfs-linux.img
 +
}
  
 +
=== Abilitare il servizio ZFS all'avvio ===
 +
# systemctl enable zfs.service
  
I don't have uefi so I install the regular grub
+
=== Terminazione dell'installazione ===
# pacman -S grub
+
Adesso è possibile uscire dal chroot, smontare il filesystem e riavviare il sistema.
 +
# exit
 +
# zfs unmount -a
 +
# zfs set mountpoint=/ rpool
 +
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
 +
# zpool export rpool
 +
# reboot
  
 +
== Hostid ==
 +
Abilitato il servizio zfs, '''dopo il primo reboot''', per evitare problemi, è necessario specificare l'hostid e rigenerare il ramdisk.
  
##########################  DIVERSAMENTE ########################################################
+
  # hostid > /etc/hostid
# mkdir /boot/EFI
+
# mkinitcpio -p linux
# mount /dev/sda1 /boot/EFI
 
# grub-install --target=x86_64-efi --efi-directory=$esp --bootloader-id=grub --recheck --debug
 
# grub-mkconfig -o /boot/grub/grub.cfg
 
##################################################################################################
 
  
 +
= Trucchi =
 +
Limitare l'utilizzo di RAM
 +
# echo "options zfs zfs_arc_max=2147483648" > /etc/modprobe.d/zfs.conf
  
 +
= Bibliografia =
 +
https://github.com/pendor/gentoo-zfs-install/blob/master/install/GentooInstall.mdown
  
# nano /etc/fstab
+
https://github.com/zfsonlinux/pkg-zfs/wiki/HOWTO-install-Ubuntu-to-a-Native-ZFS-Root-Filesystem
rpool/ROOT      /               zfs         noatime    0 0
 
  
 +
http://www.howtoforge.com/a-beginners-guide-to-btrfs
  
Edit /etc/mkinitcpio.conf and add zfs before filesystems. Also, move keyboard hook before zfs so you can type in console if something goes wrong. Your HOOKS line should look something like this:
+
https://wiki.archlinux.org/index.php/Installing_Arch_Linux_on_ZFS
  
HOOKS="base udev autodetect modconf block keyboard zfs filesystems"
+
https://bbs.archlinux.org/viewtopic.php?pid=1365007#p1365007
  
 
+
[[Category: Howto]]
Edit the pacman.conf in the chroot adding those lines
 
 
 
[demz-repo-core]  
 
Server = http://demizerone.com/$repo/$arch
 
SigLevel = Never
 
 
 
# pacman -Sy
 
# pacman -S archzfs
 
 
 
 
 
To regenerate the initramfs with the command:
 
# mkinitcpio -p linux
 
 
 
# ln -s /usr/share/zoneinfo/Europe/Rome /etc/localtime
 
 
 
# nano /etc/vconsole.conf
 
KEYMAP=it
 
 
 
 
 
Create Swap (Optional)
 
Running swap in ZVOL will currently deadlock when the system grows into swap.
 
If you NEED swap, you must create separate partitions for it and setup mdadm in necessary.
 
 
 
Swap can be run from with the zpool as a zvol:
 
 
 
    # Set size as desired. Checksum'ing isn't necessary for swap and turning it off improves performance.
 
 
 
    $ zfs create -V 2G rpool/swap
 
    $ zfs set checksum=off rpool/swap
 
    $ swapon /dev/rpool/swap
 
    $ echo "/dev/rpool/swap    none    swap    sw    0 0" >> /mnt/etc/fstab
 
 
 
 
 
# grub-mkconfig -o /boot/grub/grub.cfg
 
# grub-install /dev/sda
 
 
 
Add
 
zfs=bootfs
 
to the kernel line of grub.cfg
 
 
 
 
 
# systemctl enable zfs.service
 
 
 
# exit
 
# zfs unmount -a
 
# zfs set mountpoint=/ rpool
 
 
 
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
 
 
 
# zpool export rpool
 
 
 
 
 
After the first boot
 
 
 
If everything went fine up to this point, your system will boot. Once. For your system to be able to reboot without issues, you need to enable the zfs service and set the hostid.
 
When running ZFS on root, the machine's hostid will not be available at the time of mounting the root filesystem. There are two solutions to this. You can either place your spl hostid in the kernel parameters in your boot loader. For example, adding spl.spl_hostid=0x00bab10c.
 
The other solution is to make sure that there is a hostid in /etc/hostid, and then regenerate the initramfs image. Which will copy the hostid into the initramfs image.
 
# hostid > /etc/hostid
 
# mkinitcpio -p linux
 
 
 
 
 
 
 
BIBLIOGRAFIA
 
https://github.com/pendor/gentoo-zfs-install/blob/master/install/GentooInstall.mdown
 
https://github.com/zfsonlinux/pkg-zfs/wiki/HOWTO-install-Ubuntu-to-a-Native-ZFS-Root-Filesystem
 
http://www.howtoforge.com/a-beginners-guide-to-btrfs
 
https://wiki.archlinux.org/index.php/Installing_Arch_Linux_on_ZFS
 
https://bbs.archlinux.org/viewtopic.php?pid=1365007#p1365007
 

Versione attuale delle 08:18, 18 apr 2020

Requisiti

  • Un sistema funzionante con Arch Linux x86_64
  • Almeno 4 GB di RAM

Installation media

Dato che lo ZFS non è ufficialmente supportato da nessuna distribuzione Linux, tantomento da Arch, sarà necessario realizzare un'immagine live creata appositamente per questo scopo.

Archiso

A tale scopo, Arch Linux mette a disposizione un pacchetto, denominato Archiso, contenente una serie di script per la realizzazione di supporti per l'installazione.

# pacman -S archiso

Copiare il contenuto del pacchetto in una directory di lavoro, es.: /root/media

# cp -r /usr/share/archiso/configs/releng /root/media

Per aggiungere il supporto allo ZFS occorre:

  • Modificare le seguenti righe al file pacman.conf di archiso
[archzfs]
SigLevel = Never
Server = http://mirror.sum7.eu/archlinux/archzfs/$repo/$arch
  • Aggiungere le seguenti righe al file packages.x86_64
spl-utils
spl-dkms
zfs-utils
zfs-dkms
net-tools
  • Lanciare lo script
# ./build.sh -v

L'immagine sarà generata nella directory /root/media/out

Boot col nuovo supporto (CD/USB)

Effettuare il boot e scegliere l'architettura x86_64, ZFS non è ben supportato su i686.

SSH

Si consiglia di abilitare il demone ssh ed effettuare il processo di installazione collegandosi da un altro computer così da poter effettuare copia ed incolla da questa o altre guide.

# systemctl enable sshd.service
# systemctl start sshd.service

Preparazione del disco

Schede madri BIOS

Cenni di teoria

Per fare a meno della tradizionale partizione di /boot ed utilizzare ZFS come unico filesystem si consiglia di partizionare il disco secondo il nuovo formato GPT.

Sarà comunque necessario creare due partizioni: una per il Grub ed una per gli zpool.

La prima, denominata Bios Grub Partition, è concettualmente l'equivalente del MBR nei sistemi GPT. A differenza del MBR, la Bios Grub Partition può però essere sufficientemente grande da contenere il codice per il supporto allo ZFS. Il vantaggio sta nel fatto che a differenza della tradizionale partizione /boot dove risiedono anche kernel e ramdisk, il contenuto di quest'ultima cambia esclusivamente nei rari casi di upgrade del Grub.

Partizionamento

Col seguente comando verrà creata la partizione di Grub (EF02) a partire dal 1MB, della grandezza di 64MB; il resto del disco resterà disponibile per lo i pool dello ZFS. Se avete più dischi da utilizzare in raid, questa operazione andrà ripetuta per ciascun disco.

# sgdisk \
--new=1:2048:133120 --typecode=1:EF02 --change-name=1:"grub" \
--largest-new=2 --typecode=2:BF01 --change-name=2:"zfs" /dev/sda

Schede madri UEFI

Partizionamento

NB: NON avendo un computer con scheda madre UEFI non ho potuto verificare questa procedura e non ne ho potuto testare il funzionamento

Col seguente comando verrà creata la partizione EFI (EF00) a partire dal 1MB, della grandezza di 512MB; il resto del disco resterà disponibile per lo i pool dello ZFS.

# sgdisk \
--new=1:2048:1064960 --typecode=1:EF00 --change-name=1:"efi" \
--largest-new=2 --typecode=2:BF01 --change-name=2:"zfs" /dev/sda

La partizione EFI dovrà poi essere formattata in FAT32

# mkfs.vfat -T32 /dev/sda1

ZFS pool

Creazione del pool principale

# zpool create rpool sda2

Inizialmente il pool sarà montato in /rpool, per i nostri scopi avremo bisogno di spostarlo in /mnt

# zfs unmount rpool
# zfs set mountpoint=/mnt/ rpool

Creazione del root dataset rpool/ROOT (necessario per il boot del sistema)

# zfs create -o mountpoint=legacy rpool/ROOT
# zpool set bootfs=rpool/ROOT rpool
   

Montaggio del filesystem

# mount -t zfs rpool/ROOT /mnt

In aggiunta al root dataset è possibile crearne altri al fine di ottimizzare l'ordine del sistema, es.:

# zfs create rpool/home
# zfs create rpool/usr/src
# zfs create rpool/var
# zfs create rpool/srv

NB: /bin, /boot, /sbin, /etc, /dev, /sys e /proc devono stare nel root dataset, non possono essere parte di sub-dataset.

zpool cache

Configurare la cache degli zpool

# zpool set cachefile=/etc/zfs/rpool.cache rpool 

Copiare il file di cache nel sistema dove dovremo eseguire il chroot per l'installazione.

# mkdir -p /mnt/etc/zfs
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache

Installazione

Pacchetti base

# pacstrap /mnt base base-devel net-tools

Chroot

Effettuare il chroot nel nuovo sistama

# arch-chroot /mnt 

Configurazione del sistema di base

Aggiungere la seguente riga nel file /etc/fstab per il mountpoint del filesystem

rpool/ROOT      /               zfs         noatime     0 0

Editare il file /etc/mkinitcpio.conf aggiungendo zfs prima del filesystem e spostare keyboard prima di zfs, in modo che il vostro HOOKS assomigli a qualcosa di questo tipo

HOOKS="base udev autodetect modconf block keyboard zfs filesystems"

Aggiungere il repository per lo zfs nel pacman.conf del sistema Arch sotto chroot

[demz-repo-core] 
Server = http://demizerone.com/$repo/$arch 
SigLevel = Never

Installare il supporto per lo ZFS

# pacman -Sy
# pacman -S archzfs

In caso di necessità è possibile rigenerare il ramdisk col seguente comando

# mkinitcpio -p linux

Impostare il fuso orario

# ln -s /usr/share/zoneinfo/Europe/Rome /etc/localtime 

Impostare la mappatura della tastiera

# echo KEYMAP=it > /etc/vconsole.conf 

Installazione Grub

Sistema con BIOS

# pacman -S grub
# grub-mkconfig -o /boot/grub/grub.cfg
# grub-install /dev/sda

Sistema UEFI

NB: NON avendo un computer con scheda madre UEFI non ho potuto verificare questa procedura e non ne ho potuto testare il funzionamento

# pacman -S grub
# mkdir /boot/EFI
# mount /dev/sda1 /boot/EFI
# grub-install --target=x86_64-efi --efi-directory=$esp --bootloader-id=grub --recheck --debug
# grub-mkconfig -o /boot/grub/grub.cfg

Modifiche a Grub

Per permettere il caricamento del sistema è necessario aggiungere zfs_force=1 zfs=bootfs alla riga di caricamento del kernel nel file /boot/grub/grub.cfg.

Esempio di configurazione

set timeout=2
set default=0
menuentry 'Arch Linux'{
       insmod gzio
       insmod part_gpt
       insmod zfs
       set root='hd0,gpt2'
       linux   /ROOT@/boot/vmlinuz-linux zfs_force=1 zfs=bootfs root=ZFS=rpool/ROOT rw  quiet
       initrd  /ROOT@/boot/initramfs-linux.img
}

Abilitare il servizio ZFS all'avvio

# systemctl enable zfs.service 

Terminazione dell'installazione

Adesso è possibile uscire dal chroot, smontare il filesystem e riavviare il sistema.

# exit
# zfs unmount -a
# zfs set mountpoint=/ rpool
# cp /etc/zfs/rpool.cache /mnt/etc/zfs/rpool.cache
# zpool export rpool
# reboot

Hostid

Abilitato il servizio zfs, dopo il primo reboot, per evitare problemi, è necessario specificare l'hostid e rigenerare il ramdisk.

# hostid > /etc/hostid
# mkinitcpio -p linux

Trucchi

Limitare l'utilizzo di RAM

# echo "options zfs zfs_arc_max=2147483648" > /etc/modprobe.d/zfs.conf

Bibliografia

https://github.com/pendor/gentoo-zfs-install/blob/master/install/GentooInstall.mdown

https://github.com/zfsonlinux/pkg-zfs/wiki/HOWTO-install-Ubuntu-to-a-Native-ZFS-Root-Filesystem

http://www.howtoforge.com/a-beginners-guide-to-btrfs

https://wiki.archlinux.org/index.php/Installing_Arch_Linux_on_ZFS

https://bbs.archlinux.org/viewtopic.php?pid=1365007#p1365007