Test dei dischi su Linux

Guida completa per riconoscere il tipo di un disco, leggerne lo stato di salute e l'usura, misurarne la velocità e verificarne l'integrità.

Avvertenze prima di iniziare

• Fai sempre un backup prima di test su un disco sospetto: un disco che sta per rompersi può cedere proprio durante un test intensivo.
• I test di lettura sono sicuri. I test di scrittura su un dispositivo grezzo (/dev/sda, /dev/nvme0n1) distruggono i dati. Per misurare la scrittura usa sempre un file in una cartella del disco da provare.
• Controlla il nome del dispositivo con lsblk prima di ogni comando che scrive: scambiare sda e sdb è l'errore più comune.
• I test di scrittura prolungati consumano la vita degli SSD. Una misura di velocità è innocua, un test continuo di ore no.
• Un esito PASSED di SMART non garantisce che il disco sia sano: molti dischi si rompono senza segnali preventivi.

Strumenti

Installazione su Arch e EndeavourOS:

sudo pacman -S smartmontools nvme-cli hdparm fio ioping sysstat f3 gnome-disk-utility

Su Debian e Ubuntu:

sudo apt install smartmontools nvme-cli hdparm fio ioping sysstat f3 gnome-disk-utility

KDiskMark non è presente in tutte le distribuzioni: su Arch verifica con pacman -Ss kdiskmark, altrimenti è disponibile come Flatpak.

1. Riconoscere i dischi e il loro tipo

Elenco dei dischi

lsblk
lsblk -d -o NAME,SIZE,TYPE,ROTA,TRAN,MODEL,SERIAL
lsblk -f
sudo fdisk -l
ls -l /dev/disk/by-id/

Nel secondo comando le colonne importanti sono:

Verifica diretta della rotazione:

cat /sys/block/sda/queue/rotational

Nomi dei dispositivi

Informazioni dettagliate

sudo smartctl -i /dev/sda
sudo hdparm -I /dev/sda
sudo nvme list
sudo nvme id-ctrl /dev/nvme0

Da smartctl -i leggi:

• Rotation Rate: Solid State Device per gli SSD, oppure i giri/min (5400, 7200) per gli HDD
• Form Factor: 2.5", 3.5", M.2
• SATA Version is: la versione supportata e quella in uso
• Firmware Version
• User Capacity

Tipi di disco

Tipi di memoria flash

Dalla durata più alta alla più bassa: SLC (1 bit per cella), MLC (2), TLC (3), QLC (4). La maggior parte degli SSD di consumo è TLC o QLC.

Due dettagli che influenzano i test di velocità:

• Cache SLC: molti SSD scrivono i dati in una piccola area veloce e poi li spostano. Con scritture lunghe la velocità cala bruscamente quando la cache si esaurisce.
• DRAM-less: gli SSD senza memoria DRAM propria sono più lenti con carichi casuali pesanti.

CMR e SMR (solo per HDD)

I dischi SMR (Shingled Magnetic Recording) scrivono le tracce sovrapposte: le scritture lunghe e casuali diventano molto lente, e creano problemi in RAID e ZFS. Il sistema non sempre lo rivela: controlla il modello nella scheda tecnica del produttore.

Verificare l'interfaccia effettivamente usata

Un SSD veloce su una porta lenta viene limitato.

SATA:

sudo smartctl -i /dev/sda | grep -i "SATA Version"

L'output SATA 3.3, 6.0 Gb/s (current: 6.0 Gb/s) indica che il collegamento è al massimo. Se è 1.5 Gb/s o 3.0 Gb/s, controlla porta e cavo.

NVMe (generazione e numero di linee PCIe):

sudo lspci -vv | grep -iA 40 "Non-Volatile memory controller" | grep -E "LnkCap:|LnkSta:"

Un disco con LnkSta: Speed 8GT/s, Width x2 quando il disco è un x4 sta andando a metà della velocità: succede con slot M.2 condivisi o limitati.

USB:

lsusb -t

La velocità in fondo alla riga: 480M (USB 2.0), 5000M (USB 3.0), 10000M (USB 3.1 Gen 2), 20000M (USB 3.2 Gen 2x2). Se un disco USB 3 appare a 480M, è su una porta o un cavo USB 2.

2. Leggere lo stato e l'usura (SMART)

SMART (Self-Monitoring, Analysis and Reporting Technology) è il sistema con cui il disco registra contatori interni su errori, ore di utilizzo, temperatura e usura.

Comandi principali

sudo smartctl --scan
sudo smartctl -H /dev/sda
sudo smartctl -i /dev/sda
sudo smartctl -A /dev/sda
sudo smartctl -a /dev/sda
sudo smartctl -x /dev/sda
sudo smartctl -l error /dev/sda
sudo smartctl -l selftest /dev/sda

Funziona anche senza sudo se l'utente è nel gruppo disk, ma è più semplice usare sudo.

Dischi dietro adattatori USB

Molti adattatori non espongono SMART in modo automatico. Prova a indicare il tipo:

sudo smartctl -a -d sat /dev/sdb
sudo smartctl -a -d sat,12 /dev/sdb
sudo smartctl -a -d scsi /dev/sdb

Alcuni adattatori non lo supportano affatto.

Dischi dietro RAID hardware

sudo smartctl -a -d megaraid,0 /dev/sda
sudo smartctl -a -d cciss,0 /dev/cciss/c0d0

Il numero è l'indice del disco fisico nel controller.

Leggere la tabella degli attributi

Esempio:

ID# ATTRIBUTE_NAME          FLAG   VALUE WORST THRESH TYPE     UPDATED  WHEN_FAILED RAW_VALUE
  5 Reallocated_Sector_Ct   0x0033 100    100   010    Pre-fail Always   -           0
  9 Power_On_Hours          0x0032 097    097   000    Old_age  Always   -           12345

I produttori usano numeri e formati diversi: per ogni attributo conta soprattutto il valore grezzo e la sua tendenza nel tempo.

Attributi da guardare negli HDD

Regola pratica: valori diversi da zero e in crescita su 5, 187, 197 e 198 sono un segnale serio. Fai subito un backup e sostituisci il disco.

Attributi da guardare negli SSD SATA

I nomi variano molto da produttore a produttore. Cerca quelli simili a questi:

Per sapere quanti terabyte sono stati scritti:

sudo smartctl -A /dev/sda | grep -i "Total_LBAs_Written"

Con blocchi da 512 byte: TB scritti = RAW_VALUE × 512 / 1.000.000.000.000. Alcuni produttori usano altre unità: verifica con la documentazione o con smartctl -x, che a volte mostra già i dati in terabyte nella sezione "Device Statistics".

Calcolo rapido in shell:

raw=$(sudo smartctl -A /dev/sda | awk '/Total_LBAs_Written/ {print $NF}')
echo "scale=2; $raw * 512 / 10^12" | bc

Dischi NVMe

sudo smartctl -a /dev/nvme0
sudo nvme smart-log /dev/nvme0
sudo nvme smart-log -H /dev/nvme0
sudo nvme error-log /dev/nvme0
sudo nvme id-ctrl /dev/nvme0

Campi principali del registro NVMe:

smartctl -a mostra gli stessi dati con i terabyte già convertiti (ad esempio Data Units Written: 12.345.678 [6,32 TB]).

Per convertire a mano data_units_written:

TB scritti = data_units_written × 512000 / 10^12

Quanta vita resta a un SSD

Il dato più affidabile è Percentage Used per gli NVMe, e l'attributo di usura del produttore (177, 231, 233, 202) per i SATA. Si può confrontare anche con la TBW (Terabytes Written) dichiarata dal produttore nella scheda tecnica:

usura stimata = TB scritti / TBW dichiarata × 100

Esempio: 40 TB scritti su un disco da 600 TBW corrispondono a circa il 6,7 per cento.

Riferimenti indicativi (variano molto per modello):

Nell'uso desktop normale (circa 10 – 30 GB scritti al giorno) la durata è di molti anni. Un SSD non si spegne al raggiungimento della TBW: il valore è una garanzia, non una scadenza. Si preoccupa però quando:

• percentage_used supera circa 80 – 90
• available_spare si avvicina alla sua soglia
• compaiono media_errors o critical_warning diversi da zero
• aumentano i blocchi riallocati

Come interpretare i risultati

Temperatura

sudo smartctl -A /dev/sda | grep -i temp
sudo nvme smart-log /dev/nvme0 | grep -i temp
sensors

Intervalli indicativi:

Se un NVMe rallenta dopo pochi secondi di carico, la causa è spesso il surriscaldamento: serve un dissipatore.

3. Self-test integrati nel disco

Il disco esegue test interni sulla propria superficie o memoria.

Dischi SATA

sudo smartctl -t short /dev/sda
sudo smartctl -t long /dev/sda
sudo smartctl -t conveyance /dev/sda
sudo smartctl -c /dev/sda
sudo smartctl -l selftest /dev/sda
sudo smartctl -X /dev/sda

smartctl -c indica quanto durano i test. -X interrompe un test in corso. Il test viene eseguito dal disco e si può continuare a usare il computer; l'esito si legge poi con -l selftest. Un test long termina con Completed without error se va tutto bene, altrimenti riporta il primo LBA danneggiato.

Dischi NVMe

sudo nvme device-self-test /dev/nvme0 -s 1
sudo nvme device-self-test /dev/nvme0 -s 2
sudo nvme self-test-log /dev/nvme0

-s 1 esegue il test breve, -s 2 quello esteso. Non tutti gli NVMe supportano i self-test: in caso contrario il comando restituisce un errore.

4. Test di velocità

Regole per misure affidabili

1. Prova il disco giusto: i test su una cartella misurano il disco su cui si trova quella cartella.
2. Usa file grandi (almeno 4 GB, meglio 10 GB o più) per superare le cache.
3. Evita la cache del sistema: usa direct=1 in fio o oflag=direct in dd.
4. Disco quasi pieno = prestazioni minori in scrittura (per gli SSD).
5. Non usare il computer nel frattempo.
6. Ripeti più volte e fai la media.
7. Cifratura, compressione e RAID (LUKS, Btrfs con compressione, ZFS) cambiano i risultati: sono parte del sistema reale.
8. Ricorda la cache SLC degli SSD: scritture brevi sembrano velocissime, quelle lunghe no.

hdparm: lettura rapida

sudo hdparm -t /dev/sda
sudo hdparm -T /dev/sda
sudo hdparm -tT /dev/sda
sudo hdparm -tT /dev/nvme0n1

• -t legge dal disco senza passare dalla cache del sistema: velocità di lettura sequenziale
• -T misura la cache e la memoria RAM: non è una misura del disco

Non scrive nulla, quindi è sicuro. Ripetilo 3 volte.

dd: prova semplice

dd if=/dev/zero of=./prova.bin bs=1M count=4096 oflag=direct status=progress
dd if=./prova.bin of=/dev/null bs=1M iflag=direct status=progress
rm ./prova.bin

• Il primo comando misura la scrittura su un file di 4 GB
• Il secondo misura la lettura dello stesso file
• Alla fine elimina il file

Per svuotare la cache prima di una lettura senza direct:

sync
echo 3 | sudo tee /proc/sys/vm/drop_caches

dd è solo un test sequenziale, utile per una prova veloce. Con dati composti da soli zeri alcuni controllori (o filesystem con compressione) falsano il risultato: per misure serie usa fio.

ioping: latenza

ioping -c 10 .
ioping -c 10 /dev/sda
ioping -R /dev/sda
ioping -RL /dev/sda

• Il primo usa la cartella corrente
• -R misura le operazioni casuali al secondo (richiede dispositivo)
• -L usa la modalità sequenziale

Valori tipici: HDD alcuni millisecondi, SSD SATA circa 0,1 ms, NVMe sotto 0,1 ms. Su dispositivo grezzo ioping legge soltanto, quindi non distrugge dati.

fio: il benchmark completo

fio simula carichi di lavoro diversi. Prima crea una cartella di prova sul disco da testare:

mkdir -p /mnt/disco/test
cd /mnt/disco/test

Lettura sequenziale (come un file grande):

fio --name=seq-read --filename=./fio.bin --size=4G --rw=read --bs=1M \
    --ioengine=libaio --iodepth=8 --direct=1 --runtime=30 --time_based \
    --group_reporting

Scrittura sequenziale:

fio --name=seq-write --filename=./fio.bin --size=4G --rw=write --bs=1M \
    --ioengine=libaio --iodepth=8 --direct=1 --runtime=30 --time_based \
    --refill_buffers --group_reporting

Lettura casuale a 4 KB (carico tipico del sistema operativo):

fio --name=rand-read --filename=./fio.bin --size=4G --rw=randread --bs=4k \
    --ioengine=libaio --iodepth=32 --numjobs=4 --direct=1 --runtime=30 \
    --time_based --group_reporting

Scrittura casuale a 4 KB:

fio --name=rand-write --filename=./fio.bin --size=4G --rw=randwrite --bs=4k \
    --ioengine=libaio --iodepth=32 --numjobs=4 --direct=1 --runtime=30 \
    --time_based --refill_buffers --group_reporting

Carico misto 70% letture, 30% scritture:

fio --name=mix --filename=./fio.bin --size=4G --rw=randrw --rwmixread=70 --bs=4k \
    --ioengine=libaio --iodepth=32 --numjobs=4 --direct=1 --runtime=30 \
    --time_based --refill_buffers --group_reporting

Latenza con un solo accesso alla volta (la più vicina all'uso reale quotidiano):

fio --name=latenza --filename=./fio.bin --size=4G --rw=randread --bs=4k \
    --ioengine=libaio --iodepth=1 --numjobs=1 --direct=1 --runtime=30 \
    --time_based --group_reporting

Al termine elimina il file:

rm ./fio.bin

Parametri principali:

Come leggere il risultato:

read: IOPS=95.2k, BW=372MiB/s (390MB/s)(11.0GiB/30001msec)
     lat (usec): min=60, max=3400, avg=335.2
     clat percentiles (usec):
      |  1.00th=[  120], 50.00th=[  310], 99.00th=[  900], 99.99th=[ 2100]

• IOPS: operazioni al secondo
• BW: banda, cioè i MB/s
• lat e clat: latenze; i percentili mostrano quanto si comporta male il disco nei casi peggiori (99,00th e 99,99th)

Test di sola lettura su un dispositivo intero (nessuna scrittura):

sudo fio --name=lettura-disco --filename=/dev/nvme0n1 --readonly --rw=read --bs=1M \
    --ioengine=libaio --iodepth=8 --direct=1 --runtime=30 --time_based

Non eseguire mai fio con --rw=write o --rw=randwrite su /dev/... a meno che il disco non sia vuoto o destinato alla cancellazione.

Verificare la cache SLC con una scrittura lunga

Per capire come si comporta un SSD quando la cache finisce:

fio --name=sostenuta --filename=./fio.bin --size=100G --rw=write --bs=1M \
    --ioengine=libaio --iodepth=8 --direct=1 --refill_buffers \
    --write_bw_log=sostenuta --log_avg_msec=1000

Serve spazio libero superiore alla dimensione del file. Il file sostenuta_bw.1.log contiene la velocità secondo per secondo: al calo improvviso, la cache è esaurita. Un test di questo tipo scrive centinaia di gigabyte: ripetilo con parsimonia.

Strumenti grafici

• KDiskMark: replica i test di CrystalDiskMark (SEQ1M, RND4K con diverse code) usando fio
• GNOME Dischi (gnome-disks): menu del disco, Valutazione SMART e Benchmark del disco. Il benchmark in sola lettura è sicuro; quello con scrittura, se selezionato, cancella il contenuto della partizione

Valori di riferimento

Sono ordini di grandezza, non garanzie:

Se i risultati sono molto inferiori al previsto, controlla in ordine:

1. Il collegamento (porta, cavo, linee PCIe) con i comandi della sezione 1
2. La temperatura (throttling)
3. Lo spazio libero e lo stato del disco (cache SLC piena, SMR)
4. Il filesystem, la cifratura o la compressione
5. Il risparmio energetico e lo scheduler di I/O
6. Gli errori nel registro del kernel (sezione 6)

Monitorare l'I/O in tempo reale

iostat -xz 1
iostat -xm 2 /dev/sda
sudo iotop
sudo iotop -oPa

In iostat -x guarda r/s, w/s, rMB/s, wMB/s, await (latenza media) e %util (percentuale di utilizzo: vicino al 100% indica un disco saturo).

iotop -o mostra solo i processi che stanno facendo I/O.

Scheduler di I/O attuale:

cat /sys/block/nvme0n1/queue/scheduler
cat /sys/block/sda/queue/scheduler

La voce tra parentesi quadre è quella attiva (di solito none per gli NVMe e mq-deadline o bfq per gli altri).

5. Test di integrità

badblocks: cercare settori danneggiati

sudo badblocks -sv /dev/sdb
sudo badblocks -sv -b 4096 /dev/sdb
sudo badblocks -nsv /dev/sdb
sudo badblocks -wsv /dev/sdb

Opzioni utili: -s mostra l'avanzamento, -v è verboso, -b 4096 imposta la dimensione del blocco (consigliato per dischi grandi), -o file salva l'elenco dei blocchi difettosi.

Su un HDD il test di sola lettura per 4 TB richiede molte ore. Non usarlo sugli SSD in modalità di scrittura: consuma celle senza utilità, perché il controller gestisce da solo i blocchi difettosi. Per gli SSD sono più adatti i self-test SMART.

Controllo del filesystem

Il filesystem deve essere smontato (o si deve avviare dalla chiavetta live).

sudo umount /dev/sdb1
sudo e2fsck -f /dev/sdb1
sudo e2fsck -fn /dev/sdb1
sudo fsck -f /dev/sdb1
sudo xfs_repair -n /dev/sdb1
sudo btrfs check --readonly /dev/sdb1
sudo fsck.vfat -n /dev/sdb1
sudo ntfsfix -n /dev/sdb1

• e2fsck -fn esegue un controllo in sola lettura senza modificare nulla
• xfs_repair -n e btrfs check --readonly fanno la stessa cosa per XFS e Btrfs

Btrfs: scrub

Verifica i checksum di tutti i dati con il filesystem montato:

sudo btrfs scrub start /mnt/dati
sudo btrfs scrub status /mnt/dati
sudo btrfs device stats /mnt/dati

device stats mostra errori di lettura, scrittura e corruzione: tutti i contatori devono essere a zero.

RAID software (mdadm) e ZFS

cat /proc/mdstat
sudo mdadm --detail /dev/md0
echo check | sudo tee /sys/block/md0/md/sync_action
sudo zpool status
sudo zpool scrub nomepool

f3: chiavette e schede con capacità falsa

Alcune chiavette o schede economiche dichiarano più spazio di quello reale. f3 lo verifica scrivendo e rileggendo dati.

Sul filesystem montato (non distruttivo, riempie lo spazio con file di prova):

f3write /media/utente/CHIAVETTA
f3read /media/utente/CHIAVETTA

Se f3read segnala settori corrupted o overwritten, la capacità è falsa. Poi elimina i file *.h2w creati.

Per verificare rapidamente un dispositivo non montato, distruttivo:

sudo f3probe --destructive --time-ops /dev/sdb

6. Leggere gli errori del kernel

Gli errori di I/O compaiono nel registro del kernel prima ancora che SMART li segnali.

sudo dmesg | grep -iE "ata[0-9]|nvme|I/O error|blk_update_request|medium error|reset"
journalctl -k -p err -b
journalctl -k -b | grep -iE "ata[0-9]|nvme|I/O error"

Segnali tipici di guai:

Cambia cavo SATA e porta prima di dare la colpa al disco, soprattutto se SMART mostra errori CRC (attributo 199) e nessun settore danneggiato.

7. Monitoraggio continuo con smartd

smartd controlla periodicamente i dischi e avvisa in caso di problemi.

Attivazione

sudo systemctl enable --now smartd
systemctl status smartd

Su Debian e Ubuntu il servizio può chiamarsi smartmontools.

Configurazione: /etc/smartd.conf

DEVICESCAN -a -o on -S on -s (S/../.././02|L/../../7/03) -m root

Significato:

• DEVICESCAN: controlla tutti i dischi trovati
• -a: monitora salute, attributi, errori e self-test
• -s (S/../.././02|L/../../7/03): test breve ogni giorno alle 02:00 e test lungo ogni domenica alle 03:00
• -m root: invia l'avviso via email all'utente indicato (richiede un sistema di posta locale configurato)

Per una notifica diversa da una email, usa -M exec con uno script personalizzato.

Controllo dei log di smartd:

journalctl -u smartd -b

Verificare la configurazione

sudo smartd -q onecheck

8. TRIM per gli SSD

Il TRIM comunica all'SSD quali blocchi sono liberi, mantenendo prestazioni e durata.

lsblk -D
systemctl status fstrim.timer
sudo systemctl enable --now fstrim.timer
sudo fstrim -av

• lsblk -D: se DISC-GRAN e DISC-MAX sono maggiori di zero, il disco supporta il TRIM
• fstrim.timer: esegue il TRIM una volta a settimana
• fstrim -av: lo esegue subito su tutti i filesystem montati che lo supportano

Con LUKS il TRIM è disabilitato per impostazione predefinita (per motivi di sicurezza): va abilitato esplicitamente con l'opzione discard in /etc/crypttab e con la consapevolezza che rivela quali blocchi sono liberi.

9. Script di riepilogo

Salva come salute-dischi.sh ed eseguilo come root:

#!/usr/bin/env bash
if [ "$EUID" -ne 0 ]; then
    echo "Esegui con sudo"
    exit 1
fi

for d in $(lsblk -dno NAME,TYPE | awk '$2=="disk" && $1 !~ /^(loop|zram|ram)/ {print $1}'); do
    echo "=============================="
    echo "/dev/$d"
    lsblk -dno SIZE,MODEL,ROTA,TRAN "/dev/$d"
    smartctl -H -i "/dev/$d" | grep -E "Device Model|Model Number|Serial Number|Rotation Rate|overall-health|Health Status"
    smartctl -A "/dev/$d" | grep -iE "Percentage Used|Available Spare:|Media and Data|Critical Warning|Reallocated_Sector|Current_Pending|Offline_Uncorrectable|Reported_Uncorrect|Wear_Leveling|Power_On_Hours|Temperature|Data Units Written|Total_LBAs_Written|UDMA_CRC"
done

Esecuzione:

chmod +x salute-dischi.sh
sudo ./salute-dischi.sh

10. Procedura consigliata per un disco sospetto

1. Backup dei dati importanti
2. Identifica il disco: lsblk -d -o NAME,SIZE,ROTA,TRAN,MODEL
3. Stato generale: sudo smartctl -a /dev/sdX (o nvme smart-log)
4. Errori del kernel: journalctl -k -p err -b
5. Avvia un test lungo: sudo smartctl -t long /dev/sdX, poi leggi -l selftest
6. Se i risultati sono dubbi, cambia cavo e porta e ripeti
7. Controlla il filesystem con fsck in sola lettura
8. Misura la velocità con fio e confronta con i valori attesi
9. Se i contatori peggiorano nel tempo, sostituisci il disco

Problemi comuni

Riepilogo dei comandi

lsblk -d -o NAME,SIZE,TYPE,ROTA,TRAN,MODEL,SERIAL
sudo smartctl -a /dev/sda
sudo smartctl -a /dev/nvme0
sudo nvme smart-log /dev/nvme0
sudo smartctl -t short /dev/sda
sudo smartctl -t long /dev/sda
sudo smartctl -l selftest /dev/sda
sudo hdparm -tT /dev/sda
ioping -c 10 .
fio --name=prova --filename=./fio.bin --size=4G --rw=randread --bs=4k --iodepth=32 --direct=1 --runtime=30 --time_based
sudo badblocks -sv /dev/sdb
sudo e2fsck -fn /dev/sdb1
sudo btrfs scrub start /mnt/dati
sudo fstrim -av
journalctl -k -p err -b

Vedi anche: df-du (spazio occupato), journalctl (log del kernel), systemctl (gestire smartd e fstrim.timer), grub (se un disco guasto impedisce l'avvio).

Tag

Suggerisci una correzione