La frammentazione è un problema di vecchia data quando si tratta di spazio. Sorge quando, a causa dell'uso prolungato, i media di archiviazione ricevono blocchi di blocchi assegnati con spazio libero tra di loro. Ciò accade perché vari programmi richiedono memoria in ordine diverso e quindi libere 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 sono memorizzati in un grosso pezzo contiguo ma diffuso sul disco.

Questo problema è particolarmente evidente nei media magnetici, sebbene anche gli SSD ne soffrano. Proviamo a sbloccare un file system XFS in questo post.

Setup sandbox

Innanzitutto, per sperimentare il filesystem XFS, ho deciso di creare un Testbench invece di lavorare con dati critici su un disco. Questo testbench è costituito da una VM Ubuntu a cui è collegato un disco virtuale fornendo memoria grezza. È possibile utilizzare VirtualBox per creare la VM e quindi creare un disco aggiuntivo da collegare alla VM

Vai alle impostazioni della tua VM e sotto Impostazioni → Archiviazione Sezione È possibile aggiungere un nuovo disco al controller SATA È possibile creare un nuovo disco. Come mostrato di seguito, ma assicurati che la 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 di blocco 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 esso e formatiamola con il filesystem XFS.

Apri l'utilità separata come utente root:

$ separati -a ottimale /dev /sdb

Creiamo prima una tabella di partizione usando mklabel, questo è seguito dalla creazione di una singola partizione dall'intero disco (che ha una dimensione di 107 GB). È possibile verificare che la partizione sia effettuata elencandola usando il comando di stampa:

(separato) Mklabel GPT
(separato) MKPart Primary 0 107
(separato) Stampa
(separato) smettila

Ok, ora possiamo vedere usando LSBLK che esiste un nuovo dispositivo a blocchi sotto il dispositivo SDB, chiamato SDB1.

Formatiamo questo spazio di archiviazione come XFS e lo montiamo nella directory /mnt. Ancora una volta, fai 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 verificare che /dev /sdb1 sia montato su /mnt.

Successivamente scriviamo un sacco di file come dati fittizi a deframment qui:

$ dd if =/dev/urandom di =/mnt/myfile.TXT COUNT = 1024 BS = 1024

Il comando sopra avrebbe scritto un file myfile.txt della dimensione di 1 MB. È possibile automatizzare questo comando in un ciclo semplice utilizzando bash e generare più file. Diffondili attraverso varie directory se vuoi. Elimina alcuni di essi in modo casuale. Fai tutto questo all'interno del filesystem XFS (montato AT /MNT) e quindi controlla la frammentazione. Tutto questo è, ovviamente, facoltativo.

Deframment il tuo filesystem

La prima cosa che dobbiamo fare è capire come verificare la quantità di frammentazione. Ad esempio, il filesystem XFS che abbiamo creato in precedenza era sul nodo del dispositivo /dev /sdb. Possiamo utilizzare l'utilità XFS_DB (sta per il debug XFS) per verificare il livello di frammentazione.

$ xfs_db -c frag -r /dev /sdb1

Il flag -c prende vari comandi tra cui il comando fram per verificare il livello di frammentazione. Il flag -r utilizzato per assicurarsi che l'operazione sia interamente lettura.

Se scopriamo che c'è qualche frammentazione in questo filesystem eseguiamo il comando XFS_FSR sul nodo del dispositivo:

$ xfs_fsr /dev /sdb1

Quest'ultimo comando è tutto ciò che c'è da sbloccare il tuo filesystem, puoi aggiungerlo come un cronjob che monitorerà regolarmente il tuo filesystem. Ma farlo per XFS ha poco senso. L'allocazione basata sull'estensione di XFS garantisce che problemi come la frammentazione rimangono al minimo.

Casi d'uso

I casi d'uso in cui è necessario preoccuparti di più della frammentazione del filesystem prevede applicazioni in cui vengono scritti e riscritti molti piccoli blocchi di dati. Un database è un classico esempio di questo e i database sono noti per lasciare un sacco di "buchi" nella tua memoria. I blocchi di memoria non sono riempiti contigua rendendo sempre più piccola la quantità di spazio disponibile.

Il problema sorge non solo in termini di spazio utilizzabile ridotto, ma anche in termini di IOP ridotti che potrebbero danneggiare le prestazioni della tua applicazione. Avere una sceneggiatura per monitorare continuamente il livello di frammentazione è un modo conservativo per mantenere il sistema. Non vuoi che uno script automatizzato inizi a defraggmentare casualmente il tuo filesystem soprattutto quando viene utilizzato al carico di picco.