df e du: quanto spazio c'è e chi lo occupa

df dice quanto spazio resta su ciascun disco o partizione, mentre du dice quanto ne occupano file e cartelle. Insieme rispondono alle due domande che ci si pone quando il disco si riempie: quanto spazio ho ancora? e che cosa lo sta occupando?

Cos'è

df è l'abbreviazione di disk free, "disco libero", e du di disk usage, "uso del disco". Fanno parte del pacchetto GNU coreutils e sono eseguibili (/usr/bin/df e /usr/bin/du), presenti su qualsiasi distribuzione GNU/Linux.

Cosa fanno

• df interroga i file system montati e riporta, per ciascuno, dimensione totale, spazio usato e spazio disponibile. Risponde subito, perché legge i dati che il file system stesso tiene aggiornati.
• du visita le cartelle e somma lo spazio occupato dai file che trova. Su cartelle grandi può richiedere del tempo, perché deve scorrere ogni file.

Hanno quindi un punto di vista diverso: df guarda il disco dall'alto (quanto è pieno), du guarda dentro le cartelle (chi lo riempie). Nessuno dei due modifica nulla.

Come si usano

$ df [opzioni] [file_o_directory...]
$ du [opzioni] [file_o_directory...]

Esempio 1: lo spazio dei dischi con df -h

$ df -h
File system      Dim. Usati Dispon. Uso% Montato su
tmpfs            1,6G  2,1M    1,6G   1% /run
/dev/sda2        234G  118G    104G  54% /
tmpfs            7,8G     0    7,8G   0% /dev/shm
/dev/sda1        511M  6,1M    505M   2% /boot/efi

Senza opzioni df stampa le dimensioni in blocchi da 1 KiB, difficili da leggere: con -h (human-readable) usa K, M, G. Le colonne sono:

• File system: il dispositivo (/dev/sda2) o il tipo di file system virtuale (tmpfs).
• Dim., Usati, Dispon.: dimensione totale, spazio occupato e spazio ancora utilizzabile.
• Uso%: percentuale di spazio usato.
• Montato su: la cartella da cui il disco è accessibile.

Il file system che ti interessa di solito è quello montato su /, la radice del sistema.

Esempio 2: il disco di una cartella precisa

$ df -h ~
$ df -h /var/www

Se indichi un percorso, df mostra solo la riga del file system che lo contiene. È comodo per sapere "su che disco si trova questa cartella e quanto spazio ha".

Esempio 3: il tipo di file system con -T

$ df -hT /
File system    Tipo  Dim. Usati Dispon. Uso% Montato su
/dev/sda2      ext4  234G  118G    104G  54% /

Esempio 4: nascondere i file system virtuali con -x

Le righe dei file system virtuali (tmpfs, devtmpfs, squashfs) rendono l'elenco confuso, ma si possono escludere:

$ df -h -x tmpfs -x devtmpfs -x squashfs
File system      Dim. Usati Dispon. Uso% Montato su
/dev/sda2        234G  118G    104G  54% /
/dev/sda1        511M  6,1M    505M   2% /boot/efi
/dev/sdb1        932G  611G    274G  70% /media/dati

Con -x tipo si escludono i file system di un certo tipo; con -t tipo, al contrario, si mostrano solo quelli. Le righe squashfs, tipiche dei pacchetti Snap, risultano sempre piene al 100%: sono immagini di sola lettura, ed è normale.

Esempio 5: scegliere le colonne con --output

$ df -h --output=source,size,used,avail,pcent,target /
File system      Dim. Usati Dispon. Uso% Montato su
/dev/sda2        234G  118G    104G  54% /

Con --output si decide quali colonne mostrare. Utile negli script, come vedremo in fondo.

Esempio 6: gli inode con -i

$ df -i /
File system       Inode IUsati  ILiberi IUso% Montato su
/dev/sda2      15605760 412345 15193415    3% /

Ogni file occupa un inode, una voce nella tabella del file system, e il loro numero è fisso. Se un disco contiene milioni di file molto piccoli può esaurire gli inode pur avendo spazio libero: in quel caso non si possono più creare file e i messaggi d'errore parlano di "spazio esaurito". Con df -i si scopre il problema.

Esempio 7: la dimensione di una cartella con du -sh

$ du -sh Documenti
1,2M	Documenti

Qui -h è la forma leggibile e -s (summarize) stampa solo il totale, senza elencare tutte le sottocartelle. Senza -s, du stamperebbe una riga per ogni directory trovata.

Esempio 8: ogni file con du -a

$ du -a Documenti
4	Documenti/note.txt
1180	Documenti/relazione.pdf
8	Documenti/Archivio/vecchio.txt
12	Documenti/Archivio
1200	Documenti

Di norma du elenca solo le directory; con -a (all) mostra anche i singoli file. I numeri, senza -h, sono in kibibyte.

Esempio 9: un solo livello di profondità

$ du -h --max-depth=1 ~ | sort -h
4,0K	/home/enzo/Scrivania
1,2M	/home/enzo/Documenti
48M	/home/enzo/Immagini
2,1G	/home/enzo/.cache
3,4G	/home/enzo/Video
5,6G	/home/enzo

Con --max-depth=1 (abbreviato -d 1) du mostra la dimensione della cartella e delle sue sottocartelle dirette, senza scendere oltre. Passando l'output a sort -h, il comando che hai già visto, le voci più pesanti finiscono in fondo. L'ultima riga è il totale della cartella. Nota che compaiono anche le cartelle nascoste, come .cache.

Esempio 10: i 10 file o cartelle più pesanti

$ du -ah ~ 2>/dev/null | sort -rh | head -n 10

Con -a si includono i file, sort -rh ordina dal più grande e head tiene le prime righe. La prima è il totale della cartella stessa, le altre sono i veri "colpevoli". Il 2>/dev/null nasconde gli errori di permesso.

Esempio 11: il totale di più elementi con -c

$ du -ch *.log
4,0K	app.log
128K	nginx.log
132K	totale

Con -c (total) viene aggiunta una riga finale con il totale generale.

Esempio 12: escludere certi file con --exclude

$ du -sh --exclude='*.iso' Download

Conta lo spazio della cartella Download ignorando le immagini ISO.

Esempio 13: restare su un solo disco con -x

$ sudo du -xh --max-depth=1 / 2>/dev/null | sort -h | tail -n 5

Con -x du non attraversa i confini tra file system diversi: scorrendo / non entra in /media, /proc o negli altri dischi montati, e il risultato descrive davvero il disco principale. È il comando per capire "cosa sta riempiendo la radice".

Esempio 14: le cartelle nascoste con l'asterisco

Il comando du -sh * non include le cartelle nascoste, perché il carattere jolly ignora i nomi che iniziano con il punto. Per includerle:

$ du -sh .[!.]* * 2>/dev/null | sort -h

Il modello .[!.]* comprende i nomi che iniziano con un punto, escluso ... Se non esistono elementi nascosti, la shell lascia il modello così com'è e du segnala un errore, che nascondiamo con 2>/dev/null.

Esempio 15: uso negli script

Un avviso quando il disco supera una soglia:

#!/bin/bash
SOGLIA=90
USO=$(df --output=pcent / | tail -n 1 | tr -dc '0-9')

if [ "$USO" -ge "$SOGLIA" ]; then
    echo "Attenzione: il disco è pieno al ${USO}%"
fi

L'opzione --output=pcent stampa solo la percentuale (con una riga di intestazione), tail -n 1 prende l'ultima riga e tr -dc '0-9' tiene solo le cifre.

E un altro che mostra le 5 voci più pesanti di una cartella:

#!/bin/bash
DIR="${1:-.}"
echo "Le 5 voci più pesanti in $DIR:"
du -h --max-depth=1 "$DIR" 2>/dev/null | sort -rh | sed -n '2,6p'

Qui sort -rh mette in testa il totale, quindi con sed -n '2,6p' si saltano la prima riga e si stampano le cinque successive.

Opzioni utili

Per df:

• -h: dimensioni leggibili (multipli di 1024); -H: con multipli di 1000, come sulle confezioni dei dischi.
• -T: mostra il tipo di file system.
• -i: mostra gli inode invece dei blocchi.
• -x tipo / -t tipo: esclude o seleziona un tipo di file system.
• -l: solo i file system locali (esclude quelli di rete).
• --total: aggiunge una riga con i totali.
• --output=colonne: sceglie le colonne da mostrare.

Per du:

• -h: dimensioni leggibili.
• -s: solo il totale per ogni argomento.
• -a: mostra anche i singoli file.
• -d N / --max-depth=N: scende al massimo di N livelli.
• -c: aggiunge un totale generale.
• -x: non esce dal file system di partenza.
• --exclude=modello: ignora i file che corrispondono.
• --apparent-size: mostra la dimensione apparente dei file invece dello spazio occupato su disco.

Attenzione a

• df e du possono non coincidere, ed è normale. Le cause più comuni:
  • File cancellati ma ancora aperti: se elimini un file che un programma sta ancora usando (tipico con i log), lo spazio non viene liberato finché il programma non lo chiude. df lo conta come occupato, du non lo vede più. Con sudo lsof +L1 si trovano i file cancellati e ancora aperti; riavviare il servizio libera lo spazio.
  • Spazio riservato: sui file system ext4 una quota (di solito il 5%) è riservata a root, quindi Usati + Dispon. non fa Dim..
  • Cartelle nascoste sotto un punto di montaggio: se hai file in /media/dati prima di montarci sopra un disco, quei file continuano a occupare spazio ma du non li raggiunge.
• Disco "pieno" con spazio libero: se i messaggi dicono Spazio esaurito sul dispositivo ma df -h mostra spazio libero, controlla gli inode con df -i.
• Spazio occupato e dimensione apparente: du conta lo spazio effettivamente assegnato, a blocchi interi (di solito 4 KiB). Un file di un solo byte risulta di 4 KiB. I file "sparsi", come le immagini di macchine virtuali, possono risultare molto diversi tra ls -l (dimensione apparente) e du (spazio reale).
• Gli hard link vengono contati una sola volta da du.
• du su cartelle enormi può essere lento e generare molti errori di permesso: usa -x, restringi il percorso e usa sudo o 2>/dev/null secondo le necessità.
• -h o -H: -h usa multipli di 1024 (quindi 1G sono 1024 MiB), -H multipli di 1000. Per i confronti tra programmi usa sempre lo stesso.
• Prima di cancellare, misura: individua con du cosa pesa davvero, poi decidi cosa eliminare. Per i file di log, per esempio, spesso basta ruotarli o comprimerli, non cancellarli.
• Alternativa interattiva: ncdu permette di navigare tra le cartelle ordinate per dimensione. Non è installato di serie, ma si trova nei repository della maggior parte delle distribuzioni.

Riepilogo