Salta al contenuto principale

iostat: misurare il carico dei dischi

Inviato da tuxsa il

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 vdc

Il 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 vda

1 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.20

Con -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 0

Lo 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 o awk.
  • -h: formato leggibile. -k e -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 -y e un intervallo, oppure ignora la prima serie di valori.
  • %util al 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 a aqu-sz e ai tempi di attesa (r_await, w_await).
  • Tempi di attesa: await comprende 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: iostat indica quale disco è sotto stress, non quale processo lo causa. Per quello servono strumenti come pidstat -d o iotop (non provati qui).
  • Una sola colonna non basta: tante operazioni piccole (alto tps, pochi kB/s) e poche operazioni enormi (basso tps, tanti kB/s) possono essere ugualmente un problema; guarda sempre almeno tps, dati al secondo, attese e %util.
  • Cache: il kernel mette in cache le scritture: un dd senza conv=fsync o oflag=direct può 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 colonna dscd è recente): negli script cerca le colonne per nome.

Riepilogo

ComandoCosa fa
iostatCPU e dischi: medie dall'avvio
iostat -hNumeri in forma leggibile
iostat -y 1 55 misure da 1 secondo, senza le medie iniziali
iostat -dx 1Statistiche estese dei dischi, ogni secondo
iostat -cSolo la CPU
iostat -zNasconde i dischi inattivi
iostat -p ALLAnche le partizioni
iostat -tCon data e ora
iostat -o JSONOutput in JSON
iostat -mDati in megabyte