Linux Ordnerrechte

[Christian Seiler]

Hallo,

Woher hast Du das? Im Prinzip sind I-Nodes bzw. auch wo sie abgelegt werden  ein dateisystemspezifisches Konzept. In UNIX-Dateisystemen trennt man in der Regel nämlich zwischen Eintrag mit Dateinamen im Verzeichnis und Metadaten der Datei (Größe, Änderungsdatum). Man hat also 3 Schichten:

Wir haben gerade mal 5-6 kleine Folien zu I-Nodes im Script. Gleich im zweiten steht, dass die Anzahl der I-Nodes durch 2^16 begrenzt sei, deshalb gäbe es dann die einfach, zweifach und dreifach indirekten Zeiger.

Ähm, mit den indirekten Zeigern ist etwas anderes gemeint. In meinem Diagramm habe ich die Blöcke für die Datei einfach unter 'verwendete Blöcke' abgetan und bin nicht näher auf die Details eingegangen. Das Problem ist aber, dass wenn man z.B. eine Blockgröße von 4 KiB annimmt (was typisch ist) für eine Datei mit 4 MiB ganze 1024 Blöcke zum Speichern der enthaltenen Daten braucht. Jetzt müssen im Dateisystem irgendwie 1024 Blocknummern abgelegt werden. Verschiedene Dateisysteme verwenden verschiedene Strategien dafür.

Im konkreten Fall des ext2-Dateisystems (gilt *nicht* allgemein für jedes Dateisystem unter Linux!) gibt es folgende Strategie: Pro Inode-Eintrag ist nach den ganzen Metadaten noch Platz für 15 Referenzen auf Blöcke. Nun würde man mit 15 Blöcken pro Datei auf magere 60 KiB kommen - das wäre etwas wenig. ;-) Daher wird folgendes gemacht: Die ersten 12 Einträge zeigen auf die ersten 12 Blöcke der Datei. Der 13. Eintrag zeigt auf einen Block (der dann nicht mehr für Daten zur Verfügung steht), der selbst wieder Zeiger auf die nächsten Blöcke (ab dem 13. Block der Datei) zeigt. Aber es passen ja nur soundsoviele Zeiger in einen Block (typischerweise 1024 Stück), d.h. dann wäre nach knapp über 4 MiB für die maximale Dateigröße Schluss - auch noch viel zu wenig. Also zeigt der 14. Eintrag in der Inode auf einen Block, der Zeiger auf Blöcke enthält, die selbst zeiger auf Blöcke mit dem Inhalt enthalten. Und beim 15. gibt's dann 3 Indirektionsschichten. Um das mal aufzumalen:

(xxx == irgend eine Zahl, die den Block angibt, ich bin zu faul mir jetzt
  so extrem viele zufällige Zahlen auszudenken)
 (aaa, bbb, ccc == irgend eine Zahl, die einen Block angibt, der Zeiger
  auf weitere Blöcke enthält)

(bitte Browserfenster groß machen, damit man die Zeichnung erkennen
  kann)

+------------------------+
 | Inode                  |
 +------------------------+
 | Metadaten              |
 | (Dateigröße, Rechte,   |
 | Erstellungsdatum, ...) |
 +------------------------+
 | Blockreferenzen        | ____
 |  1. xxx                |     \  |  2. xxx                |      |
 |  3. xxx                |      |
 |  4. xxx                |      |
 |  5. xxx                |      |
 |  6. xxx                |      \____ Diese verweisen direkt auf die
 |  7. xxx                |      /     ersten 12 Blöcke mit dem Inhalt
 |  8. xxx                |      |     der Datei.
 |  9. xxx                |      |
 | 10. xxx                |      |
 | 11. xxx                |      |
 | 12. xxx                |_____/         +--------------------+
 | 13. aaa     -----------|-------------->| Block mit Zeigern* |
 | 14. bbb     -----------|----------+    +--------------------+__
 | 15. ccc     -----------|--+       |    |    xxx             |  \  +------------------------+  |       |    |    xxx             |   |_  Diese verweisen auf die nächsten
                             |       |    |    ...             |   |   Inhaltsblöcke der Datei.
                  +----------+       |    |    xxx             |__/
                  |                  |    +--------------------+
                  v                  v
     +--------------------+       +--------------------+
     | Block mit Zeigern* |       | Block mit Zeigern* |
     +--------------------+       +--------------------+
     | bbb                |       | aaa                |
     | bbb                |       | aaa                |
     | ...                |       | ...                |
  +--|-bbb                |       | aaa ---------------|-----+
  |  +--------------------+       +--------------------+     |
  |                                                          |
  |       +--------------------+                             v
  +------>| Block mit Zeigern* |                   +--------------------+
          +--------------------+                   | Block mit Zeigern* |
          | aaa                |                   +--------------------+__
          | aaa                |                   | xxx                |  \           | ...                |                   | xxx                |   |_____
          | aaa----------------|------+            | ...                |   |     |
          +--------------------+      |            | xxx                |__/      |
                                      |            +--------------------+         |
                                      v                                           |
                       +--------------------+                          Diese verweisen auf
                       | Block mit Zeigern* |                        die nächsten Inhaltsblöcke
                       +--------------------+__                            der Datei.
                       | xxx                |  \                        | xxx                |   |___ Diese verweisen auf die nächsten
                       | ...                |   |    Inhaltsblöcke der Datei.
                       | xxx                |__/
                       +--------------------+

* Diese Blöcke stehen natürlich nicht mehr für Dateiinhalt zur Verfügung
   und Nehmen daher Platz im Dateisystem weg.

Wohlgemerkt: Dies gilt *nur* für das ext2-Dateisystem (und vermutlich auch, wg. Kompabilität damit, ext3 und ext4) - andere Dateisysteme können das vollkommen anders implementieren, es ist kein allgemeines Prinzip von Linux-Dateisystemen.

Woher Deine Zahl mit 2^16 Inodes kommt, ist mir aber weiterhin schleierhaft (und die Indirektion hat ja wie Du gesehen hast nichts mit der Zahl der Inodes zu tun sondern nur etwas wie Inodes Blöcke referenzieren) - mein ext4-Dateisystem auf einer 60 GiB-Partition hat zum Beispiel maximal 4833280 Inodes zur Verfügung (und damit wäre dies das theoretische Maximum an Dateien auf dieser Partition).

Wenn ich an die Beschränkung von 2^16 denke (so wie es bei uns im Script steht), dann könnte das Dateisystem ja nur 65536 Dateien verwalten, was überhaupt kein Sinn macht.

Ja, eben. Ich verwende von meinen 4 Millionen Inodes ja schon über 800000, d.h. wenn mein Limit 65536 wäre, dann wäre ich schon längst aufgeschmissen. ;-)

Wie viele Inodes nun möglich sind hängt stark vom Dateisystem ab - eine allgemeine Zahl kann ich Dir nicht nennen. Manchmal kann man die Maximalanzahl auch festlegen, wenn man das Dateisystem anlegt. Die Maximalzahl an Inodes gibt (grob) die Maximalzahl an inhaltlich unterschiedlichen Dateien an, die es im Dateisystem geben kann.

Ich hätte vermutet, dass die Anzahl evtl. an der Adressierung (Adressleitungen zur Festplatte beschränkt sei). 16, 32, 64 bit. (Genau so viele Dateien kann es dann verarbeiten)

Die Maximalzahl an Inodes ist natürlich schon irgendwie durch die Größe des Inode-Zählers in einem Verzeichniseintrag begrenzt (d.h. wie viel bit der hat), aber ein Dateisystem hat evtl. noch zusätzliche, andere Limits auf die maximale Inode-Zahl außer der reinen Größe dieses Zählers.

Vergiss aber bitte mal die Adressleitungen der Festplatte an dieser Stelle: Wie physikalische Festplattensektoren adressiert werden gibt Dir nur eine Grenze für die maximal ansprechbare Festplattenkapazität (hardwaremäßig!), was Du an Daten und somit auch was für ein Dateisystem Du drauftust, ist da völlig egal.

Viele Grüße,
Christian