Storage Tools die man kennen sollte: Unterschied zwischen den Versionen

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen
(Die Seite wurde neu angelegt: „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 un…“)
 
 
Zeile 1: Zeile 1:
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.
+
Rund um Partitionen und Dateisysteme gibt es eine Reihe kleiner Werkzeuge, die man nicht täglich braucht, aber kennen sollte – zum Nachsehen, was wo liegt, wie es der Platte geht und wer gerade auf sie zugreift. Die Werkzeuge zum Anlegen und Reparieren (<code>fdisk</code>, <code>gdisk</code>, <code>mkfs</code>, <code>fsck</code>, <code>mount</code>) haben eigene Artikel; hier geht es ums Anschauen und Diagnostizieren.
  
Alle Beispiele verwenden Datenpartitionen ab <code>/dev/sdb</code>. '''<code>/dev/sda</code> ist die Systemplatte und wird nie angefasst.'''
+
=Was liegt wo?=
  
=Eigenschaften von XFS=
+
==lsblk – Blockgeräte als Baum==
 +
<code>lsblk</code> zeigt alle Blockgeräte – Platten, Partitionen, LVM-Volumes, RAID-Verbünde – als Baum, samt Größe und Mountpunkt. Es liest nur aus <code>/sys</code> und rührt die Platten nicht an, ist also gefahrlos und der übliche erste Blick auf ein System. Mit <code>-i</code> zeichnet es den Baum aus einfachen ASCII-Zeichen.
 +
*lsblk -i
  
==Kerncharakteristik==
+
NAME  MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
*Journaling-Dateisystem – kein Copy-on-Write wie btrfs oder ZFS.
+
sda      8:0    0  50G  0 disk
*Aufbau in unabhängigen '''Allocation Groups (AGs)''' statt klassischer Block Groups.
+
|-sda1  8:1    0  49G  0 part /
*Online-Vergrößern möglich, '''Verkleinern nicht''' – weder online noch offline.
+
`-sda2  8:2    0  1G  0 part [SWAP]
*Sehr gute Skalierung bei großen Dateien und hoher Parallelität, ausgelegt bis in den Exabyte-Bereich.
+
sdb      8:16  0  20G  0 disk
 +
`-sdb1  8:17  0  20G  0 part /mnt/work
  
==Erweiterte Funktionen==
+
Mit <code>-f</code> kommen Dateisystemtyp, Label und UUID dazu – die Sicht, die man für <code>/etc/fstab</code> braucht.
*ACLs (Access Control Lists), erweiterte Attribute (xattr) und Quota-Unterstützung (User, Group, Project).
+
*lsblk -f
 +
 
 +
==blkid – UUID, Label und Typ==
 +
<code>blkid</code> liest die Signatur eines Dateisystems und gibt UUID, Label und Typ aus – genau die Werte, mit denen man einen Eintrag in <code>/etc/fstab</code> baut. Ohne Argument zeigt es alle Geräte, mit Gerätenamen nur das eine.
 +
*blkid /dev/sdb1
 +
 
 +
/dev/sdb1: UUID="1b40fc1f-21dd-497e-9266-454f206f67b2" TYPE="ext4" PARTUUID="983b9a7b-01"
  
=Architektur=
+
==file -s – was ist das für ein Dateisystem?==
 +
<code>file</code> erkennt Dateitypen an ihrem Inhalt. Mit <code>-s</code> (''special files'') liest es auch Blockgeräte und sagt, was darauf liegt – ohne zu mounten. Das ist der schnellste Weg, eine unbekannte oder scheinbar leere Platte einzuordnen, etwa bevor man sie formatiert.
 +
*file -s /dev/sdb1
  
Auch ext4 unterteilt das Volume in Gruppen. Der Unterschied liegt nicht in der Gruppierung selbst, sondern in Zweck und Locking-Granularität:
+
/dev/sdb1: Linux rev 1.0 ext4 filesystem data, UUID=1b40fc1f-... (extents) (64bit)
  
*'''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.
+
Zeigt <code>file -s</code> nur „data", liegt entweder kein Dateisystem darauf oder die Platte ist wirklich leer.
*'''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).
+
==findmnt aktuelle Mounts durchsuchen==
 +
<code>findmnt</code> stellt die eingehängten Dateisysteme als Baum dar und ist übersichtlicher als <code>mount</code> ohne Argumente. Mit einem Mountpunkt oder Gerät als Argument zeigt es gezielt einen Eintrag samt seiner tatsächlichen Optionen – nützlich, um zu prüfen, ob ein <code>noexec</code> oder <code>ro</code> aus der fstab wirklich greift.
 +
*findmnt
  
{{#drawio:xfs-ag}}
+
*findmnt /mnt/work
''Abbildung 1: Aufbau der Allocation Groups''
 
  
==Die zentralen Metadaten-Strukturen==
+
==df – freier Platz je Dateisystem==
 +
<code>df</code> (''disk free'') zeigt Belegung und freien Platz aller eingehängten Dateisysteme. <code>-h</code> macht die Zahlen lesbar (''human''), sonst rechnet df in 1-KiB-Blöcken.
 +
*df -h
  
*'''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.
+
Dateisystem    Größe Benutzt Verf. Verw% Eingehängt auf
*'''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).
+
/dev/sda1        49G    12G  35G  26% /
*'''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.
+
/dev/sdb1        20G    1,2G  18G    7% /mnt/work
*'''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=
+
Mit <code>-i</code> zählt df statt der Blöcke die '''Inodes'''. Das erklärt den klassischen Fall der vollen Platte trotz freiem Platz: Wenn viele winzige Dateien alle Inodes belegt haben, ist das Dateisystem voll, obwohl <code>df -h</code> noch freien Platz zeigt.
 +
*df -i
  
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.
+
Ohne Filter listet df auch die vielen virtuellen Dateisysteme (<code>tmpfs</code>, <code>devtmpfs</code>, <code>squashfs</code> von Snap-Paketen) mit auf. <code>-t</code> beschränkt auf einen Typ, <code>-x</code> blendet einen aus – so bleibt nur das Wesentliche stehen.
 +
*df -h -t ext4
  
{{#drawio:xfs-delalloc}}
+
*df -h -x tmpfs -x devtmpfs
''Abbildung 2: Delayed Allocation''
 
  
Delayed Allocation ist kein XFS-Alleinstellungsmerkmal ext4 nutzt dasselbe Prinzip (siehe [[ext4 Eigenschaften]]).
+
==du / ncdu was belegt den Platz?==
 +
Während <code>df</code> das ganze Dateisystem betrachtet, geht <code>du</code> (''disk usage'') den Verzeichnisbaum durch und summiert, was einzelne Verzeichnisse verbrauchen. Der häufigste Aufruf zeigt die oberste Ebene mit lesbaren Größen; <code>-s</code> fasst je Argument zusammen, <code>-h</code> macht es lesbar.
 +
*du -sh /var/*
  
=XFS ist kein Copy-on-Write=
+
128M    /var/cache
 +
2,1G    /var/lib
 +
890M    /var/log
  
{| class="wikitable"
+
Für die reine Suche nach dem größten Brocken hilft Sortieren:
! Eigenschaft !! ext4 / XFS !! btrfs / ZFS
+
*du -h /var | sort -rh | head -20
|-
 
| 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).
+
<code>ncdu</code> (''NCurses du'') ist die interaktive Variante: es liest den Baum einmal ein und lässt einen dann mit den Pfeiltasten hineinnavigieren, immer den größten Verbraucher oben. Der bequemste Weg, eine vollgelaufene Platte aufzuräumen.
 +
*ncdu /var
  
=Wachsen und Schrumpfen=
+
=Was steckt in der Platte?=
  
{| class="wikitable"
+
==smartctl – Gesundheit der Platte==
! !! ext4 !! XFS
+
<code>smartctl</code> liest die SMART-Werte einer Platte aus – interne Zähler, die die Firmware führt: Betriebsstunden, Einschaltzyklen, wiederzugewiesene Sektoren, Lesefehler. Steigende Werte bei ''Reallocated_Sector_Ct'' oder ''Pending_Sector'' sind das deutlichste Frühwarnzeichen für eine sterbende Platte. Das Werkzeug gehört zum Paket <code>smartmontools</code>.
|-
+
*smartctl -a /dev/sdb
| 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.
+
Die Gesamtbewertung allein, ohne die lange Attributliste:
 +
*smartctl -H /dev/sdb
  
=Wann XFS, wann ext4?=
+
SMART overall-health self-assessment test result: PASSED
  
*'''XFS''' bei sehr großen Volumes (Multi-TB, Datenbanken, Fileserver), hoher paralleler I/O-Last und großen Dateien mit sequentiellem Zugriff.
+
Einen Selbsttest anstoßen (läuft im Hintergrund, Ergebnis später in <code>-a</code>):
*'''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.
+
*smartctl -t short /dev/sdb
  
=Administration=
+
==hdparm – Parameter und Tempo==
 +
<code>hdparm</code> zeigt und ändert Parameter von ATA-/SATA-Platten. <code>-I</code> gibt die Geräteinformationen aus (Modell, Firmware, unterstützte Funktionen), <code>-tT</code> misst die Lesegeschwindigkeit einmal von der Platte und einmal aus dem Cache – der schnelle Durchsatztest.
 +
*hdparm -I /dev/sdb
  
Die folgenden Werkzeuge gehören zum täglichen Umgang mit XFS auf RHEL/Rocky.
+
*hdparm -tT /dev/sdb
  
==Ein Dateisystem anlegen==
+
Timing cached reads:  18000 MB in  2.00 seconds = 9000 MB/sec
*mkfs.xfs /dev/sdb2
+
Timing buffered disk reads: 450 MB in  3.01 seconds = 149 MB/sec
  
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).
+
Vorsicht: <code>hdparm</code> kann mit anderen Schaltern auch schreibend Plattenparameter ändern. Zum reinen Nachsehen sind <code>-I</code> und <code>-tT</code> gefahrlos.
*mkfs.xfs -f -L test /dev/sdb2
 
  
meta-data=/dev/sdb2              isize=512    agcount=4, agsize=327680 blks
+
=Wer greift auf die Platte zu?=
          =                      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.
+
==iostat – I/O-Rate je Gerät==
 +
<code>iostat</code> zeigt Durchsatz und Auslastung je Platte. Der erste Ausdruck sind Mittelwerte seit dem Systemstart; mit einem Intervall dahinter kommt fortlaufend der aktuelle Wert. <code>-x</code> liefert die erweiterten Spalten, darunter <code>%util</code> (wie ausgelastet die Platte ist) und die Wartezeiten. Gehört zum Paket <code>sysstat</code>.
 +
*iostat -x 2
  
==Informationen abrufen==
+
Interessant ist vor allem die Spalte <code>%util</code>: Werte dauerhaft nahe 100 % bedeuten, dass die Platte der Engpass ist.
Metadaten und Aufbau anzeigen – wahlweise über das Gerät oder über den Mountpunkt.
 
*xfs_info /dev/sdb2
 
  
Label und UUID aller Blockgeräte:
+
==iotop – I/O je Prozess==
*lsblk -f
+
<code>iotop</code> ist <code>top</code> für Platten-I/O: es zeigt, welcher Prozess gerade wie viel liest und schreibt. Wenn eine Platte grundlos rödelt, findet man hier den Verursacher. Braucht Root-Rechte.
 +
*iotop
  
==Online vergrößern==
+
Nur die Prozesse zeigen, die tatsächlich I/O machen:
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.
+
*iotop -o
*xfs_growfs /mnt/work
 
  
==Reparieren==
+
==ioping – Latenz in Echtzeit==
Nur im '''ausgehängten''' Zustand.
+
<code>ioping</code> ist das I/O-Gegenstück zu <code>ping</code>: es schickt einzelne Anfragen an die Platte und misst die Antwortzeit jeder einzelnen. Gut, um die Reaktionszeit einer Platte zu beurteilen – bei SSDs Bruchteile einer Millisekunde, bei HDDs mehrere Millisekunden.
*umount /mnt/work
+
*ioping /dev/sdb
  
*xfs_repair /dev/sdb2
+
4 KiB <<< /dev/sdb: request time = 6.12 ms
 +
4 KiB <<< /dev/sdb: request time = 5.98 ms
  
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.
+
==lsof – wer hat was offen?==
*xfs_repair -L /dev/sdb2
+
<code>lsof</code> (''list open files'') zeigt offene Dateien und die Prozesse dahinter. Auf einen Mountpunkt angewandt ist es das Mittel gegen ein blockiertes Aushängen: es nennt den Prozess, der das Dateisystem festhält (siehe [[Linux mount und umount]]).
 +
*lsof /mnt/work
  
==Label oder UUID nachträglich ändern==
+
COMMAND  PID USER  FD  TYPE DEVICE  NODE NAME
Ohne Neuformatieren, nur im ausgehängten Zustand.
+
bash    2417 root  cwd    DIR  8,17    2 /mnt/work
*xfs_admin -L neuesLabel /dev/sdb2
 
  
*xfs_admin -U generate /dev/sdb2
+
Im Beispiel hält eine <code>bash</code> das Verzeichnis fest, weil es ihr Arbeitsverzeichnis (<code>cwd</code>) ist – nach <code>cd /</code> lässt sich aushängen.
  
==Fragmentierung==
+
=Kurzübersicht=
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.
+
{| class="wikitable"
*xfs_fsr /dev/sdb2
+
! Werkzeug !! wofür
 +
|-
 +
| <code>lsblk</code> || Blockgeräte und Mountpunkte als Baum
 +
|-
 +
| <code>blkid</code> || UUID, Label, Typ einer Partition
 +
|-
 +
| <code>file -s</code> || Dateisystem-Signatur eines Geräts, ungemountet
 +
|-
 +
| <code>findmnt</code> || eingehängte Dateisysteme durchsuchen
 +
|-
 +
| <code>df</code> || freier Platz und Inodes je Dateisystem
 +
|-
 +
| <code>du</code> / <code>ncdu</code> || Platzverbrauch von Verzeichnissen
 +
|-
 +
| <code>smartctl</code> || SMART-Gesundheitswerte einer Platte
 +
|-
 +
| <code>hdparm</code> || Platten-Parameter und Lesetempo
 +
|-
 +
| <code>iostat</code> || I/O-Rate je Gerät
 +
|-
 +
| <code>iotop</code> || I/O je Prozess
 +
|-
 +
| <code>ioping</code> || Platten-Latenz in Echtzeit
 +
|-
 +
| <code>lsof</code> || offene Dateien, Blockierer beim Aushängen
 +
|}
  
==Freeze und Unfreeze==
+
=Nachinstallieren=
Für einen konsistenten Snapshot eines laufenden Systems, etwa vor einem LVM-Snapshot. Einfrieren:
 
*xfs_freeze -f /mnt/work
 
  
Wieder auftauen:
+
Nicht alle sind vorinstalliert. Die üblichen Pakete:
*xfs_freeze -u /mnt/work
 
  
==Quota==
+
*apt install smartmontools sysstat iotop ioping ncdu hdparm
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]]
+
*dnf install smartmontools sysstat iotop ioping ncdu hdparm
[[Kategorie:Rocky Linux Kurs]]
 

Aktuelle Version vom 20. August 2026, 05:44 Uhr

Rund um Partitionen und Dateisysteme gibt es eine Reihe kleiner Werkzeuge, die man nicht täglich braucht, aber kennen sollte – zum Nachsehen, was wo liegt, wie es der Platte geht und wer gerade auf sie zugreift. Die Werkzeuge zum Anlegen und Reparieren (fdisk, gdisk, mkfs, fsck, mount) haben eigene Artikel; hier geht es ums Anschauen und Diagnostizieren.

Was liegt wo?

lsblk – Blockgeräte als Baum

lsblk zeigt alle Blockgeräte – Platten, Partitionen, LVM-Volumes, RAID-Verbünde – als Baum, samt Größe und Mountpunkt. Es liest nur aus /sys und rührt die Platten nicht an, ist also gefahrlos und der übliche erste Blick auf ein System. Mit -i zeichnet es den Baum aus einfachen ASCII-Zeichen.

  • lsblk -i
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
sda      8:0    0  50G  0 disk
|-sda1   8:1    0  49G  0 part /
`-sda2   8:2    0   1G  0 part [SWAP]
sdb      8:16   0  20G  0 disk
`-sdb1   8:17   0  20G  0 part /mnt/work

Mit -f kommen Dateisystemtyp, Label und UUID dazu – die Sicht, die man für /etc/fstab braucht.

  • lsblk -f

blkid – UUID, Label und Typ

blkid liest die Signatur eines Dateisystems und gibt UUID, Label und Typ aus – genau die Werte, mit denen man einen Eintrag in /etc/fstab baut. Ohne Argument zeigt es alle Geräte, mit Gerätenamen nur das eine.

  • blkid /dev/sdb1
/dev/sdb1: UUID="1b40fc1f-21dd-497e-9266-454f206f67b2" TYPE="ext4" PARTUUID="983b9a7b-01"

file -s – was ist das für ein Dateisystem?

file erkennt Dateitypen an ihrem Inhalt. Mit -s (special files) liest es auch Blockgeräte und sagt, was darauf liegt – ohne zu mounten. Das ist der schnellste Weg, eine unbekannte oder scheinbar leere Platte einzuordnen, etwa bevor man sie formatiert.

  • file -s /dev/sdb1
/dev/sdb1: Linux rev 1.0 ext4 filesystem data, UUID=1b40fc1f-... (extents) (64bit)

Zeigt file -s nur „data", liegt entweder kein Dateisystem darauf oder die Platte ist wirklich leer.

findmnt – aktuelle Mounts durchsuchen

findmnt stellt die eingehängten Dateisysteme als Baum dar und ist übersichtlicher als mount ohne Argumente. Mit einem Mountpunkt oder Gerät als Argument zeigt es gezielt einen Eintrag samt seiner tatsächlichen Optionen – nützlich, um zu prüfen, ob ein noexec oder ro aus der fstab wirklich greift.

  • findmnt
  • findmnt /mnt/work

df – freier Platz je Dateisystem

df (disk free) zeigt Belegung und freien Platz aller eingehängten Dateisysteme. -h macht die Zahlen lesbar (human), sonst rechnet df in 1-KiB-Blöcken.

  • df -h
Dateisystem    Größe Benutzt Verf. Verw% Eingehängt auf
/dev/sda1        49G     12G   35G   26% /
/dev/sdb1        20G    1,2G   18G    7% /mnt/work

Mit -i zählt df statt der Blöcke die Inodes. Das erklärt den klassischen Fall der vollen Platte trotz freiem Platz: Wenn viele winzige Dateien alle Inodes belegt haben, ist das Dateisystem voll, obwohl df -h noch freien Platz zeigt.

  • df -i

Ohne Filter listet df auch die vielen virtuellen Dateisysteme (tmpfs, devtmpfs, squashfs von Snap-Paketen) mit auf. -t beschränkt auf einen Typ, -x blendet einen aus – so bleibt nur das Wesentliche stehen.

  • df -h -t ext4
  • df -h -x tmpfs -x devtmpfs

du / ncdu – was belegt den Platz?

Während df das ganze Dateisystem betrachtet, geht du (disk usage) den Verzeichnisbaum durch und summiert, was einzelne Verzeichnisse verbrauchen. Der häufigste Aufruf zeigt die oberste Ebene mit lesbaren Größen; -s fasst je Argument zusammen, -h macht es lesbar.

  • du -sh /var/*
128M    /var/cache
2,1G    /var/lib
890M    /var/log

Für die reine Suche nach dem größten Brocken hilft Sortieren:

  • du -h /var | sort -rh | head -20

ncdu (NCurses du) ist die interaktive Variante: es liest den Baum einmal ein und lässt einen dann mit den Pfeiltasten hineinnavigieren, immer den größten Verbraucher oben. Der bequemste Weg, eine vollgelaufene Platte aufzuräumen.

  • ncdu /var

Was steckt in der Platte?

smartctl – Gesundheit der Platte

smartctl liest die SMART-Werte einer Platte aus – interne Zähler, die die Firmware führt: Betriebsstunden, Einschaltzyklen, wiederzugewiesene Sektoren, Lesefehler. Steigende Werte bei Reallocated_Sector_Ct oder Pending_Sector sind das deutlichste Frühwarnzeichen für eine sterbende Platte. Das Werkzeug gehört zum Paket smartmontools.

  • smartctl -a /dev/sdb

Die Gesamtbewertung allein, ohne die lange Attributliste:

  • smartctl -H /dev/sdb
SMART overall-health self-assessment test result: PASSED

Einen Selbsttest anstoßen (läuft im Hintergrund, Ergebnis später in -a):

  • smartctl -t short /dev/sdb

hdparm – Parameter und Tempo

hdparm zeigt und ändert Parameter von ATA-/SATA-Platten. -I gibt die Geräteinformationen aus (Modell, Firmware, unterstützte Funktionen), -tT misst die Lesegeschwindigkeit einmal von der Platte und einmal aus dem Cache – der schnelle Durchsatztest.

  • hdparm -I /dev/sdb
  • hdparm -tT /dev/sdb
Timing cached reads:   18000 MB in  2.00 seconds = 9000 MB/sec
Timing buffered disk reads: 450 MB in  3.01 seconds = 149 MB/sec

Vorsicht: hdparm kann mit anderen Schaltern auch schreibend Plattenparameter ändern. Zum reinen Nachsehen sind -I und -tT gefahrlos.

Wer greift auf die Platte zu?

iostat – I/O-Rate je Gerät

iostat zeigt Durchsatz und Auslastung je Platte. Der erste Ausdruck sind Mittelwerte seit dem Systemstart; mit einem Intervall dahinter kommt fortlaufend der aktuelle Wert. -x liefert die erweiterten Spalten, darunter %util (wie ausgelastet die Platte ist) und die Wartezeiten. Gehört zum Paket sysstat.

  • iostat -x 2

Interessant ist vor allem die Spalte %util: Werte dauerhaft nahe 100 % bedeuten, dass die Platte der Engpass ist.

iotop – I/O je Prozess

iotop ist top für Platten-I/O: es zeigt, welcher Prozess gerade wie viel liest und schreibt. Wenn eine Platte grundlos rödelt, findet man hier den Verursacher. Braucht Root-Rechte.

  • iotop

Nur die Prozesse zeigen, die tatsächlich I/O machen:

  • iotop -o

ioping – Latenz in Echtzeit

ioping ist das I/O-Gegenstück zu ping: es schickt einzelne Anfragen an die Platte und misst die Antwortzeit jeder einzelnen. Gut, um die Reaktionszeit einer Platte zu beurteilen – bei SSDs Bruchteile einer Millisekunde, bei HDDs mehrere Millisekunden.

  • ioping /dev/sdb
4 KiB <<< /dev/sdb: request time = 6.12 ms
4 KiB <<< /dev/sdb: request time = 5.98 ms

lsof – wer hat was offen?

lsof (list open files) zeigt offene Dateien und die Prozesse dahinter. Auf einen Mountpunkt angewandt ist es das Mittel gegen ein blockiertes Aushängen: es nennt den Prozess, der das Dateisystem festhält (siehe Linux mount und umount).

  • lsof /mnt/work
COMMAND   PID USER   FD   TYPE DEVICE  NODE NAME
bash     2417 root  cwd    DIR   8,17     2 /mnt/work

Im Beispiel hält eine bash das Verzeichnis fest, weil es ihr Arbeitsverzeichnis (cwd) ist – nach cd / lässt sich aushängen.

Kurzübersicht

Werkzeug wofür
lsblk Blockgeräte und Mountpunkte als Baum
blkid UUID, Label, Typ einer Partition
file -s Dateisystem-Signatur eines Geräts, ungemountet
findmnt eingehängte Dateisysteme durchsuchen
df freier Platz und Inodes je Dateisystem
du / ncdu Platzverbrauch von Verzeichnissen
smartctl SMART-Gesundheitswerte einer Platte
hdparm Platten-Parameter und Lesetempo
iostat I/O-Rate je Gerät
iotop I/O je Prozess
ioping Platten-Latenz in Echtzeit
lsof offene Dateien, Blockierer beim Aushängen

Nachinstallieren

Nicht alle sind vorinstalliert. Die üblichen Pakete:

  • apt install smartmontools sysstat iotop ioping ncdu hdparm
  • dnf install smartmontools sysstat iotop ioping ncdu hdparm