104.2 Lezione 1

Certificazione:

LPIC-1

Versione:

5.0

Argomento:

104 Dispositivi, Il Filesystem Linux, Filesystem Hierarchy Standard

Obiettivo:

104.2 Mantenere l’integrità dei filesystem

Lezione:

1 di 1

Introduzione

I moderni filesystem Linux hanno un "diario di bordo" . Ciò significa che ogni operazione viene registrata in un log interno (il journal) prima di essere eseguita. Se l’operazione viene interrotta a causa di un errore di sistema (come un kernel panic, un’interruzione di corrente, ecc.), questa può essere ricostruita controllando il journal, evitando il danneggiamento del filesystem e la perdita di dati.

Ciò riduce notevolmente la necessità di controlli manuali del file system, anche se potrebbero comunque ancora essere necessari. Conoscere gli strumenti specifici utilizzati (e i parametri corrispondenti) può rappresentare la differenza tra una cena a casa con la tua famiglia o una notte intera nella sala server a lavoro.

In questa lezione discuteremo gli strumenti disponibili per monitorare l’utilizzo del filesystem, ottimizzarne il funzionamento e come controllare e riparare i danni.

Controllare l’Utilizzo dei Dischi

Ci sono due comandi che possono essere usati per controllare quanto spazio viene usato e quanto ne resta su un determinato filesystem. Il primo è du, che sta per “disk usage” (utilizzo del disco).

du è di natura ricorsiva. Nella sua forma più elementare, il comando mostrerà semplicemente quanti blocchi da 1 Kilobyte vengono utilizzati dalla directory corrente e da tutte le sue sottodirectory:

$ du
4816	.

Questo non è molto utile, quindi possiamo richiedere un output più “human readable” aggiungendo il parametro -h:

$ du -h
4.8M	.

Per impostazione predefinita, du mostra solo il conteggio dell’utilizzo delle directory (considerando tutti i file e le sottodirectory al suo interno). Per mostrare un conteggio individuale per tutti i file nella directory, usa il parametro -a:

$ du -ah
432K	./geminoid.jpg
508K	./Linear_B_Hero.jpg
468K	./LG-G8S-ThinQ-Mirror-White.jpg
656K	./LG-G8S-ThinQ-Range.jpg
60K	./Stranger3_Titulo.png
108K	./Baidu_Banho.jpg
324K	./Xiaomi_Mimoji.png
284K	./Mi_CC_9e.jpg
96K	./Mimoji_Comparativo.jpg
32K	./Xiaomi FCC.jpg
484K	./geminoid2.jpg
108K	./Mimoji_Abre.jpg
88K	./Mi8_Hero.jpg
832K	./Tablet_Linear_B.jpg
332K	./Mimoji_Comparativo.png
4.8M	.

Il comportamento predefinito è mostrare l’utilizzo di ogni sottodirectory, quindi l’utilizzo totale della directory corrente, inclusa la sottodirectory:

$ du -h
4.8M	./Temp
6.0M	.

Nell’esempio sopra, possiamo vedere che la sottodirectory Temp occupa 4.8 MB e la directory corrente, inclusa Temp, occupa 6.0 MB. Ma quanto spazio occupano i file nella directory corrente, escluse le sottodirectory? Per questo abbiamo il parametro -S:

$ du -Sh
4.8M	./Temp
1.3M	.

Tip	Tieni presente che i parametri della riga di comando fanno distinzione tra maiuscole e minuscole: `-s` è diverso da `-S`.

Se vuoi mantenere questa distinzione tra lo spazio usato dai file nella directory corrente e lo spazio usato dalle sottodirectory, ma vuoi anche un totale generale alla fine, puoi aggiungere il parametro -c:

$ du -Shc
4.8M	./Temp
1.3M	.
6.0M	total

Puoi controllare quanto “profondo” l’output di du dovrebbe andare con il parametro -d N, dove N indica i livelli. Per esempio, se usi il parametro -d 1, mostrerà la directory corrente e le sue sottodirectory, ma non le sottodirectory di queste ultime.

Vedi la differenza di seguito. Senza -d:

$ du -h
216K	./somedir/anotherdir
224K	./somedir
232K	.

E limitando la profondità a un livello con -d 1:

$ du -h -d1
224K	./somedir
232K	.

Si noti che anche se anotherdir non viene mostrato, le sue dimensioni vengono comunque prese in considerazione.

Potresti voler escludere alcuni tipi di file dal conteggio, cosa che puoi fare con --exclude="PATTERN", dove PATTERN è il modello rispetto al quale desideri rapportarti. Considera questa directory:

$ du -ah
124K	./ASM68K.EXE
2.0M	./Contra.bin
36K	./fixheadr.exe
4.0K	./README.txt
2.1M	./Contra_NEW.bin
4.0K	./Built.bat
8.0K	./Contra_Main.asm
4.2M	.

Ora, useremo --exclude per filtrare ogni file con l’estensione .bin:

$ du -ah --exclude="*.bin"
124K	./ASM68K.EXE
36K	./fixheadr.exe
4.0K	./README.txt
4.0K	./Built.bat
8.0K	./Contra_Main.asm
180K	.

Notare che il totale non riflette più la dimensione dei file esclusi.

Controllo dello Spazio Libero

du funziona a livello di file. C’è un altro comando che può mostrare l’utilizzo del disco e quanto spazio è disponibile a livello di filesystem. Questo comando è df.

Il comando df fornirà un elenco di tutti i filesystem disponibili (già montati) sul tuo sistema, inclusa la loro dimensione totale, quanto spazio è stato utilizzato, quanto spazio è disponibile, la percentuale di utilizzo e dove è montato:

$ df
Filesystem     1K-blocks      Used Available Use% Mounted on
udev             2943068         0   2943068   0% /dev
tmpfs             595892      2496    593396   1% /run
/dev/sda1      110722904  25600600  79454800  25% /
tmpfs            2979440    951208   2028232  32% /dev/shm
tmpfs               5120         0      5120   0% /run/lock
tmpfs            2979440         0   2979440   0% /sys/fs/cgroup
tmpfs             595888        24    595864   1% /run/user/119
tmpfs             595888       116    595772   1% /run/user/1000
/dev/sdb1          89111      1550     80824   2% /media/carol/part1
/dev/sdb3          83187      1550     75330   3% /media/carol/part3
/dev/sdb2          90827      1921     82045   3% /media/carol/part2
/dev/sdc1      312570036 233740356  78829680  75% /media/carol/Samsung Externo

Tuttavia, mostrare la dimensione in blocchi da 1 KB non è molto facile da usare. Come in du, puoi aggiungere l’opzione -h per ottenere un output più “human readable”:

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
udev            2.9G     0  2.9G   0% /dev
tmpfs           582M  2.5M  580M   1% /run
/dev/sda1       106G   25G   76G  25% /
tmpfs           2.9G  930M  2.0G  32% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           2.9G     0  2.9G   0% /sys/fs/cgroup
tmpfs           582M   24K  582M   1% /run/user/119
tmpfs           582M  116K  582M   1% /run/user/1000
/dev/sdb1        88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3        82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2        89M  1.9M   81M   3% /media/carol/part2
/dev/sdc1       299G  223G   76G  75% /media/carol/Samsung Externo

Puoi anche usare il parametro -i per mostrare gli inode usati/disponibili invece dei blocchi:

$ df -i
Filesystem      Inodes  IUsed   IFree IUse% Mounted on
udev            737142    547  736595    1% /dev
tmpfs           745218    908  744310    1% /run
/dev/sda6      6766592 307153 6459439    5% /
tmpfs           745218    215  745003    1% /dev/shm
tmpfs           745218      4  745214    1% /run/lock
tmpfs           745218     18  745200    1% /sys/fs/cgroup
/dev/sda1        62464    355   62109    1% /boot
tmpfs           745218     43  745175    1% /run/user/1000

Un parametro utile è -T, che stamperà anche il tipo di ogni filesystem:

$ df -hT
Filesystem     Type      Size  Used Avail Use% Mounted on
udev           devtmpfs  2.9G     0  2.9G   0% /dev
tmpfs          tmpfs     582M  2.5M  580M   1% /run
/dev/sda1      ext4      106G   25G   76G  25% /
tmpfs          tmpfs     2.9G  930M  2.0G  32% /dev/shm
tmpfs          tmpfs     5.0M     0  5.0M   0% /run/lock
tmpfs          tmpfs     2.9G     0  2.9G   0% /sys/fs/cgroup
tmpfs          tmpfs     582M   24K  582M   1% /run/user/119
tmpfs          tmpfs     582M  116K  582M   1% /run/user/1000
/dev/sdb1      ext4       88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3      ext4       82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2      ext4       89M  1.9M   81M   3% /media/carol/part2
/dev/sdc1      fuseblk   299G  223G   76G  75% /media/carol/Samsung Externo

Conoscendo il tipo di filesystem è possibile filtrare l’output. Puoi mostrare solo i filesystem di un dato tipo con -t TYPE, o escludere i filesystem di un dato tipo con -x TYPE, come negli esempi seguenti.

Escludere i filesystem tmpfs:

$ df -hx tmpfs
Filesystem      Size  Used Avail Use% Mounted on
udev            2.9G     0  2.9G   0% /dev
/dev/sda1       106G   25G   76G  25% /
/dev/sdb1        88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3        82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2        89M  1.9M   81M   3% /media/carol/part2
/dev/sdc1       299G  223G   76G  75% /media/carol/Samsung Externo

Mostrare solo filesystem ext4:

$ df -ht ext4
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       106G   25G   76G  25% /
/dev/sdb1        88M  1.6M   79M   2% /media/carol/part1
/dev/sdb3        82M  1.6M   74M   3% /media/carol/part3
/dev/sdb2        89M  1.9M   81M   3% /media/carol/part2

Puoi anche personalizzare l’output di df, selezionando cosa visualizzare e in quale ordine, usando il parametro --output = seguito da un elenco di campi separati da virgole che desideri visualizzare. Alcuni dei campi disponibili sono:

source: Il dispositivo corrispondente al filesystem.
fstype: Il tipo di filesystem.
size: La dimensione totale di un filesystem.
used: Quanto spazio viene utilizzato.
avail: Quanto spazio è disponibile.
pcent: La percentuale utilizzata.
target: Dove è montato il filesystem (mount point).

Se desideri un output che mostri destinazione, origine, tipo e utilizzo, puoi utilizzare:

$ df -h --output=target,source,fstype,pcent
Mounted on                    Filesystem     Type     Use%
/dev                          udev           devtmpfs   0%
/run                          tmpfs          tmpfs      1%
/                             /dev/sda1      ext4      25%
/dev/shm                      tmpfs          tmpfs     32%
/run/lock                     tmpfs          tmpfs      0%
/sys/fs/cgroup                tmpfs          tmpfs      0%
/run/user/119                 tmpfs          tmpfs      1%
/run/user/1000                tmpfs          tmpfs      1%
/media/carol/part1            /dev/sdb1      ext4       2%
/media/carol/part3            /dev/sdb3      ext4       3%
/media/carol/part2            /dev/sdb2      ext4       3%
/media/carol/Samsung Externo  /dev/sdc1      fuseblk   75%

df può anche essere usato per controllare le informazioni sull’inode, passando i seguenti campi a --output=:

itotal: Il numero totale di inode nel filesystem.
iused: Il numero di inode utilizzati nel filesystem.
iavail: Il numero di inode disponibili nel filesystem.
ipcent: La percentuale di inode utilizzati nel filesystem.

Per esempio:

$ df --output=source,fstype,itotal,iused,ipcent
Filesystem     Type      Inodes  IUsed IUse%
udev           devtmpfs  735764    593    1%
tmpfs          tmpfs     744858   1048    1%
/dev/sda1      ext4     7069696 318651    5%
tmpfs          tmpfs     744858    222    1%
tmpfs          tmpfs     744858      3    1%
tmpfs          tmpfs     744858     18    1%
tmpfs          tmpfs     744858     22    1%
tmpfs          tmpfs     744858     40    1%

Manutenzione dei filesystem ext2, ext3 e ext4

Per controllare un filesystem dagli errori (e, si spera, correggerli), Linux fornisce l’utility fsck (pensa a “filesystem check” e non dimenticherai mai il nome). Nella sua forma più semplice, puoi invocarlo con fsck seguito dalla posizione del filesystem che vuoi controllare:

# fsck /dev/sdb1
fsck from util-linux 2.33.1
e2fsck 1.44.6 (5-Mar-2019)
DT_2GB: clean, 20/121920 files, 369880/487680 blocks

Warning

NON eseguire MAI fsck (o utilità correlate) su un filesystem montato. In tal caso, i dati potrebbero andare persi.

fsck stesso non controllerà il filesystem, chiamerà semplicemente per farlo l’utilità appropriata per il tipo di filesystem. Nell’esempio sopra, poiché non è stato specificato un tipo di filesystem, fsck ha assunto un filesystem ext2/3/4 per impostazione predefinita e chiamato e2fsck.

Per specificare un filesystem, usa l’opzione -t, seguita dal nome del filesystem, come in fsck -t vfat /dev/sdc. In alternativa, puoi chiamare direttamente un’utilità specifica del filesystem, come fsck.msdos per i filesystem FAT.

Tip	Digita `fsck` seguito da `Tab` due volte per visualizzare un elenco di tutti i comandi correlati sul tuo sistema.

fsck può accettare alcuni argomenti dalla riga di comando. Questi sono alcuni dei più comuni:

-A: Controlla tutti i filesystem elencati in /etc/fstab.
-C: Visualizza una barra di avanzamento durante il controllo di un filesystem. Attualmente funziona solo su filesystem ext2/3/4.
-N: Visualizza ciò che sarebbe stato fatto e uscirà, senza effettivamente controllare il filesystem.
-R: Se usato insieme a -A, salta il controllo del filesystem di root.
-V: Modalità dettagliata, visualizza più informazioni del normale durante il funzionamento. Questo è utile per il debug.

L’utilità specifica per i filesystem ext2, ext3 ed ext4 è e2fsck, chiamata anche fsck.ext2, fsck.ext3 e fsck.ext4 (questi tre sono semplicemente collegamenti a e2fsck). Per impostazione predefinita, viene eseguito in modalità interattiva: quando viene rilevato un errore del file system, si ferma e chiede all’utente cosa fare. L’utente deve digitare y per risolvere il problema, n per lasciarlo non risolto o a per correggere il problema corrente e tutti i successivi.

Ovviamente sedersi davanti a un terminale in attesa che e2fsck ti chieda cosa fare non è un uso produttivo del tuo tempo, specialmente se hai a che fare con un grande filesystem. Quindi, ci sono opzioni che causano l’esecuzione di e2fsck in modalità non interattiva:

-p: Tenta di correggere automaticamente eventuali errori trovati. Se viene rilevato un errore che richiede l’intervento dell’amministratore di sistema, e2fsck fornisce una descrizione del problema e uscirà.
-y: Questo risponde y (yes) a tutte le domande.
-n: L’opposto di -y. Oltre a rispondere n (no) a tutte le domande, fa sì che il filesystem venga montato in sola lettura, quindi non può essere modificato.
-f: Forza e2fsck a controllare un filesystem anche se è contrassegnato come “pulito” (clean), cioè è stato correttamente smontato.

Ottimizzazione di un Filesystem ext

I filesystem ext2, ext3 ed ext4 hanno un numero di parametri che possono essere regolati, o ottimizzati, dall’amministratore per soddisfare meglio le esigenze del sistema. L’utility usata per visualizzare o modificare questi parametri si chiama tune2fs.

Per vedere i parametri correnti per un dato filesystem, usa l’opzione -l seguita dal dispositivo che rappresenta la partizione. L’esempio seguente mostra l’output di questo comando sulla prima partizione del primo disco (/dev/sda1) di una macchina:

# tune2fs -l /dev/sda1
tune2fs 1.44.6 (5-Mar-2019)
Filesystem volume name:   <none>
Last mounted on:          /
Filesystem UUID:          6e2c12e3-472d-4bac-a257-c49ac07f3761
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index filetype needs_recovery extent 64bit flex_bg sparse_super large_file huge_file dir_nlink extra_isize metadata_csum
Filesystem flags:         signed_directory_hash
Default mount options:    user_xattr acl
Filesystem state:         clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              7069696
Block count:              28255605
Reserved block count:     1412780
Free blocks:              23007462
Free inodes:              6801648
First block:              0
Block size:               4096
Fragment size:            4096
Group descriptor size:    64
Reserved GDT blocks:      1024
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         8192
Inode blocks per group:   512
Flex block group size:    16
Filesystem created:       Mon Jun 17 13:49:59 2019
Last mount time:          Fri Jun 28 21:14:38 2019
Last write time:          Mon Jun 17 13:53:39 2019
Mount count:              8
Maximum mount count:      -1
Last checked:             Mon Jun 17 13:49:59 2019
Check interval:           0 (<none>)
Lifetime writes:          20 GB
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:	          256
Required extra isize:     32
Desired extra isize:      32
Journal inode:            8
First orphan inode:       5117383
Default directory hash:   half_md4
Directory Hash Seed:      fa95a22a-a119-4667-a73e-78f77af6172f
Journal backup:           inode blocks
Checksum type:            crc32c
Checksum:                 0xe084fe23

I filesystem ext mantengono un contatore dei montaggi (Mount counts). Questo conteggio aumenta di 1 ogni volta che il filesystem viene montato, e quando viene raggiunto un valore di soglia (il Maximum mount count) il sistema viene automaticamente controllato con e2fsck all’avvio successivo.

Il numero massimo di montaggi può essere impostato con il parametro -c N, dove N è il numero di volte in cui il filesystem può essere montato senza essere controllato. Il parametro -C N imposta il numero di volte che il sistema è stato montato sul valore di N. Nota che i parametri della riga di comando fanno distinzione tra maiuscole e minuscole, quindi -c è diverso da -C.

È anche possibile definire un intervallo di tempo tra le verifiche, con il parametro -i, seguito da un numero e dalle lettere d per giorni, m per mesi e y per anni. Per esempio, -i 10d controllerebbe il filesystem al successivo riavvio ogni 10 giorni. Usa zero come valore per disabilitare questa funzione.

-L può essere usato per impostare un’etichetta per il filesystem. Questa etichetta può contenere fino a 16 caratteri. Il parametro -U imposta l’UUID per il filesystem, che è un numero esadecimale a 128 bit. Nell’esempio sopra, l’UUID è 6e2c12e3-472d-4bac-a257-c49ac07f3761. Sia l’etichetta che l’UUID possono essere usati al posto del nome del dispositivo (come /dev/sda1) per montare il filesystem.

L’opzione -e BEHAVIOUR definisce il comportamento del kernel quando viene rilevato un errore del filesystem. Ci sono tre possibili comportamenti:

continue: Continuerà l’esecuzione normalmente.
remount-ro: Rimonterà il filesystem in sola lettura.
panic: Provocherà un kernel panic.

Il comportamento predefinito è continue. remount-ro potrebbe essere utile nelle applicazioni sensibili ai dati, poiché interromperà immediatamente le scritture sul disco, evitando ulteriori potenziali errori.

I filesystem ext3 sono fondamentalmente filesystem ext2 con un journal. Usando tune2fs puoi aggiungere un journal a un filesystem ext2, convertendolo così in ext3. La procedura è semplice, basta passare il parametro -j a tune2fs, seguito dal dispositivo contenente il filesystem:

# tune2fs -j /dev/sda1

Successivamente, quando si monta il filesystem convertito, non dimenticare di impostare il tipo su ext3 in modo che il journal possa essere utilizzato.

Quando si ha a che fare con filesystem journal, il parametro -J consente di utilizzare parametri aggiuntivi per impostare alcune opzioni del journal, come -J size= per impostare la dimensione del journal (in megabyte), -J location= per specificare dove il journal dovrebbe essere memorizzato (o un blocco specifico, o una posizione specifica sul disco con suffissi come M o G) e persino posizionare il journal su un dispositivo esterno con -J device=.

È possibile specificare più parametri contemporaneamente separandoli con una virgola. Per esempio: -J size=10, location=100M,device=/dev/sdb1 creerà un Journal da 10 MB nella posizione 100 MB sul dispositivo /dev/sdb1.

Warning

tune2fs ha un’opzione “forza bruta” (brute force), -f, che lo costringerà a completare un’operazione anche se vengono rilevati errori. Inutile dire che questo dovrebbe essere usato solo con estrema cautela.

Mantenere un filesystem XFS

Per i filesystem XFS, l’equivalente di fsck è xfs_repair. Se sospetti che qualcosa non vada nel filesystem, la prima cosa da fare è controllarlo per rilevare eventuali danni.

Questo può essere fatto passando il parametro -n a xfs_repair, seguito dal dispositivo contenente il filesystem. Il parametro -n significa “nessuna modifica”: il filesystem verrà controllato, verranno segnalati errori ma non verrà effettuata alcuna riparazione:

# xfs_repair -n /dev/sdb1
Phase 1 - find and verify superblock...
Phase 2 - using internal log
        - zero log...
        - scan filesystem freespace and inode maps...
        - found root inode chunk
Phase 3 - for each AG...
        - scan (but do not clear) agi unlinked lists...
        - process known inodes and perform inode discovery...
        - agno = 0
        - agno = 1
        - agno = 2
        - agno = 3
        - process newly discovered inodes...
Phase 4 - check for duplicate blocks...
        - setting up duplicate extent list...
        - check for inodes claiming duplicate blocks...
        - agno = 1
        - agno = 3
        - agno = 0
        - agno = 2
No modify flag set, skipping phase 5
Phase 6 - check inode connectivity...
        - traversing filesystem ...
        - traversal finished ...
        - moving disconnected inodes to lost+found ...
Phase 7 - verify link counts...
No modify flag set, skipping filesystem flush and exiting.

Se vengono trovati errori, puoi procedere con le riparazioni senza il parametro -n, in questo modo: xfs_repair /dev/sdb1.

xfs_repair accetta un certo numero di opzioni della riga di comando. Tra loro:

-l LOGDEV e -r RTDEV: Questi sono necessari se il filesystem ha un registro esterno e sezioni in tempo reale. In questo caso, sostituire LOGDEV e RTDEV con i dispositivi corrispondenti.
-m N: Viene usato per limitare l’uso della memoria di xfs_repair a N megabyte, cosa che può essere utile nelle impostazioni di un server. Secondo la pagina man, per impostazione predefinita xfs_repair ridimensionerà il suo utilizzo della memoria secondo necessità, fino al 75% della RAM fisica del sistema.
-d: La modalità "dangerous" abiliterà la riparazione dei filesystem che sono montati in sola lettura.
-v: Potresti averlo indovinato: modalità dettagliata. Ogni volta che viene usato questo parametro, la “verbosità” viene aumentata (per esempio, -vv visualizzerà più informazioni rispetto a -v).

Notare che xfs_repair non è in grado di riparare i filesystem con un registro “sporco” (dirty). Puoi “azzerare” un registro corrotto con il parametro -L, ma tieni presente che questa è una ultima risorsa in quanto potrebbe provocare il danneggiamento del filesystem e la perdita di dati.

Per eseguire il debug di un filesystem XFS, è possibile utilizzare l’utility xfs_db, come in xfs_db /dev/sdb1. Viene utilizzato principalmente per ispezionare vari elementi e parametri del filesystem.

Questa utility ha un prompt interattivo, come parted, con molti comandi interni. È disponibile anche un sistema di aiuto: digita help per vedere un elenco di tutti i comandi, e help seguito dal nome del comando per vedere maggiori informazioni sul comando.

Un altro utile comando è xfs_fsr, che può essere usato per riorganizzare (“deframmentare”) un filesystem XFS. Quando viene eseguito senza alcun argomento aggiuntivo, verrà eseguito per due ore e proverà a deframmentare tutti i filesystem XFS montati e scrivibili elencati nel file /etc/mtab/. Potrebbe essere necessario installare questa utilità utilizzando il gestore di pacchetti per la distribuzione Linux, poiché potrebbe non far parte di un’installazione predefinita. Per maggiori informazioni consultare la pagina man corrispondente.

Esercizi Guidati

Usando du, come possiamo controllare quanto spazio viene utilizzato solo dai file nella directory corrente?
Usando df, elenca le informazioni per ogni filesystem ext4, con gli output che includono i seguenti campi, in ordine: device, mount point, total number of inodes, number of available inodes, percentage of free space.
Qual è il comando per eseguire e2fsck su /dev/sdc1 in modalità non interattiva, cercando di correggere automaticamente la maggior parte degli errori?
Supponiamo che /dev/sdb1 sia un filesystem ext2. Come puoi convertirlo in ext3 e allo stesso tempo resettare il conteggio dei montaggi e cambiare la sua etichetta in UserData?
Come puoi controllare gli errori su un filesystem XFS, senza riparare i danni riscontrati?

Esercizi Esplorativi

Considera di avere un filesystem ext4 su /dev/sda1 con i seguenti parametri, ottenuti tramite tune2fs:
```
Mount count:              8
Maximum mount count:      -1
```
Cosa succederà al prossimo avvio se viene eseguito il comando tune2fs -c 9 /dev/sda1?
Considera il seguente output di du -h:
```
$ du -h
216K	./somedir/anotherdir
224K	./somedir
232K	.
```
Quanto spazio è occupato solo dai file nella directory corrente? Come potremmo riscrivere il comando per mostrare più chiaramente queste informazioni?
Cosa succederebbe al filesystem ext2 /dev/sdb1 se venisse eseguito il comando seguente?
```
# tune2fs -j /dev/sdb1 -J device=/dev/sdc1 -i 30d
```
Come possiamo controllare gli errori su un filesystem XFS su /dev/sda1 che ha una sezione di log su /dev/sdc1, senza effettivamente fare alcuna riparazione?
Qual è la differenza tra i parametri -T e -t in df?

Sommario

In questa lezione abbiamo imparato:

Come controllare lo spazio utilizzato e quello libero su un filesystem.
Come adattare l’output di df alle proprie esigenze.
Come controllare l’integrità e riparare un filesystem con fsck e e2fsck.
Come mettere a punto un filesystem ext con tune2fs.
Come controllare e riparare i filesystem XFS con xfs_repair.

In questa lezione sono stati discussi i seguenti comandi:

du: Visualizza la quantità di spazio su disco in uso su un filesystem.
df: Visualizza la quantità di spazio su disco disponibile (libero) su un filesystem.
fsck: L’utilità di riparazione generica del controllo del file system.
e2fsck: L’utilità di riparazione del controllo del file system specifica per i file system estesi (ext2/3/4).
tune2fs: Modifica i parametri del filesystem su un filesystem esteso (ext2/3/4).
xfs_repair: L’equivalente di fsck per i filesystem XFS.
xfs_db: Questa utility è usata per visualizzare vari parametri di un filesystem XFS.

Risposte agli Esercizi Guidati

Usando du, come possiamo controllare quanto spazio viene utilizzato solo dai file nella directory corrente?

Per prima cosa, usa il parametro -S per separare l’output della directory corrente dalle sue sottodirectory. Quindi, usa -d 0 per limitare la profondità di output a zero, che significa “nessuna sottodirectory”. Non dimenticare -h per ottenere un output in un formato “leggibile dall’uomo”:
```
$ du -S -h -d 0
```
o
```
$ du -Shd 0
```
Usando df, elenca le informazioni per ogni filesystem ext4, con gli output che includono i seguenti campi, in ordine: device, mount point, total number of inodes, number of available inodes, percentage of free space.

Puoi filtrare i filesystem con l’opzione -t seguita dal nome del filesystem. Per ottenere l’output desiderato, utilizzare --output=source,target,itotal,iavail,pcent. Quindi la risposta è:
```
$ df -t ext4 --output=source,target,itotal,iavail,pcent
```
Qual è il comando per eseguire e2fsck su /dev/sdc1 in modalità non interattiva, cercando di correggere automaticamente la maggior parte degli errori?

Il parametro per provare automaticamente a correggere la maggior parte degli errori è -p. Quindi la risposta è:
```
# e2fsck -p /dev/sdc1
```
Supponiamo che /dev/sdb1 sia un filesystem ext2. Come puoi convertirlo in ext3 e allo stesso tempo resettare il conteggio dei montaggi e cambiare la sua etichetta in UserData?

Ricorda che per convertire un filesystem ext2 in ext3 è solo necessario aggiungere un journal, che può essere fatto con il parametro -j. Per azzerare il conteggio delle montature, usa -c 0. Per cambiare l’etichetta usa -L UserData. La risposta corretta è quindi:
```
# tune2fs -j -C 0 -L UserData /dev/sdb1
```
Come puoi controllare gli errori su un filesystem XFS, senza riparare i danni riscontrati?

Usa il parametro -n, come in xfs -n, seguito dal dispositivo corrispondente.

Risposte agli Esercizi Esplorativi

Considera di avere un filesystem ext4 su /dev/sda1 con i seguenti parametri, ottenuti tramite tune2fs:
```
Mount count:              8
Maximum mount count:      -1
```
Cosa succederà al prossimo avvio se viene eseguito il comando tune2fs -c 9 /dev/sda1?

Il comando imposterà il numero massimo di montaggi per il filesystem a 9. Dato che il numero di montaggi è attualmente 8, il prossimo avvio del sistema provocherà un controllo del filesystem.
Considera il seguente output di du -h:
```
$ du -h
216K	./somedir/anotherdir
224K	./somedir
232K	.
```
Quanto spazio è occupato solo dai file nella directory corrente? Come potremmo riscrivere il comando per mostrare più chiaramente queste informazioni?

Del totale di 232K utilizzati, 224K sono usati dalla sottodirectory somedir e dalle sue sottodirectory. Quindi, escludendo quelli, abbiamo 8K occupati dai file nella directory corrente. Questa informazione può essere mostrata più chiaramente usando il parametro -S, che separerà le directory nel conteggio.
Cosa succederebbe al filesystem ext2 /dev/sdb1` se venisse eseguito il comando seguente?
```
# tune2fs -j /dev/sdb1 -J device=/dev/sdc1 -i 30d
```
Un journal verrà aggiunto a /dev/sdb1, convertendolo in ext3. Il journal sarà memorizzato sul dispositivo /dev/sdc1 e il filesystem verrà controllato ogni 30 giorni.
Come possiamo controllare gli errori su un filesystem XFS su /dev/sda1 che ha una sezione di log su /dev/sdc1, senza effettivamente fare alcuna riparazione?

Usa xfs_repair, seguito da -l /dev/sdc1 per indicare il dispositivo contenente la sezione di log e -n per evitare di apportare modifiche.
```
# xfs_repair -l /dev/sdc1 -n
```
Qual è la differenza tra i parametri -T e -t in df?

L’opzione -T includerà il tipo di ogni filesystem nell’output di df. -t invece mostrerà solo i filesystem del tipo dato in output, escludendo tutti gli altri.