Due cose che mancavano ai miei SSD: il TRIM dopo BitLocker e una write cache che il mio server HPE aveva spento in silenzio

Illustrazione per l'articolo sulla velocità: una lumaca lenta

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski

HP3, il mio HPE MicroServer Gen10 Plus v2, è tornato su Debian 13 con OpenZFS. Perché abbia lasciato di nuovo Windows è una storia per un altro post. Questo parla del ripristino successivo, e di un’impostazione che si nascondeva in bella vista da due sistemi operativi e due post del blog.

Il piano era noioso, come dovrebbero essere i ripristini: un pool RAIDZ1 nuovo sugli stessi tre SSD WD Red SA500, dataset per utente, poi circa 1,7 TB ricopiati da un disco USB con rsync. Il solito flusso di lavoro: io prendo le decisioni, il mio co-admin IA (Claude) lancia i comandi e tiene d’occhio i numeri. E furono proprio i numeri a cominciare a sembrare sbagliati.

Indice

🐌 Sette megabyte al secondo. Per SSD.

La copia procedeva a 25-35 MB/s. La stima diceva circa sedici ore. Persino cose piccole come zfs create o zpool status restavano appese per minuti, in attesa che il gruppo di transazioni successivo finisse di sincronizzarsi. Poi zpool iostat -l ha mostrato il vero problema:

$ zpool iostat -vl storage 5 1
                                  bandwidth      total_wait    disk_wait
                                  read  write    read  write   read  write
storage                          3.42K  22.7M     1ms  233ms    1ms   65ms
  raidz1-0                       3.42K  22.7M     1ms  233ms    1ms   65ms
    ata-WD_Red_SA500_..._00458   1.14K  7.57M     1ms  262ms    1ms   68ms
    ata-WD_Red_SA500_..._01387   1.14K  7.58M     1ms  258ms    1ms   72ms
    ata-WD_Red_SA500_..._02050   1.14K  7.58M     1ms  181ms    1ms   57ms

$ cat /proc/pressure/io
some avg10=94.05 avg60=90.06 avg300=80.24
full avg10=88.82 avg60=84.62 avg300=75.87

Circa 7,5 MB/s per disco con 65 ms di latenza, e la macchina passava intorno al 90 % del tempo ad aspettare l’I/O. Sono SSD SATA dichiarati per ben oltre 500 MB/s in scrittura sequenziale. 65 ms è territorio da dischi meccanici. Anzi peggio: un HDD decente fa meglio.

🕵️ Sospettato numero uno: il TRIM, e c’ero già passato

Il TRIM era il primo sospettato, e non solo in teoria. Mi aveva già fregato una volta. Quando avevo spostato per la prima volta questi SSD da Windows a Linux, avevo installato Debian su dischi che erano stati cifrati con BitLocker. I numeri erano orribili quanto adesso, e quella volta la soluzione fu un TRIM. Così, quando sono tornati gli stessi sintomi, è scattato il déjà vu.

Perché BitLocker e gli SSD siano una combinazione così pessima quando reinstalli dipende da come un SSD vede il mondo. Non ha idea di cosa sia un file. Conosce solo blocchi logici, e un blocco è “in uso” dal momento in cui ci viene scritto qualcosa finché qualcuno non dice esplicitamente “questo puoi dimenticarlo”. Quel qualcuno è il TRIM (o discard in gergo Linux). Un filesystem lo invia quando cancella i file. Un mkfs o un zpool create nuovo sopra vecchi dati non lo fa necessariamente per tutto il disco.

BitLocker porta tutto questo al peggio. I dati cifrati sono indistinguibili dal rumore casuale, quindi dentro il disco non c’è nulla da comprimere o deduplicare. E una volta che un volume è stato cifrato e usato per un po’, gran parte della flash contiene quelli che l’SSD deve trattare come dati preziosi. Poi io cancello il disco con un sistema operativo nuovo. La tabella delle partizioni è nuova, il filesystem è nuovo, ma nessuno dice all’SSD che tutti quei vecchi blocchi ora sono spazzatura. Dal suo punto di vista il disco è ancora pieno.

Questo fa male perché la flash non può essere sovrascritta sul posto. Si scrive in pagine e si cancella in blocchi molto più grandi. Un disco che si crede pieno non ha più blocchi già cancellati. Per ogni nuova scrittura il suo garbage collector deve prima trovare un blocco, copiare altrove le pagine ancora “valide” (il vecchio rumore cifrato), cancellare il blocco e solo allora scrivere i dati nuovi. Una scrittura dell’host diventa diverse scritture interne (write amplification). Il throughput crolla, la latenza esplode, e in più il disco si consuma prima.

Il modo giusto, che scrivo qui perché il me del futuro lo faccia davvero: prima di dare SSD usati a un nuovo filesystem, fai il discard completo. Questo distrugge tutto ciò che c’è sul disco, ed è proprio lo scopo:

# Before zpool create / mkfs — irreversibly wipes the drive!
blkdiscard /dev/disk/by-id/ata-WD_Red_SA500_2.5_2TB_...

# Check that the drive supports TRIM at all (non-zero DISC-GRAN/DISC-MAX):
lsblk --discard /dev/sdX

Su un SSD SATA inattivo, blkdiscard di solito impiega da qualche secondo a pochi minuti per l’intero disco. Farlo dopo con zpool trim su un pool attivo funziona anche. ZFS fa il discard solo dello spazio che non usa. Ma è più lento, compete con l’I/O reale e aiuta solo dal momento in cui gira.

C’è una terza opzione che ho notato solo più tardi, mentre frugavo nel BIOS per altro (vedi sotto): l’HPE RBSU ha SATA Secure Erase e SATA Sanitize integrati. Sono la versione firmware della stessa idea. Il disco stesso butta via tutto, comprese le proprie tabelle di mapping, e torna fresco come il primo giorno, con tutti i blocchi liberi. Per SSD che stanno comunque per essere cancellati, è probabilmente il reset più pulito che ci sia, e non serve nessun sistema operativo in esecuzione. Stesso avvertimento, a lettere più grandi: cancella il disco completamente.

Questa volta avevo saltato quel passaggio, quindi abbiamo avviato un zpool trim storage completo in mezzo al ripristino. Quaranta minuti dopo era al 2 %, e la copia era appena più veloce. Il TRIM era parte del problema, ma non la parte che trasformava gli SSD in floppy. C’era anche qualcosa di più basilare che non andava. E quando sai cos’era, anche un TRIM che si trascina al 2 % comincia ad avere senso.

💡 Sospettato numero due: una parola in sysfs

$ for d in sda sdb sdc sdd; do echo "$d $(cat /sys/block/$d/queue/write_cache)"; done
sda write through
sdb write through
sdc write through
sdd write through

$ hdparm -W /dev/disk/by-id/ata-WD_Red_SA500_2.5_2TB_...
 write-caching =  0 (off)

Write through. La write cache dei dischi era spenta. Ogni SSD ha un piccolo buffer DRAM: accetta le scritture in arrivo, risponde “fatto” e poi le scrive sulla flash in blocchi grandi ed efficienti. Senza, il disco deve completare ogni singola scrittura sulla flash prima di rispondere. Per un SSD è più o meno il modo peggiore di lavorare, perché la flash si scrive in pagine grandi e si cancella in blocchi ancora più grandi. Tante piccole scritture separate significano scritture lente e usura in più.

Chi l’aveva spenta? Non Debian, che quell’impostazione non la tocca. Risponde il log del kernel, due secondi dopo l’accensione, molto prima che giri qualsiasi cosa in userspace:

$ dmesg | grep -i "write cache"
[    2.101312] sd 2:0:0:0: [sda] Write cache: disabled, read cache: enabled
[    2.101316] sd 3:0:0:0: [sdc] Write cache: disabled, read cache: enabled
[    2.101332] sd 5:0:0:0: [sdd] Write cache: disabled, read cache: enabled
[    2.101407] sd 4:0:0:0: [sdb] Write cache: disabled, read cache: enabled
[    3.644946] sd 6:0:0:0: [sde] Write cache: enabled, read cache: enabled   ← USB stick
[  530.822448] sd 7:0:0:0: [sdf] Write cache: enabled, read cache: enabled   ← USB disk

Tutti e quattro gli SSD SATA interni partono disabled, mentre entrambi i dispositivi USB partono enabled. I dischi SATA escono di fabbrica con la write cache attiva, quindi qualcosa la spegne durante il POST, e quel qualcosa è il firmware del server. HPE a quanto pare imposta di default “drive write cache off” per i dischi SATA e, come si è scoperto, non ti lascia cambiarlo (ne parlo più sotto). Gli indizi puntano dritti alla piattaforma, non a Linux.

⚡ Un comando dopo

$ for d in /dev/disk/by-id/ata-WD_Red_SA500_2.5_2TB_*[0-9]; do hdparm -W1 "$d"; done
 setting drive write-caching to 1 (on)
 write-caching =  1 (on)
 ...
Write cache spentaWrite cache accesa
Throughput del ripristino rsync25–35 MB/s85–95 MB/s
Pressione I/O (PSI, some avg60)~90 %~30–45 %
Tempo di ripristino stimato~16 ore~6 ore
Collo di bottigliagli SSDil disco USB da 2,5" da cui copiavo

Dal vivo, a copia in corso, senza reboot. Gli SSD sono passati dall’essere il problema all’aspettare un disco rigido USB portatile. Finito il ripristino, ho fatto anche un benchmark pulito.

📊 Il benchmark pulito: stessi dischi, un interruttore

Dopo che il ripristino era terminato e il pool era di nuovo inattivo (circa 1,3 TB occupati, TRIM ancora in pausa), ho rifatto gli stessi test dd del post originale sul NAS, due volte: una con la write cache dei dischi di nuovo spenta, una con la cache accesa. Questa volta ho preso sul serio le lezioni di quel post: un dataset di test dedicato con compression=off, un file da 1 GiB di dati casuali servito dalla RAM (/dev/shm) così che /dev/urandom non possa diventare il collo di bottiglia, fsync alla fine e letture O_DIRECT così che l’ARC non possa abbellire i numeri in lettura.

zfs create -o compression=off storage/bench
head -c 1G /dev/urandom > /dev/shm/rand.bin

dd if=/dev/shm/rand.bin of=/storage/bench/t bs=1M conv=fsync                 # buffered + fsync
dd if=/dev/shm/rand.bin of=/storage/bench/t bs=1M oflag=direct conv=fsync    # O_DIRECT
dd if=/dev/shm/rand.bin of=/storage/bench/t4k bs=4k count=5000 oflag=direct,dsync
dd if=/storage/bench/t of=/dev/null bs=1M iflag=direct                       # read
TestWrite cache spentaWrite cache accesaFattore
Scrittura sequenziale 1M, buffered + fsync8 MB/s547 MB/s~68×
Scrittura sequenziale 1M, O_DIRECT2 MB/s239 MB/s~120×
Scrittura 4K, O_DIRECT + dsync292 kB/s334 kB/s~1×
Lettura sequenziale 1M, O_DIRECT972 MB/s865 MB/s–

Due megabyte al secondo. Su SSD. Il primo tentativo usava un file da 4 GiB come nel post originale. Con la cache spenta arrivava a 3 MB/s e ci avrebbe messo ben più di mezz’ora, quindi l’ho ridotto a 1 GiB. Già questo è un risultato.

Cosa dice davvero la tabella:

  • Le scritture salgono di un fattore da 70 a 120. Non è più un guadagno di tuning. È la differenza tra “rotto” e “funzionante”.
  • Le letture non cambiano. Ovvio, è una cache di scrittura. La piccola differenza è rumore tra un’esecuzione e l’altra.
  • Le scritture sincrone 4K non migliorano affatto, ed è corretto. Con dsync ogni singola scrittura 4K termina con un cache flush, quindi la cache si svuota alla stessa velocità con cui si riempie. Per carichi con molte scritture sincrone (database, NFS con sync, VM) la risposta non è la cache del disco. È un log device separato per ZFS (SLOG) o SSD con power-loss protection. La write cache non è magia. Impedisce solo al disco di fare ogni scrittura nel modo più faticoso possibile.
  • Rispetto al post originale (138 MB/s buffered, 15,4 MB/s O_DIRECT), oggi i numeri con la cache spenta sono persino peggiori. Sospetto che sia il secondo problema di questo post all’opera: allora i dischi erano freschi, questa volta erano pieni di vecchi dati BitLocker e il TRIM non era ancora girato. Due cose mancanti, e ognuna peggiora l’altra.

🔙 La parte in cui rileggo il mio blog

Ecco il pezzo un po’ imbarazzante. Sono gli stessi tre SSD nella stessa macchina di cui ho già scritto due volte. Entrambe le volte i numeri mi stavano dicendo esattamente questo, ed entrambe le volte ho trovato una spiegazione plausibile e sono andato avanti.

Primo errore: Building a RAIDZ1 NAS on Debian 13 with OpenZFS. Avevo misurato 138 MB/s in scrittura buffered e 15,4 MB/s con O_DIRECT, circa nove volte più lento. Avevo persino scritto che mi “aveva sorpreso abbastanza da ricontrollarlo due e tre volte”. Poi l’avevo spiegato con il batching dei transaction group di ZFS: le scritture buffered vengono raggruppate in scritture a stripe completo, O_DIRECT lo aggira. Quella parte è vera. Ma la spiegazione era troppo comoda. Con la cache del disco spenta, ogni scrittura non raggruppata deve aspettare la flash stessa, ed è questo che trasforma “un po’ più lento” in “nove volte più lento”. Persino il numero “buono” meritava una seconda occhiata: 138 MB/s su tre SSD SATA non sono un granché.

Secondo errore: Enough YAML for Now, sul lato Windows. Storage Spaces in parità sugli stessi dischi: 88 MiB/s in scrittura sequenziale, 461 IOPS in scrittura casuale e una latenza al 99° percentile di oltre un secondo. Avevo dato la colpa alla parità: “Le letture sono ottime. Le scritture sono… parità.” Il costo read-modify-write della parità è reale. Ma avevo anche lanciato DiskSpd con -Sh, che disattiva deliberatamente la write cache del disco per il test. Il benchmark misurava “nessuna write cache” per costruzione, ed era proprio così che il server girava comunque ogni giorno. Il caso peggiore e la realtà quotidiana coincidevano, e non mi sono mai chiesto perché.

Due sistemi operativi, due benchmark, due spiegazioni ragionevoli, un’impostazione che nessuno ha controllato. La lezione non è “i benchmark mentono”. È che ho confrontato i numeri con le mie aspettative sul software e mai con la scheda tecnica dell’hardware. 15 MB/s in scrittura su un SSD avrebbero dovuto essere un campanello d’allarme, qualunque filesystem ci fosse sopra.

🛡️ È sicuro accenderla?

È la domanda ovvia: se HPE la spegne, forse c’è un motivo.

Un motivo c’è, e qui per lo più non si applica. La cache del disco è RAM volatile. Se manca la corrente, ciò che contiene e che non è ancora sulla flash va perso. Gli SSD enterprise hanno condensatori per questo (“power-loss protection”), gli SSD consumer e da NAS di solito no. In più, un classico server HPE usa un controller RAID Smart Array con la propria cache alimentata a batteria. In quel design la cache del disco è nel migliore dei casi ridondante e nel peggiore un rischio, quindi spegnerla è la scelta prudente. Per un produttore che non sa quale sistema operativo, filesystem o controller userai, “spenta” è il default sicuro.

Su un filesystem moderno, una write cache è sicura perché il filesystem dice al disco quando i dati devono stare su memoria stabile. In ogni punto che conta, ZFS, ext4 e NTFS inviano un cache flush e non considerano nulla confermato finché il disco non lo conferma. ZFS in più è copy-on-write, quindi un crash ti lascia o l’ultimo stato consistente o quello nuovo, mai un miscuglio. L’unico vero pericolo è un disco che conferma flush che non ha mai eseguito (firmware economico e losco) oppure, su Windows, spuntare “Turn off Windows write-cache buffer flushing on the device”. Quella casella è davvero la casella “mi piace vivere pericolosamente”.

E nel mio caso tutti e tre i server HP stanno comunque dietro un UPS. Ciò che resta nella lista delle cose da fare è far spegnere in modo pulito HP3 quando la batteria si sta esaurendo (NUT). Un UPS che si scarica mentre il server continua a scrivere rimanda soltanto il blackout.

💾 SSD, HDD e il PC sotto la tua scrivania

  • Gli SSD soffrono di più. La flash si scrive in pagine e si cancella in blocchi. Senza cache il disco non può raccogliere le piccole scritture, quindi ognuna costa più tempo e più usura. Ecco come si arriva a 7,5 MB/s.
  • Anche gli HDD ci perdono, soprattutto nelle scritture casuali, perché il disco non può più riordinare le richieste per minimizzare il movimento della testina. Le scritture sequenziali soffrono meno.
  • I normali PC desktop sono quasi sempre a posto. I BIOS consumer non toccano l’impostazione, e Windows lascia attivo “Enable write caching on the device” per i dischi interni. Il mio jump host, una normale scheda madre desktop, dice write back sia per l’HDD da 8 TB sia per l’SSD NVMe. Anche NVMe ha una write cache volatile, controllata dal sistema operativo e attiva di default.
  • Le unità USB su Windows sono l’eccezione che probabilmente hai già sentito sulla tua pelle. Di default sono su “Quick removal”, dove Windows rinuncia alla cache write-back dal suo lato così puoi strappare via la chiavetta senza espellerla. È uno dei motivi per cui le copie grandi su USB spesso sembrano più lente su Windows che su Linux.

Controlla tu stesso:

# Linux
cat /sys/block/*/queue/write_cache
dmesg | grep -i "write cache"
hdparm -W /dev/sdX                      # SATA

# Windows (PowerShell)
Get-PhysicalDisk | Get-StorageAdvancedProperty   # IsDeviceCacheEnabled, IsPowerProtected

🔧 Rendere la cosa permanente

hdparm -W1 è volatile: il disco lo resetta al successivo ciclo di alimentazione, e il firmware lo spegne di nuovo a ogni avvio. Quindi anche la correzione deve avvenire a ogni avvio. Per ora è una regola udev:

# /etc/udev/rules.d/69-ssd-write-cache.rules
# HPE firmware disables the SATA SSD write cache at boot (write through).
# ZFS and ext4 issue cache flushes, so enabling it is safe.
ACTION=="add|change", KERNEL=="sd[a-z]", SUBSYSTEM=="block", ENV{ID_BUS}=="ata", \
  ATTR{queue/rotational}=="0", RUN+="/usr/sbin/hdparm -W1 /dev/%k"

Tocca solo dischi ATA interni non rotazionali, quindi la riceve anche l’SSD del sistema operativo e i dispositivi USB restano in pace.

Il BIOS non sarebbe il posto migliore? In teoria sì: un’impostazione firmware vale prima che si carichi qualsiasi sistema operativo, sopravvive a una reinstallazione e copre anche installer e sistemi di ripristino. Così ho riavviato nell’RBSU (F9) e sono andato a cercare. Sotto System Configuration → BIOS/Platform Configuration → Storage Options → SATA Controller Options sul MicroServer Gen10 Plus v2 ci sono esattamente tre voci:

  • Embedded SATA Configuration: SATA AHCI Support
  • SATA Secure Erase
  • SATA Sanitize

Tutto qui. Nessun “Drive Write Cache”, e niente nemmeno nelle opzioni di performance. In modalità AHCI il firmware spegne la cache e non ti dà modo di cambiarlo. (I controller Smart Array hanno una “Physical Drive Write Cache Policy”, ma passare questa macchina a una modalità RAID per avere quella manopola nasconderebbe i dischi a Linux e si porterebbe via il pool ZFS. Non è un’opzione.) Quindi la regola udev non è una cintura di sicurezza accanto alla vera correzione. È la correzione, applicata dal sistema operativo a ogni avvio, perché nient’altro lo farà.

Il che significa anche che deve far parte dell’installazione, non di qualcosa da ricordarsi dopo. Se alla prossima reinstallazione si dimentica questo unico file, si torna a 7,5 MB/s, e probabilmente a un altro post sul blog.

Gli altri due server HP hanno quasi certamente lo stesso default. Toccherà a loro quando avrò deciso cosa farne.

🎯 In sintesi

Ho scritto due post pieni di benchmark accurati: dati comprimibili contro incomprimibili, ARC contro page cache, i file di test riempiti di zeri di DiskSpd. Erano buone lezioni, e parlavano tutte del software che mi mentiva. Nel frattempo l’hardware era onestissimo: una parola in sysfs, una riga in dmesg e una lezione sul TRIM che avevo già imparato una volta dopo l’installazione con BitLocker e prontamente dimenticato. Non ho mai guardato.

La prossima volta che un numero sembra strano, la prima domanda non è “come lo spiega il mio filesystem?”. È “cosa dovrebbe fare questo hardware?”. Un SSD SATA a 15 MB/s non è una curiosa stranezza del filesystem. È un’impostazione, o un TRIM mancante, o nel mio caso entrambi. 🔍💾

La mia checklist per riutilizzare SSD su un server d’ora in poi:

  1. Prima il discard. blkdiscard su ogni SSD usato prima di creare il pool (oppure SATA Secure Erase / Sanitize del BIOS), soprattutto se c’era BitLocker o un’altra cifratura completa del disco.
  2. Includi la regola udev nell’installazione sulle macchine HPE in modalità AHCI. Il BIOS non lo sistemerà per te.
  3. Controlla la write cache. dmesg | grep -i "write cache" e /sys/block/*/queue/write_cache. Ti aspetti “write back”.
  4. Confronta con la scheda tecnica, non con le tue aspettative sul filesystem.
  5. Solo dopo fai il benchmark, con dati incomprimibili, su un pool inattivo.

📚 Altro in questa serie: il NAS RAIDZ1

Alcuni testi e immagini di questo sito sono creati con l’aiuto dell’IA o generati dall’IA. Dettagli