Aktuelle Version vom 19. August 2026, 17:30 Uhr

XFS ist ein 64-Bit-Journaling-Dateisystem, ursprünglich von Silicon Graphics (SGI) in den 1990er Jahren für IRIX und High-Performance-Computing entwickelt und seit 2001 im Linux-Kernel. Auf Red Hat, Rocky und CentOS ist es das Standard-Dateisystem. Dieser Artikel behandelt Aufbau und Besonderheiten von XFS sowie die Werkzeuge zur Administration.

Alle Beispiele verwenden Datenpartitionen ab /dev/sdb. /dev/sda ist die Systemplatte und wird nie angefasst.

Eigenschaften von XFS

Kerncharakteristik

Journaling-Dateisystem – kein Copy-on-Write wie btrfs oder ZFS.
Aufbau in unabhängigen Allocation Groups (AGs) statt klassischer Block Groups.
Online-Vergrößern möglich, Verkleinern nicht – weder online noch offline.
Sehr gute Skalierung bei großen Dateien und hoher Parallelität, ausgelegt bis in den Exabyte-Bereich.

Erweiterte Funktionen

ACLs (Access Control Lists), erweiterte Attribute (xattr) und Quota-Unterstützung (User, Group, Project).

Architektur

Auch ext4 unterteilt das Volume in Gruppen. Der Unterschied liegt nicht in der Gruppierung selbst, sondern in Zweck und Locking-Granularität:

Ext4 Block Groups dienen vor allem der Lokalität – Inodes nah bei ihren Datenblöcken, kurze Seek-Wege auf HDDs. Die Allokation läuft faktisch über einen globalen, seriell arbeitenden Allocator.
XFS Allocation Groups sind für echte Parallelität entworfen – praktisch unabhängige Mini-Dateisysteme innerhalb eines Geräts. Jede AG hat eigene AGF/AGI-Locks, sodass mehrere Threads gleichzeitig in verschiedenen AGs allozieren können, ohne sich zu blockieren.

Merksatz: Beide haben Gruppen – ext4 nutzt sie für Lokalität (seriell), XFS für Locking-Granularität (parallel).

[Bearbeiten]

Abbildung 1: Aufbau der Allocation Groups

Die zentralen Metadaten-Strukturen

Superblock – nur in AG 0 der echte Superblock, in allen weiteren AGs eine Kopie zur Redundanz. Enthält die globalen Parameter: Blockgröße, AG-Größe, Inode-Größe, UUID.
AGF (Allocation Group Free Space) – verwaltet den freien Platz innerhalb der AG über zwei parallele B+Trees: einer sortiert nach Blocknummer (Suche nach freiem Extent nahe bestehender Daten), einer nach Extent-Größe (passenden freien Extent für eine Allokation finden).
AGI (Allocation Group Inode Information) – verwaltet Inodes ohne feste Bitmap, dynamisch per B+Tree. Deshalb ist die Zahl der Inodes bei XFS – anders als bei ext4 – beim mkfs nicht fest vorgegeben, sondern wächst mit Bedarf.
B+Trees – XFS verwendet fast überall B+Trees statt linearer Bitmaps (Free Space, Inodes, Extents, große Verzeichnisse). Suchen, Einfügen und Löschen laufen in O(log n) statt linearem Scan.

Delayed Allocation

XFS reserviert beim Schreiben zunächst nur virtuell Platz im RAM (Extent-Reservierung); die tatsächliche physische Blockzuweisung erfolgt erst beim Flush auf die Platte. Dadurch werden viele kleine Schreibvorgänge zu einem großen zusammenhängenden Extent zusammengefasst – weniger Fragmentierung bei sequentiellen Lasten wie Datenbank-Dumps, Logs oder großen Kopien.

[Bearbeiten]

Abbildung 2: Delayed Allocation

Delayed Allocation ist kein XFS-Alleinstellungsmerkmal – ext4 nutzt dasselbe Prinzip (siehe ext4 Eigenschaften).

XFS ist kein Copy-on-Write

Eigenschaft	ext4 / XFS	btrfs / ZFS
Schreibprinzip	Overwrite in-place	Copy-on-Write
Crash-Konsistenz	Metadaten-Journal (Redo/Replay)	alter Block bleibt bis zum Pointer-Swap gültig
Snapshots	nicht nativ (nur über LVM darunter)	nativ, quasi kostenlos
Prüfsummen je Block	nein (nur Metadaten)	ja (Standard)

Merksatz: CoW = nie überschreiben, immer umbiegen (btrfs/ZFS). Journaling = überschreiben, aber die Absicht vorher protokollieren (ext4/XFS).

Wachsen und Schrumpfen

	ext4	XFS
Online vergrößern	ja (`resize2fs`)	ja (`xfs_growfs`)
Offline vergrößern	ja	ja
Verkleinern	ja, aber nur offline	nicht unterstützt

Einmal als XFS formatiert und zu groß gewachsen, gibt es nur den Weg über Backup, Neuformatieren und Restore. Ein xfs_shrink existiert nicht.

Wann XFS, wann ext4?

XFS bei sehr großen Volumes (Multi-TB, Datenbanken, Fileserver), hoher paralleler I/O-Last und großen Dateien mit sequentiellem Zugriff.
ext4 bei kleineren Partitionen, wo man Verkleinern braucht, bei geringerem RAM-/Overhead-Anspruch und didaktisch, um den Offline-Shrink mit resize2fs zu zeigen.

Administration

Die folgenden Werkzeuge gehören zum täglichen Umgang mit XFS auf RHEL/Rocky.

Ein Dateisystem anlegen

mkfs.xfs /dev/sdb2

Mit Label und erzwungenem Überschreiben. -f legt auch dann an, wenn schon ein Dateisystem existiert; -L setzt ein Label (max. 12 Zeichen).

mkfs.xfs -f -L test /dev/sdb2

meta-data=/dev/sdb2              isize=512    agcount=4, agsize=327680 blks
         =                       sectsz=512   attr=2, projid32bit=1
         =                       crc=1        finobt=1, sparse=1, rmapbt=0
         =                       reflink=1    bigtime=1 inobtcount=1 nrext64=0
data     =                       bsize=4096   blocks=1310720, imaxpct=25
         =                       sunit=0      swidth=0 blks
naming   =version 2              bsize=4096   ascii-ci=0, ftype=1
log      =internal log           bsize=4096   blocks=16384, version=2
         =                       sectsz=512   sunit=0 blks, lazy-count=1
realtime =none                   extsz=4096   blocks=0, rtextents=0

In der Ausgabe sieht man agcount=4: vier Allocation Groups. Das Journal (log) liegt intern im Dateisystem selbst.

Informationen abrufen

Metadaten und Aufbau anzeigen – wahlweise über das Gerät oder über den Mountpunkt.

xfs_info /dev/sdb2

Label und UUID aller Blockgeräte:

lsblk -f

Online vergrößern

Voraussetzung: das darunterliegende Blockgerät oder der LV wurde bereits vergrößert (etwa mit lvextend). Wichtig: xfs_growfs arbeitet auf dem Mountpunkt, nicht auf dem Gerät – anders als resize2fs bei ext4.

xfs_growfs /mnt/work

Reparieren

Nur im ausgehängten Zustand.

umount /mnt/work

xfs_repair /dev/sdb2

Bei beschädigtem Log wird es mit -L verworfen. Datenverlust möglich – nur als letzter Ausweg, wenn der normale Log-Replay beim Mounten fehlschlägt.

xfs_repair -L /dev/sdb2

Label oder UUID nachträglich ändern

Ohne Neuformatieren, nur im ausgehängten Zustand.

xfs_admin -L neuesLabel /dev/sdb2

xfs_admin -U generate /dev/sdb2

Fragmentierung

Grad der Fragmentierung prüfen:

xfs_db -c frag -r /dev/sdb2

Defragmentieren. Ohne Geräteangabe durchsucht xfs_fsr alle gemounteten XFS-Dateisysteme.

xfs_fsr /dev/sdb2

Freeze und Unfreeze

Für einen konsistenten Snapshot eines laufenden Systems, etwa vor einem LVM-Snapshot. Einfrieren:

xfs_freeze -f /mnt/work

Wieder auftauen:

xfs_freeze -u /mnt/work

Quota

Quota wird über eine Mount-Option in /etc/fstab aktiviert: uquota (User), gquota (Group) oder pquota (Project). Auswertung:

xfs_quota -x -c 'report' /mnt/work

@@ Zeile 1: / Zeile 1: @@
-=Was ist xfs?=
+XFS ist ein 64-Bit-Journaling-Dateisystem, ursprünglich von Silicon Graphics (SGI) in den 1990er Jahren für IRIX und High-Performance-Computing entwickelt und seit 2001 im Linux-Kernel. Auf Red Hat, Rocky und CentOS ist es das Standard-Dateisystem. Dieser Artikel behandelt Aufbau und Besonderheiten von XFS sowie die Werkzeuge zur Administration.
-*XFS (Extended File System) ist ein Dateisystem, das für UNIX-ähnliche Betriebssysteme entwickelt wurde.
-*Es wurde von Silicon Graphics Inc. (SGI) entwickelt und ist bekannt für seine Skalierbarkeit, Leistung und Zuverlässigkeit. Hier ist eine grundlegende Einführung in XFS:
+Alle Beispiele verwenden Datenpartitionen ab <code>/dev/sdb</code>. '''<code>/dev/sda</code> ist die Systemplatte und wird nie angefasst.'''
-;Entwicklung und Geschichte:
-*XFS wurde in den 1990er Jahren von SGI entwickelt, um den Anforderungen von High-Performance-Computing- und Serverumgebungen gerecht zu werden.
+=Eigenschaften von XFS=
-*Es wurde erstmals im Jahr 2001 in das Linux-Kernel-Hauptentwicklungszweig integriert.
-;Skalierbarkeit:
+==Kerncharakteristik==
-*XFS ist für große Dateisysteme ausgelegt und kann mit sehr großen Speicherkapazitäten umgehen. *Es kann Dateisysteme bis zu mehreren Exabyte unterstützen und bietet Unterstützung für hohe Anzahlen von Dateien und Verzeichnissen.
+*Journaling-Dateisystem – kein Copy-on-Write wie btrfs oder ZFS.
-;Journaling:
+*Aufbau in unabhängigen '''Allocation Groups (AGs)''' statt klassischer Block Groups.
-*Wie viele moderne Dateisysteme verwendet XFS Journaling, um die Integrität des Dateisystems bei unerwarteten Systemabstürzen oder Stromausfällen zu gewährleisten.
+*Online-Vergrößern möglich, '''Verkleinern nicht''' – weder online noch offline.
-*Das Journalprotokolliert Änderungen, die an den Dateisystemmetadaten vorgenommen werden, und ermöglicht eine schnelle Wiederherstellung des Dateisystems im Falle eines Fehlers.
+*Sehr gute Skalierung bei großen Dateien und hoher Parallelität, ausgelegt bis in den Exabyte-Bereich.
-;Leistung:
-*XFS bietet eine hohe Leistung durch effiziente Algorithmen und Strukturen.
+==Erweiterte Funktionen==
-*Es ist besonders gut für Anwendungen geeignet, die große Dateien oder viele kleine Dateien verarbeiten müssen.
+*ACLs (Access Control Lists), erweiterte Attribute (xattr) und Quota-Unterstützung (User, Group, Project).
-*Die parallele Verarbeitung und das effiziente Handling von Metadaten tragen zur hohen Leistungsfähigkeit von XFS bei.
-;Erweiterte Funktionen:
+=Architektur=
-*XFS bietet erweiterte Funktionen wie Unterstützung für ACLs (Access Control Lists), erweiterte Attribute und Quota-Unterstützung.
-*Diese Funktionen ermöglichen eine feinere Kontrolle über den Dateizugriff und die Dateiverwaltung.
+Auch ext4 unterteilt das Volume in Gruppen. Der Unterschied liegt nicht in der Gruppierung selbst, sondern in Zweck und Locking-Granularität:
-;Betriebssystemunterstützung:
-*XFS wurde ursprünglich für das IRIX-Betriebssystem von SGI entwickelt, aber später wurde es auch in andere UNIX-ähnliche Betriebssysteme portiert, darunter Linux.
+*'''Ext4 Block Groups''' dienen vor allem der '''Lokalität''' – Inodes nah bei ihren Datenblöcken, kurze Seek-Wege auf HDDs. Die Allokation läuft faktisch über einen globalen, seriell arbeitenden Allocator.
-*Heutzutage ist XFS eine Standardoption für viele Linux-Distributionen und wird oft für Speicher-intensive Anwendungen und Dateisysteme verwendet, die eine hohe Leistung erfordern.
+*'''XFS Allocation Groups''' sind für echte '''Parallelität''' entworfen – praktisch unabhängige Mini-Dateisysteme innerhalb eines Geräts. Jede AG hat eigene AGF/AGI-Locks, sodass mehrere Threads gleichzeitig in verschiedenen AGs allozieren können, ohne sich zu blockieren.
-*Insgesamt ist XFS ein leistungsfähiges und skalierbares Dateisystem, das besonders gut für Anwendungen geeignet ist, die große Datenmengen verarbeiten müssen und hohe Anforderungen an die Leistung und Zuverlässigkeit haben.
+'''Merksatz:''' Beide haben Gruppen – ext4 nutzt sie für Lokalität (seriell), XFS für Locking-Granularität (parallel).
+{{#drawio:xfs-ag}}
+''Abbildung 1: Aufbau der Allocation Groups''
+==Die zentralen Metadaten-Strukturen==
+*'''Superblock''' – nur in AG 0 der echte Superblock, in allen weiteren AGs eine Kopie zur Redundanz. Enthält die globalen Parameter: Blockgröße, AG-Größe, Inode-Größe, UUID.
+*'''AGF (Allocation Group Free Space)''' – verwaltet den freien Platz innerhalb der AG über zwei parallele B+Trees: einer sortiert nach Blocknummer (Suche nach freiem Extent nahe bestehender Daten), einer nach Extent-Größe (passenden freien Extent für eine Allokation finden).
+*'''AGI (Allocation Group Inode Information)''' – verwaltet Inodes '''ohne feste Bitmap''', dynamisch per B+Tree. Deshalb ist die Zahl der Inodes bei XFS – anders als bei ext4 – beim <code>mkfs</code> '''nicht''' fest vorgegeben, sondern wächst mit Bedarf.
+*'''B+Trees''' – XFS verwendet fast überall B+Trees statt linearer Bitmaps (Free Space, Inodes, Extents, große Verzeichnisse). Suchen, Einfügen und Löschen laufen in O(log n) statt linearem Scan.
+=Delayed Allocation=
+XFS reserviert beim Schreiben zunächst nur virtuell Platz im RAM (Extent-Reservierung); die tatsächliche physische Blockzuweisung erfolgt erst beim Flush auf die Platte. Dadurch werden viele kleine Schreibvorgänge zu einem großen zusammenhängenden Extent zusammengefasst – weniger Fragmentierung bei sequentiellen Lasten wie Datenbank-Dumps, Logs oder großen Kopien.
+{{#drawio:xfs-delalloc}}
+''Abbildung 2: Delayed Allocation''
+Delayed Allocation ist kein XFS-Alleinstellungsmerkmal – ext4 nutzt dasselbe Prinzip (siehe [[ext4 Eigenschaften]]).
+=XFS ist kein Copy-on-Write=
+{| class="wikitable"
+! Eigenschaft !! ext4 / XFS !! btrfs / ZFS
+|-
+| Schreibprinzip || Overwrite in-place || Copy-on-Write
+|-
+| Crash-Konsistenz || Metadaten-Journal (Redo/Replay) || alter Block bleibt bis zum Pointer-Swap gültig
+|-
+| Snapshots || nicht nativ (nur über LVM darunter) || nativ, quasi kostenlos
+|-
+| Prüfsummen je Block || nein (nur Metadaten) || ja (Standard)
+|}
+'''Merksatz:''' CoW = nie überschreiben, immer umbiegen (btrfs/ZFS). Journaling = überschreiben, aber die Absicht vorher protokollieren (ext4/XFS).
+=Wachsen und Schrumpfen=
+{| class="wikitable"
+! !! ext4 !! XFS
+|-
+| Online vergrößern || ja (<code>resize2fs</code>) || ja (<code>xfs_growfs</code>)
+|-
+| Offline vergrößern || ja || ja
+|-
+| Verkleinern || ja, aber nur offline || '''nicht unterstützt'''
+|}
+Einmal als XFS formatiert und zu groß gewachsen, gibt es nur den Weg über Backup, Neuformatieren und Restore. Ein <code>xfs_shrink</code> existiert nicht.
+=Wann XFS, wann ext4?=
+*'''XFS''' bei sehr großen Volumes (Multi-TB, Datenbanken, Fileserver), hoher paralleler I/O-Last und großen Dateien mit sequentiellem Zugriff.
+*'''ext4''' bei kleineren Partitionen, wo man Verkleinern braucht, bei geringerem RAM-/Overhead-Anspruch und didaktisch, um den Offline-Shrink mit <code>resize2fs</code> zu zeigen.
+=Administration=
+Die folgenden Werkzeuge gehören zum täglichen Umgang mit XFS auf RHEL/Rocky.
+==Ein Dateisystem anlegen==
+*mkfs.xfs /dev/sdb2
+Mit Label und erzwungenem Überschreiben. <code>-f</code> legt auch dann an, wenn schon ein Dateisystem existiert; <code>-L</code> setzt ein Label (max. 12 Zeichen).
+*mkfs.xfs -f -L test /dev/sdb2
+ meta-data=/dev/sdb2              isize=512    agcount=4, agsize=327680 blks
+          =                       sectsz=512   attr=2, projid32bit=1
+          =                       crc=1        finobt=1, sparse=1, rmapbt=0
+          =                       reflink=1    bigtime=1 inobtcount=1 nrext64=0
+ data     =                       bsize=4096   blocks=1310720, imaxpct=25
+          =                       sunit=0      swidth=0 blks
+ naming   =version 2              bsize=4096   ascii-ci=0, ftype=1
+ log      =internal log           bsize=4096   blocks=16384, version=2
+          =                       sectsz=512   sunit=0 blks, lazy-count=1
+ realtime =none                   extsz=4096   blocks=0, rtextents=0
+In der Ausgabe sieht man <code>agcount=4</code>: vier Allocation Groups. Das Journal (<code>log</code>) liegt intern im Dateisystem selbst.
+==Informationen abrufen==
+Metadaten und Aufbau anzeigen – wahlweise über das Gerät oder über den Mountpunkt.
+*xfs_info /dev/sdb2
+Label und UUID aller Blockgeräte:
+*lsblk -f
+==Online vergrößern==
+Voraussetzung: das darunterliegende Blockgerät oder der LV wurde bereits vergrößert (etwa mit <code>lvextend</code>). Wichtig: <code>xfs_growfs</code> arbeitet auf dem '''Mountpunkt''', nicht auf dem Gerät – anders als <code>resize2fs</code> bei ext4.
+*xfs_growfs /mnt/work
+==Reparieren==
+Nur im '''ausgehängten''' Zustand.
+*umount /mnt/work
+*xfs_repair /dev/sdb2
+Bei beschädigtem Log wird es mit <code>-L</code> verworfen. Datenverlust möglich – nur als letzter Ausweg, wenn der normale Log-Replay beim Mounten fehlschlägt.
+*xfs_repair -L /dev/sdb2
+==Label oder UUID nachträglich ändern==
+Ohne Neuformatieren, nur im ausgehängten Zustand.
+*xfs_admin -L neuesLabel /dev/sdb2
+*xfs_admin -U generate /dev/sdb2
+==Fragmentierung==
+Grad der Fragmentierung prüfen:
+*xfs_db -c frag -r /dev/sdb2
+Defragmentieren. Ohne Geräteangabe durchsucht <code>xfs_fsr</code> alle gemounteten XFS-Dateisysteme.
+*xfs_fsr /dev/sdb2
+==Freeze und Unfreeze==
+Für einen konsistenten Snapshot eines laufenden Systems, etwa vor einem LVM-Snapshot. Einfrieren:
+*xfs_freeze -f /mnt/work
+Wieder auftauen:
+*xfs_freeze -u /mnt/work
+==Quota==
+Quota wird über eine Mount-Option in <code>/etc/fstab</code> aktiviert: <code>uquota</code> (User), <code>gquota</code> (Group) oder <code>pquota</code> (Project). Auswertung:
+*xfs_quota -x -c 'report' /mnt/work
+[[Kategorie:Dateisysteme]]
+[[Kategorie:Rocky Linux Kurs]]

Xfs: Unterschied zwischen den Versionen