File system

Approfondimento · Linux

File system e permessi

Su Linux un file non è “un nome su un disco”: è un inode con metadati, raggiunto da uno o più nomi, dentro una gerarchia montata in un punto preciso. Permessi, ACL, attributi e contesti di sicurezza decidono chi può fare cosa. Questa pagina parte dalla struttura delle directory e arriva a mount, ext4, XFS, Btrfs e overlayfs, con i comandi per Debian/Ubuntu e Red Hat/Fedora separati dove cambiano davvero.

In breve. Due regole evitano la maggior parte dei disastri. La prima: chmod 777 non è una soluzione, è un modo per rimandare il problema. La seconda: prima di cancellare o riparare qualcosa, si guarda findmnt, df -hT, df -i, namei -l e dmesg. Il file system raramente mente; quasi sempre stiamo guardando il posto sbagliato.

Per preparare dischi e partizioni da zero la pagina Installazione da riga di comando copre GPT, ESP, LUKS e prima installazione; qui si presume un sistema già avviato. Per il kernel e i moduli che implementano i file system c’è Il kernel e la sua gestione.

La gerarchia FHS

Il Filesystem Hierarchy Standard (FHS 3.0, 2015) non è un’imposizione del kernel: è una convenzione che le distribuzioni seguono per far funzionare script, manuali e aspettative degli amministratori. Il kernel conosce solo il punto di mount; è la distribuzione a decidere che cosa mettere in /usr e che cosa in /var.

PercorsoContenutoNote
/RadiceTutto parte da qui; il file system radice deve bastare per avviare e riparare
/bin /sbinBinari essenzialiCon lo usrmerge sono symlink a /usr/bin e /usr/sbin
/lib /lib64Librerie condiviseAnche queste spesso symlink a /usr/lib
/usrProgrammi, librerie, documentazioneDati condivisibili e in gran parte di sola lettura
/usr/localSoftware installato dall’amministratoreNon gestito dal package manager
/etcConfigurazione del sistemaTesto, specifico della macchina; niente binari
/varDati variabiliLog, cache, spool, database, code
/tmpFile temporaneiSpesso tmpfs; può essere svuotata al boot
/var/tmpTemporanei persistentiSopravvive al riavvio, con scadenze più lunghe
/homeHome degli utentiSpesso su partizione o volume separato
/rootHome di rootNon è / e non dovrebbe stare su NFS
/optPacchetti software aggiuntiviConvenzione per prodotti di terze parti
/srvDati serviti dal sistemaWeb, FTP, repository locali
/mnt /mediaMount temporanei e rimovibili/media per USB e CD, /mnt per l’amministratore
/runStato runtimetmpfs, ricreato a ogni boot; PID, socket, lock
/proc /sysPseudo file systemInterfacce al kernel: processi, dispositivi, parametri
/devDispositiviGestito da devtmpfs e udev
/boot /efiKernel, initramfs, bootloader/efi è la ESP su molti sistemi UEFI

Lo usrmerge è la ragione per cui su un sistema moderno /bin non è una directory vera. Si verifica con ls -ld /bin /sbin /lib: se sono symlink, il contenuto fisico è sotto /usr. Non è un dettaglio estetico: semplifica i pacchetti, i container e gli aggiornamenti atomici, ma rompe script che assumono percorsi separati.

# Dove sono montate le cose
findmnt /
findmnt -T /var/lib
df -hT
lsblk -f

# La gerarchia spiegata dal sistema
man 7 hier
man 7 file-hierarchy

Inode, nomi e metadati

Un inode è la struttura che descrive un file: tipo, permessi, proprietario, gruppo, dimensione, timestamp, numero di link e puntatori ai blocchi o agli extent. Il nome non sta nell’inode: sta nella directory, che è una tabella nome → numero di inode. Per questo un file può avere più nomi e per questo rm non cancella i dati se qualcuno ha ancora il file aperto.

stat file.txt
ls -li file.txt
stat -c '%n inode=%i size=%s mode=%a owner=%U:%G links=%h' file.txt
find /var -xdev -inum 1234567 2>/dev/null

I timestamp hanno significati diversi e non sono intercambiabili:

TimestampQuando cambiaSi può impostare?
atimeAll’accesso in letturaSì, ma spesso disabilitato o attenuato
mtimeQuando cambia il contenutoSì, con touch -m
ctimeQuando cambiano inode o metadatiNo, è gestito dal kernel
btimeAlla creazione, se il file system lo registraNo; dipende da file system e kernel

relatime è il compromesso predefinito sulla maggior parte dei sistemi: aggiorna atime solo se è più vecchio di mtime o di 24 ore. noatime elimina del tutto gli aggiornamenti e riduce le scritture; strictatime li impone a ogni lettura. Su un portatile o su un database conviene quasi sempre noatime.

Esaurire gli inode è diverso dall’esaurire lo spazio: df -h può dire che c’è spazio e df -i mostrare il 100%. Succede con milioni di file piccoli, cache, sessioni, maildir o repository. ext4 crea un numero fisso di inode al mkfs (si può aumentare con -N o -i); XFS li alloca dinamicamente e ne soffre molto meno; Btrfs non ha una tabella di inode tradizionale.

df -i
du --inodes -x /var | sort -n | tail -n 20
find /var -xdev -type f | wc -l

# Quanti inode ha un ext4 e quanti sono liberi
sudo tune2fs -l /dev/nvme0n1p2 | grep -i inode

Per risolvere un percorso componente per componente, inclusi i permessi di ogni directory attraversata, si usa namei -l. È il comando che risponde alla domanda “perché cat dice Permission denied se il file è leggibile?”: quasi sempre manca x su una directory superiore.

namei -l /srv/app/config/settings.yml
realpath /srv/app/config/settings.yml
readlink -f /usr/bin/python3

Tipi di file, hard link e symlink

In Linux “file” è un concetto ampio: directory, dispositivi, pipe e socket sono file. Il primo carattere di ls -l dice il tipo.

CarattereTipoEsempio
-File regolareTesto, binario, archivio
dDirectoryContenitore di nomi
lSymlink/usr/bin/python3
bDispositivo a blocchi/dev/nvme0n1
cDispositivo a caratteri/dev/tty, /dev/null
pFIFO / named pipemkfifo
sSocketComunicazione locale tra processi

Un hard link è un altro nome per lo stesso inode. Deve stare nello stesso file system, non può puntare a una directory (tranne . e ..) e incrementa il contatore dei link. Un symlink è un file che contiene un percorso: può attraversare file system, puntare a una directory e anche essere “rotto” se il bersaglio non esiste.

# Hard link: stesso inode, due nomi
ln originale.txt copia-hard.txt
ls -li originale.txt copia-hard.txt

# Symlink: percorso relativo o assoluto
ln -s ../config/settings.yml settings.yml
ln -sfn /srv/app/current /srv/app/live
readlink settings.yml
readlink -f settings.yml

# Trovare link e file con piu nomi
find /srv -xdev -type l -ls
find /srv -xdev -links +1 -ls

rm rimuove un nome e decrementa il contatore; i dati restano finché l’ultimo link e l’ultimo file descriptor aperto non vengono chiusi. mv dentro lo stesso file system è una rinomina quasi istantanea; tra file system diversi è una copia seguita da una cancellazione, e non preserva necessariamente ACL, xattr e hard link. Per copiare un albero completo con i metadati:

cp -a /srv/app /srv/app.bak
rsync -aHAX --numeric-ids /srv/app/ /backup/app/
getfacl -R /srv/app > /backup/app.acl
getfattr -R -d -m - /srv/app > /backup/app.xattr

Permessi POSIX

Ogni file ha un proprietario, un gruppo e tre triple di permessi: owner, group, other. Per un file r significa leggere, w scrivere, x eseguire. Per una directory significano cose diverse: r elencare i nomi, w creare, cancellare o rinominare voci, x attraversare e accedere agli elementi. Senza x una directory non si apre, anche se si conosce il nome esatto del file.

OttaleSimbolicoSignificato
7rwxLettura, scrittura, esecuzione
6rw-Lettura e scrittura
5r-xLettura ed esecuzione
4r--Sola lettura
3-wxScrittura ed esecuzione
2-w-Sola scrittura
1--xSola esecuzione o attraversamento
0---Nessun permesso
# Forma simbolica
chmod u+x script.sh
chmod g-w,o=r file.txt
chmod a+r document.txt
chmod u=rw,g=r,o= file.txt

# Forma numerica
chmod 755 /srv/app
chmod 644 /etc/app.conf
chmod 600 ~/.ssh/id_ed25519
chmod 700 ~/bin

# Proprietario e gruppo
chown alice:dev /srv/app
chgrp www-data /var/www/html
chown -h alice:dev link-simbolico

# Umask: i bit tolti ai nuovi file
umask
umask -S
umask 077

umask 022 crea file 644 e directory 755; umask 077 crea file 600 e directory 700. La X maiuscola in chmod è utile nei find: aggiunge x solo alle directory e ai file che erano già eseguibili.

# Aggiungere x alle directory senza rendere eseguibili i file
find /srv/app -type d -exec chmod u+x {} +
find /srv/app -type f -perm /111 -exec chmod u+x {} +

# Permessi esatti, tutti, oppure almeno uno
find /srv -xdev -perm 0644
find /srv -xdev -perm -o+w
find /srv -xdev -perm /u+s

ls -l mostra i permessi, ma non tutta la storia: + finale indica la presenza di ACL, . indica un contesto SELinux. stat e getfacl danno il quadro completo.

SUID, SGID e sticky bit

I tre bit speciali non sono permessi aggiuntivi: cambiano l’identità con cui un processo accede o il modo in cui una directory gestisce le cancellazioni.

BitSu un fileSu una directory
4000 SUIDIl processo parte con l’EUID del proprietarioIgnorato
2000 SGIDIl processo parte con l’EGID del gruppoI nuovi file ereditano il gruppo; le sottodirectory ereditano SGID
1000 stickyIgnoratoSolo il proprietario del file, il proprietario della directory o root possono cancellare o rinominare
chmod u+s /usr/local/bin/programma
chmod g+s /srv/team
chmod +t /srv/condivisa
ls -ld /tmp /srv/team
find / -xdev -perm -4000 -type f 2>/dev/null

SUID è comodo e pericoloso: un binario SUID compromesso gira con i privilegi del proprietario. Gli script con shebang non vengono eseguiti con SUID su Linux; per concedere un privilegio specifico si usano le capability, che sono granulari.

getcap -r / 2>/dev/null
setcap cap_net_bind_service=+ep /usr/local/bin/mio-server
getcap /usr/local/bin/mio-server
capsh --print

nosuid, nodev e noexec sono opzioni di mount che disinnescano questi meccanismi su partizioni non fidate, come /tmp, /home o una USB. Non sostituiscono i permessi, ma riducono la superficie d’attacco.

findmnt -o TARGET,SOURCE,FSTYPE,OPTIONS
findmnt -T /tmp
mount | grep -E 'nosuid|noexec|nodev'

ACL, attributi e contesti

I permessi POSIX hanno tre classi; le ACL permettono di aggiungere utenti e gruppi specifici senza cambiare proprietario o gruppo. Una ACL è composta da voci u:utente:rwx, g:gruppo:r-x, m::rwx (mask) e o::---. La mask limita i permessi effettivi di tutte le voci tranne owner e other.

# ACL di accesso
setfacl -m u:alice:rw /srv/app/report.txt
setfacl -m g:dev:rx /srv/app
getfacl /srv/app/report.txt

# ACL predefinita: vale per i nuovi file creati nella directory
setfacl -m d:u:alice:rwx /srv/team
setfacl -m d:g:dev:rx /srv/team
getfacl /srv/team

# Copiare, rimuovere, ricorsivo
getfacl -R /srv/app > acl.txt
setfacl --restore=acl.txt
setfacl -b /srv/app/report.txt
setfacl -k /srv/team
setfacl -R -m u:alice:rX /srv/app

chmod su un file con ACL modifica la mask, non le singole voci: è una fonte classica di “permessi che cambiano da soli”. ls -l mostra + per segnalare che c’è una ACL. Le ACL richiedono supporto del file system e l’opzione di mount acl, attiva per default su ext4, XFS e Btrfs.

Gli attributi estesi (xattr) sono coppie nome/valore associate a un file. Linux usa namespace come user., security., trusted. e system.; le capability stanno in security.capability, i contesti SELinux in security.selinux.

getfattr -d -m - file.txt
setfattr -n user.note -v "da rivedere" file.txt
getfattr -n user.note file.txt
rsync -aX /srv/app/ /backup/app/
tar --xattrs --acls -cpf backup.tar /srv/app

chattr cambia attributi del file system, non xattr generici. I più usati sono +i (immutabile: nessuno può scrivere, rinominare o cancellare finché il bit resta impostato, nemmeno root) e +a (solo append). Sono utili per file di configurazione critici e log, ma vanno documentati: un +i dimenticato fa impazzire il prossimo amministratore.

lsattr /etc/ssh/sshd_config
chattr +i /etc/ssh/sshd_config
chattr -i /etc/ssh/sshd_config
chattr +a /var/log/audit/audit.log

Su sistemi con SELinux o AppArmor i permessi POSIX non bastano: ls -Z mostra il contesto, restorecon lo ripristina, semanage fcontext aggiunge una regola persistente. Su Ubuntu e Debian il profilo AppArmor può negare un accesso che chmod sembra aver concesso.

ls -Z /var/www/html
getenforce
restorecon -Rv /var/www/html
semanage fcontext -a -t httpd_sys_content_t '/srv/www(/.*)?'
aa-status

Mount, fstab e UUID

Un file system non è visibile finché non viene montato su una directory. Il kernel tiene una tabella dei mount; lo spazio utente la legge da /proc/self/mountinfo, e /etc/mtab è ormai un symlink a /proc/self/mounts. findmnt è il modo più leggibile per interrogarla.

lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,PARTUUID,MOUNTPOINTS
blkid
findmnt
findmnt -T /var/lib
findmnt --verify

/etc/fstab ha sei campi. Un errore qui può impedire il boot o far partire il sistema in emergency mode.

CampoSignificatoEsempio
DeviceUUID, LABEL, PARTUUID o percorsoUUID=1234-abcd
Mount pointDirectory di destinazione/srv/data
TypeTipo di file systemext4, xfs, btrfs, nfs4
OptionsOpzioni separate da virgoladefaults,noatime,nosuid,nodev
DumpUsato da dump; quasi sempre 00
PassOrdine di fsck; 0 per non controllare2
# /etc/fstab
UUID=1234-abcd  /srv/data  ext4  defaults,noatime,nosuid,nodev  0  2
UUID=5678-efgh  /boot/efi  vfat  umask=0077,shortname=winnt      0  2
server:/export  /mnt/nfs   nfs4  vers=4.2,hard,noatime            0  0
tmpfs           /srv/tmp   tmpfs size=2G,mode=1777,nosuid,nodev  0  0

Preferisci UUID= o PARTUUID= ai nomi /dev/sdX, che cambiano con l’ordine di enumerazione. nofail evita che un disco assente blocchi il boot; x-systemd.automount monta solo al primo accesso; x-systemd.device-timeout=10s limita l’attesa. Dopo ogni modifica:

sudo systemctl daemon-reload
sudo mount -a
findmnt --verify
systemctl list-units --type=mount

mount --bind rende visibile una directory in un altro punto senza formattare nulla; --rbind include i sotto-mount; --move sposta un mount. Sono gli stessi meccanismi che usano chroot, i container e i sistemi di recupero.

sudo mount --bind /srv/app /mnt/app
sudo mount --rbind /dev /mnt/chroot/dev
sudo mount -o remount,rw /
sudo umount /mnt/app
sudo umount -l /mnt/app
fuser -vm /mnt/app
lsof +D /mnt/app

umount -l è un lazy unmount: stacca il mount dalla gerarchia ma aspetta che i processi chiudano i file. umount -f forza, utile su NFS bloccato. Prima di smontare, fuser -vm e lsof +D dicono chi tiene aperto il file system. Su NFS un mount hard può bloccare un processo per sempre se il server sparisce; soft restituisce un errore, con il rischio di dati incompleti.

ext4, XFS, Btrfs e overlayfs

Non esiste il file system migliore in assoluto. Esiste quello giusto per il carico, la dimensione, la necessità di snapshot e il sistema operativo che si sta usando.

File systemPunti fortiLimitiUso tipico
ext4 Maturo, semplice, journaling, extents, crescita e riduzione offline Niente snapshot nativi, niente checksum dei dati, inode fissi Default su Debian e Ubuntu, sistemi generali
XFS Ottimo su file grandi e I/O parallelo, reflink, crescita online Non si può ridurre, repair meno “automatico” Default su RHEL, server e storage ad alte prestazioni
Btrfs CoW, checksum, subvolumi, snapshot, send/receive, compressione RAID 5/6 sconsigliato, manutenzione più complessa Default su Fedora e openSUSE, desktop e snapshot
overlayfs Unione di più directory, strati immutabili Non è un file system per dati persistenti generici Container, immagini, live system
tmpfs Velocissimo, in RAM, dimensione configurabile Volatile, consuma memoria /run, /dev/shm, cache temporanee
NFS Condivisione di rete, centralizzata Latenza, blocchi, dipendenza dal server Home, export, storage condiviso

ext4

ext4 è il discendente diretto di ext3: journaling, extent al posto della mappa dei blocchi, allocazione ritardata, checksum dei metadati nelle versioni recenti. La dimensione massima del volume è nell’ordine degli exabyte, quella di un file è 16 TiB; il limite pratico è quasi sempre il disco, non il file system. Di default riserva il 5% dei blocchi a root: su un volume grande conviene ridurlo.

# Creare, etichettare, controllare
sudo mkfs.ext4 -L data /dev/nvme0n1p3
sudo tune2fs -L data /dev/nvme0n1p3
sudo tune2fs -m 1 /dev/nvme0n1p3
sudo dumpe2fs -h /dev/nvme0n1p3
sudo e2fsck -f /dev/nvme0n1p3

# Crescere online, ridurre solo da smontato
sudo resize2fs /dev/nvme0n1p3
sudo umount /srv/data
sudo e2fsck -f /dev/nvme0n1p3
sudo resize2fs /dev/nvme0n1p3 500G

e2fsck su un file system montato in scrittura è una cattiva idea: può corrompere i dati. Si esegue da un live, dopo umount, oppure al boot. resize2fs può crescere a caldo; per ridurre serve spazio libero, file system smontato e un controllo preventivo.

XFS

XFS è pensato per scalare: allocation group, journaling, delayed logging, reflink per le copie copy-on-write. Cresce online, non si riduce. È il default di Red Hat Enterprise Linux e una scelta solida per database, file grandi e carichi paralleli.

sudo mkfs.xfs -L data /dev/nvme0n1p3
sudo xfs_info /srv/data
sudo xfs_growfs /srv/data
sudo xfs_repair -n /dev/nvme0n1p3
sudo xfs_repair /dev/nvme0n1p3
sudo xfs_admin -L nuovo-nome /dev/nvme0n1p3
sudo xfs_quota -x -c 'report -h' /srv/data

xfs_repair -n è la scansione in sola lettura: va eseguita per prima, da smontato. xfs_repair senza -n modifica il file system e può richiedere -L per azzerare il log, operazione da fare solo dopo un backup. xfs_fsr deframmenta, ma su SSD non serve.

Btrfs

Btrfs è copy-on-write: ogni scrittura crea nuovi blocchi e i vecchi restano referenziati finché servono. Da qui derivano snapshot istantanei, subvolumi, checksum e compressione trasparente. È il default di Fedora e openSUSE, e una buona scelta quando servono snapshot prima di un aggiornamento.

sudo mkfs.btrfs -L data /dev/nvme0n1p3
sudo mount -o compress=zstd,noatime /dev/nvme0n1p3 /srv/data
sudo btrfs filesystem usage /srv/data
sudo btrfs subvolume create /srv/data/@app
sudo btrfs subvolume snapshot -r /srv/data/@app /srv/data/@app-2026-11-14
sudo btrfs subvolume list /srv/data
sudo btrfs scrub start -Bd /srv/data
sudo btrfs balance start -dusage=50 /srv/data
sudo btrfs check --readonly /dev/nvme0n1p3

scrub rilegge i dati e verifica i checksum; balance ridistribuisce i chunk e può recuperare spazio; check --readonly è la diagnosi. btrfs check --repair è pericoloso e va usato solo su consiglio di chi conosce il caso specifico, con backup pronto. Il RAID 5/6 di Btrfs non è consigliato per dati importanti: usa RAID 1 o 10, oppure lascia il RAID all’hardware o a mdadm.

Gli snapshot non sono backup: stanno sullo stesso file system e condividono i blocchi. Se il disco muore, muoiono entrambi. Per un backup vero si usa btrfs send verso un altro supporto:

sudo btrfs send /srv/data/@app-2026-11-14 | \
  ssh backup 'btrfs receive /backup/data'
sudo btrfs send -p /srv/data/@app-2026-11-13 \
  /srv/data/@app-2026-11-14 | ssh backup 'btrfs receive /backup/data'

overlayfs e tmpfs

overlayfs unisce più directory in una sola vista. Gli strati lower sono di sola lettura, l’upper raccoglie le modifiche e workdir è una directory di lavoro che deve stare sullo stesso file system dell’upper. È il meccanismo con cui Docker, Podman e i live system sovrappongono immagini senza copiarle.

sudo mkdir -p /lower /upper /work /merged
sudo mount -t overlay overlay \
  -o lowerdir=/lower,upperdir=/upper,workdir=/work /merged
findmnt -T /merged
sudo umount /merged

Un file modificato nell’upper viene copiato per intero (copy-up); una cancellazione crea un whiteout. Per questo overlayfs è ottimo per immagini immutabili e meno adatto a database o file molto grandi modificati in place.

tmpfs vive in RAM e swap: veloce, volatile, con dimensione e numero di inode configurabili. /run e /dev/shm sono tmpfs; una tmpfs troppo grande può esaurire la memoria e attivare l’OOM killer.

mount -t tmpfs -o size=2G,mode=1777,nr_inodes=100k tmpfs /srv/tmp
df -h /dev/shm /run
findmnt -T /srv/tmp

Spazio, inode e manutenzione

“Disco pieno” è una diagnosi, non un comando. df guarda il file system, du somma i file visibili, lsof trova i file cancellati ma ancora aperti. I tre numeri possono raccontare storie diverse.

df -hT
df -i
du -sh /var/* | sort -h
du -x -d 2 /srv | sort -h | tail -n 20
ncdu -x /srv

# File grandi, senza attraversare altri file system
find / -xdev -type f -size +1G -printf '%s %p\n' 2>/dev/null | sort -n | tail

# File cancellati ancora aperti
lsof +L1
lsof -nP | grep deleted

Se df dice pieno e du non trova nulla, il colpevole è spesso un file cancellato tenuto aperto da un processo: il suo spazio non torna finché il file descriptor non viene chiuso. Si risolve riavviando il servizio, oppure troncando il file via /proc/PID/fd/N con cautela.

# Trovare il processo e il file
lsof +L1
ls -l /proc/PID/fd

# Troncare un log enorme ancora aperto (senza cancellarlo)
: > /var/log/app.log
truncate -s 0 /var/log/app.log

# Spazio riservato da ext4
sudo tune2fs -l /dev/nvme0n1p2 | grep -i reserved
sudo tune2fs -m 1 /dev/nvme0n1p2

Su ext4 il 5% riservato a root è utile per il sistema ma esagerato su un volume dati da terabyte. Su Btrfs gli snapshot e i subvolumi consumano spazio anche se du non li vede: btrfs filesystem usage e btrfs qgroup show sono più affidabili. Su overlayfs i file nell’upper possono essere copie complete.

Le quote limitano spazio e inode per utente o gruppo. Su ext4 e XFS si gestiscono con strumenti diversi; su Btrfs si usano i qgroup.

# ext4: quota utente
sudo quotaon -v /srv/data
sudo edquota -u alice
quota -s
sudo repquota -a

# XFS: quota integrata
sudo xfs_quota -x -c 'report -h' /srv/data
sudo xfs_quota -x -c 'limit -u bsoft=10g bhard=12g alice' /srv/data

# Btrfs: qgroup
sudo btrfs quota enable /srv/data
sudo btrfs qgroup show -reF /srv/data

La manutenzione ordinaria comprende log, cache e TRIM. Su SSD è meglio un fstrim periodico che discard continuo: il primo batch riduce il costo, il secondo può penalizzare le scritture.

journalctl --disk-usage
sudo journalctl --vacuum-size=500M
sudo systemd-tmpfiles --clean
sudo fstrim -av
systemctl status fstrim.timer
systemctl enable --now fstrim.timer

# Non farlo su un disco che non sia un SSD, e mai alla cieca
sudo blkdiscard /dev/nvme0n1

blkdiscard cancella l’intero dispositivo: va usato solo su dischi che si vogliono azzerare. fallocate e truncate creano file di dimensione precisa senza scrivere tutti i byte; dd scrive davvero e può essere lentissimo.

Diagnostica e recupero

Un ordine di intervento che funziona: 1) individua il file system con findmnt -T; 2) controlla spazio e inode con df -hT e df -i; 3) risali i permessi con namei -l, getfacl, ls -Z; 4) leggi dmesg -T e journalctl -k per gli errori I/O; 5) solo dopo valuta fsck o xfs_repair.

SintomoCausa probabileVerifica
Permission denied Manca x su una directory, ACL, SELinux/AppArmor, noexec namei -l, getfacl, ls -Z, findmnt -T
No space left on device Inode esauriti, blocchi riservati, quota, file cancellati aperti, snapshot df -i, lsof +L1, quota -s, btrfs filesystem usage
Read-only file system Errore I/O, errors=remount-ro, mount ro dmesg -T, findmnt -T, smartctl -a
Structure needs cleaning Corruzione XFS xfs_repair -n da smontato
UNEXPECTED INCONSISTENCY Corruzione ext4 o journal incompleto e2fsck -f da smontato
wrong fs type Tipo sbagliato, modulo assente, dispositivo sbagliato lsblk -f, blkid, modprobe
Too many levels of symbolic links Loop di symlink namei -l, readlink -f
Stale file handle NFS: export o server cambiato mount, showmount -e, log del server
Operation not permitted su chown Non root, capability mancante, NFS root squash id, capsh --print, opzioni export

Prima di riparare, si fa un backup se possibile. Poi si smonta il file system, si esegue lo strumento giusto e si legge l’output senza rispondere “sì” a tutto. fsck generico chiama il checker del tipo corretto; e2fsck, xfs_repair e btrfs check sono specifici.

# Individuare il file system e i supporti
findmnt -T /srv/data
lsblk -f
sudo smartctl -a /dev/nvme0n1

# Controlli in sola lettura
sudo e2fsck -n /dev/nvme0n1p3
sudo xfs_repair -n /dev/nvme0n1p3
sudo btrfs check --readonly /dev/nvme0n1p3

# Riparazione: solo da smontato e con backup
sudo umount /srv/data
sudo e2fsck -f /dev/nvme0n1p3
sudo xfs_repair /dev/nvme0n1p3
sudo btrfs check --readonly /dev/nvme0n1p3

Se il sistema non parte per un errore in fstab, si arriva in emergency mode. Si monta la radice in sola lettura, si corregge il file, si verifica con findmnt --verify e si riavvia. Aggiungere nofail ai dischi non essenziali evita che un’unità assente blocchi tutto.

# Da emergency mode: rimontare la radice in scrittura
mount -o remount,rw /
vi /etc/fstab
findmnt --verify
mount -a
systemctl reboot

Per capire chi sta scrivendo o leggendo un percorso, oltre a lsof e fuser servono strace e fatrace. strace -e trace=file mostra le chiamate di un processo; fatrace mostra le modifiche globali al file system, utile per scoprire quale servizio riempie un disco.

strace -f -e trace=file -p PID
fatrace -f W
inotifywait -m -r /srv/app

Regola d’oro. Un file system non si ripara “per provare”. Prima si guarda, poi si fa un backup, poi si smonta, poi si ripara. E se il disco mostra errori I/O o SMART degradato, il problema non è il file system: è l’hardware, e va sostituito prima che porti via i dati.

Fonti

Comportamenti e comandi verificati il 14 novembre 2026 su kernel 7.x. I default cambiano tra distribuzioni e versioni: ext4 è il default storico di Debian/Ubuntu, XFS di RHEL, Btrfs di Fedora e openSUSE. Prima di formattare o riparare, controlla sempre lsblk -f, findmnt -T e la documentazione della tua distribuzione.