Con vmstat abbiamo visto che il sistema è lento per colpa dell'attesa sul disco (la colonna wa alta). Ma quale disco? Quanti dati legge e scrive? Le richieste restano in coda? A queste domande risponde iostat, che mostra l'attività di ogni dispositivo a blocchi.
Cos'è
iostat fa parte del pacchetto sysstat, insieme a mpstat, pidstat e sar. A differenza di vmstat o free, che sono in procps, su molte distribuzioni sysstat non è installato di default: su Debian e Ubuntu si installa con sudo apt install sysstat (vedi apt). Nel mio sandbox non c'era: l'ho installato con apt e ho usato la versione 12.6.1.
Cosa fa
Legge i contatori del kernel su ogni disco (da /proc/diskstats) e riporta quante operazioni al secondo sono state fatte, quanti dati sono stati letti e scritti, quanto tempo le richieste hanno atteso e per quanta parte del tempo il disco è stato occupato. In più mostra, in testa, l'uso della CPU, compresa la quota di tempo passata ad aspettare l'I/O. Come vmstat, può ripetere la misura a intervalli regolari.
Come si usa
$ iostat [opzioni] [DISPOSITIVO...] [INTERVALLO [CONTEGGIO]]Non servono permessi di root per leggere le statistiche (il mio sandbox è root, quindi non l'ho verificato). Gli esempi vengono da una macchina virtuale con 2 CPU e dischi virtuali vda, vdb, vdc...; vda è il disco di sistema. Nella prima riga di ogni output ho sostituito il nome del computer con web01 e ho sostituito le tabulazioni con spazi. La data è mostrata in formato americano (11/15/26): con una lingua diversa potrebbe comparire come 15/11/26.
Esempio 1: il report predefinito
$ iostat -h vda vdc
Linux 6.18.44-fc-v470 (web01) 11/15/26 _x86_64_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
1.7% 0.0% 2.1% 2.4% 0.1% 93.7%
tps kB_read/s kB_wrtn/s kB_dscd/s kB_read kB_wrtn kB_dscd Device
636.90 3.2M 19.1M 19.1M 1.1G 6.7G 6.7G vda
3.88 335.2k 0.0k 0.0k 117.6M 0.0k 0.0k vdcIl blocco avg-cpu riassume la CPU (%iowait è il tempo passato ad attendere il disco). Poi, per ogni disco: tps (operazioni di I/O al secondo), le quantità lette, scritte e "scartate" (dscd, le operazioni di discard/TRIM) al secondo e il totale da quando il sistema è avviato. L'opzione -h scrive i numeri in forma leggibile (k, M, G) e sposta il nome del disco in fondo alla riga, ottenendo righe più strette. Senza -h le stesse colonne sono più larghe (circa 94 caratteri). Attenzione: come per vmstat, questo primo report mostra le medie dall'avvio, non l'attività di adesso.
Esempio 2: la misura attuale (intervallo e -y)
$ iostat -hy 1 1 vda
avg-cpu: %user %nice %system %iowait %steal %idle
0.0% 0.0% 0.0% 0.0% 0.0% 100.0%
tps kB_read/s kB_wrtn/s kB_dscd/s kB_read kB_wrtn kB_dscd Device
0.00 0.0k 0.0k 0.0k 0.0k 0.0k 0.0k vda1 1 chiede una misura di un secondo, e -y salta il report iniziale con le medie dall'avvio: quello che vedi è lo stato del secondo appena trascorso. Qui il disco era a riposo, quindi tutto è a zero. Senza il conteggio, iostat 1 continua a stampare ogni secondo fino a Ctrl+C; con -y e un intervallo, la prima riga è già un'attività vera. Nel resto dell'articolo ometto l'intestazione con il kernel.
Esempio 3: le statistiche estese (-x)
$ SEL='/^Device/ { for (i = 1; i <= NF; i++) c[$i] = i }
> /^vda/ { printf "r/s=%s w/s=%s wkB/s=%s w_await=%s %%util=%s\n",
> $c["r/s"], $c["w/s"], $c["wkB/s"], $c["w_await"], $c["%util"] }'
$ iostat -dxy vda 1 1 | awk "$SEL" # a riposo
r/s=0.00 w/s=0.00 wkB/s=0.00 w_await=0.00 %util=0.00
$ iostat -dxy vda 1 1 | awk "$SEL" # mentre dd scrive blocchi da 1 MiB
r/s=3.00 w/s=353.00 wkB/s=361472.00 w_await=1.00 %util=35.20
$ iostat -dxy vda 1 1 | awk "$SEL" # mentre dd scrive blocchi da 4 KiB
r/s=0.00 w/s=24759.00 wkB/s=99036.00 w_await=0.03 %util=69.20Con -x ogni disco ha una riga di oltre venti colonne, larga circa 190 caratteri, che qui non riporto per intero: ho estratto con awk (cercando le colonne per nome, con lo script contenuto nella variabile SEL) solo le più utili. I tre casi vengono da prove reali con dd e scrittura diretta sul disco (oflag=direct): a riposo tutto è a zero; scrivendo blocchi da 1 MiB si hanno circa 353 scritture al secondo (361 MB/s) e il disco occupato per il 35% del tempo; scrivendo blocchi da 4 KiB le scritture salgono a quasi 25.000 al secondo ma i dati restano a 99 MB/s e %util arriva al 69%. Le colonne chiave sono r/s e w/s (richieste al secondo), rkB/s e wkB/s (dati al secondo), r_await e w_await (tempo medio di attesa e servizio di una richiesta in millisecondi), aqu-sz (lunghezza media della coda) e %util (percentuale di tempo in cui il disco aveva richieste in corso).
Esempio 4: solo la CPU
$ iostat -cy 1 1
avg-cpu: %user %nice %system %iowait %steal %idle
0.00 0.00 1.50 23.50 0.00 75.00-c stampa solo il blocco della CPU (-d, al contrario, solo quello dei dischi). La riga qui sopra l'ho presa mentre dd scriveva 600 MiB con conv=fsync: il processore era in attesa del disco il 23,5% del tempo (%iowait) e fermo per il 75%. Una seconda prova con 900 MiB ha dato un %iowait del 34,8% e un %system del 16,4%. È lo stesso fenomeno visto con vmstat, ma qui puoi poi vedere quale disco lo causa.
Esempio 5: scegliere i dischi e togliere il rumore
$ iostat -dz 1 2
$ iostat -d vda vdc
$ iostat -p vda
$ iostat -d nope; echo $?
Device tps kB_read/s kB_wrtn/s kB_dscd/s kB_read kB_wrtn kB_dscd
0-z omette i dischi senza attività nell'intervallo; elencando i nomi dei dispositivi (vda vdc) si limita il report a quelli; -p vda mostra anche le partizioni del disco indicato (-p ALL tutti i dischi e le loro partizioni). Attenzione a un dettaglio insidioso: se scrivi male il nome del dispositivo (l'ultimo comando) iostat non dà errore: stampa solo l'intestazione (qui con le colonne ravvicinate, e prima la riga con il kernel, che ho omesso) e termina con codice 0. L'output degli altri tre comandi non lo riporto perché cambia da sistema a sistema.
Esempio 6: unità, data e ora, JSON
$ iostat -md vda
vda 18.83 0.44 6.83 6.82 137 2112 2108
$ iostat -dt vda 1 1
11/15/26 16:55:16
Device tps kB_read/s kB_wrtn/s kB_dscd/s kB_read kB_wrtn kB_dscd
$ iostat -o JSON -d vda
{"sysstat": {
"hosts": [
{
"nodename": "web01",-m usa i megabyte al posto dei kilobyte (le colonne cambiano nome in MB_read/s, ecc.); -k li riporta in kilobyte; -t aggiunge la data e l'ora a ogni report (utile nei log); -o JSON produce l'output in formato JSON, adatto a strumenti automatici. Nell'esempio ho accorciato gli spazi di -t e ho riportato solo l'inizio dell'output JSON, sostituendo il nome del computer; i valori delle altre righe sono quelli del mio sandbox e i tuoi saranno diversi.
Esempio 7: uso negli script
#!/bin/bash
DEV="${1:?uso: $0 dispositivo [soglia]}"
SOGLIA="${2:-80}"
util=$(iostat -dxy "$DEV" 1 1 | awk -v d="$DEV" '
/^Device/ { for (i = 1; i <= NF; i++) if ($i == "%util") c = i }
$1 == d { print $c }')
[ -n "$util" ] || { echo "dispositivo non trovato: $DEV" >&2; exit 2; }
echo "$DEV: %util=$util"
awk -v u="$util" -v s="$SOGLIA" 'BEGIN { exit !(u >= s) }' && exit 1
exit 0Lo script misura per un secondo l'uso di un disco e termina con codice 1 se %util raggiunge la soglia (80 per default). Cerca la colonna %util per nome, e non per posizione, perché l'ordine delle colonne cambia tra le versioni di sysstat (è la stessa tecnica di selezione usata nell'esempio 3). A riposo ha stampato vda: %util=0.00 (codice 0); mentre dd scriveva blocchi da 4 KiB ha dato vda: %util=66.40 con soglia 50 (codice 1) e vda: %util=67.60 con soglia 95 (codice 0); per un disco inesistente "dispositivo non trovato" (codice 2). Senza argomenti stampa il messaggio d'uso e termina con errore (codice 1).
Opzioni utili
-d: solo i dischi.-c: solo la CPU.-x: statistiche estese (tempi di attesa, coda,%util). Le righe sono larghe: per il terminale conviene un schermo ampio oawk.-h: formato leggibile.-ke-m: unità (kilobyte, megabyte).-y: salta il report iniziale con le medie dall'avvio.-z: omette i dischi inattivi.-p [DISPOSITIVO|ALL]: include le partizioni.-t: aggiunge data e ora.-o JSON: output in JSON.-N: mostra i nomi dei dispositivi device-mapper (LVM) al posto dei nomi tecnici: non l'ho provato perché il sandbox non ha LVM.-V: versione.
Attenzione a
- Il primo report è la media dall'avvio: usa
-ye un intervallo, oppure ignora la prima serie di valori. %utilal 100% non significa sempre "saturo": sui dischi che gestiscono più richieste insieme (SSD, NVMe, volumi di rete) può arrivare al 100% mentre il dispositivo ha ancora margine. Valuta insieme aaqu-sze ai tempi di attesa (r_await,w_await).- Tempi di attesa:
awaitcomprende l'attesa in coda e il servizio; valori in crescita insieme a una coda lunga indicano un disco in difficoltà. - Dischi virtuali: su una macchina virtuale i numeri riflettono ciò che vede il sistema ospite, non necessariamente il disco fisico sottostante.
- Non dice chi:
iostatindica quale disco è sotto stress, non quale processo lo causa. Per quello servono strumenti comepidstat -doiotop(non provati qui). - Una sola colonna non basta: tante operazioni piccole (alto
tps, pochi kB/s) e poche operazioni enormi (bassotps, tanti kB/s) possono essere ugualmente un problema; guarda sempre almenotps, dati al secondo, attese e%util. - Cache: il kernel mette in cache le scritture: un
ddsenzaconv=fsyncooflag=directpuò non muovere il disco finché i dati non vengono svuotati. Nei miei test ho usato questi flag proprio per vederli. - Intestazioni e formato: nomi e ordine delle colonne cambiano tra le versioni di
sysstat(la colonnadscdè recente): negli script cerca le colonne per nome.
Riepilogo
| Comando | Cosa fa |
|---|---|
iostat | CPU e dischi: medie dall'avvio |
iostat -h | Numeri in forma leggibile |
iostat -y 1 5 | 5 misure da 1 secondo, senza le medie iniziali |
iostat -dx 1 | Statistiche estese dei dischi, ogni secondo |
iostat -c | Solo la CPU |
iostat -z | Nasconde i dischi inattivi |
iostat -p ALL | Anche le partizioni |
iostat -t | Con data e ora |
iostat -o JSON | Output in JSON |
iostat -m | Dati in megabyte |