Fragmentering är ett långvarigt problem när det gäller lagring. Det uppstår när lagringsmediet på grund av långvarig användning får bitar av tilldelade block med ledigt utrymme mellan sig. Detta händer eftersom olika program begär minne i olika ordning och sedan frigör minnet vid olika tidpunkter. Att ha bitar av icke allokerat utrymme mellan data minskar det totala tillgängliga utrymmet på disken (lagringseffektivitet) och även prestanda för disken, eftersom data inte lagras i en stor sammanhängande bit utan sprids över disken.

Detta problem är särskilt uppenbart i magnetiska medier även om SSD-enheter lider av det också. Låt oss försöka defragmentera ett XFS-filsystem i det här inlägget.

Sandbox-installation

Först, för att experimentera med XFS-filsystem, bestämde jag mig för att skapa en testbänk istället för att arbeta med kritisk data på en disk. Denna testbänk består av en virtuell Ubuntu-dator till vilken en virtuell disk är ansluten som ger rå lagring. Du kan använda VirtualBox för att skapa den virtuella datorn och sedan skapa en ytterligare disk att bifoga till den virtuella datorn

Gå bara till din VM: s inställningar och under Inställningar → Lagring avsnitt kan du lägga till en ny disk till SATA-styrenheten kan du skapa en ny disk. Som visas nedan, men se till att din virtuella dator är avstängd när du gör det.

När den nya disken har skapats slår du på den virtuella datorn och öppnar terminalen. Kommandot lsblk listar alla tillgängliga blockenheter.

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

Bortsett från huvudblockeringsenheten sda, där operativsystemet är installerat finns det nu en ny SDB-enhet. Låt oss snabbt skapa en partition från den och formatera den med XFS-filsystem.

Öppna delat verktyg som rotanvändare:

$ parted -a optimal / dev / sdb

Låt oss skapa en partitionstabell först med mklabel, detta följs av att skapa en enda partition av hela disken (som är 107 GB i storlek). Du kan verifiera att partitionen är skapad genom att lista den med utskriftskommandot:

(delad) mklabel gpt
(delad) mkpart primär 0 107
(delad) tryck
(parted) slutade

Okej, nu kan vi se med hjälp av lsblk att det finns en ny blockeringsenhet under sdb-enheten, kallad sdb1.

Låt oss formatera denna lagring som xfs och montera den i / mnt-katalogen. Återigen gör följande åtgärder som root:

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

Det sista kommandot skriver ut alla monterade filsystem och du kan kontrollera att / dev / sdb1 är monterad på / mnt.

Därefter skriver vi en massa filer som dummydata för att defragmentera här:

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

Ovanstående kommando skulle skriva en fil myfile.txt på 1 MB storlek. Du kan automatisera detta kommando till en enkel för loop med bash och generera fler sådana filer. Sprid dem över olika kataloger om du vill. Ta bort några av dem slumpmässigt. Gör allt detta i xfs-filsystemet (monterat på / mnt) och leta efter fragmentering. Allt detta är naturligtvis frivilligt.

Defragmentera ditt filsystem

Det första vi behöver göra är att ta reda på hur man kontrollerar mängden fragmentering. Till exempel var xfs-filsystemet vi skapade tidigare på enhetsnod / dev / sdb. Vi kan använda verktyget xfs_db (står för xfs-felsökning) för att kontrollera fragmenteringsnivån.

$ xfs_db -c frag -r / dev / sdb1

Flaggan -c tar olika kommandon bland vilka är frag-kommandot för att kontrollera fragmenteringsnivån. Flaggan -r används för att se till att operationen är helt skrivskyddad.

Om vi ​​upptäcker att det finns någon fragmentering i detta filsystem kör vi kommandot xfs_fsr på enhetsnoden:

$ xfs_fsr / dev / sdb1

Det här sista kommandot är allt som finns för att defragmentera ditt filsystem, du kan lägga till detta som en cronjobb som regelbundet övervakar ditt filsystem. Men att göra det för xfs är lite meningsfullt. Den omfattningsbaserade tilldelningen av XFS säkerställer att problem som fragmentering förblir till ett minimum.

Använd fall

Användningsfallet där du behöver oroa dig mest för fragmentering av filsystem involverar applikationer där många små bitar av data skrivs och skrivs om. En databas är ett klassiskt exempel på detta och databaser är ökända för att lämna massor av "hål" i din lagring. Minnesblock fylls inte ihop, vilket gör mängden tillgängligt utrymme mindre och mindre över tiden.

Problemet uppstår inte bara när det gäller minskat användbart utrymme utan också när det gäller minskad IOPS som kan skada din applikations prestanda. Att ha ett manus för att kontinuerligt övervaka fragmenteringsnivån är ett konservativt sätt att underhålla systemet. Du vill inte att ett automatiskt skript slumpmässigt ska börja defragmentera ditt filsystem, särskilt inte när det används vid toppbelastning.