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.
Scrivi cosa vuoi fare: la ricerca guarda comandi, descrizioni e titoli delle sezioni.
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.
| Percorso | Contenuto | Note |
|---|---|---|
/ | Radice | Tutto parte da qui; il file system radice deve bastare per avviare e riparare |
/bin /sbin | Binari essenziali | Con lo usrmerge sono symlink a /usr/bin e /usr/sbin |
/lib /lib64 | Librerie condivise | Anche queste spesso symlink a /usr/lib |
/usr | Programmi, librerie, documentazione | Dati condivisibili e in gran parte di sola lettura |
/usr/local | Software installato dall’amministratore | Non gestito dal package manager |
/etc | Configurazione del sistema | Testo, specifico della macchina; niente binari |
/var | Dati variabili | Log, cache, spool, database, code |
/tmp | File temporanei | Spesso tmpfs; può essere svuotata al boot |
/var/tmp | Temporanei persistenti | Sopravvive al riavvio, con scadenze più lunghe |
/home | Home degli utenti | Spesso su partizione o volume separato |
/root | Home di root | Non è / e non dovrebbe stare su NFS |
/opt | Pacchetti software aggiuntivi | Convenzione per prodotti di terze parti |
/srv | Dati serviti dal sistema | Web, FTP, repository locali |
/mnt /media | Mount temporanei e rimovibili | /media per USB e CD, /mnt per l’amministratore |
/run | Stato runtime | tmpfs, ricreato a ogni boot; PID, socket, lock |
/proc /sys | Pseudo file system | Interfacce al kernel: processi, dispositivi, parametri |
/dev | Dispositivi | Gestito da devtmpfs e udev |
/boot /efi | Kernel, 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:
| Timestamp | Quando cambia | Si può impostare? |
|---|---|---|
atime | All’accesso in lettura | Sì, ma spesso disabilitato o attenuato |
mtime | Quando cambia il contenuto | Sì, con touch -m |
ctime | Quando cambiano inode o metadati | No, è gestito dal kernel |
btime | Alla creazione, se il file system lo registra | No; 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.
| Carattere | Tipo | Esempio |
|---|---|---|
- | File regolare | Testo, binario, archivio |
d | Directory | Contenitore di nomi |
l | Symlink | /usr/bin/python3 |
b | Dispositivo a blocchi | /dev/nvme0n1 |
c | Dispositivo a caratteri | /dev/tty, /dev/null |
p | FIFO / named pipe | mkfifo |
s | Socket | Comunicazione 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.
| Ottale | Simbolico | Significato |
|---|---|---|
7 | rwx | Lettura, scrittura, esecuzione |
6 | rw- | Lettura e scrittura |
5 | r-x | Lettura ed esecuzione |
4 | r-- | Sola lettura |
3 | -wx | Scrittura ed esecuzione |
2 | -w- | Sola scrittura |
1 | --x | Sola 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.
| Bit | Su un file | Su una directory |
|---|---|---|
4000 SUID | Il processo parte con l’EUID del proprietario | Ignorato |
2000 SGID | Il processo parte con l’EGID del gruppo | I nuovi file ereditano il gruppo; le sottodirectory ereditano SGID |
1000 sticky | Ignorato | Solo 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.
| Campo | Significato | Esempio |
|---|---|---|
| Device | UUID, LABEL, PARTUUID o percorso | UUID=1234-abcd |
| Mount point | Directory di destinazione | /srv/data |
| Type | Tipo di file system | ext4, xfs, btrfs, nfs4 |
| Options | Opzioni separate da virgola | defaults,noatime,nosuid,nodev |
| Dump | Usato da dump; quasi sempre 0 | 0 |
| Pass | Ordine di fsck; 0 per non controllare | 2 |
# /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 system | Punti forti | Limiti | Uso 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.
| Sintomo | Causa probabile | Verifica |
|---|---|---|
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
- Filesystem Hierarchy Standard 3.0 — struttura delle directory e usrmerge.
man 7 hier,man 7 file-hierarchy— gerarchia secondo Linux e systemd.man 2 stat,man 7 inode,man 7 path_resolution— metadati, inode e risoluzione dei percorsi.man 5 acl,man 1 setfacl,man 1 getfacl— ACL POSIX e mask.man 7 capabilities,man 1 setcap,man 1 getcap— capability al posto di SUID.man 8 mount,man 5 fstab,man 8 findmnt— mount, opzioni e generazione delle unità systemd.- Linux kernel documentation — filesystems/ext4, xfs, btrfs, overlayfs, nfs.
- e2fsprogs, xfsprogs, btrfs-progs, util-linux, acl, attr, libcap — strumenti e manuali dei rispettivi progetti.
- Debian, Ubuntu, Red Hat e Arch Wiki — pacchetti, default delle distribuzioni e procedure di recupero.
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.