[GUIDA] Bcache, luks e btrfs: Archlinux on steroids [parte II]

Ed eccoci per la seconda parte di questa guida, dove tratterò l'installazione Arch con BTRFS, l'aggiunta del caching device ed l'affinamento dell'installazione. La parte su Bcache & crittografia del disco la trovate nella prima parte della guida.

I link alle guide:

• https://wiki.archlinux.org/index.php/Installing_on_Btrfs_root 
• https://wiki.archlinux.org/index.php/Bcache 
• https://wiki.archlinux.org/index.php/Dm-crypt_with_LUKS 
• http://forums.gentoo.org/viewtopic-t-959542.html

... E l'indice: 

PARTE I

• installazione Arch minimale su ssd
  • base install con archiso
• compilazione del kernel e patch per l'inclusione del modulo bcache
  • instalazione dei pacchetti "linux-bcache-git" e "bcache-tools-git"
• preparazione dell'hdd
  • creazione del volume bcache di backend
  • encryption della partizione

PARTE II

• clone dell'installazione Arch da ssd a hdd
  • creazione del fs BTRFS
  • sync dell'installazione precedente
  • modifica dei files fstab ed affini
• termine installazione
  • chroot e modifica del bootloader
  • inclusione dell'hook in mkinitcpio.conf
  • eliminare Arch sull'ssd
  • creare il device di cache

PARTE III

• Bonus:
  • CryptoSwap + hibernation
  • UsbKeyFile per l'autenticazione

Eravamo rimasti nella Prima parte con un volume crittografato aperto e mappato in /dev/mapper/btrfs

┌──[j0lly@TheH0le]──[~] 
└── cryptsetup luksOpen /dev/bcache0 btrfs

Btrfs_ è il _device mapper_ name che daremo alla partizione una volta aperta. Per formattare il device, installate btrfs-progs, se ancora non lo avete fatto e cominciate definendo il vostro _layout_ per le partizioni che volete gestire. Per prima cosa, create il _Root device_ con il comando:

┌──[j0lly@TheH0le]──[~] 
└── mkfs.btrfs -L btrfs_container /dev/mapper/btrfs

La procedura seguente intende utilizzare tutte le ultime features che btrfs consente, tra cui:

• la possibilità di creare snapshots di qualsiasi partizione (anche l'intero filesystem);
• la gestione separata dei subvolumes in maniera dinamica;
• la compressione trasparente dei dati sul filesystem.

Quest'ultima novità di questo stupendo filesystem è vale da sola tutta la fatica spesa: la compressione permette di salvare spazio sul disco, velocizzare la lettura dei files e permette il funzionamento impostandolo per singolo subvolume! Quindi, montate il filesystem root e create i vostri volumi come fareste in lvm, non dimenticando la compressione ;):

┌──[j0lly@TheH0le]──[~] 
└── mount -o defaults,noatime /dev/mapper/btrfs /mnt/ && cd /mnt/

Prima di tutto, create la directory di snapshot:

┌──[j0lly@TheH0le]──[/mnt] 
└── mkdir __snapshot

Poi create un subvolume che fungerà da root del sistema:

┌──[j0lly@TheH0le]──[~] 
└── btrfs subvol create __active

Anche in questo caso la nomenclatura è presa dal Wiki Arch, per mantenere la compatibilità con gli strumenti al momento disponibili su Arch. Ora smontate pure il vostro filesystem, e preparatevi alla magia:

┌──[j0lly@TheH0le]──[~] 
└── mount -o defaults,noatime,compress=lzo,subvol=__active /dev/mapper/btrfs && cd /mnt/

Ora  il subvolume __active è montato e pronto per gestire l'intera installazione; notate l'opzione compress= che permette di comprimere i dati (il formato lzo sembra essere il miglior compromesso tra compressione e consumo di cpu); tenete presente che la compressione del filesystem funziona in realtime per la scrittura dei dati, quindi è il caso che la attiviate fin da subito e in maniera persistente (se volete utilizzarla) o avrete parti del filesystem compresse ed altre no. Ora potete creare tutti i subvolume che preferite; sono molto flessibili e consiglio di utilizzarli in maniera estensiva; io ho fatto così:

┌──[j0lly@TheH0le]──[~] 
└── btrfs subvol list 
ID 256 gen 8545 top level 5 path __active 
ID 259 gen 8433 top level 256 path usr 
ID 260 gen 8567 top level 256 path var 
ID 265 gen 8567 top level 256 path home/j0lly 
ID 266 gen 3697 top level 256 path home/j0lly/images 
ID 267 gen 8449 top level 256 path home/j0lly/music

Le opzioni di mount sono propagate anche ai figli, se non specificato altrimenti. Sulla mia "nuova" root ho poi restorato il sistema backuppato precedentemente, per risparmiare un paio di comandi e non installare da zero. È il momento di affinare le configurazioni.; non dimenticatevi di popolare /etc/fstab. Il mio è così:

┌──[j0lly@TheH0le]──[~] 
└── cat /etc/fstab 
#/etc/fstab: static file system information 
# 
# <file system> <dir> <type> <options> <dump> <pass> 
LABEL=btrfs_container / btrfs rw,space_cache,thread_pool=32,noatime,subvol=__active,compress=lzo 0 0 
/dev/sda3 /boot ext4 defaults 1 0 
/dev/mapper/cryptswap none swap defaults 0 0

Tenete presente un paio di accorgimenti:

• non è necessario montare i subvolume dentro al vostro volume root (nel mio caso __active) perchè verranno montati in automatico;
• non dimenticate di specificare opzioni come subvol e compress (se volete utilizzarli;
• btrfs non necessita assolutamente di fsck all'avvio, quindi mettete 0 nella seconda colonna delle partizioni btrfs;
• vorrete probabilmente montare la partizione di boot (esterna e non crittografata).

Siamo quasi-quasi a buon punto; manca da rigenerare il ramdisk e reinstallare il bootloader, quindi montate la partizione di boot (che io ho riutilizzato dall'installazione ponte sulla ssd) ed entrate in chroot. Reinstallate Grub ed aggiornate le entry ( per non rischiare, potreste aggiungere una stringa di boot per l'ssd. in caso qualcosa andasse storto). Prima di ricreare il grub.cfg, editate /etc/default/grub per aggiungere questi parametri non ancora gestiti da Grub:

┌──[j0lly@TheH0le]──[~] 
└── cat /etc/default/grub 
GRUB_DEFAULT=0 GRUB_TIMEOUT=5 
GRUB_DISTRIBUTOR="Arch" 
GRUB_CMDLINE_LINUX_DEFAULT="quiet" 
GRUB_CMDLINE_LINUX="cryptdevice=/dev/bcache0:btrfs1 cryptkey=/dev/disk/by-label/Rec_Me:ext4:/xxxxxxxxxxxxx resume=/dev/mapper/cryptswap" 
[...]

• cryptdevice: specificate il device bcache da utilizzare per LUKS: se non usate il label in fstab, ricordate di allineare il nome che date al container.
• cryptkey: questo è il path per la chiave automatica (parleremo dopo di questo) per non immettere la password all'avvio.
• resume: anche questo sarà utilizzato succcessivamente; è il path del device di resume dall'ibernazione.

Per l'hook in mkinitcpio, modificate la configurazione aggiungendo le righe seguenti in /etc/mkinitcpio.conf:

┌──[j0lly@TheH0le]──[~] 
└── cat /etc/mkinitcpio.conf 
# vim:set ft=sh 
# MODULES 
# The following modules are loaded before any boot hooks are 
# run. Advanced users may wish to specify all system modules 
# in this array. For instance: 
# MODULES="piix ide_disk reiserfs" 
#
MODULES="" MODULES="crc32c dm_mod" 
[...]   
HOOKS="base udev modconf block bcache encrypt openswap resume btrfs filesystems keyboard keymap" 
[...]

Non ricordo assolutamente dove ho letto dei moduli crc32 e dm_mod, ma quando avrò tempo di testare un ramdisk senza di essi farò un aggiornamento. Riguardo gli HOOK, cercate di pensare alla vostra configurazione; nel mio caso l'ordine cronologico è: bcache encrypt btrfs. importanete: Openswap e resume sono hook che ho aggiunto successivamente e che verranno documentati nella terza parte della guida e non dovreste utilizzarli adesso (anche perchè openswap è uno script creato appositamente per l'apertura del volume swap criptato e potrebbe darvi noie al boot). Ora ricreate l'initrfs:

┌──[j0lly@TheH0le]──[~]
└── mkinitcpio -L linux-bcache-git -g /boot/initramfs-bcache.img

Uscite dal chroot, incrociate le dita e.... rebootate. Se tutto è andato bene avrete avviato il vostro nuovo sistema! Dovreste essere sulla vostra partizione bcache, aperta con luks e montata in / con btrfs! Il peggio è fatto e potete bervi una birra ;). Se il vostro sistema è stabile, potete eliminare la vecchia installazione sull'ssd o, meglio ancora, potete creare la partizione/iso di recovery (_non mi stanco di ripeterlo: È IMPORTANTE!) facendo un altro _sync dall'installazione ancora presente. Quando sarete pronti formattate il disco e create una partizione; in base alla disponibilità di spazio che avete sull'SSD e se segliete di avere lo swap, potete decidere di utilizzare tutto il disco SSD come raw device (io ho tenuto 8Gb di spazio per lo swap). Ora potete creare e registrate il caching device, registrandolo al backing device già esistente e funzionante; i devices di cache possono essere collegati, registrati e scollegati a caldo, anche se bcache0 esiste già.

┌──[j0lly@TheH0le]──[~]
└── make-bcache --cache --block 512 /dev/sdb1

┌──[j0lly@TheH0le]──[~]
└── echo d893f034-1440-4a8c-bb40-ae82e01bc7d6 > /sys/block/bcache0/bcache/attach

l'UUID lo trovate sotto /sys/fs/bcacahe/. Ora che tutto è al suo posto, un reboot finale non guasta, per verificare che funzioni correttamente. Se siete abbastanza temerari, potete abilitare il writeback nel device: l'SSD fa da cache anche in scrittura, aumentando prestazioni ma, indubbiamente, aggiungendo ulteriori rischi di perdita di dati ( per attivate, echo writeback > /sys/block/sda/sda*/bcache/cache_mode ).

Suggerimento: Mi capitato alcune volte durante alcune modifiche che il device bcache non partisse all'avvio (non è sicuramente una tecnologia "matura" ;)) e quindi riporto la soluzione trovata direttamente sulla wiki Arch e Gentoo per fare un recovery della partizione e fixare il porbema da dentro (spesso basta ri-registrare il cahing device:

cat /sys/block/sda/sda3/bcache/running
0
echo 1 > /sys/block/sda/sda3/bcache/running

Tenete presente che se avete abilitato il writeback e c'erano dati non salvati, quei dati verranno persi :(. Con questo ho terminato anche la seconda parte della guida. Nella terza ed ultima parte scriverò come creare un device di swap da utilizzare per l'ibernazione in maniera sicura crittografando il partizione, e il metodo utilizzato da me per ovviare alle continue richieste di password all'avvio tramite una chiave salvata su un dispositivo esterno (chiavetta usb).

That's all, alla porssima!