La frammentazione è un problema di vecchia data quando si tratta di storage. Si verifica quando, a causa dell'uso prolungato, il supporto di archiviazione ottiene blocchi di blocchi allocati con spazio libero tra di loro. Questo accade perché vari programmi richiedono la memoria in ordine diverso e poi liberano la memoria in momenti diversi. Avere blocchi di spazio non allocato tra i dati riduce lo spazio disponibile totale nel disco (efficienza di archiviazione) e anche le prestazioni del disco, poiché i dati non vengono archiviati in un grande blocco contiguo ma si diffondono sul disco.

Questo problema è particolarmente evidente nei supporti magnetici, anche se ne soffrono anche gli SSD. Proviamo a deframmentare un file system XFS in questo post.

Configurazione sandbox

Innanzitutto, per sperimentare con il filesystem XFS, ho deciso di creare un banco di prova invece di lavorare con dati critici su un disco. Questo banco di prova è costituito da una macchina virtuale Ubuntu a cui è connesso un disco virtuale che fornisce spazio di archiviazione non elaborato. Puoi usare VirtualBox per creare la VM e quindi creare un disco aggiuntivo da collegare alla VM

Vai alle impostazioni della tua VM e sotto Impostazioni → Memoria sezione puoi aggiungere un nuovo disco al controller SATA puoi creare un nuovo disco. Come mostrato di seguito, ma assicurati che la tua VM sia spenta quando lo fai.

Una volta creato il nuovo disco, accendi la VM e apri il terminale. Il comando lsblk elenca tutti i dispositivi a blocchi disponibili.

$ lsblk
sda      8:0    0   60G  0 disco
├─sda1   8:1     0    1M  0 parte
└─sda2   8:2    0   60G  0 parte /
sdb      8:16   0  100G  0 disco
sr0    11:0    1 1024M  0 rom

A parte il dispositivo di blocco principale sda, dove è installato il sistema operativo, ora c'è un nuovo dispositivo sdb. Creiamo rapidamente una partizione da essa e formattiamola con il filesystem XFS.

Apri l'utilità parted come utente root:

$ parted -a ottimale /dev/sdb

Creiamo prima una tabella delle partizioni usando mklabel, seguito dalla creazione di una singola partizione dall'intero disco (che ha una dimensione di 107 GB). Puoi verificare che la partizione sia stata creata elencandola usando il comando print:

(parted) mklabel gpt
(parted) mkpart primary 0 107
(parted) stampa
(separato) esci

Ok, ora possiamo vedere usando lsblk che c'è un nuovo dispositivo a blocchi sotto il dispositivo sdb, chiamato sdb1.

Formattiamo questa memoria come xfs e montiamola nella directory /mnt. Ancora una volta, esegui le seguenti azioni come root:

$ mkfs.xfs /dev/sdb1
$ mount /dev/sdb1 /mnt
$ df -h

L'ultimo comando stamperà tutti i filesystem montati e puoi controllare che /dev/sdb1 sia montato su /mnt.

Quindi scriviamo un mucchio di file come dati fittizi da deframmentare qui:

$ dd if=/dev/urandom of=/mnt/myfile.txt conteggio=1024 bs=1024

Il comando precedente scriverebbe un file miofile.txt di 1 MB di dimensione. Puoi automatizzare questo comando in un semplice ciclo for usando bash e generare più file di questo tipo. Diffondili in varie directory, se lo desideri. Eliminane alcuni a caso. Fai tutto questo all'interno del filesystem xfs (montato su /mnt) e poi controlla la frammentazione. Tutto questo è, ovviamente, facoltativo.

Deframmenta il tuo filesystem

La prima cosa che dobbiamo fare è capire come controllare la quantità di frammentazione. Ad esempio, il filesystem xfs che abbiamo creato in precedenza era sul nodo del dispositivo /dev/sdb. Possiamo usare l'utility xfs_db (sta per xfs debugging) per controllare il livello di frammentazione.

$ xfs_db -c frag -r /dev/sdb1

Il flag -c accetta vari comandi tra cui il comando frag per controllare il livello di frammentazione. Il flag -r utilizzato per assicurarsi che l'operazione sia interamente di sola lettura.

Se troviamo che c'è qualche frammentazione in questo filesystem, eseguiamo il comando xfs_fsr sul nodo del dispositivo:

$ xfs_fsr /dev/sdb1

Questo ultimo comando è tutto ciò che serve per deframmentare il tuo filesystem, puoi aggiungerlo come cronjob che controllerà regolarmente il tuo filesystem. Ma farlo per xfs ha poco senso. L'allocazione basata sull'estensione di XFS garantisce che problemi come la frammentazione rimangano al minimo.

Casi d'uso

I casi d'uso in cui devi preoccuparti di più della frammentazione del filesystem coinvolgono applicazioni in cui vengono scritti e riscritti molti piccoli blocchi di dati. Un database è un classico esempio di ciò e i database sono noti per lasciare molti, molti "buchi" nel tuo spazio di archiviazione. I blocchi di memoria non vengono riempiti in modo contiguo, rendendo la quantità di spazio disponibile sempre più piccola nel tempo.

Il problema si pone non solo in termini di spazio utilizzabile ridotto, ma anche in termini di IOPS ridotti che potrebbero danneggiare le prestazioni dell'applicazione. Avere uno script per monitorare continuamente il livello di frammentazione è un modo conservativo di mantenere il sistema. Non vuoi che uno script automatico inizi a deframmentare in modo casuale il tuo filesystem, specialmente quando viene utilizzato al picco di carico.