Ext4: Unterschied zwischen den Versionen

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen
 
(5 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
=ext4 Eigenschaften=
+
Ext4 ist das am weitesten verbreitete Dateisystem unter Linux und in den meisten Distributionen die Voreinstellung. Dieser Artikel behandelt die Eigenschaften von ext4 und die Werkzeuge zum Anlegen (<code>mkfs.ext4</code>), Abstimmen (<code>tune2fs</code>), Prüfen (<code>fsck.ext4</code>) und Ansehen (<code>dumpe2fs</code>, <code>debugfs</code>) eines Dateisystems. Der Aufbau eines ext-Dateisystems – Inodes, Superblock, Blockgruppen – ist im Artikel [[Linux Dateisystem Aufbau]] beschrieben.
==Was ist das?==
+
 
Ext4 ist ein weit verbreitetes Dateisystem für Linux-Betriebssysteme. Es wurde als Nachfolger des älteren Ext3-Dateisystems entwickelt und bietet zahlreiche Verbesserungen und zusätzliche Funktionen. Hier sind die wichtigsten Eigenschaften von Ext4:
+
=Eigenschaften von ext4=
 +
 
 +
Ext4 wurde als Nachfolger von Ext3 entwickelt und bringt gegenüber diesem eine Reihe von Verbesserungen mit.
  
 
==Größere Dateisysteme==
 
==Größere Dateisysteme==
*Ext4 verwaltet sehr große Dateisysteme: bis zu 1 Exbibyte (EiB) pro Dateisystem und bis zu 16 Tebibyte (TiB) pro Datei.
+
*Ext4 verwaltet bis zu 1 Exbibyte (EiB) pro Dateisystem und bis zu 16 Tebibyte (TiB) pro Datei.
 
*Die 16 TiB je Datei gelten bei der üblichen Blockgröße von 4 KiB. Bei kleineren Blöcken sinkt der Wert entsprechend.
 
*Die 16 TiB je Datei gelten bei der üblichen Blockgröße von 4 KiB. Bei kleineren Blöcken sinkt der Wert entsprechend.
  
Zeile 11: Zeile 13:
 
*Erreicht wird das vor allem durch '''Extents''' (zusammenhängende Blockbereiche statt einzelner Block-für-Block-Verweise), '''Multiblock-Allokation''' (mehrere Blöcke werden in einem Schritt reserviert) und '''Delayed Allocation''' (die Zuordnung auf der Platte wird bis zum Schreiben aufgeschoben, was Fragmentierung verringert).
 
*Erreicht wird das vor allem durch '''Extents''' (zusammenhängende Blockbereiche statt einzelner Block-für-Block-Verweise), '''Multiblock-Allokation''' (mehrere Blöcke werden in einem Schritt reserviert) und '''Delayed Allocation''' (die Zuordnung auf der Platte wird bis zum Schreiben aufgeschoben, was Fragmentierung verringert).
  
==Dateisystemjournaling==
+
==Journaling==
 
*Ext4 führt ein Journal, das nach einem Absturz die Konsistenz sicherstellt und langwierige komplette Prüfungen erspart.
 
*Ext4 führt ein Journal, das nach einem Absturz die Konsistenz sicherstellt und langwierige komplette Prüfungen erspart.
*Es gibt drei Modi: '''journal''' (Metadaten '''und''' Daten werden ins Journal geschrieben, am sichersten, aber am langsamsten), '''ordered''' (nur Metadaten ins Journal, Daten werden vorher geschrieben – der voreingestellte Kompromiss) und '''writeback''' (nur Metadaten, ohne Reihenfolgegarantie – am schnellsten, aber nach einem Absturz können alte Daten in neuen Dateien stehen).
+
*Es gibt drei Modi: '''journal''' (Metadaten '''und''' Daten ins Journal, am sichersten, aber am langsamsten), '''ordered''' (nur Metadaten ins Journal, Daten werden vorher geschrieben – der voreingestellte Kompromiss) und '''writeback''' (nur Metadaten, ohne Reihenfolgegarantie – am schnellsten, aber nach einem Absturz können alte Daten in neuen Dateien stehen).
  
 
==Online-Defragmentierung==
 
==Online-Defragmentierung==
Zeile 28: Zeile 30:
 
*Ext4 ist mit Ext3 und Ext2 kompatibel. Ein bestehendes Ext3- oder Ext2-Dateisystem lässt sich zu Ext4 aufrüsten, indem die neuen Features nachträglich eingeschaltet werden.
 
*Ext4 ist mit Ext3 und Ext2 kompatibel. Ein bestehendes Ext3- oder Ext2-Dateisystem lässt sich zu Ext4 aufrüsten, indem die neuen Features nachträglich eingeschaltet werden.
  
==Zusammenfassend==
+
=Ein Dateisystem anlegen: mkfs.ext4=
*Diese Eigenschaften machen Ext4 zu einem robusten und leistungsfähigen Dateisystem für Linux.
 
*Es ist in vielen Distributionen die Voreinstellung und eignet sich wegen seiner Stabilität und Skalierbarkeit für Desktop wie Server.
 
  
=ext4 erstellen eines Dateisystem=
 
==Allgemein==
 
 
<code>mkfs.ext4</code> legt ein ext4-Dateisystem auf einer Partition oder einem Gerät an. Der Aufruf ohne Optionen genügt für den Normalfall – Blockgröße, Anzahl der Inodes und die übrigen Kennwerte werden aus der Gerätegröße abgeleitet.
 
<code>mkfs.ext4</code> legt ein ext4-Dateisystem auf einer Partition oder einem Gerät an. Der Aufruf ohne Optionen genügt für den Normalfall – Blockgröße, Anzahl der Inodes und die übrigen Kennwerte werden aus der Gerätegröße abgeleitet.
  
 
'''Achtung:''' <code>mkfs.ext4</code> fragt nicht nach und überschreibt ein vorhandenes Dateisystem sofort. Das Ziel muss die gewünschte Partition sein (z. B. <code>/dev/sdg1</code>), nicht die ganze Platte, außer man will das Dateisystem wirklich ohne Partitionstabelle direkt aufs Gerät legen.
 
'''Achtung:''' <code>mkfs.ext4</code> fragt nicht nach und überschreibt ein vorhandenes Dateisystem sofort. Das Ziel muss die gewünschte Partition sein (z. B. <code>/dev/sdg1</code>), nicht die ganze Platte, außer man will das Dateisystem wirklich ohne Partitionstabelle direkt aufs Gerät legen.
  
=Ein ext4-Dateisystem anlegen=
+
==Ein ext4-Dateisystem anlegen==
 
*mkfs.ext4 /dev/sdg1
 
*mkfs.ext4 /dev/sdg1
  
Zeile 51: Zeile 49:
 
  Writing superblocks and filesystem accounting information: done
 
  Writing superblocks and filesystem accounting information: done
  
Aus der Ausgabe lässt sich schon einiges ablesen: die Blockgröße (4k), die Zahl der Blöcke und Inodes, die UUID und die Blöcke, auf denen die Superblock-Kopien liegen – genau die aus dem Artikel zum Dateisystem-Aufbau.
+
Aus der Ausgabe lässt sich schon einiges ablesen: die Blockgröße (4k), die Zahl der Blöcke und Inodes, die UUID und die Blöcke, auf denen die Superblock-Kopien liegen.
  
 
==Wichtige Optionen==
 
==Wichtige Optionen==
Zeile 108: Zeile 106:
 
*mkfs.ext4 -n /dev/sdg1
 
*mkfs.ext4 -n /dev/sdg1
  
==Kontrolle nach dem Anlegen==
+
=Ein Dateisystem abstimmen: tune2fs=
Die Kennwerte des fertigen Dateisystems zeigt <code>dumpe2fs</code> im Kopfbereich.
+
 
 +
<code>tune2fs</code> ändert die Parameter eines bestehenden ext2/ext3/ext4-Dateisystems, ohne es neu anzulegen. Angewendet wird es auf die Partition, nicht auf ein gemountetes Verzeichnis. Die meisten Änderungen sind auch im eingehängten Zustand möglich; Ausnahmen nennt <code>tune2fs</code> selbst.
 +
 
 +
==Anzeigen von Informationen==
 +
Zeigt den Superblock-Inhalt: UUID, Label, Block- und Inode-Zahl, Features, Zähler und Prüfintervalle.
 +
*tune2fs -l /dev/sdg1
 +
 
 +
==Maximale Mount-Zahl bis zur Zwangsprüfung==
 +
Nach so vielen Mount-Vorgängen erzwingt das System beim nächsten Start eine Prüfung mit <code>fsck</code>. Hier: alle 30 Mounts.
 +
*tune2fs -c 30 /dev/sdg1
 +
 
 +
Auf den meisten aktuellen Distributionen ist diese Zwangsprüfung abgeschaltet (Wert 0), weil ein fsck-Lauf beim Booten unerwünscht ist. Abschalten:
 +
*tune2fs -c 0 /dev/sdg1
 +
 
 +
==Zeitintervall bis zur Zwangsprüfung==
 +
Prüfung nach einer festen Zeitspanne statt nach Mount-Zahl. Hier: alle zwei Monate (<code>d</code> Tage, <code>w</code> Wochen, <code>m</code> Monate).
 +
*tune2fs -i 2m /dev/sdg1
 +
 
 +
Auch dieses Intervall ist meist auf 0 gesetzt. Abschalten:
 +
*tune2fs -i 0 /dev/sdg1
 +
 
 +
==Größe des Journals festlegen==
 +
Legt die Größe des Journals fest, hier 32 MiB. Das ist die Größe des Journals selbst, kein Cache.
 +
*tune2fs -J size=32m /dev/sdg1
 +
 
 +
==Journaling ein- oder ausschalten==
 +
Journaling einschalten (macht aus ext2 praktisch ext3):
 +
*tune2fs -O has_journal /dev/sdg1
 +
 
 +
Journaling ausschalten – das vorangestellte <code>^</code> entfernt ein Feature:
 +
*tune2fs -O ^has_journal /dev/sdg1
 +
 
 +
==Dateisystem-Label ändern==
 +
Setzt das Label, über das die Partition auch in <code>/etc/fstab</code> als <code>LABEL=</code> angesprochen werden kann.
 +
*tune2fs -L daten-platte /dev/sdg1
 +
 
 +
==Für root reservierten Anteil ändern==
 +
<code>-m</code> setzt den Prozentsatz der Blöcke, die dem Superuser vorbehalten bleiben (Vorgabe 5 %). Das ist '''nicht''' die Zahl der erlaubten Mounts – die regelt <code>-c</code>. Auf reinen Datenplatten kann man den Wert senken:
 +
*tune2fs -m 1 /dev/sdg1
 +
 
 +
Denselben Anteil als feste Blockzahl statt in Prozent setzt <code>-r</code>.
 +
 
 +
==UUID ändern==
 +
Setzt eine neue UUID; <code>random</code> würfelt eine. Nötig etwa, nachdem eine Platte geklont wurde und zwei Dateisysteme dieselbe UUID tragen.
 +
*tune2fs -U random /dev/sdg1
 +
 
 +
=Ein Dateisystem prüfen und reparieren: fsck.ext4=
 +
 
 +
<code>fsck.ext4</code> (auch als <code>e2fsck</code>) prüft ein ext2/ext3/ext4-Dateisystem auf Fehler und repariert sie. Aufgerufen wird es auf der Partition, nicht auf einem Verzeichnis.
 +
 
 +
'''Achtung – nur im ausgehängten Zustand:''' Eine gemountete Partition darf man '''nicht''' reparieren. fsck arbeitet direkt auf den Strukturen der Platte; laufen gleichzeitig Schreibzugriffe des Kernels, zerstört das das Dateisystem. Vor der Prüfung also aushängen:
 +
 
 +
==Partition aushängen==
 +
*umount /dev/sdg1
 +
 
 +
Nur-Lesen-Prüfungen (<code>-n</code>) sind auch im gemounteten Zustand gefahrlos, weil sie nichts schreiben – die Ergebnisse können dann aber ungenau sein, weil sich das Dateisystem unter der Prüfung ändert.
 +
 
 +
==Optionen==
 +
 
 +
{| class="wikitable"
 +
! Option !! Beschreibung
 +
|-
 +
| <code>-p</code> || Automatische Reparatur ''(preen)''. Behebt alle eindeutigen Fehler ohne Rückfrage und ist der empfohlene Weg für Skripte und den Boot-Vorgang. Bei mehrdeutigen Schäden bricht fsck ab und verlangt einen manuellen Lauf.
 +
|-
 +
| <code>-a</code> || Wie <code>-p</code>, aber die ältere Form. Nur aus Kompatibilität vorhanden; man nimmt <code>-p</code>.
 +
|-
 +
| <code>-y</code> || Beantwortet '''alle''' Rückfragen mit „Ja". Für den manuellen Lauf an einem beschädigten Dateisystem, wenn man alle Korrekturen zulassen will.
 +
|-
 +
| <code>-n</code> || Öffnet das Dateisystem nur lesend und beantwortet alle Fragen mit „Nein". Prüft, ohne etwas zu ändern.
 +
|-
 +
| <code>-f</code> || Erzwingt eine vollständige Prüfung, auch wenn das Dateisystem als sauber markiert ist.
 +
|-
 +
| <code>-c</code> || Sucht zusätzlich mit <code>badblocks</code> nach defekten Blöcken und trägt sie aus.
 +
|-
 +
| <code>-v</code> || Ausführliche Ausgabe.
 +
|}
 +
 
 +
<code>-y</code> und <code>-n</code> schließen sich aus, ebenso <code>-p</code> und <code>-y</code>. Man wählt eine Betriebsart.
 +
 
 +
==Beispiele==
 +
 
 +
===Vollständige Prüfung ohne Änderung===
 +
Der sichere Einstieg: zeigt gefundene Fehler an, schreibt aber nichts. Auch im gemounteten Zustand unbedenklich.
 +
*fsck.ext4 -n /dev/sdg1
 +
 
 +
===Erzwungene Prüfung===
 +
Prüft auch dann durch, wenn das Dateisystem als sauber markiert ist – etwa wenn man trotz „clean"-Status Zweifel hat.
 +
*fsck.ext4 -f /dev/sdg1
 +
 
 +
===Automatische Reparatur===
 +
Behebt alle eindeutigen Fehler ohne Rückfrage. Der übliche Weg für einen unbeaufsichtigten Lauf.
 +
*fsck.ext4 -p /dev/sdg1
 +
 
 +
===Manuelle Reparatur, alles bestätigen===
 +
Beantwortet jede Rückfrage mit „Ja". Für den Fall, dass <code>-p</code> abgebrochen hat und man die Reparatur von Hand zulässt.
 +
*fsck.ext4 -y /dev/sdg1
 +
 
 +
===Vollständige Prüfung mit Suche nach defekten Blöcken===
 +
*fsck.ext4 -cf /dev/sdg1
 +
 
 +
==Wenn der Superblock beschädigt ist==
 +
Ist der primäre Superblock zerstört, findet fsck das Dateisystem nicht mehr. Dann greift man auf eine der Kopien zurück, deren Lage <code>mkfs</code> beim Anlegen ausgegeben hat (und die <code>dumpe2fs</code> oder <code>mkfs -n</code> anzeigen). Die erste Kopie liegt meist auf Block 32768:
 +
*fsck.ext4 -b 32768 /dev/sdg1
 +
 
 +
=Ein Dateisystem ansehen: dumpe2fs und debugfs=
 +
 
 +
<code>dumpe2fs</code> und <code>debugfs</code> zeigen die internen Strukturen eines ext-Dateisystems – Superblock, Gruppen, Inodes, Verzeichnisse. <code>dumpe2fs</code> liest nur; <code>debugfs</code> kann im Ernstfall auch schreiben und ist damit ein Werkzeug für Datenrettung. Beide setzen an der Partition an, nicht am Mountpunkt.
 +
 
 +
'''Achtung:''' Schreibende <code>debugfs</code>-Zugriffe (mit <code>-w</code>) gehören nur an ein '''ausgehängtes''' Dateisystem. Lesend ist <code>debugfs</code> auch am gemounteten gefahrlos, kann dann aber veraltete Werte zeigen.
 +
 
 +
==dumpe2fs: Kennwerte lesen==
 +
 
 +
===Nur den Superblock===
 +
Zeigt UUID, Label, Block- und Inode-Zahl, Features, Journalgröße und Prüfintervalle – ohne die lange Gruppenliste.
 
*dumpe2fs -h /dev/sdg1
 
*dumpe2fs -h /dev/sdg1
  
=ext4 tuning eines Dateisystem=
+
===Alles inklusive Blockgruppen===
=ext4 Reparatur=
+
Zeigt zusätzlich für jede Gruppe die Lage von Superblock-Kopie, Bitmaps und Inode-Tabelle sowie die freien Blöcke und Inodes.
=Aufgaben ext4=
+
*dumpe2fs /dev/sdg1
 +
 
 +
===Nur die Lage der Superblock-Kopien===
 +
Praktisch, um für eine Reparatur mit <code>fsck -b</code> eine Backup-Kopie zu finden.
 +
*dumpe2fs /dev/sdg1 | grep -i superblock
 +
 
 +
==debugfs: interaktiv im Dateisystem==
 +
 
 +
<code>debugfs</code> öffnet das Dateisystem und wartet dann auf Kommandos. Ohne <code>-w</code> ist es schreibgeschützt.
 +
 
 +
===Dateisystem lesend öffnen===
 +
*debugfs /dev/sdg1
 +
 
 +
debugfs 1.47.0 (5-Feb-2023)
 +
debugfs:
 +
 
 +
Innerhalb von <code>debugfs</code> stehen unter anderem diese Kommandos zur Verfügung:
 +
 
 +
{| class="wikitable"
 +
! Kommando !! Wirkung
 +
|-
 +
| <code>stat &lt;NUMMER&gt;</code> || Inode anzeigen: Typ, Rechte, Link Count, Blöcke, Zeitstempel
 +
|-
 +
| <code>ls -l</code> || Verzeichnisinhalt mit Inode-Nummern
 +
|-
 +
| <code>ncheck NUMMER</code> || zu einer Inode-Nummer den Pfad suchen
 +
|-
 +
| <code>imap &lt;NUMMER&gt;</code> || in welcher Gruppe und an welchem Byte der Inode liegt
 +
|-
 +
| <code>blocks &lt;NUMMER&gt;</code> || die von einer Datei belegten Blocknummern
 +
|-
 +
| <code>cat &lt;NUMMER&gt;</code> || Inhalt einer Datei über ihre Inode-Nummer ausgeben
 +
|-
 +
| <code>freei &lt;NUMMER&gt;</code> || Inode als frei markieren (nur mit <code>-w</code>)
 +
|-
 +
| <code>undel</code> || gelöschte Datei wiederherstellen (nur mit <code>-w</code>)
 +
|-
 +
| <code>q</code> || debugfs verlassen
 +
|}
 +
 
 +
===Einen Inode direkt ansehen===
 +
Die spitzen Klammern bedeuten „Inode-Nummer", ohne Klammern wäre es ein Dateiname.
 +
*debugfs -R "stat <4711>" /dev/sdg1
 +
 
 +
===Zu einer Inode-Nummer den Pfad finden===
 +
Zeigt, welche Datei zu einer Inode-Nummer gehört – etwa, wenn <code>fsck</code> eine Nummer gemeldet hat.
 +
*debugfs -R "ncheck 4711" /dev/sdg1
 +
 
 +
===Zum Schreiben öffnen (Datenrettung)===
 +
Nur am ausgehängten Dateisystem. Mit <code>-w</code> lassen sich gelöschte Dateien mit <code>undel</code> zurückholen, solange ihre Blöcke noch nicht überschrieben sind.
 +
*debugfs -w /dev/sdg1
 +
 
 +
=Aufgaben=
 +
 
 +
Vorbereitung: Auf <code>/dev/sdb</code> müssen drei Partitionen angelegt sein (<code>/dev/sdb1</code> bis <code>/dev/sdb3</code>). Falls nicht, zuerst mit <code>fdisk</code> oder <code>gdisk</code> anlegen. '''Wichtig:''' immer die Partition ansprechen (<code>/dev/sdb1</code>), nie die ganze Platte (<code>/dev/sdb</code>) – sonst wird die Partitionstabelle überschrieben.
 +
 
 +
==Dateisysteme anlegen==
 +
 
 +
* Erstellen Sie ein ext4-Dateisystem auf der 1. Partition von /dev/sdb.
 +
<!-- Lösung: mkfs.ext4 /dev/sdb1 -->
 +
 
 +
* Erstellen Sie ein ext4-Dateisystem auf der 2. Partition mit einer Blockgröße von 2048.
 +
<!-- Lösung: mkfs.ext4 -b 2048 /dev/sdb2 -->
 +
 
 +
* Erstellen Sie ein ext4-Dateisystem auf der 3. Partition mit 3072 Inodes.
 +
<!-- Lösung: mkfs.ext4 -N 3072 /dev/sdb3 -->
 +
 
 +
* Lassen Sie sich vor dem Anlegen nur anzeigen, was mkfs auf der 1. Partition tun würde, ohne zu schreiben.
 +
<!-- Lösung: mkfs.ext4 -n /dev/sdb1 -->
 +
 
 +
==Dateisysteme abstimmen==
 +
 
 +
* Ändern Sie das Label des Dateisystems auf der 1. Partition zu "daten-platte".
 +
<!-- Lösung: tune2fs -L daten-platte /dev/sdb1 -->
 +
 
 +
* Stellen Sie die maximale Mount-Zahl bis zur Zwangsprüfung auf 30 für die 2. Partition ein.
 +
<!-- Lösung: tune2fs -c 30 /dev/sdb2 -->
 +
 
 +
* Stellen Sie das Prüfintervall auf 2 Monate für die 3. Partition ein.
 +
<!-- Lösung: tune2fs -i 2m /dev/sdb3 -->
 +
 
 +
* Senken Sie den für root reservierten Anteil auf der 1. Partition auf 1 Prozent.
 +
<!-- Lösung: tune2fs -m 1 /dev/sdb1 -->
 +
 
 +
==Dateisysteme ansehen==
 +
 
 +
* Zeigen Sie den Superblock (nur den Kopf) der 1. Partition an und prüfen Sie, ob das Label "daten-platte" gesetzt ist.
 +
<!-- Lösung: dumpe2fs -h /dev/sdb1 -->
 +
 
 +
* Finden Sie heraus, auf welchen Blöcken die Superblock-Kopien der 2. Partition liegen.
 +
<!-- Lösung: dumpe2fs /dev/sdb2 | grep -i superblock -->
 +
 
 +
* Sehen Sie sich mit debugfs den Wurzel-Inode (Nummer 2) der 1. Partition an.
 +
<!-- Lösung: debugfs -R "stat <2>" /dev/sdb1 -->
 +
 
 +
==Dateisysteme prüfen==
 +
 
 +
Hinweis: fsck nur auf ausgehängten Partitionen ausführen. Falls eine Partition gemountet ist, vorher <code>umount</code>.
 +
 
 +
* Führen Sie eine Überprüfung des Dateisystems auf der 1. Partition durch.
 +
<!-- Lösung: fsck.ext4 /dev/sdb1 -->
 +
 
 +
* Führen Sie eine erzwungene Überprüfung der 2. Partition durch.
 +
<!-- Lösung: fsck.ext4 -f /dev/sdb2 -->
 +
 
 +
* Prüfen Sie die 3. Partition, ohne Änderungen vorzunehmen.
 +
<!-- Lösung: fsck.ext4 -n /dev/sdb3 -->
 +
 
 +
* Reparieren Sie die 1. Partition über eine Superblock-Kopie (Block 32768), als wäre der primäre Superblock beschädigt.
 +
<!-- Lösung: fsck.ext4 -b 32768 /dev/sdb1 -->
 +
 
 +
==Zusammenhängende Aufgabe==
 +
 
 +
Diese Aufgabe verbindet alle Werkzeuge zu einem durchgehenden Ablauf auf der 2. Partition.
 +
 
 +
* Legen Sie auf /dev/sdb2 ein ext4-Dateisystem mit dem Label "archiv" und einer für root reservierten Quote von 0 Prozent an.
 +
<!-- Lösung: mkfs.ext4 -L archiv -m 0 /dev/sdb2 -->
 +
 
 +
* Notieren Sie sich aus der Ausgabe die UUID und den ersten Superblock-Backup-Block.
 +
<!-- Lösung: aus der mkfs-Ausgabe ablesen, alternativ: dumpe2fs -h /dev/sdb2 -->
 +
 
 +
* Kontrollieren Sie mit dumpe2fs, dass Label und Reservat stimmen.
 +
<!-- Lösung: dumpe2fs -h /dev/sdb2 | grep -iE 'volume name|reserved block count' -->
 +
 
 +
* Schalten Sie die Zwangsprüfung nach Mount-Zahl und nach Zeit ganz ab.
 +
<!-- Lösung: tune2fs -c 0 -i 0 /dev/sdb2 -->
 +
 
 +
* Erzwingen Sie eine vollständige Prüfung des frisch angelegten Dateisystems.
 +
<!-- Lösung: fsck.ext4 -f /dev/sdb2 -->
  
*[[ext4 Eigenschaften]]
+
* Öffnen Sie das Dateisystem mit debugfs und lassen Sie sich den Wurzel-Inode anzeigen.
*[[ext4 erstellen eines Dateisystem]]
+
<!-- Lösung: debugfs -R "stat <2>" /dev/sdb2 -->
*[[ext4 tuning eines Dateisystem]]
 
*[[ext4 Reparatur]]
 
*[[Aufgaben ext4]]
 

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

Ext4 ist das am weitesten verbreitete Dateisystem unter Linux und in den meisten Distributionen die Voreinstellung. Dieser Artikel behandelt die Eigenschaften von ext4 und die Werkzeuge zum Anlegen (mkfs.ext4), Abstimmen (tune2fs), Prüfen (fsck.ext4) und Ansehen (dumpe2fs, debugfs) eines Dateisystems. Der Aufbau eines ext-Dateisystems – Inodes, Superblock, Blockgruppen – ist im Artikel Linux Dateisystem Aufbau beschrieben.

Eigenschaften von ext4

Ext4 wurde als Nachfolger von Ext3 entwickelt und bringt gegenüber diesem eine Reihe von Verbesserungen mit.

Größere Dateisysteme

  • Ext4 verwaltet bis zu 1 Exbibyte (EiB) pro Dateisystem und bis zu 16 Tebibyte (TiB) pro Datei.
  • Die 16 TiB je Datei gelten bei der üblichen Blockgröße von 4 KiB. Bei kleineren Blöcken sinkt der Wert entsprechend.

Verbesserte Leistung

  • Ext4 arbeitet schneller als Ext3, besonders bei großen Dateisystemen und bei vielen Dateioperationen wie dem Anlegen und Löschen.
  • Erreicht wird das vor allem durch Extents (zusammenhängende Blockbereiche statt einzelner Block-für-Block-Verweise), Multiblock-Allokation (mehrere Blöcke werden in einem Schritt reserviert) und Delayed Allocation (die Zuordnung auf der Platte wird bis zum Schreiben aufgeschoben, was Fragmentierung verringert).

Journaling

  • Ext4 führt ein Journal, das nach einem Absturz die Konsistenz sicherstellt und langwierige komplette Prüfungen erspart.
  • Es gibt drei Modi: journal (Metadaten und Daten ins Journal, am sichersten, aber am langsamsten), ordered (nur Metadaten ins Journal, Daten werden vorher geschrieben – der voreingestellte Kompromiss) und writeback (nur Metadaten, ohne Reihenfolgegarantie – am schnellsten, aber nach einem Absturz können alte Daten in neuen Dateien stehen).

Online-Defragmentierung

  • Fragmentierte Dateien lassen sich im laufenden Betrieb neu ordnen, ohne das Dateisystem auszuhängen. Das Werkzeug dazu ist e4defrag.

Erweiterte Attribute

  • Ext4 speichert erweiterte Attribute (xattr) – zusätzliche Metadaten an Dateien und Verzeichnissen. Darauf setzen unter anderem SELinux-Kontexte, POSIX-ACLs und Capabilities auf.

Verschlüsselung

  • Ext4 kann einzelne Verzeichnisse auf Dateiebene verschlüsseln (fscrypt). Das Feature muss beim Anlegen aktiviert sein (-O encrypt).
  • Das ist etwas anderes als LUKS/dm-crypt: LUKS verschlüsselt das gesamte Blockgerät unter dem Dateisystem, fscrypt einzelne Verzeichnisse im Dateisystem.

Rückwärtskompatibilität

  • Ext4 ist mit Ext3 und Ext2 kompatibel. Ein bestehendes Ext3- oder Ext2-Dateisystem lässt sich zu Ext4 aufrüsten, indem die neuen Features nachträglich eingeschaltet werden.

Ein Dateisystem anlegen: mkfs.ext4

mkfs.ext4 legt ein ext4-Dateisystem auf einer Partition oder einem Gerät an. Der Aufruf ohne Optionen genügt für den Normalfall – Blockgröße, Anzahl der Inodes und die übrigen Kennwerte werden aus der Gerätegröße abgeleitet.

Achtung: mkfs.ext4 fragt nicht nach und überschreibt ein vorhandenes Dateisystem sofort. Das Ziel muss die gewünschte Partition sein (z. B. /dev/sdg1), nicht die ganze Platte, außer man will das Dateisystem wirklich ohne Partitionstabelle direkt aufs Gerät legen.

Ein ext4-Dateisystem anlegen

  • mkfs.ext4 /dev/sdg1
mke2fs 1.47.0 (5-Feb-2023)
Creating filesystem with 2621440 4k blocks and 655360 inodes
Filesystem UUID: 1b40fc1f-21dd-497e-9266-454f206f67b2
Superblock backups stored on blocks: 
	32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (16384 blocks): done
Writing superblocks and filesystem accounting information: done

Aus der Ausgabe lässt sich schon einiges ablesen: die Blockgröße (4k), die Zahl der Blöcke und Inodes, die UUID und die Blöcke, auf denen die Superblock-Kopien liegen.

Wichtige Optionen

Option Erklärung
-b BLOCKSIZE Blockgröße in Byte: 1024, 2048 oder 4096
-L LABEL Volume-Label setzen
-U UUID UUID setzen (random für einen Zufallswert)
-N ANZAHL feste Anzahl der Inodes
-i BYTES ein Inode je so viele Byte – je größer der Wert, desto weniger Inodes
-m PROZENT für root reservierter Anteil (Vorgabe 5 %)
-T TYP Verwendungszweck: small, floppy, news u. a. – steuert die Inode-Dichte
-E OPTION erweiterte Optionen, z. B. -E lazy_itable_init=0
-O FEATURE Feature ein- oder ausschalten, z. B. -O encrypt oder -O ^has_journal
-n nichts anlegen, nur anzeigen, was geschähe (u. a. die Lage der Superblock-Kopien)

-N und -i steuern beide die Zahl der Inodes, aber auf verschiedene Weise: -N gibt die Zahl direkt vor, -i gibt an, für wie viele Byte Nutzdaten ein Inode angelegt wird. Beides zusammen anzugeben ergibt keinen Sinn.

Beispiele

Mit festgelegter Blockgröße

Erlaubt sind 1024, 2048 oder 4096 Byte pro Block.

  • mkfs.ext4 -b 2048 /dev/sdg1

Mit fester Anzahl der Inodes

  • mkfs.ext4 -N 3072 /dev/sdg1

Mit Byte pro Inode

Je größer die Zahl, desto weniger Inodes werden angelegt.

  • mkfs.ext4 -i 1024 /dev/sdg1

Mit Volume-Label

  • mkfs.ext4 -L daten-platte /dev/sdg1

Mit vorgegebener UUID

  • mkfs.ext4 -U 3c52166d-7803-42f4-952a-88bf43e11268 /dev/sdg1

Mit geändertem Reservat für root

Standard sind 5 %. Auf reinen Datenplatten ohne Systemdateien kann man den Wert senken.

  • mkfs.ext4 -m 1 /dev/sdg1

Nur anzeigen, nichts schreiben

Zeigt die geplanten Kennwerte und die Lage der Superblock-Kopien, ohne die Platte zu verändern.

  • mkfs.ext4 -n /dev/sdg1

Ein Dateisystem abstimmen: tune2fs

tune2fs ändert die Parameter eines bestehenden ext2/ext3/ext4-Dateisystems, ohne es neu anzulegen. Angewendet wird es auf die Partition, nicht auf ein gemountetes Verzeichnis. Die meisten Änderungen sind auch im eingehängten Zustand möglich; Ausnahmen nennt tune2fs selbst.

Anzeigen von Informationen

Zeigt den Superblock-Inhalt: UUID, Label, Block- und Inode-Zahl, Features, Zähler und Prüfintervalle.

  • tune2fs -l /dev/sdg1

Maximale Mount-Zahl bis zur Zwangsprüfung

Nach so vielen Mount-Vorgängen erzwingt das System beim nächsten Start eine Prüfung mit fsck. Hier: alle 30 Mounts.

  • tune2fs -c 30 /dev/sdg1

Auf den meisten aktuellen Distributionen ist diese Zwangsprüfung abgeschaltet (Wert 0), weil ein fsck-Lauf beim Booten unerwünscht ist. Abschalten:

  • tune2fs -c 0 /dev/sdg1

Zeitintervall bis zur Zwangsprüfung

Prüfung nach einer festen Zeitspanne statt nach Mount-Zahl. Hier: alle zwei Monate (d Tage, w Wochen, m Monate).

  • tune2fs -i 2m /dev/sdg1

Auch dieses Intervall ist meist auf 0 gesetzt. Abschalten:

  • tune2fs -i 0 /dev/sdg1

Größe des Journals festlegen

Legt die Größe des Journals fest, hier 32 MiB. Das ist die Größe des Journals selbst, kein Cache.

  • tune2fs -J size=32m /dev/sdg1

Journaling ein- oder ausschalten

Journaling einschalten (macht aus ext2 praktisch ext3):

  • tune2fs -O has_journal /dev/sdg1

Journaling ausschalten – das vorangestellte ^ entfernt ein Feature:

  • tune2fs -O ^has_journal /dev/sdg1

Dateisystem-Label ändern

Setzt das Label, über das die Partition auch in /etc/fstab als LABEL= angesprochen werden kann.

  • tune2fs -L daten-platte /dev/sdg1

Für root reservierten Anteil ändern

-m setzt den Prozentsatz der Blöcke, die dem Superuser vorbehalten bleiben (Vorgabe 5 %). Das ist nicht die Zahl der erlaubten Mounts – die regelt -c. Auf reinen Datenplatten kann man den Wert senken:

  • tune2fs -m 1 /dev/sdg1

Denselben Anteil als feste Blockzahl statt in Prozent setzt -r.

UUID ändern

Setzt eine neue UUID; random würfelt eine. Nötig etwa, nachdem eine Platte geklont wurde und zwei Dateisysteme dieselbe UUID tragen.

  • tune2fs -U random /dev/sdg1

Ein Dateisystem prüfen und reparieren: fsck.ext4

fsck.ext4 (auch als e2fsck) prüft ein ext2/ext3/ext4-Dateisystem auf Fehler und repariert sie. Aufgerufen wird es auf der Partition, nicht auf einem Verzeichnis.

Achtung – nur im ausgehängten Zustand: Eine gemountete Partition darf man nicht reparieren. fsck arbeitet direkt auf den Strukturen der Platte; laufen gleichzeitig Schreibzugriffe des Kernels, zerstört das das Dateisystem. Vor der Prüfung also aushängen:

Partition aushängen

  • umount /dev/sdg1

Nur-Lesen-Prüfungen (-n) sind auch im gemounteten Zustand gefahrlos, weil sie nichts schreiben – die Ergebnisse können dann aber ungenau sein, weil sich das Dateisystem unter der Prüfung ändert.

Optionen

Option Beschreibung
-p Automatische Reparatur (preen). Behebt alle eindeutigen Fehler ohne Rückfrage und ist der empfohlene Weg für Skripte und den Boot-Vorgang. Bei mehrdeutigen Schäden bricht fsck ab und verlangt einen manuellen Lauf.
-a Wie -p, aber die ältere Form. Nur aus Kompatibilität vorhanden; man nimmt -p.
-y Beantwortet alle Rückfragen mit „Ja". Für den manuellen Lauf an einem beschädigten Dateisystem, wenn man alle Korrekturen zulassen will.
-n Öffnet das Dateisystem nur lesend und beantwortet alle Fragen mit „Nein". Prüft, ohne etwas zu ändern.
-f Erzwingt eine vollständige Prüfung, auch wenn das Dateisystem als sauber markiert ist.
-c Sucht zusätzlich mit badblocks nach defekten Blöcken und trägt sie aus.
-v Ausführliche Ausgabe.

-y und -n schließen sich aus, ebenso -p und -y. Man wählt eine Betriebsart.

Beispiele

Vollständige Prüfung ohne Änderung

Der sichere Einstieg: zeigt gefundene Fehler an, schreibt aber nichts. Auch im gemounteten Zustand unbedenklich.

  • fsck.ext4 -n /dev/sdg1

Erzwungene Prüfung

Prüft auch dann durch, wenn das Dateisystem als sauber markiert ist – etwa wenn man trotz „clean"-Status Zweifel hat.

  • fsck.ext4 -f /dev/sdg1

Automatische Reparatur

Behebt alle eindeutigen Fehler ohne Rückfrage. Der übliche Weg für einen unbeaufsichtigten Lauf.

  • fsck.ext4 -p /dev/sdg1

Manuelle Reparatur, alles bestätigen

Beantwortet jede Rückfrage mit „Ja". Für den Fall, dass -p abgebrochen hat und man die Reparatur von Hand zulässt.

  • fsck.ext4 -y /dev/sdg1

Vollständige Prüfung mit Suche nach defekten Blöcken

  • fsck.ext4 -cf /dev/sdg1

Wenn der Superblock beschädigt ist

Ist der primäre Superblock zerstört, findet fsck das Dateisystem nicht mehr. Dann greift man auf eine der Kopien zurück, deren Lage mkfs beim Anlegen ausgegeben hat (und die dumpe2fs oder mkfs -n anzeigen). Die erste Kopie liegt meist auf Block 32768:

  • fsck.ext4 -b 32768 /dev/sdg1

Ein Dateisystem ansehen: dumpe2fs und debugfs

dumpe2fs und debugfs zeigen die internen Strukturen eines ext-Dateisystems – Superblock, Gruppen, Inodes, Verzeichnisse. dumpe2fs liest nur; debugfs kann im Ernstfall auch schreiben und ist damit ein Werkzeug für Datenrettung. Beide setzen an der Partition an, nicht am Mountpunkt.

Achtung: Schreibende debugfs-Zugriffe (mit -w) gehören nur an ein ausgehängtes Dateisystem. Lesend ist debugfs auch am gemounteten gefahrlos, kann dann aber veraltete Werte zeigen.

dumpe2fs: Kennwerte lesen

Nur den Superblock

Zeigt UUID, Label, Block- und Inode-Zahl, Features, Journalgröße und Prüfintervalle – ohne die lange Gruppenliste.

  • dumpe2fs -h /dev/sdg1

Alles inklusive Blockgruppen

Zeigt zusätzlich für jede Gruppe die Lage von Superblock-Kopie, Bitmaps und Inode-Tabelle sowie die freien Blöcke und Inodes.

  • dumpe2fs /dev/sdg1

Nur die Lage der Superblock-Kopien

Praktisch, um für eine Reparatur mit fsck -b eine Backup-Kopie zu finden.

  • dumpe2fs /dev/sdg1 | grep -i superblock

debugfs: interaktiv im Dateisystem

debugfs öffnet das Dateisystem und wartet dann auf Kommandos. Ohne -w ist es schreibgeschützt.

Dateisystem lesend öffnen

  • debugfs /dev/sdg1
debugfs 1.47.0 (5-Feb-2023)
debugfs:

Innerhalb von debugfs stehen unter anderem diese Kommandos zur Verfügung:

Kommando Wirkung
stat <NUMMER> Inode anzeigen: Typ, Rechte, Link Count, Blöcke, Zeitstempel
ls -l Verzeichnisinhalt mit Inode-Nummern
ncheck NUMMER zu einer Inode-Nummer den Pfad suchen
imap <NUMMER> in welcher Gruppe und an welchem Byte der Inode liegt
blocks <NUMMER> die von einer Datei belegten Blocknummern
cat <NUMMER> Inhalt einer Datei über ihre Inode-Nummer ausgeben
freei <NUMMER> Inode als frei markieren (nur mit -w)
undel gelöschte Datei wiederherstellen (nur mit -w)
q debugfs verlassen

Einen Inode direkt ansehen

Die spitzen Klammern bedeuten „Inode-Nummer", ohne Klammern wäre es ein Dateiname.

  • debugfs -R "stat <4711>" /dev/sdg1

Zu einer Inode-Nummer den Pfad finden

Zeigt, welche Datei zu einer Inode-Nummer gehört – etwa, wenn fsck eine Nummer gemeldet hat.

  • debugfs -R "ncheck 4711" /dev/sdg1

Zum Schreiben öffnen (Datenrettung)

Nur am ausgehängten Dateisystem. Mit -w lassen sich gelöschte Dateien mit undel zurückholen, solange ihre Blöcke noch nicht überschrieben sind.

  • debugfs -w /dev/sdg1

Aufgaben

Vorbereitung: Auf /dev/sdb müssen drei Partitionen angelegt sein (/dev/sdb1 bis /dev/sdb3). Falls nicht, zuerst mit fdisk oder gdisk anlegen. Wichtig: immer die Partition ansprechen (/dev/sdb1), nie die ganze Platte (/dev/sdb) – sonst wird die Partitionstabelle überschrieben.

Dateisysteme anlegen

  • Erstellen Sie ein ext4-Dateisystem auf der 1. Partition von /dev/sdb.
  • Erstellen Sie ein ext4-Dateisystem auf der 2. Partition mit einer Blockgröße von 2048.
  • Erstellen Sie ein ext4-Dateisystem auf der 3. Partition mit 3072 Inodes.
  • Lassen Sie sich vor dem Anlegen nur anzeigen, was mkfs auf der 1. Partition tun würde, ohne zu schreiben.

Dateisysteme abstimmen

  • Ändern Sie das Label des Dateisystems auf der 1. Partition zu "daten-platte".
  • Stellen Sie die maximale Mount-Zahl bis zur Zwangsprüfung auf 30 für die 2. Partition ein.
  • Stellen Sie das Prüfintervall auf 2 Monate für die 3. Partition ein.
  • Senken Sie den für root reservierten Anteil auf der 1. Partition auf 1 Prozent.

Dateisysteme ansehen

  • Zeigen Sie den Superblock (nur den Kopf) der 1. Partition an und prüfen Sie, ob das Label "daten-platte" gesetzt ist.
  • Finden Sie heraus, auf welchen Blöcken die Superblock-Kopien der 2. Partition liegen.
  • Sehen Sie sich mit debugfs den Wurzel-Inode (Nummer 2) der 1. Partition an.

Dateisysteme prüfen

Hinweis: fsck nur auf ausgehängten Partitionen ausführen. Falls eine Partition gemountet ist, vorher umount.

  • Führen Sie eine Überprüfung des Dateisystems auf der 1. Partition durch.
  • Führen Sie eine erzwungene Überprüfung der 2. Partition durch.
  • Prüfen Sie die 3. Partition, ohne Änderungen vorzunehmen.
  • Reparieren Sie die 1. Partition über eine Superblock-Kopie (Block 32768), als wäre der primäre Superblock beschädigt.

Zusammenhängende Aufgabe

Diese Aufgabe verbindet alle Werkzeuge zu einem durchgehenden Ablauf auf der 2. Partition.

  • Legen Sie auf /dev/sdb2 ein ext4-Dateisystem mit dem Label "archiv" und einer für root reservierten Quote von 0 Prozent an.
  • Notieren Sie sich aus der Ausgabe die UUID und den ersten Superblock-Backup-Block.
  • Kontrollieren Sie mit dumpe2fs, dass Label und Reservat stimmen.
  • Schalten Sie die Zwangsprüfung nach Mount-Zahl und nach Zeit ganz ab.
  • Erzwingen Sie eine vollständige Prüfung des frisch angelegten Dateisystems.
  • Öffnen Sie das Dateisystem mit debugfs und lassen Sie sich den Wurzel-Inode anzeigen.