Fragmentering er et mangeårig problem når det gjelder lagring. Det oppstår når lagringsmediene på grunn av langvarig bruk får biter av tildelte blokker med ledig plass mellom seg. Dette skjer fordi forskjellige programmer ber om minne i annen rekkefølge og deretter frigjøre minnet til forskjellige tider. Å ha biter av ikke tildelt plass mellom data reduserer den totale tilgjengelige plassen på disken (lagringseffektivitet) og også ytelsen til disken, siden dataene ikke er lagret i en stor sammenhengende del, men spredt over disken.

Dette problemet er spesielt tydelig i magnetiske medier, selv om SSD -er lider av det også. La oss prøve å defragmentere et XFS -filsystem i dette innlegget.

Sandkasseoppsett

For det første, for å eksperimentere med XFS -filsystem, bestemte jeg meg for å lage en testbench i stedet for å jobbe med kritiske data på en disk. Denne testbenken består av en Ubuntu VM som en virtuell disk er tilkoblet med rålagring. Du kan bruke VirtualBox til å lage VM og deretter opprette en ekstra disk for å feste til VM

Bare gå til VMs innstillinger og under Innstillinger → lagring Seksjon Du kan legge til en ny disk til SATA -kontrolleren. Du kan opprette en ny disk. Som vist nedenfor, men sørg for at VM -en din er slått av når du gjør dette.

Når den nye disken er opprettet, slå på VM og åpne opp terminalen. Kommandoen LSBLK viser alle tilgjengelige blokkenheter.

$ 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 fra hovedblokkenheten SDA, Der OS er installert, er det nå en ny SDB -enhet. La oss raskt lage en partisjon fra den og formatere den med XFS -filsystem.

Åpne opp skilt verktøy som rotbruker:

$ delt -en optimal /dev /sdb

La oss lage en partisjonstabell først ved hjelp av Mklabel, dette blir fulgt av å lage en enkelt partisjon ut av hele disken (som er 107 GB i størrelse). Du kan bekrefte at partisjonen er gjort ved å oppgi den ved hjelp av utskriftskommando:

(skilt) mklabel gpt
(skilt) mkpart primær 0 107
(skilt) utskrift
(skilt) slutte

Ok, nå kan vi se ved hjelp av LSBLK at det er en ny blokkenhet under SDB -enheten, kalt SDB1.

La oss formatere denne lagringen som XFS og montere den i /MNT -katalogen. Igjen, gjør følgende handlinger som root:

$ MKFS.XFS /Dev /SDB1
$ mount /dev /sdb1 /mnt
$ df -h

Den siste kommandoen vil skrive ut alle monterte filsystemer, og du kan sjekke at /dev /sdb1 er montert AT /MNT.

Neste gang skriver vi en haug med filer som dummy data for å defragmentere her:

$ dd if =/dev/urandom av =/mnt/myfile.TXT Count = 1024 BS = 1024

Kommandoen ovenfor ville skrive en fil myfil.txt av 1 MB størrelse. Du kan automatisere denne kommandoen til en enkel for loop ved hjelp av bash og generere flere slike filer. Spre dem over forskjellige kataloger hvis du vil. Slett noen få av dem tilfeldig. Gjør alt dette inne i XFS -filsystemet (montert AT /MNT) og sjekk deretter for fragmentering. Alt dette er selvfølgelig valgfritt.

Defragment filsystemet ditt

Det første vi trenger å gjøre er å finne ut hvordan du kan sjekke fragmenteringsmengden. For eksempel var XFS -filsystemet vi opprettet tidligere på Device Node /Dev /SDB. Vi kan bruke verktøyet XFS_DB (står for XFS -feilsøking) for å sjekke fragmenteringsnivået.

$ xfs_db -c frag -r /dev /sdb1

-C -flagget tar forskjellige kommandoer blant dem er frag -kommandoen for å sjekke fragmenteringsnivået. -R -flagget som brukes for å sikre at operasjonen er helt skrivebeskyttet.

Hvis vi finner ut at det er noen fragmentering i dette filsystemet, kjører vi XFS_FSR -kommandoen på enhetsnoden:

$ xfs_fsr /dev /sdb1

Denne siste kommandoen er alt det er for å defragmentere filsystemet ditt, du kan legge til dette som en cronjob som regelmessig overvåker filsystemet ditt. Men å gjøre det for XFS gir lite mening. Omfangbasert tildeling av XFS sikrer at problemer som fragmentering holder seg til et minimum.

Bruk saker

Brukssakene der du trenger å bekymre deg mest for fragmentering. En database er et klassisk eksempel på dette, og databaser er beryktet for å legge igjen mye og mange "hull" i lagringen. Minneblokker er ikke sammenhengende fylt, noe som gjør mengden tilgjengelig plass mindre og mindre over tid.

Problemet oppstår som ikke bare når det gjelder redusert brukbar plass, men også når det gjelder reduserte IOP -er som kan skade applikasjonens ytelse. Å ha et skript for kontinuerlig å overvåke fragmenteringsnivået er en konservativ måte å opprettholde systemet. Du vil ikke at et automatisert skript skal begynne å defragmentere filsystemet ditt, spesielt når det brukes ved toppbelastning.