home
erste Version am 08.10.2014
letzte Änderung am 09.10.2014

Zusatzinfos zu FillBD2

Hier habe ich meine Dateisystem-Analysen und Tests für FillBD2 protokolliert.



Inhalt
  1. Untersuchungen zu Datenträgern und Dateisystemen
    1. FAT32
    2. Vortests
    3. genisoimage
      1. Datei: ISO9660
      2. Datei: ISO9660 + Joliet (-J)
      3. Datei: ISO9660 + Joliet (-J -joliet-long)
      4. Datei: ISO9660 + Rock Ridge (-r)
      5. Datei: ISO9660 + Joliet + Rock Ridge (-r -J -joliet-long)
      6. Datei: ISO9660 + UDF 1.02 (-udf)
      7. Datei: ISO9660 + Joliet + Rock Ridge + UDF 1.02 (-r -J -joliet-long -udf)
      8. Datei: ISO9960:1999 (-iso-level 4)
      9. Verzeichnis: ISO9660
      10. Verzeichnis: ISO9660 + Joliet (-J)
      11. Verzeichnis: ISO9660 + Joliet (-J -joliet-long)
      12. Verzeichnis: ISO9660 + Rock Ridge (-r)
      13. Verzeichnis: ISO9660 + Joliet + Rock Ridge (-r -J -joliet-long)
      14. Verzeichnis: ISO9660 + UDF 1.02 (-udf)
      15. Verzeichnis: ISO9660 + Joliet + Rock Ridge + UDF 1.02 (-r -J -joliet-long -udf)
      16. Verzeichnis: ISO9660:1999 (-iso-level 4)
    4. mkudffs
    5. Zusammenfassung
  2. Tests
    1. Test 1 - wenige (ca. 25) relativ große Dateien
    2. Test 2 - 250 Verzeichnisse und etwas mehr (76 - 77) Dateien
    3. Test 3 - acht Verzeichnisse und viele (ca. 6.900) Dateien
    4. Fazit
  3. Verbesserungsmöglichkeiten für Version 2.1

Untersuchungen zu Datenträgern und Dateisystemen

Laut Wikipedia (und anderen Quellen) haben die üblichen Backup-Datenträger folgende Kapazitäten:
Medium
Herleitung Kapazität
Kapazität [Byte]
74-minute CD-R 333000 * 2048 681.984.000
80-minute CD-R 360000 * 2048 737.280.000
DVD-R 2298496 * 2048
4.707.319.808
DVD+R 2295104 * 2048 4.700.372.992
BluRay
25.025.314.816

Bei den unter Kapazität angegebenen Werten handelt es sich um die Kapazität ohne Dateisystem.
Folglich sind auch noch die Dateisysteme zu berücksichtigen.
Leider ist die Doku-Lage dafür reichlich bescheiden, wenn es um die Frage geht, wieviel Byte eine Datei tatsächlich belegen wird bzw. speziell, wieviel Byte an zusätzlichen Verwaltungsinformationen zu der realen Dateigröße hinzu kommen.

Folgende Dateisysteme sollen hier für Backup-Medien betrachtet werden:
Von einer Betrachtung der ext2-, ext3- und ext4-Dateisysteme habe ich abgesehen, weil die offenbar nicht dafür vorgesehen sind, komplett gefüllt zu werden und sowas für Backups einfach nur grauenvoll ist.


FAT32

Am einfachsten ist es mit FAT32. Doku gibt es bei Microsoft.
Hier muss erstmal die Dateigröße auf das nächste Vielfache der Dateisystem-Blockgröße aufgerundet werden.
Zusätzlich ist noch der Platzbedarf für Directory-Einträge zu berücksichtigen.
Unter der Annahme, dass alle Datei- und Verzeichnisnamen über die 8.3-Notation hinausgehen, berechnet sich der Platzbedarf für einen Directory-Eintrag:
    32+(LängeDateiname/13)*32        bzw.     LängeDateiname*2.5+32
Das Ergebnis ist auf das nächste Vielfache von 32 aufzurunden.

Ein Verzeichnis belegt ebenfalls diesen Platz für seinen Namen.
Und immer einen zusätzlichen Block.
In diesem Block ist dann wieder Platz für Datei- oder Verzeichnisnamen.


Vortests

Um nach ersten Tests ein Regelwerk für alle zu betrachtenden Dateisysteme erstellen zu können, wollte ich zunächst mal "eine zweite Meinung" zu den (in den ISO-Dateien enthaltenen) Dateisystemen haben. Etwas verunsichert hat mich beispielsweise folgender Text in der MAN-Page zu genisoimage:
-udf   Include UDF filesystem support in the generated filesystem image.  UDF support is currently  in  alpha
       status  and  for  this  reason, it is not possible to create UDF-only images.  UDF data structures are
       currently coupled to the Joliet structures, so there are many pitfalls with  the  current  implementa-
       tion.  There is no UID/GID support, there is no POSIX permission support, there is no support for sym-
       links.  Note that UDF wastes the space from sector ~20 to sector 256 at the beginning of the  disc  in
       addition to the space needed for real UDF data structures.
Bei meiner Suche nach einem geeigneten Tool bin ich bei superuser.com gelandet und konnte dann mit disktype die gewünschten Informationen auslesen:
Dateisystem
Ausgabe von disktype
ISO9660
ISO9660 file system
ISO9660 + Joliet + Rock Ridge
ISO9660 file system + Joliet extension
ISO9660 + Joliet + Rock Ridge + UDF
ISO9660 file system + Joliet extension + UDF file system (1.02)
ISO9660 + UDF
ISO9660 file system + UDF file system (1.02)
UDF (mkudffs)
UDF file system (2.01)

Da Joliet und Rock Ridge laut MAN-Page eh besser zusammen genutzt werden ("For greater portability, consider using both Joliet and Rock Ridge extensions."), wird es in FillBD2 wie ein Dateisystem behandelt.
Und wegen der unzeitgemäßen Verstümmelung der Dateinamen wird ISO9660 als alleiniges Dateisystem von FillBD2 nicht unterstützt.


genisoimage

Mit dem Kommando genisoimage kann für eine oder mehrere Dateien eine ISO-Datei erzeugt werden, die dann die Datei[en] enthält.
Über Parameter wird gesteuert, welche Dateisysteme dabei innerhalb der ISO-Datei angelegt werden sollen.

Um nun halbwegs strukturiert an die gewünschten Informationen bzgl. der Dateisysteme zu kommen, habe ich mir erstmal ein Script zum Erzeugen von Testdaten gebaut.
In dem Script werden 150 Dateien einer festen Größe und mit einer festen Dateinamen-Länge in einem Verzeichnis angelegt und nach jeder Datei der Platzbedarf ermittelt, der für alle Dateien in dem Verzeichnis nötig wäre.
Pro neuer Datei wird der Platzbedarf für sieben Dateisysteme mit folgenden Kommandos ermittelt:
Kommando
Dateisysteme
#
genisoimage -print-size                         <verz> ISO9660 0
genisoimage -print-size -J                      <verz> ISO9660 + Joliet 1
genisoimage -print-size -J -joliet-long         <verz> ISO9660 + Joliet 2
genisoimage -print-size -r                      <verz> ISO9660 + Rock Ridge 3
genisoimage -print-size -r -J -joliet-long      <verz> ISO9660 + Joliet + Rock Ridge 4
genisoimage -print-size -udf                    <verz> ISO9660 + UDF 1.02 5
genisoimage -print-size -r -J -joliet-long -udf <verz> ISO9660 + Joliet + Rock Ridge + UDF 1.02 6

Die Tests 0 bis 3 werden hier nur deshalb berücksichtigt, um daran die Regeln der einzelnen Dateisysteme ableiten zu können und dann für die kombinierten Dateisysteme genauere Werte zu erhalten.

Lässt man dieses Script nun mit unterschiedlichen Datei-Größen laufen, ist die erste Erkenntnis, dass bei den UDF-Dateisystemen (Nummer 5 und 6) pro Datei immer gleich zwei Blöcke belegt werden, bei den anderen Dateisystemen hingegen nur einer.

Im Folgenden das [Teil-]Ergebnis von drei Läufen mit 10 Byte, 2048 Byte und 2049 Byte Dateilänge.
In der ersten Spalte wird die Anzahl der Dateien ausgegeben, in der zweiten die benötigte Anzahl von Blöcken (zu 2.048 Byte) je Dateisystem und in der dritten Spalte die Differenz zur Block-Anzahl aus der vorigen Zeile.

Das Script liefert für Dateien zu je 10 Byte mit einer Dateinamenlänge von 6 Zeichen:
   0 ['174', '180', '180', '175', '181', '417', '423'] [174, 180, 180, 175, 181, 417, 423]
   1 ['175', '181', '181', '176', '182', '419', '425'] [1, 1, 1, 1, 1, 2, 2]
   2 ['176', '182', '182', '177', '183', '421', '427'] [1, 1, 1, 1, 1, 2, 2]
   3 ['177', '183', '183', '178', '184', '423', '429'] [1, 1, 1, 1, 1, 2, 2]
   4 ['178', '184', '184', '179', '185', '425', '431'] [1, 1, 1, 1, 1, 2, 2]
   5 ['179', '185', '185', '180', '186', '427', '433'] [1, 1, 1, 1, 1, 2, 2]
   6 ['180', '186', '186', '181', '187', '429', '435'] [1, 1, 1, 1, 1, 2, 2]
   7 ['181', '187', '187', '182', '188', '431', '437'] [1, 1, 1, 1, 1, 2, 2]
   8 ['182', '188', '188', '183', '189', '433', '439'] [1, 1, 1, 1, 1, 2, 2]
   9 ['183', '189', '189', '184', '190', '435', '441'] [1, 1, 1, 1, 1, 2, 2]
  10 ['184', '190', '190', '185', '191', '437', '443'] [1, 1, 1, 1, 1, 2, 2]
  11 ['185', '191', '191', '186', '192', '439', '445'] [1, 1, 1, 1, 1, 2, 2]
  12 ['186', '192', '192', '187', '193', '441', '447'] [1, 1, 1, 1, 1, 2, 2]
  13 ['187', '193', '193', '188', '194', '443', '449'] [1, 1, 1, 1, 1, 2, 2]
  14 ['188', '194', '194', '189', '195', '445', '451'] [1, 1, 1, 1, 1, 2, 2]
  15 ['189', '195', '195', '190', '196', '447', '453'] [1, 1, 1, 1, 1, 2, 2]
  16 ['190', '196', '196', '192', '198', '449', '456'] [1, 1, 1, 2, 2, 2, 3]
  17 ['191', '197', '197', '193', '199', '451', '458'] [1, 1, 1, 1, 1, 2, 2]
[.....]

Für Dateien zu je 2048 Byte mit einer Dateinamenlänge von 6 Zeichen:
   0 ['174', '180', '180', '175', '181', '417', '423'] [174, 180, 180, 175, 181, 417, 423]
   1 ['175', '181', '181', '176', '182', '419', '425'] [1, 1, 1, 1, 1, 2, 2]
   2 ['176', '182', '182', '177', '183', '421', '427'] [1, 1, 1, 1, 1, 2, 2]
   3 ['177', '183', '183', '178', '184', '423', '429'] [1, 1, 1, 1, 1, 2, 2]
   4 ['178', '184', '184', '179', '185', '425', '431'] [1, 1, 1, 1, 1, 2, 2]
   5 ['179', '185', '185', '180', '186', '427', '433'] [1, 1, 1, 1, 1, 2, 2]
   6 ['180', '186', '186', '181', '187', '429', '435'] [1, 1, 1, 1, 1, 2, 2]
   7 ['181', '187', '187', '182', '188', '431', '437'] [1, 1, 1, 1, 1, 2, 2]
   8 ['182', '188', '188', '183', '189', '433', '439'] [1, 1, 1, 1, 1, 2, 2]
   9 ['183', '189', '189', '184', '190', '435', '441'] [1, 1, 1, 1, 1, 2, 2]
  10 ['184', '190', '190', '185', '191', '437', '443'] [1, 1, 1, 1, 1, 2, 2]
  11 ['185', '191', '191', '186', '192', '439', '445'] [1, 1, 1, 1, 1, 2, 2]
  12 ['186', '192', '192', '187', '193', '441', '447'] [1, 1, 1, 1, 1, 2, 2]
  13 ['187', '193', '193', '188', '194', '443', '449'] [1, 1, 1, 1, 1, 2, 2]
  14 ['188', '194', '194', '189', '195', '445', '451'] [1, 1, 1, 1, 1, 2, 2]
  15 ['189', '195', '195', '190', '196', '447', '453'] [1, 1, 1, 1, 1, 2, 2]
  16 ['190', '196', '196', '192', '198', '449', '456'] [1, 1, 1, 2, 2, 2, 3]
  17 ['191', '197', '197', '193', '199', '451', '458'] [1, 1, 1, 1, 1, 2, 2]
[.....]


Und für Dateien zu je 2049 Byte mit einer Dateinamenlänge von 6 Zeichen:
   0 ['174', '180', '180', '175', '181', '417', '423'] [174, 180, 180, 175, 181, 417, 423]
   1 ['176', '182', '182', '177', '183', '420', '426'] [2, 2, 2, 2, 2, 3, 3]
   2 ['178', '184', '184', '179', '185', '423', '429'] [2, 2, 2, 2, 2, 3, 3]
   3 ['180', '186', '186', '181', '187', '426', '432'] [2, 2, 2, 2, 2, 3, 3]
   4 ['182', '188', '188', '183', '189', '429', '435'] [2, 2, 2, 2, 2, 3, 3]
   5 ['184', '190', '190', '185', '191', '432', '438'] [2, 2, 2, 2, 2, 3, 3]
   6 ['186', '192', '192', '187', '193', '435', '441'] [2, 2, 2, 2, 2, 3, 3]
   7 ['188', '194', '194', '189', '195', '438', '444'] [2, 2, 2, 2, 2, 3, 3]
   8 ['190', '196', '196', '191', '197', '441', '447'] [2, 2, 2, 2, 2, 3, 3]
   9 ['192', '198', '198', '193', '199', '444', '450'] [2, 2, 2, 2, 2, 3, 3]
  10 ['194', '200', '200', '195', '201', '447', '453'] [2, 2, 2, 2, 2, 3, 3]
  11 ['196', '202', '202', '197', '203', '450', '456'] [2, 2, 2, 2, 2, 3, 3]
  12 ['198', '204', '204', '199', '205', '453', '459'] [2, 2, 2, 2, 2, 3, 3]
  13 ['200', '206', '206', '201', '207', '456', '462'] [2, 2, 2, 2, 2, 3, 3]
  14 ['202', '208', '208', '203', '209', '459', '465'] [2, 2, 2, 2, 2, 3, 3]
  15 ['204', '210', '210', '205', '211', '462', '468'] [2, 2, 2, 2, 2, 3, 3]
  16 ['206', '212', '212', '208', '214', '465', '472'] [2, 2, 2, 3, 3, 3, 4]
  17 ['208', '214', '214', '210', '216', '468', '475'] [2, 2, 2, 2, 2, 3, 3]
[.....]

In der ersten Zeile, dritten Spalte ist der Dateisystem-Overhead abzulesen.
Bei einer Blockgröße von 2.048 Byte ergeben sich also folgende initiale, formatierte Kapazitäten für DVD+R:
Dateisystem
Blöcke
leere Kapazität
ISO9660
174
4.700.016.640
ISO9660 + Joliet 180
4.700.004.352
ISO9660 + Joliet (long)
180
4.700.004.352
ISO9660 + Rock Ridge
175
4.700.014.592
ISO9660 + Joliet (long) + Rock Ridge 181
4.700.002.304
ISO9660 + UDF 1.02
417
4.699.518.976
ISO9660 + Joliet (long) + Rock Ridge + UDF 1.02
423
4.699.506.688

Aus den drei Läufen ist weiterhin erkennbar, dass bei der 16'ten Datei ein zusätzlicher Block bei den Dateisystemen 3, 4 und 6 belegt wird.
Wird das Testdaten-Script nun so erweitert, dass es die Positionen dieser zusätzlichen Blöcke ermittelt, kommen die im Folgenden dargestellten Tabellen heraus.
Diese Tabellen sind so aufgebaut, dass in der
Die unterste Zeile enthält einen Index der belegten Blöcke (der für eine Zeile allerdings dann nicht mehr stimmt, wenn dort in einer links gelegenen Spalte ein +2 oder +3 vorkam).

Daraus ist dann pro Dateisystem jeweils eine Formel abzuleiten, die zu einer gegebenen Dateinamen-Länge deren Platzbedarf im Directory ermittelt.



Datei: ISO9660

0 006 48+1 96+1 144+1
0 016 45+1 91+1 137+1
0 ... ... ... ...
0 251 45+1 91+1 137+1


1
2
3
Dateisystem 0 stellt einen Sonderfall dar, weil es keine langen Dateinamen erlaubt.
Dementsprechend verhält es sich oberhalb von 8+3 immer gleich.
Auch wenn es wegen seiner unzeitgemäßen Dateinamen-Verstümmelung nicht alleine betrachtet werden soll, muss es doch berücksichtigt werden, weil es bei allen mittels genisoimage erstellten ISO-Dateien mit an Bord ist.
Hier passen offenbar 44 Dateien mit Maximal-Länge in einen Block zu 2.048 Byte.
Somit also 2048/44=47 Byte pro Dateiname - unabhängig von der Länge des Dateinamens.



Datei: ISO9660 + Joliet (-J)

1 006 44+1 48+1 88+1 96+1 132+1 144+1
1 016 30+1 45+1 61+1 91+1 92+1 123+1 137+1
1 026 24+1 45+1 47+1 70+1 91+1 93+1 116+1 137+1 139+1
1 036 19+1 38+1 45+1 57+1 76+1 91+1 95+1 114+1 133+1 137+1
1 046 16+1 32+1 45+1 48+1 64+1 80+1 91+1 96+1 112+1 128+1 137+1 144+1
1
059
14+1 27+1 40+1 45+1 53+1 66+1 79+1 91+1 92+1 105+1 118+1 131+1 137+1 144+1
1
060
13+1 26+1 39+1 45+1 52+1 65+1 78+1 91+2 104+1 117+1 130+1 137+1 143+1
1
061
13+1 26+1 39+1 45+1 52+1 65+1 78+1 91+2 104+1 117+1 130+1 137+1 143+1
1 062 13+1 25+1 37+1 45+1 49+1 61+1 73+1 85+1 91+1 97+1 109+1 121+1 133+1 137+1 145+1
1 084 13+1 25+1 37+1 45+1 49+1 61+1 73+1 85+1 91+1 97+1 109+1 121+1 133+1 137+1 145+1
1 085 13+1 25+1 37+1 45+1 49+1 61+1 73+1 85+1 91+1 97+1 109+1 121+1 133+1 137+1 145+1
1 106 13+1 25+1 37+1 45+1 49+1 61+1 73+1 85+1 91+1 97+1 109+1 121+1 133+1 137+1 145+1
1 206 13+1 25+1 37+1 45+1 49+1 61+1 73+1 85+1 91+1 97+1 109+1 121+1 133+1 137+1 145+1
1 251 13+1 25+1 37+1 45+1 49+1 61+1 73+1 85+1 91+1 97+1 109+1 121+1 133+1 137+1 145+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Die Daten zu Dateisystem 1 sehen im ersten Moment sonderbar sprunghaft aus.
Wenn man dann aber ISO9660 ausblendet (hier farblich angedeutet), erscheint es schon deutlich gleichmäßiger.
Weiterhin fällt auf, dass ab 62 Zeichen langen Dateinamen keine Veränderung mehr auftritt.
Laut Wikipedia kann Joliet gemäß Spezifikation bis zu 64 Unicode-Zeichen aufnehmen.

Es ergeben sich folgende Abstände:
Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(44+88/2+132/3)/3=44 2048/44=46,55 46,55-2*6=35
016
(30+61/2+92/3+123/4)/4=30,48 2048/30,48=67,19 67,19-2*16=36
026
(24+47/2+70/3+93/4+116/5+139/6)/6=23,41 2048/23,41=87,48 87,48-2*26=36
036
(19+38/2+57/3+76/4+95/5+114/6+133/7)/7=19 2048/19=107,79 107,79-2*36=36
046
(16+32/2+48/3+64/4+80/5+96/6+112/7+128/8+144/9)/9=16 2048/16=128 128-2*46=36
060
(13+26/2+39/3+52/4+65/5+78/6+104/7+117/8+130/9+143/10)/10=13,62 2048/13,62=150,37 150,37-2*60=31
062
(13+25/2+37/3+49/4+61/5+73/6+85/7+97/8+109/9+121/10+133/11+145/12)/12=12,26 2048/12,26=167,05 167,05-2*62=44
Somit ohne ISO9660 etwa:
    if nam_len<62
        dir_size=nam_len*2+36
    else
        dir_size=167



Datei: ISO9660 + Joliet (-J -joliet-long)

2 006 44+1 48+1 88+1 96+1 132+1 144+1
2 016 30+1 45+1 61+1 91+1 92+1 123+1 137+1
2 026 24+1 45+1 47+1 70+1 91+1 93+1 116+1 137+1 139+1
2 036 19+1 38+1 45+1 57+1 76+1 91+1 95+1 114+1 133+1 137+1
2 046 16+1 32+1 45+1 48+1 64+1 80+1 91+1 96+1 112+1 128+1 137+1 144+1
2 081 11+1 21+1 31+1 41+1 45+1 51+1 61+1 71+1 81+1 91+2 101+1 111+1 121+1 131+1 137+1 141+1
2 084 10+1 20+1 30+1 40+1 45+1 50+1 60+1 70+1 80+1 90+1 91+1 100+1 110+1 120+1 130+1 137+1 140+1
2 085 10+1 20+1 30+1 40+1 45+1 50+1 60+1 70+1 80+1 90+1 91+1 100+1 110+1 120+1 130+1 137+1 140+1
2
096
9+1
18+1
27+1
36+1
45+1
54+1
63+1
72+1
81+1
90+1
91+1
99+1
108+1
117+1
126+1
135+1
137+1
144+1
2
097
9+1
17+1
25+1
33+1
41+1
45+1
49+1
57+1
65+1
73+1
81+1
89+1
91+1
97+1
105+1
113+1
121+1
129+1
137+2
145+1
2 106 9+1 17+1 25+1 33+1 41+1 45+1 49+1 57+1 65+1 73+1 81+1 89+1 91+1 97+1 105+1 113+1 121+1 129+1 137+2 145+1
2 206 9+1 17+1 25+1 33+1 41+1 45+1 49+1 57+1 65+1 73+1 81+1 89+1 91+1 97+1 105+1 113+1 121+1 129+1 137+2 145+1
2 251 9+1 17+1 25+1 33+1 41+1 45+1 49+1 57+1 65+1 73+1 81+1 89+1 91+1 97+1 105+1 113+1 121+1 129+1 137+2 145+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Mit mkisofs (auf dem genisoimage basiert) können zu 103 Zeichen lange Dateinamen problemlos verarbeitet werden.
Daher beginnt der Bereich, ab dem ein längerer Dateiname keine Änderung mehr bringt, hier etwas später.
ISO9660 wird wieder erstmal ausgeblendet.

Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(44+88/2+132/3)/3=44 2048/44=46,55
46,55-2*6=35
016
(30+61/2+92/3+123/4)/4=30,48 2048/30,48=67,19
67,19-2*16=36
026
(24+47/2+70/3+93/4+116/5+139/6)/6=23,41 2048/23,41=87,48
87,48-2*26=36
036
(19+38/2+57/3+76/4+95/5+114/6+133/7)/7=19 2048/19=107,79
107,79-2*36=36
046
(16+32/2+48/3+64/4+80/5+96/6+112/7+128/8+144/9)/9=16 2048/16=128
128-2*46=36
081
(11+21/2+31/3+41/4+51/5+61/6+71/7+81/8+91/9+101/10+111/11+121/12+131/13+141/14)/14=10,23 2048/10,23=200,2
200,2-2*81=39
084
(10+20/2+30/3+40/4+50/5+60/6+70/7+80/8+90/9+100/10+110/11+120/12+130/13+140/14)/14=10
2048/10=204,8
204,8-2*84=37
096
(9+18/2+27/3+36/4+54/5+63/6+72/7+81/8+90/9+99/10+108/11+117/12+126/13+135/14+144/15)/15=9,74
2048/9,74=210,27
210,27-2*96=19
097
(9+17/2+25/3+33/4+41/5+49/6+57/7+65/8+73/9+81/10+89/11+97/12+105/13+113/14+121/15+129/16+137/17+145/18)/18=8,19
2048/8,19=250,06
250,06-2*97=57
Also ohne ISO9660 etwa:
    if nam_len<97
        dir_size=nam_len*2+39
    else
        dir_size=251



Datei: ISO9660 + Rock Ridge (-r)

3 006 16+1 33+1 50+1 67+1 84+1 101+1 118+1 135+1
3 016 14+1 29+1 44+1 59+1 74+1 89+1 104+1 119+1 134+1 149+1
3 026 13+1 27+1 41+1 55+1 69+1 83+1 97+1 111+1 125+1 139+1
3 036 12+1 25+1 38+1 51+1 64+1 77+1 90+1 103+1 116+1 129+1 142+1
3 046 12+1 24+1 36+1 48+1 60+1 72+1 84+1 96+1 108+1 120+1 132+1 144+1
3
056
11+1
22+1
33+1
44+1
55+1
66+1
77+1
88+1
99+1
110+1
121+1
132+1
143+1
3
066
10+1
21+1
32+1
43+1
54+1
65+1
76+1
87+1
98+1
109+1
120+1
131+1
142+1
3
076
10+1
20+1
30+1
40+1
50+1
60+1
70+1
80+1
90+1
100+1
110+1
120+1
130+1
140+1
3 081 10+1 20+1 30+1 40+1 50+1 60+1 70+1 80+1 90+1 100+1 110+1 120+1 130+1 140+1
3 084 10+1 20+1 30+1 40+1 50+1 60+1 70+1 80+1 90+1 100+1 110+1 120+1 130+1 140+1
3 085 1+1 9+1 19+1 29+1 39+1 49+1 59+1 69+1 79+2 89+1 99+1 109+1 119+1 129+1 139+1 149+1
3 106 1+1 9+1 18+1 27+1 36+1 45+1 54+1 63+1 72+1 79+1 81+1 90+1 99+1 108+1 117+1 126+1 135+1 144+1
3 206 1+1 8+1 16+1 17+1 24+1 32+1 33+1 40+1 48+1 49+1 56+1 64+1 65+1 72+1 80+1 81+1 88+1 96+1 97+1 104+1 112+1 113+1 120+1 128+1 129+1 ...
3 251 1+1 8+1 12+1 16+1 23+1 24+1 32+1 34+1 40+1 45+1 48+1 56+2 64+1 67+1 72+1 78+1 80+1 88+1 89+1 96+1 100+1 104+1 111+1 112+1 120+1 ...


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Rock Ridge kann laut Wikipedia bis zu 255 Zeichen lange Dateinamen verarbeiten.
Bei diesem Dateisystem ist ISO9660 schwerlich herauszurechnen, weil die 48 bzw. 45 nicht als dedizierter Wert vorkommt und die Werte auch so recht linear ansteigen.
Die unmittelbarste Auffälligkeit ist der erste zusätzliche Block bei Dateinamen mit 85 oder mehr Zeichen.
Warum überschreitet der erste Dateiname mit 85 Zeichen bereits die Blockgröße von 2048 Byte, wenn bei 84 Zeichen noch 9 Dateinamen in den ersten Block passten?
Auch werden bei 79 Dateien mit einem Namen dieser Länge (85 Zeichen) plötzlich zwei Blöcke auf einen Schlag reserviert.
Und bei 106 Zeichen Länge macht ebenfalls die 79'te Dateien die ansonsten gleichmäßige Steigung kaputt.
Dem SourceCode von genisoimage konnte ich den Grund dafür nicht entnehmen, habe aber auch nicht versucht, ihn in Gänze zu verstehen bzw. mir primär die Datenstukturen und die Kommentare angesehen.
Ein Blick via hexdump in entsprechende ISO-Dateien mit mehreren Dateien, deren Dateinamen jeweils kritische Längen hatten, hat mir zwar den Grund für den zusätzlichen Block bei der 79'ten Datei geliefert (78*26<2048, 79*26>2048), mich aber trotzdem ziemlich frustriert.
...und zu dem Schluß kommen lassen, dass ich dafür nicht versuchen will, den Platzbedarf im Directory möglichst korrekt zu ermitteln.
Was für ein erbärmlicher Kräpelkram...

Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(16+33/2+50/3+67/4+84/5+101/6+118/7+135/8)/8=16,66 2048/16=128
128-6=122
016
(14+29/2+44/3+59/4+74/5+89/6+104/7+119/8+134/9+149/10)/10=14,71
2048/14=146,29
146,29-16=131
026
(13+27/2+41/3+55/4+69/5+83/6+97/7+111/8+125/9+139/10)/10=13,71
2048/13=157,54
157,54-26=132
036
(12+25/2+38/3+51/4+64/5+77/6+90/7+103/8+116/9+129/10+142/11)/11=12,73 2048/12=170,67
170,67-36=135
046
(12+24/2+36/3+48/4+60/5+72/6+84/7+96/8+108/9+120/10+132/11+144/12)/12=12 2048/12=170,67
170,67-46=125
081
(10+20/2+30/3+40/4+50/5+60/6+70/7+80/8+90/9+100/10+110/11+120/12+130/13+140/14)/14=10 2048/10=204,8
204,8-81=124
084
(10+20/2+30/3+40/4+50/5+60/6+70/7+80/8+90/9+100/10+110/11+120/12+130/13+140/14)/14=10
2048/10=204,8 204,8-84=121
085
ein Block bei der ersten und der 79'ten Datei (also alle 78 Dateien) stört die +10-Reihe
2048/10=204,8 204,8-85=120
106
ein Block bei der ersten und der 79'ten Datei (also alle 78 Dateien) stört die +9-Reihe 2048/9=227,6 227,6-106=122
206
Blöcke bei der ersten, 17'ten, 33'ten, 49'ten, 65'ten, 81'ten, 97'ten, 113'ten,129'ten und 145'ten Datei (also alle 16 Dateien) stören die +8-Reihe


251
Blöcke bei der ersten, 12'ten, 23'ten, 34'ten, 45'ten, 56'ten, 67'ten, 78'ten, 89'ten, 100'ten, 111'ten, 122'ten, 133'ten und 144'ten Datei (also alle 11 Dateien) stören die +8-Reihe


Also mit ISO9660 etwa:
    if nam_len<85
        dir_size=nam_len+135
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das schon



Datei: ISO9660 + Joliet + Rock Ridge (-r -J -joliet-long)

4 006 16+1 33+1 44+1 50+1 67+1 84+1 88+1 101+1 118+1 132+1 135+1
4 016 14+1 29+1 30+1 44+1 59+1 61+1 74+1 89+1 92+1 104+1 119+1 123+1 134+1 149+1
4 026 13+1 24+1 27+1 41+1 47+1 55+1 69+1 70+1 83+1 93+1 97+1 111+1 116+1 125+1 139+2
4 036 12+1 19+1 25+1 38+2 51+1 57+1 64+1 76+1 77+1 90+1 95+1 103+1 114+1 116+1 129+1 133+1 142+1
4 046 12+1 16+1 24+1 32+1 36+1 48+2 60+1 64+1 72+1 80+1 84+1 96+2 108+1 112+1 120+1 128+1 132+1 144+2
4 081 10+1 11+1 20+1 21+1 30+1 31+1 40+1 41+1 50+1 51+1 60+1 61+1 70+1 71+1 80+1 81+1 90+1 91+1 100+1 101+1 110+1 111+1 120+1 121+1 130+1 131+1 ...
4 084 10+2 20+2 30+2 40+2 50+2 60+2 70+2 80+2 90+2 100+2 110+2 120+2 130+2 140+2
4 085 1+1 9+1 10+1 19+1 20+1 29+1 30+1 39+1 40+1 49+1 50+1 59+1 60+1 69+1 70+1 79+2 80+1 89+1 90+1 99+1 100+1 109+1 110+1 119+1 120+1 129+1 ...
4 106 1+1 9+2 17+1 18+1 25+1 27+1 33+1 36+1 41+1 45+1 49+1 54+1 57+1 63+1 65+1 72+1 73+1 79+1 81+2 89+1 90+1 97+1 99+1 105+1 108+1 113+1 ...
4 206 1+1 8+1 9+1 16+1 17+2 24+1 25+1 32+1 33+2 40+1 41+1 48+1 49+2 56+1 57+1 64+1 65+2 72+1 73+1 80+1 81+2 88+1 89+1 96+1 97+2 104+1 ...
4 251 1+1 8+1 9+1 12+1 16+1 17+1 23+1 24+1 25+1 32+1 33+1 34+1 40+1 41+1 45+1 48+1 49+1 56+2 57+1 64+1 65+1 67+1 72+1 73+1 78+1 80+1 ...


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Mischung von Joliet...:
    if nam_len<97
        dir_size=nam_len*2+39
    else
        dir_size=251
...und Rock Ridge:
    if nam_len<85
        dir_size=nam_len+135
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das schon
ergibt:
    if nam_len<85
        dir_size=nam_len*3+174
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das auch für zwei Dateisysteme



Datei: ISO9660 + UDF 1.02 (-udf -D)

5 006 42+1 48+1 85+1 96+1 128+1 144+1
5 016 36+1 45+1 73+1 91+1 110+1 137+1 146+1
5 026 30+1 45+1 60+1 90+1 91+1 120+1 137+1
5 036 27+1 45+1 54+1 81+1 91+1 108+1 135+1 137+1
5 046 23+1 45+1 47+1 70+1 91+1 93+1 116+1 137+1 140+1
5 081 17+1 34+1 45+1 51+1 68+1 86+1 91+1 103+1 120+1 137+2
5 084 17+1 33+1 45+1 50+1 66+1 83+1 91+1 99+1 116+1 132+1 137+1 149+1
5 085 17+1 33+1 45+1 50+1 66+1 83+1 91+1 99+1 116+1 132+1 137+1 149+1
5 106 14+1 28+1 42+1 45+1 56+1 69+1 83+1 91+1 97+1 111+1 125+1 137+1 139+1
5 206 9+1 17+1 25+1 33+1 42+1 45+1 50+1 58+1 66+1 75+1 83+1 91+2 99+1 108+1 116+1 124+1 132+1 137+1 141+1 149+1
5 251 7+1 14+1 21+1 28+1 35+1 42+1 45+1 49+1 56+1 63+1 71+1 78+1 85+1 91+1 92+1 99+1 106+1 113+1 120+1 127+1 134+1 137+1 141+1 148+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Der Umstand, dass bei UDF immer gleich zwei Blöcke belegt werden (s.o.), wird an anderer Stelle pauschal abgehandelt.
Hier geht es nur um die Blips …. wenn also das Directory erweitert wird.
Und ISO9660 wird auch hier erstmal ausgeblendet.

Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(42+85/2+128/3)/3=42,39 2048/42,39=48,32 48,32-6=43
016
(36+73/2+110/3+146/4)/4=36,42
2048/36,42=56,24 56,24-16=41
026
(30+60/2+90/3+120/4)/4=30 2048/30=68,27
68,27-26=43
036
(27+54/2+81/3+108/4+135/5)/5=27 2048/27=75,86
75,86-36=40
046
(23+47/2+70/3+93/4+116/5+140/6)/6=23,27 2048/23,27=88,02
88,02-46=43
081
(17+34/2+51/3+68/4+103/5+120/6)/6=18,1 2048/18,1=113,15
113,15-81=33
085
(17+33/2+50/3+66/4+83/5+99/6+116/7+132/8+149/9)/9=16,6
2048/16,6=123,38
123,38-85=39
106
(14+28/2+42/3+56/4+69/5+83/6+97/7+111/8+125/9+139/10)/10=13,92
2048/13,92=147,13
147,13-106=42
206
(9+17/2+25/3+33/4+42/5+50/6+58/7+66/8+75/9+83/10+99/11+108/12+116/13+124/14+132/15+141/16+149/17)/17=8,6
2048/8,6=238,14
238,14-206=33
251
(7+14/2+21/3+28/4+35/5+42/6+49/7+56/8+63/9+71/10+78/11+85/12+92/13+99/14+106/15+113/16+120/17+127/18+134/19+141/20+148/21)/21=7,04
2048/7,04=290,91
290,91-251=40
Also ohne ISO9660 etwa:
    dir_size=nam_len+43
Mit ISO9660 dann:
    dir_size=nam_len+43+47=nam_len+90



Datei: ISO9660 + Joliet + Rock Ridge + UDF 1.02 (-r -J -joliet-long -udf)

6 006 16+1 33+1 42+1 44+1 50+1 67+1 84+1 85+1 88+1 101+1 118+1 128+1 132+1 135+1
6 016 14+1 29+1 30+1 36+1 44+1 59+1 61+1 73+1 74+1 89+1 92+1 104+1 110+1 119+1 123+1 134+1 146+1 149+1
6 026 13+1 24+1 27+1 30+1 41+1 47+1 55+1 60+1 69+1 70+1 83+1 90+1 93+1 97+1 111+1 116+1 120+1 125+1 139+2
6 036 12+1 19+1 25+1 27+1 38+2 51+1 54+1 57+1 64+1 76+1 77+1 81+1 90+1 95+1 103+1 108+1 114+1 116+1 129+1 133+1 135+1 142+1
6 046 12+1 16+1 23+1 24+1 32+1 36+1 47+1 48+2 60+1 64+1 70+1 72+1 80+1 84+1 93+1 96+2 108+1 112+1 116+1 120+1 128+1 132+1 140+1 144+2
6 081 10+1 11+1 17+1 20+1 21+1 30+1 31+1 34+1 40+1 41+1 50+1 51+2 60+1 61+1 68+1 70+1 71+1 80+1 81+1 86+1 90+1 91+1 100+1 101+1 ...
6 084 10+2 17+1 20+2 30+2 33+1 40+2 50+3 60+2 66+1 70+2 80+2 83+1 90+2 99+1 100+2 110+2 116+1 120+2 130+2 132+1 140+2 149+1
6 085 1+1 9+1 10+1 17+1 19+1 20+1 29+1 30+1 33+1 39+1 40+1 49+1 50+2 59+1 60+1 66+1 69+1 70+1 79+2 80+1 83+1 89+1 90+1 99+2 ...
6 106 1+1 9+2 14+1 17+1 18+1 25+1 27+1 29+1 33+1 36+1 41+1 43+1 45+1 49+1 54+1 57+2 63+1 65+1 71+1 72+1 73+1 79+1 81+2 86+1 ...
6 206 1+1 8+1 9+1 14+1 16+1 17+2 24+1 25+1 29+1 32+1 33+2 40+1 41+1 43+1 48+1 49+2 56+1 57+2 64+1 65+2 71+1 72+1 73+1 80+1 ...
6 251 1+1 8+1 9+1 12+1 14+1 16+1 17+1 23+1 24+1 25+1 29+1 32+1 33+1 34+1 40+1 41+1 43+1 45+1 48+1 49+1 56+2 57+2 64+1 65+1 ...


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Mischung von Joliet + Rock Ridge...:
    if nam_len<85
        dir_size=nam_len*3+174
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das auch für zwei Dateisysteme
...und UDF 1.02 (ohne ISO9660, weil ja schon in Rock Ridge enthalten):
    dir_size=nam_len+43
ergibt:
    if nam_len<85
        dir_size=nam_len*4+217
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das auch für drei Dateisysteme



Datei: ISO9960:1999 (-iso-level 4)

Nachtrag für ISO9660:1999
7 006 50+1 101+1
7 016 40+1 80+1 120+1
7 026 33+1 67+1 101+1 135+1
7 036 29+1 58+1 87+1 116+1 145+1
7 046 25+1 50+1 75+1 100+1 125+1
7 081 18+1 35+1 52+1 69+1 86+1 103+1 120+1 137+1
7 084 17+1 34+1 51+1 68+1 85+1 102+1 119+1 136+1
7 085 17+1 34+1 51+1 68+1 85+1 102+1 119+1 136+1
7 106 15+1 29+1 43+1 57+1 71+1 85+1 99+1 113+1 127+1 141+1
7
193
9+1
18+1
27+1
36+1
45+1
54+1
63+1
72+1
81+1
90+1
99+1
108+1
117+1
126+1
135+1
144+1
7
194
9+1
17+1
25+1
33+1
41+1
49+1
57+1
65+1
73+1
81+1
89+1
97+1
105+1
113+1
121+1
129+1
137+1
145+1
7 206 9+1 17+1 25+1 33+1 41+1 49+1 57+1 65+1 73+1 81+1 89+1 97+1 105+1 113+1 121+1 129+1 137+1 145+1
7 251 9+1 17+1 25+1 33+1 41+1 49+1 57+1 65+1 73+1 81+1 89+1 97+1 105+1 113+1 121+1 129+1 137+1 145+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Schema F:
Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(50+101/2)/2=50,25 2048/50,25=40,76
40,76-6=35
016
(40+80/2+120/3)/3=40
2048/40=51,2
51,2-16=36
026
(33+67/2+101/3+135/4)/4=33,48 2048/33,48=61,18 61,18-26=36
036
(29+58/2+87/3+116/4+145/5)/5=29
2048/29=70,63
70,63-36=35
046
(25+50/2+75/3+100/4+125/5)/5=25 2048/25=81,92
81,92-46=36
081
(18+35/2+52/3+69/4+89/5+103/6+120/7+137/8)/8=17,42 2048/17,42=117,57 117,57-81=37
106
(15+29/2+43/3+57/4+71/5+85/6+99/7+113/8+127/9+141/10)/10=14,3
2048/14,3=143,22 143,22-106=38
193
(9+18/2+27/3+36/4+45/5+54/6+63/7+72/8+81/9+90/10+99/11+108/12+117/13+126/14+135/15+144/16)/16=9
2048/9=227,56
227,56-193=35
194
(9+17/2+25/3+33/4+41/5+49/6+57/7+65/8+73/9+81/10+89/11+97/12+105/13+11/14+121/15+129/16+137/17+145/18)/18=7,79
2048/7,79=262,91 262,91-194=69
Somit:
    if nam_len<194
        dir_size=nam_len+38
    else
        dir_size=263



Nun den ganzen Spaß nochmal für Verzeichnisse.

Verzeichnisnamenlänge von 6 Zeichen:
   0 ['174', '180', '180', '175', '181', '417', '423'] [174, 180, 180, 175, 181, 417, 423]
   1 ['175', '182', '182', '176', '183', '420', '427'] [1, 2, 2, 1, 2, 3, 4]
   2 ['176', '184', '184', '177', '185', '423', '431'] [1, 2, 2, 1, 2, 3, 4]
   3 ['177', '186', '186', '178', '187', '426', '435'] [1, 2, 2, 1, 2, 3, 4]
   4 ['178', '188', '188', '179', '189', '429', '439'] [1, 2, 2, 1, 2, 3, 4]
   5 ['179', '190', '190', '180', '191', '432', '443'] [1, 2, 2, 1, 2, 3, 4]
   6 ['180', '192', '192', '181', '193', '435', '447'] [1, 2, 2, 1, 2, 3, 4]
   7 ['181', '194', '194', '182', '195', '438', '451'] [1, 2, 2, 1, 2, 3, 4]
   8 ['182', '196', '196', '183', '197', '441', '455'] [1, 2, 2, 1, 2, 3, 4]
   9 ['183', '198', '198', '184', '199', '444', '459'] [1, 2, 2, 1, 2, 3, 4]
  10 ['184', '200', '200', '185', '201', '447', '463'] [1, 2, 2, 1, 2, 3, 4]
  11 ['185', '202', '202', '186', '203', '450', '467'] [1, 2, 2, 1, 2, 3, 4]
  12 ['186', '204', '204', '187', '205', '453', '471'] [1, 2, 2, 1, 2, 3, 4]
  13 ['187', '206', '206', '188', '207', '456', '475'] [1, 2, 2, 1, 2, 3, 4]
  14 ['188', '208', '208', '189', '209', '459', '479'] [1, 2, 2, 1, 2, 3, 4]
  15 ['189', '210', '210', '190', '211', '462', '483'] [1, 2, 2, 1, 2, 3, 4]
  16 ['190', '212', '212', '192', '214', '465', '488'] [1, 2, 2, 2, 3, 3, 5]
  17 ['191', '214', '214', '193', '216', '468', '492'] [1, 2, 2, 1, 2, 3, 4]
[.....]
Anhand der dritten Spalte kann man ablesen, wieviele Blöcke die Dateisysteme für jedes Verzeichnis reservieren:
Dateisystem
Blöcke pro Verzeichnis
Blöcke einzeln
ISO9660
1
1
ISO9660 + Joliet
2
1+ 1
ISO9660 + Joliet (long)
2
1+ 1
ISO9660 + Rock Ridge
1
1+ 0
ISO9660 + Joliet (long) + Rock Ridge 2
1+1+0
ISO9660 + UDF 1.02 3
1+ 2
ISO9660 + Joliet (long) + Rock Ridge + UDF 1.02 4
1+1+0+2



Verzeichnis: ISO9660

0 006 50+1 101+1
0 016 48+1 96+1 144+1
0 ... ... ... ...
0 251 48+1 96+1 144+1


1
2
3
Analog zu Dateien kann man hier ansetzen: 2048/47=44 Byte pro Verzeichnisname - unabhängig von dessen Länge.



Verzeichnis: ISO9660 + Joliet (-J)

1 006 44+1 50+1 88+1 101+1 132+1
1 016 30+1 48+1 61+1 92+1 96+1 103+4 123+1 144+1
1 026 24+1 47+1 48+1 69+4 70+1 93+1 96+1 116+1 137+4 139+1 144+1
1 036 19+1 38+1 48+1 52+4 57+1 76+1 95+1 96+1 103+4 114+1 133+1 144+1
1 046 16+1 32+1 41+4 48+2 64+1 80+1 82+4 96+2 112+1 123+4 128+1 144+2
1
063
13+1
25+1
31+4
37+1
48+1
49+1
61+1
62+4
73+1
85+1
92+4
96+1
97+1
109+1
121+1
123+4
133+4
144+1
145+1
1 064 13+1 25+1 31+4 37+1 48+1 49+1 61+5 73+1 85+1 91+4 96+1 97+1 109+1 121+5 133+1 144+1 145+1
1 084 13+1 25+1 31+4 37+1 48+1 49+1 61+5 73+1 85+1 91+4 96+1 97+1 109+1 121+5 133+1 144+1 145+1
1 085 13+1 25+1 31+4 37+1 48+1 49+1 61+5 73+1 85+1 91+4 96+1 97+1 109+1 121+5 133+1 144+1 145+1
1 106 13+1 25+1 31+4 37+1 48+1 49+1 61+5 73+1 85+1 91+4 96+1 97+1 109+1 121+5 133+1 144+1 145+1
1 206 13+1 25+1 31+4 37+1 48+1 49+1 61+5 73+1 85+1 91+4 96+1 97+1 109+1 121+5 133+1 144+1 145+1
1 251 13+1 25+1 31+4 37+1 48+1 49+1 61+5 73+1 85+1 91+4 96+1 97+1 109+1 121+5 133+1 144+1 145+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Nach dem Ausblenden von ISO9660 fällt auf, dass ab einer Verzeichnisnamen-Länge von 64 Zeichen keine Änderung mehr auftritt.
Leider fällt auch auf, dass die relativ gleichmäßig steigenden Reihen gelegentlich unterbrochen werden und zwar dann gleich mit vier Blöcke am Stück.

Erstmal wieder Schema F - aber ohne die 4'er Blips:
Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(44+88/2+132/3)/3=44 2048/44=46,55
46,55-2*6=35
016
(30+61/2+92/3+123/4)/4=30,48
2048/30,48=67,2
67,2-2*16=36
026
(24+47/2+70/3+93/4+116/5+139/6)/6=23,41 2048/23,41=87,49
87,49-2*26=36
036
(19+38/2+57/3+76/4+95/5+114/6+133/7)/7=19
2048/19=107,79
107,79-2*36=36
046
(16+32/2+48/3+64/4+80/5+96/6+112/7+128/8+144/9)/9=16
2048/16=128
128-2*46=36
064
(13+25/2+37/3+49/4+61/5+73/6+85/7+97/8+109/9+121/10+133/11+145/12)/12=12,26
2048/12,26=167,05 167,05-2*64=40
Also ohne ISO9660 und ohne 4'er Blips etwa:
    if nam_len<64
        dir_size=nam_len*2+40
    else
        dir_size=168

Zur Blip-Analyse habe ich ein ISO von 500 Verzeichnissen (mit 6 Zeichen Länge) angelegt und vom Test-Script folgende Tabelle geliefert bekommen:
0
006

292+4
1 -J
006 205+4
292+4 410+4
2 -J -joliet-long
006 205+4
292+4 410+4
3 -r
006

292+4
4 -r -J -joliet-long
006 205+4 220+2 292+4 410+4
5 -udf
006

292+4
6 -r -J -joliet-long -udf
006 205+4 220+2 292+4 410+4
Will heißen: die Blips kommen bei ISO9660 und Joliet vor und damit indirekt bei allen Dateisystemen.
Allerdings nur bei Verzeichnissen.
Bei Dateien hat die Blip-Suche (glücklicherweise) nichts gefunden.
Fazit: da die Formeln zur Bestimmung der Größe eines Datei- oder Verzeichnis-Namens alle aufgerundet sind, werden sie einfach noch etwas großzügiger aufgerundet, um damit die (relativ selten auftretenden) Blips zu kompensieren.



Verzeichnis: ISO9660 + Joliet (-J -joliet-long)

2 006 44+1 50+1 88+1 101+1 132+1
2 016 30+1 48+1 61+1 92+1 96+1 103+4 123+1 144+1
2 026 24+1 47+1 48+1 69+4 70+1 93+1 96+1 116+1 137+4 139+1 144+1
2 036 19+1 38+1 48+1 52+4 57+1 76+1 95+1 96+1 103+4 114+1 133+1 144+1
2 046 16+1 32+1 41+4 48+2 64+1 80+1 82+4 96+2 112+1 123+4 128+1 144+2
2 081 11+1 21+1 25+4 31+1 41+1 48+1 49+4 51+1 61+1 71+1 73+4 81+1 91+1 96+1 97+4 101+1 111+1 121+5 131+1 141+1 144+1 145+4
2 084 10+1 20+1 24+4 30+1 40+1 47+4 48+1 50+1 60+1 70+5 80+1 90+1 94+4 96+1 100+1 110+1 117+4 120+1 130+1 140+5 144+1
2 085 10+1 20+1 23+4 30+1 40+1 46+4 48+1 50+1 60+1 69+4 70+1 80+1 90+1 92+4 96+1 100+1 110+1 116+4 120+1 130+1 139+4 140+1 144+1
2
102
9+1
17+1
20+4
25+1
33+1
39+4
41+1
48+1
49+1
57+1
58+4
65+1
73+1
78+4
81+1
89+1
96+1
97+5
105+1
113+1
116+4
121+1
129+1
136+4
137+1
144+1
145+1
2
103
9+1
17+1
20+4
25+1
33+1
39+4
41+1
48+1
49+1
57+1
58+4
65+1
73+1
77+4
81+1
89+1
96+5
97+1
105+1
113+1
115+4
121+1
129+1
134+4
137+1
144+1
145+1
2 106 9+1 17+1 20+4 25+1 33+1 39+4 41+1 48+1 49+1 57+1 58+4 65+1 73+1 77+4 81+1 89+1 96+5 97+1 105+1 113+1 115+4 121+1 129+1 134+4 137+1 144+1 145+1
2 206 9+1 17+1 20+4 25+1 33+1 39+4 41+1 48+1 49+1 57+1 58+4 65+1 73+1 77+4 81+1 89+1 96+5 97+1 105+1 113+1 115+4 121+1 129+1 134+4 137+1 144+1 145+1
2 251 9+1 17+1 20+4 25+1 33+1 39+4 41+1 48+1 49+1 57+1 58+4 65+1 73+1 77+4 81+1 89+1 96+5 97+1 105+1 113+1 115+4 121+1 129+1 134+4 137+1 144+1 145+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Hier fällt nach dem Ausblenden von ISO9660 auf, dass ab einer Verzeichnisnamen-Länge von 103 Zeichen keine Änderung mehr auftritt.

Die Mittelwerte wieder ohne Blips (bis 46 keine Veränderung zu Joliet ohne "long"):
Länge
Mittelwert von "Anzahl der Dateien bis zum nächsten zusätzlichen Block"
Byte pro Dateiname
Overhead pro Datei
006
(44+88/2+132/3)/3=44 2048/44=46,55
46,55-2*6=35
016
(30+61/2+92/3+123/4)/4=30,48
2048/30,48=67,2
67,2-2*16=36
026
(24+47/2+70/3+93/4+116/5+139/6)/6=23,41 2048/23,41=87,49
87,49-2*26=36
036
(19+38/2+57/3+76/4+95/5+114/6+133/7)/7=19
2048/19=107,79
107,79-2*36=36
046
(16+32/2+48/3+64/4+80/5+96/6+112/7+128/8+144/9)/9=16
2048/16=128
128-2*46=36
085
10+20+30....=10
2048/10=204,8 204,8-2*85=35
103
(9+17/2+25/3+33/4+41/5+49/6+57/7+65/8+73/9+81/10+89/11+97/12+105/13+113/14+121/15+129/16+137/17+145/18)/18=8,2
2048/8,2=249,76
249,76-2*103=44
Also ohne ISO9660 etwa:
    if nam_len<103
        dir_size=nam_len*2+40
    else
        dir_size=250



Verzeichnis: ISO9660 + Rock Ridge (-r)

3 006 16+1 33+1 50+1 67+1 84+1 101+1 118+1 135+1
3 016 14+1 29+1 44+1 59+1 74+1 89+1 104+1 119+1 134+1 149+1
3 026 13+1 27+1 41+1 55+1 69+1 83+1 97+1 111+1 125+1 139+1
3 036 13+1 26+1 39+1 52+1 65+1 78+1 91+1 104+1 117+1 130+1 143+1
3 046 12+1 24+1 36+1 48+1 60+1 72+1 84+1 96+1 108+1 120+1 132+1 144+1
3 081 10+1 20+1 30+1 40+1 50+1 60+1 70+1 80+1 90+1 100+1 110+1 120+1 130+1 140+1
3 084 10+1 20+1 30+1 40+1 50+1 60+1 70+1 80+1 90+1 100+1 110+1 120+1 130+1 140+1
3 085 1+1 9+1 19+1 29+1 39+1 49+1 59+1 69+1 79+2 89+1 99+1 109+1 119+1 129+1 139+1 149+1
3 106 1+1 9+1 18+1 27+1 36+1 45+1 54+1 63+1 72+1 79+1 81+1 90+1 99+1 108+1 117+1 126+1 135+1 144+1
3 206 1+1 9+1 17+1 18+1 27+1 33+1 36+1 45+1 49+1 54+1 63+1 65+1 72+1 81+2 90+1 97+1 99+1 108+1 113+1 117+1 126+1 129+1 135+1 144+1 145+1
3 251 1+1 9+1 12+1 18+1 23+1 27+1 34+1 36+1 45+2 54+1 56+1 63+1 67+1 72+1 78+1 81+1 89+1 90+1 99+1 100+1 108+1 111+1 117+1 122+1 126+1 133+1 135+1 144+2


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Der Inhalt der Tabelle ähnelt sehr dem, aus der entsprechenden Tabelle für Dateien.
Daher (mit ISO9660):
    if nam_len<85
        dir_size=nam_len+135
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das schon



Verzeichnis: ISO9660 + Joliet + Rock Ridge (-r -J -joliet-long)

4 006 16+1 33+1 44+1 50+1 67+1 84+1 88+1 101+1 118+1 132+1 135+1
4 016 14+1 29+1 30+1 44+1 59+1 61+1 74+1 89+1 92+1 103+4 104+1 119+1 123+1 134+1 149+1
4 026 13+1 24+1 27+1 41+1 47+1 55+1 69+5 70+1 83+1 93+1 97+1 111+1 116+1 125+1 137+4 139+2
4 036 13+1 19+1 26+1 38+1 39+1 52+5 57+1 65+1 76+1 78+1 91+1 95+1 103+4 104+1 114+1 117+1 130+1 133+1 143+1
4 046 12+1 16+1 24+1 32+1 36+1 41+4 48+2 60+1 64+1 72+1 80+1 82+4 84+1 96+2 108+1 112+1 120+1 123+4 128+1 132+1 144+2
4 081 10+1 11+1 20+1 21+1 25+4 30+1 31+1 40+1 41+1 49+4 50+1 51+1 60+1 61+1 70+1 71+1 73+4 80+1 81+1 90+1 91+1 97+4 100+1 101+1 110+1 111+1 ...
4 084 10+2 20+2 24+4 30+2 40+2 47+4 50+2 60+2 70+6 80+2 90+2 94+4 100+2 110+2 117+4 120+2 130+2 140+6
4 085 1+1 9+1 10+1 19+1 20+1 23+4 29+1 30+1 39+1 40+1 46+4 49+1 50+1 59+1 60+1 69+5 70+1 79+2 80+1 89+1 90+1 92+4 99+1 100+1 109+1 110+1 ...
4 106 1+1 9+2 17+1 18+1 20+4 25+1 27+1 33+1 36+1 39+4 41+1 45+1 49+1 54+1 57+1 58+4 63+1 65+1 72+1 73+1 77+4 79+1 81+2 89+1 90+1 96+4 ...
4 206 1+1 9+2 17+2 18+1 20+4 25+1 27+1 33+2 36+1 39+4 41+1 45+1 49+2 54+1 57+1 58+4 63+1 65+2 72+1 73+1 77+4 81+3 89+1 90+1 96+4 97+2 ...
4 251 1+1 9+2 12+1 17+1 18+1 20+4 23+1 25+1 27+1 33+1 34+1 36+1 39+4 41+1 45+2 49+1 54+1 56+1 57+1 58+4 63+1 65+1 67+1 72+1 73+1 77+4 ...


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Mischung von Joliet...:
    if nam_len<103
        dir_size=nam_len*2+40
    else
        dir_size=250
...und Rock Ridge:
    if nam_len<85
        dir_size=nam_len+135
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das schon
ergibt:
    if nam_len<85
        dir_size=nam_len*3+175
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das auch für zwei Dateisysteme



Verzeichnis: ISO9660 + UDF 1.02 (-udf -D)

5 006 42+1 50+1 85+1 101+1 128+1
5 016 36+1 48+1 73+1 96+1 110+1 144+1 146+1
5 026 30+1 48+1 60+1 90+1 96+1 120+1 144+1
5 036 27+1 48+1 54+1 81+1 96+1 108+1 135+1 144+1
5 046 23+1 47+1 48+1 70+1 93+1 96+1 116+1 140+1 144+1
5 081 17+1 34+1 48+1 51+1 68+1 86+1 96+1 103+1 120+1 137+1 144+1
5 084 17+1 33+1 48+1 50+1 66+1 83+1 96+1 99+1 116+1 132+1 144+1 149+1
5 085 17+1 33+1 48+1 50+1 66+1 83+1 96+1 99+1 116+1 132+1 144+1 149+1
5 106 14+1 28+1 42+1 48+1 56+1 69+1 83+1 96+1 97+1 111+1 125+1 139+1 144+1
5 206 9+1 17+1 25+1 33+1 42+1 48+1 50+1 58+1 66+1 75+1 83+1 91+1 96+1 99+1 108+1 116+1 124+1 132+1 141+1 144+1 149+1
5 251 7+1 14+1 21+1 28+1 35+1 42+1 48+1 49+1 56+1 63+1 71+1 78+1 85+1 92+1 96+1 99+1 106+1 113+1 120+1 127+1 134+1 141+1 144+1 148+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Werden die von ISO9660 geerbten Werte ignoriert, ergibt sich ein identischer Inhalt zur Datei-Tabelle für UDF 1.02.
Daher ohne ISO9660:
    dir_size=nam_len+43
Mit ISO9660 dann:
    dir_size=nam_len+43+44=nam_len+87



Verzeichnis: ISO9660 + Joliet + Rock Ridge + UDF 1.02 (-r -J -joliet-long -udf)

6 006 16+1 33+1 42+1 44+1 50+1 67+1 84+1 85+1 88+1 101+1 118+1 128+1 132+1 135+1
6 016 14+1 29+1 30+1 36+1 44+1 59+1 61+1 73+1 74+1 89+1 92+1 103+4 104+1 110+1 119+1 123+1 134+1 146+1 149+1
6 026 13+1 24+1 27+1 30+1 41+1 47+1 55+1 60+1 69+5 70+1 83+1 90+1 93+1 97+1 111+1 116+1 120+1 125+1 137+4 139+2
6 036 13+1 19+1 26+1 27+1 38+1 39+1 52+5 54+1 57+1 65+1 76+1 78+1 81+1 91+1 95+1 103+4 104+1 108+1 114+1 117+1 130+1 133+1 135+1 143+1
6 046 12+1 16+1 23+1 24+1 32+1 36+1 41+4 47+1 48+2 60+1 64+1 70+1 72+1 80+1 82+4 84+1 93+1 96+2 108+1 112+1 116+1 120+1 123+4 128+1 132+1 140+1 144+2
6 081 10+1 11+1 17+1 20+1 21+1 25+4 30+1 31+1 34+1 40+1 41+1 49+4 50+1 51+2 60+1 61+1 68+1 70+1 71+1 73+4 80+1 81+1 86+1 90+1 91+1 97+4 100+1 ...
6 084 10+2 17+1 20+2 24+4 30+2 33+1 40+2 47+4 50+3 60+2 66+1 70+6 80+2 83+1 90+2 94+4 99+1 100+2 110+2 116+1 117+4 120+2 130+2 132+1 140+6 149+1
6 085 1+1 9+1 10+1 17+1 19+1 20+1 23+4 29+1 30+1 33+1 39+1 40+1 46+4 49+1 50+2 59+1 60+1 66+1 69+5 70+1 79+2 80+1 83+1 89+1 90+1 92+4 99+2 ...
6 106 1+1 9+2 14+1 17+1 18+1 20+4 25+1 27+1 29+1 33+1 36+1 39+4 41+1 43+1 45+1 49+1 54+1 57+2 58+4 63+1 65+1 71+1 72+1 73+1 77+4 79+1 81+2 ...
6 206 1+1 9+2 14+1 17+2 18+1 20+4 25+1 27+1 29+1 33+2 36+1 39+4 41+1 43+1 45+1 49+2 54+1 57+2 58+4 63+1 65+2 71+1 72+1 73+1 77+4 81+3 86+1 ...
6 251 1+1 9+2 12+1 14+1 17+1 18+1 20+4 23+1 25+1 27+1 29+1 33+1 34+1 36+1 39+4 41+1 43+1 45+2 49+1 54+1 56+1 57+2 58+4 63+1 65+1 67+1 71+1 ...


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Mischung von Joliet + Rock Ridge...:
    if nam_len<85
        dir_size=nam_len*3+175
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das auch für zwei Dateisysteme
...und UDF 1.02 (ohne ISO9660, weil ja schon in Rock Ridge enthalten):
    dir_size=nam_len+43
ergibt:
    if nam_len<85
        dir_size=nam_len*3+218
    else
        dir_size=2048        # pro Datei ein kompletter Block im Directory...dann passt das auch für zwei Dateisysteme



Verzeichnis: ISO9660:1999 (-iso-level 4)

Nachtrag für ISO9660:1999
7 006 50+1 101+1
7 016 40+1 80+1 120+1
7 026 33+1 67+1 101+1 121+4 135+1
7 036 29+1 58+1 87+1 93+4 116+1 145+1
7 046 25+1 50+1 75+1 76+4 100+1 125+1
7 081 18+1 35+1 46+4 52+1 69+1 86+1 91+4 103+1 120+1 137+5
7 085 17+1 34+1 44+4 51+1 68+1 85+1 88+4 102+1 119+1 131+4 136+1
7 106 15+1 29+1 36+4 43+1 57+1 71+1 72+4 85+1 99+1 108+4 113+1 127+1 141+1 144+4
7 156 11+1 21+1 25+4 31+1 41+1 50+4 51+1 61+1 71+1 75+4 81+1 91+1 100+4 101+1 111+1 121+1 125+4 131+1 141+1
7 206 9+1 17+1 20+4 25+1 33+1 39+4 41+1 49+1 57+1 58+4 65+1 73+1 77+4 81+1 89+1 96+4 97+1 105+1 113+1 115+4 121+1 129+1 134+4 137+1 145+1
7 207 9+1 17+1 19+4 25+1 33+1 38+4 41+1 49+1 57+5 65+1 73+1 76+4 81+1 89+1 95+4 97+1 105+1 113+1 114+4 121+1 129+1 133+4 137+1 145+1
7 216 9+1 17+1 19+4 25+1 33+1 38+4 41+1 49+1 57+5 65+1 73+1 76+4 81+1 89+1 95+4 97+1 105+1 113+1 114+4 121+1 129+1 133+4 137+1 145+1
7 251 9+1 17+1 19+4 25+1 33+1 38+4 41+1 49+1 57+5 65+1 73+1 76+4 81+1 89+1 95+4 97+1 105+1 113+1 114+4 121+1 129+1 133+4 137+1 145+1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Ach nöö. Menno.... Für Dateien sah dieses Dateisystem so schön aus.
Ich will nicht mehr. Wenn mir einer Geld dafür gibt, mach ichs.


mkudffs

Anmerkung: große Teile des folgenden Textes sind vor dem obigen Text zu genisoimage entstanden.

Für UDF-only bietet sich dann noch folgende Prozedur an, mit der ein beschreibbares ISO gemountet werden kann:
truncate -s 4700372992 /1.5TB/DVD+R.iso
mkudffs --vid="dede test" /1.5TB/DVD+R.iso
sudo mount
/1.5TB/DVD+R.iso /home/dede/mnt/
sudo chown dede /home/dede/mnt/
sudo chgrp users /home/dede/mnt/


# und optional noch:
sudo rmdir /home/dede/mnt/lost+found/

# Unmount mit:
sudo umount /home/dede/mnt/

Das UDF v2.01-Medium wurde mit einer Größe von 4.700.372.992 Byte (DVD+R) angelegt.
Innerhalb des UDF-Dateisystems werden 4.698.988.544 freie Byte bei einer Blockgröße von 2.048 Byte gemeldet.
Damit ergibt sich ein initialer Dateisystem-Overhead von 1.384.448 Byte.
Das passt ärgerlicherweise nicht ganz zu dem via genisoimage ermittelten Wert.
Dort gibts mehr Dateisysteme und trotzdem ist die Kapazität größer.
Möglicherweise liegt es daran, dass genisoimage eine andere UDF-Version als 2.01 einsetzt.
Die MAN-Page von genisoimage schweigt dazu leider. (Aber disktype hats bestätigt)

Die bei genisoimage genutzte Vorgehensweise funktioniert hier nicht, weil die ISO-Datei bereits von Anfang an maximale Größe hat.

Ein Test mit 14 Dateien, deren auf 2.048 Byte Blockgröße aufgerundete Dateigrößen in Summe 4.698.986.496 Byte belegen würden, wurden auf ein mit obiger Prozedur erstelltes UDF-Medium mit 4.698.988.544 Byte formatierter Kapazität kopiert.
4.698.988.544 minus 4.698.986.496 ergibt eine Restkapazität von 2.048 Byte.
Theoretisch zumindest.

Praktisch kam aber folgende Tabelle heraus, wenn die Restkapazität vor und nach jedem Kopiervorgang protokolliert wird:
fs vor copy
fs nach copy
verbrauch
dateigröße
delta
#
len_sum
Dateiname
4698988544 4180523008 518465536 518463488 2048 1 30 2013-05-25-wheezy-raspbian.zip
4180523008 3575291904 605231104 605229056 2048 2 60 2013-09-25-wheezy-raspbian.zip
3575291904 3141584896 433707008 433704960 2048 3 94 ESXi_4.1.1_348481_IBM_20120604.iso
3141584896 2703529984 438054912 438052864 2048 4 128 ESXi_4.1.2_502767_IBM_20120601.iso
2703529984 2372456448 331073536 331071488 2048 5 162 ESXi_5.0.0_474610_IBM_20120614.iso
2372456448 2041237504 331218944 331216896 2048 6 196 ESXi_5.0.1_623860_IBM_20120614.iso
2041237504 1416480768 624756736 624754688 2048 7 268 OpenWrt-SDK-ar71xx-for-linux-i486-gcc-4.6-linaro_uClibc-0.9.33.2.tar.bz2
1416480768 662169600 754311168 754309120 2048 8 291 UrbanTerror_41_FULL.zip
662169600 323276800 338892800 338890752 2048 9 341 VMware-Workstation-Full-8.0.2-591240.x86_64.bundle
323276800 318300160 4976640 4974592 2048 10 368 galileocomputing_python.zip
318300160 45737984 272562176 272560128 2048 11 393 raspbmc-2013-12-23.img.gz
45737984 37773312 7964672 7962624 2048 12 406 ut4_dicks.pk3
37773312 34447360 3325952 3323904 2048 13 419 ut4_doom9.pk3
34447360 2048 34445312 34471936 -26624 14 437 ut4_tohunga_b5.pk3

Hier kann man erkennen, dass bei allen Dateien ein zusätzlicher Block belegt wurde (in der Spalte delta, die die Differnz von verbrauch und dateigröße widergibt).
Bei den ersten 13 Dateien wurden also 13*2.048=26.624 Byte mehr belegt, als eigentlich hätten benötigt werden sollen.
Die Restkapazität beträgt 2.048 Byte, somit fehlen für die letzte Datei genau diese 26.624 Byte.

Anhand dieser Daten könnte man denken, die Reservierung eines zusätzlichen Blocks pro Datei würde das Problem lösen.
Dieser zusätzliche Block pro Datei passt auch zu den bei genisoimage gemachten Erfahrungen.
Ein Block langt aber nicht.

Weil das leere Medium gemountet werden kann, besteht für UDF 2.01 die Möglichkeit, einzeln pro Datei/Verzeichnis zu analysieren.
Daher werden hier per Script reichlich Dateien und Verzeichnisse im Wurzelverzeichnis angelegt.
Mehrere Läufe mit unterschiedlichen Datei- bzw. Verzeichnisnamen-Längen haben folgende Werte ergeben:
Anzahl Dateien pro Verzeichnis
Dateigröße in KB
Datei- bzw. Verzeichnis-namen-Länge
zusätzlich benötigte Blöcke
zusätzlich benötigte Byte
100
10
16
3
6.144
200
10
16
6
12.288
200
10
56
10
20.480
200
10
106
15
30.720
200
100
106
15
30.720
200
10
156
20
40.960

Die Dateigröße ändert die Anzahl der zusätzlich benötigten Blöcke offenbar nicht.
Trägt man Daten von Dateinamen-Länge und den zusätzlich benötigten Blöcken in ein Koordinatensystem ein, entsteht eine Gerade.
Die Steigung beträgt m=(y2-y1)/(x2-x1)=(40.960-30.720)/(156-106)=(30.720-12.288)/(106-16)=204,8
Der Y-Schnittpunkt beträgt n=m*(x-x1)+y1=204,8*(0-106)+30.720=204,8*(0-16)+12.288=9.011,2
Und somit y=m*x+n=204,8*x+9.011,2 oder für eine einzelne Datei y=1,024*x+45.
Also sind pro Datei bzw. Verzeichnis zusätzlich zu reservieren: 1,024*LängeName+45.
Nur leider ist das nicht genau genug....weil es eigentlich keine Gerade ist.

Werden per Script Dateien oder Verzeichnisse angelegt, deren Name unterschiedliche Längen aufweisen und wird vor und nach jeder solchen Datei die erwartete Kapazität des Datenträgers geprüft und protokolliert, wenn es nicht passte, ergibt sich folgende Liste:
Länge Name
Block 1
Block 2
Block 3
Block 4
Block 5
Block 6
Block 7
Block 8
Block 9
Block 10
6
36
3
42
42
41
42
42
41
42
42
16
31
2
36
36
35
36
35
36
35
36
26
25
2
29
30
29
29
29
...
30
29
36
22
2
26
26
26
...




46
19
2
22
22
23
22
22
...
23
22
56
18
1
20
21
20
20
21
20
20
21
66
16
1
18
18
18
17
18
18
18

76
15
0
17
17
16
17
17
16


106
11
1
13
12
13
13
13
...
12
13
156
8
0
10
9
10
9
...
9
9
10
206
7
0
8
7
7
7
8
7
7
7
251
5
0
6
6
6
...
7
6
6
6
Will also z.B. für die erste Zeile heißen:
Wenn Dateien oder Verzeichnisse angelegt werden, deren Namen jeweils 6 Byte lang sind, wird nach 36 Dateien der erste zusätzliche Block belegt.
Nach weiteren 3 Dateien bereits der nächste Block, dann dauert es aber 42 Dateien bis zum dritten Block, nochmal 42 bis zum vierten Block, u.s.w.
Das lässt sich für Block 1 nun näherungsweise in eine Formel umsetzen. Und zwar:
    y = 1729 / (x + 41)

Fasst man nun den ersten und den zweiten Block zusammen, liegt deren Summe schon näher an den Werten ab Block 3.
Somit könnte man beim ersten Bedarf nach einem zusätzlichen Block gleich zwei Blöcke reservieren und alles mit einer Formel abhandeln.
Für die Werte ab Block 3 ergibt sich näherungsweise folgende Formel:
    y = 2051 / (x + 42)

Allerdings liefert das nur die Anzahl der Dateien bis zum ersten zusätzlichen Block.
Um zu der Anzahl von Dateien zu gelangen, die in einen Directory-Block hineinpassen, ist die Blockgröße durch die Dateianzahl bis zum nächsten Block zu teilen.
Somit:
    y = 2048 / (2051 / (x + 42)) = 2048 / 2051 * (x + 42)
2048 ist nicht wirklich weit von 2051 entfernt bzw. ergibt 2048/2051 fast "1". Also vereinfacht:
    y = x + 42
Da nun aber der erste Block (bzw. die ersten zwei Blöcke) etwas zu spät reserviert würden, wird einfach großzügig aufgerundet bzw. die 42 durch 50 ersetzt.
Bei vielen Dateien in einem Verzeichnis führt das dann leider dazu, dass zu viele Blöcke reserviert würden.
Daher der finale Programm-Code zur Directory-Größen-Bestimmung für UDF 2.01:
    if filesInDir>100:
      add+=len_nam+42
    else:
      add+=len_nam+50

Weil bei Verzeichnissen mit vielen sehr kleinen Dateien Platz reserviert wurde, der dann am Ende gar nicht genutzt war, habe ich diesbezüglich nochmal genauer analysiert und dabei herausgefunden, dass Dateien bis 1.832 Byte keinen zusätzlichen Block belegen.
Daher die Datei-Sonderregel für UDF 2.01:
    if fileSize>1832:                               # bei Dateien größer als 1832 Byte...
      fileSizeAdj+=self.blockSize                   # muss ein zusätzlicher Block reserviert werden


Zusammenfassung

Es ergeben sich folgende Formeln zur Berechnung der Größe im Directory für die von FillBD2 unterstützten Dateisysteme:
Dateisystem
Formel Datei
Formel Verzeichnis
FAT32
aufVielfachesVon32Aufgerundet(nam_len*2,5+32)
wie Datei
JolietRR if len_nam<85:
   dir_size=nam_len*3+174
else:
   dir_size=2048
if nam_len<85
   dir_size=nam_len*3+175
else
   dir_size=2048
UDF1.02 ohne ISO9660:
   dir_size=nam_len+43
mit ISO9660:
   dir_size=nam_len+90
ohne ISO9660:
   dir_size=nam_len+43
mit ISO9660:
   dir_size=nam_len+87
UDF2.01 if filesInDir>100:
   dir_size=nam_len+42
else:
   dir_size=nam_len+50


wie Datei

Weil die Unterschiede zwischen "Formel Datei" und "Formel Verzeichnis" sehr gering sind, soll im Programm diesbezüglich nicht unterschieden werden.
Es werden die jeweils blau markierten Formeln verwendet.

Pro Datei oder Verzeichnis ist immer mindestens ein Block zu reservieren.
Bei Dateien ist die Dateigröße auf ein Vielfaches der Blockgröße aufzurunden.
Die folgende Tabelle listet die dazu zusätzlich zu reservierenden Blöcke auf:
Dateisystem
Anzahl Blöcke Datei
Anzahl Blöcke Verzeichnis
FAT32
0 0
JolietRR 0
1
UDF1.02 1
2
UDF2.01 1*
1**
       
*
nur bei Dateien >1.832 Byte

**
zusammen mit der ersten Erweiterung


Tests

Nun sollen die ermittelten Korrektur-Werte anhand von Tests überprüft werden.
Es werden drei Verzeichnisse angelegt, die dann mit Dateizusammenstellungen gefüllt werden.
Als Blockgröße wird immer 2.048 eingestellt, die Zielgröße ist gleich dem Verzeichnisnamen (unterhalb von /1TB/).
Im Programm unter Setup Profiles siehts dazu folgendermaßen aus:
TestProfile
Die Füllung erfolgt so, dass die berechnete Restkapazität kleiner oder gleich der Blockgröße (=2.048) ist.

Test 1 - wenige (ca. 25) relativ große Dateien

Quelle: 294 Dateien zwischen 100MB und 200MB.
Profil zur ISO-Erstellung
Größe ISO-Datei
Delta
tst1 (ISO9960 + JolietRR)
4.700.370.944 2.048
tst2 (ISO9960 + UDF1.02) 4.700.368.896
4.096
tst3 (ISO9960 + JolietRR + UDF1.02) 4.700.368.896
4.096
Ergebnis:
Alle drei ISO-Dateien sind kleiner oder gleich der Maximalgröße des Mediums (4.700.372.992).
Alle drei ISO-Dateien lassen sich erfolgreich mounten.
Für tst1.iso (ISO9660+JolietRR) wird beim mount gemeldet: "mount: /dev/loop0 is write-protected, mounting read-only"

Bei der mit mkudffs erstellten mountbaren ISO-Datei (mit 4.698.988.544 Byte formatierter Kapazität) passten alle berechneten Dateien auf das Medium, Restkapazität war 2.048 Byte.

Test 2 - 250 Verzeichnisse und etwas mehr (76 - 77) Dateien

Quelle: 158 Dateien zwischen 3,7MB und 70MB.
Es werden immer 250 leere Verzeichnisse mit Verzeichnisnamen-Länge von 106 Zeichen vorab in die jeweilige Dateizusammenstellung gelegt.
Profil zur ISO-Erstellung
Größe ISO-Datei
Delta
Blöcke
tst1 (ISO9960 + JolietRR) 4.700.090.368
282.624
138
tst2 (ISO9960 + UDF1.02) 4.700.368.896
4.096
2
tst3 (ISO9960 + JolietRR + UDF1.02) 4.700.088.320
284.672
139
Ergebnis:
Analog zu Test 1.
Zusätzlich:
Bei tst3.iso wurden die Dateinamen nach 103 Zeichen abgeschnitten.
Was sehr sonderbar ist, weil bei tst1.iso und tst2.iso lange Namen korrekt erhalten bleiben.
Das Tool disktype meldet für alle drei ISO-Dateien die jeweils erwarteten Dateisysteme.
Bei genisoimage wird der Parameter -joliet-long immer bei JolietRR übergeben und erlaubt dann laut MAN-Page "up to 103 Unicode characters".
Warum aber bei tst1.iso dieses Abschneiden nach 103 Zeichen nicht gegriffen hat, ist mir unklar....

Bei der mit mkudffs erstellten mountbaren ISO-Datei passten alle berechneten Dateien auf das Medium, Restkapazität war 2.048 Byte bzw. ein Block.

Test 3 - acht Verzeichnisse und viele (ca. 6.900) Dateien

Quelle: acht Verzeichnisse mit insgesamt 6.707 Fotos werden vorab in die jeweilige Dateizusammenstellung gelegt.
Danach wird die Dateizusammenstellung aus 424 weiteren Fotos aufgefüllt.
Profil zur ISO-Erstellung
Größe ISO-Datei
Delta
Blöcke
tst1 (ISO9960 + JolietRR) 4.700.264.448 108.544 53
tst2 (ISO9960 + UDF1.02) 4.700.344.320 28.672 14
tst3 (ISO9960 + JolietRR + UDF1.02) 4.700.239.872 133.120 65
Ergebnis:
Analog zu Test 1.

Bei der mit mkudffs erstellten mountbaren ISO-Datei passten alle berechneten Dateien auf das Medium, Restkapazität war 10.240 Byte bzw. 5 Blöcke.


Fazit

Im schlechtesten Fall (Test 2.3) sind 284.672 Byte ungenutzte Kapazität übrig geblieben.
Selbst das ergibt immer noch erfreuliche:
    (4.699.506.688 - 284.672) / 4.699.506.688 * 100 = 99,993942513%
Der beste Fall ergibt:
    (4.699.506.688 - 2.048) / 4.699.506.688 * 100 = 99,999956421%


Verbesserungsmöglichkeiten für Version 2.1

Wenn die ermittelten Formeln per Script gegen die obigen Tabellen in Kapitel 1.3 geprüft werden, liefern sie zwar immer rechtzeitig die Notwendigkeit für einen neuen Block, bei den kombinierten Dateisystemen jedoch meist deutlich zu früh.

Die folgende Tabelle zeigt in Zeile 1 die gemessenen Werte für UDF1.02 (Test 5) bei 36 Zeichen Dateinamenlänge.
In Zeile 2 sind die gemäß Formel berechneten Werte für UDF1.02 dargestellt, in Zeile 3 die für ISO9660.
Zeile 4 zeigt die im Programm (zwangsläufig) verwendete Formel für die Kombination ISO9660+UDF1.02.
gemessen
5 036 27+1 45+1 54+1 81+1 91+1 108+1 135+1 137+1
Formel UDF1.02
036
26

52
78

104 130

Formel ISO9660
036

44


88


131
Formel ISO9660+UDF1.02 036
13
26
38
51
64
76
89
102
114
127
140
Würden UDF1.02 und ISO9660 einzeln betrachtet werden, wären nach 150 Dateien die drei unnötig reservierten Blöcke nicht reserviert worden.

Bei Test 3 ([ISO9960] + Rock Ridge) sieht es deutlich besser aus, weil ISO9960 und Rock Ridge gemeinsam in einer Directory-Stuktur liegen.
gemessen
3 036 12+1 25+1 38+1 51+1 64+1 77+1 90+1 103+1 116+1 129+1 142+1
Formel
Rock Ridge
036
12
24
36
48
60
72
84
96
108
120
132
144
Hier ist keine Aufteilung möglich, weil Rock Ridge und ISO9660 gemeinsam in einer Directory-Stuktur abgelegt werden.
Aber dieses Dateisystem ist ohnehin nicht einzeln in FillBD2 auswählbar.

Bei Test 4 (Joliet + Rock Ridge) ergibt sich:
gemessen
4 036 12+1 19+1 25+1 38+2 51+1 57+1 64+1 76+1 77+1 90+1 95+1 103+1 114+1 116+1 129+1 133+1 142+1
Formel
Joliet
036

19


37

56


74

93


111

130


148
Formel
Rock Rige
036
12

24
36

48

60
72

84

96
108

120

132
144

Formel Joliet+Rock Ridge 036 8
15
22
30
37
44
51
59
66
73
80
88
95
102
109
117
124
131
138
146
Eine Aufteilung von Joliet und Rock Ridge würde bei 150 Dateien keine Verbesserung bezüglich der unnötig reservierten Blöcke bringen.
Bei weniger Dateien liegt der einzeln berechnete Wert allerdings immer näher am gemessenen Wert.
Somit wird ein zusätzlicher Directory-Block ggf. später reserviert und damit steigt die Qualität des berechneten Wertes.

Test 6 (Joliet + Rock Ridge + UDF 1.02):
gemessen
6 036 12+1 19+1 25+1 27+1 38+2 51+1 54+1 57+1 64+1 76+1 77+1 81+1 90+1 95+1 103+1 108+1 114+1 116+1 129+1 133+1 135+1 142+1
Formel
Joliet 036

19



37


56


74


93



111


130


148
Formel Rock Ridge
036 12

24

36

48


60
72


84

96

108

120


132
144

Formel UDF 1.02
036


26



52




78



104



130




Formel
Joliet+Rock Ridge+UDF1.02 036
6
12
18
23
29
35
40
46
52
57
63
69
74
80
86
91
97
103
108
114
120
131
137
142
148
Auch hier würde eine Aufteilung der drei Dateisysteme bei 150 Dateien keine Verbesserung bezüglich der reservierten Blöcke bringen.
Bis zur 36'ten Datei ist die Qualität der einzeln berechneten Werte allerdings deutlich höher.


Der derzeitige Füll-Algorithmus erwartet pro Datei eine absolute / finale Dateigröße und die Anzahl von Dateien kann nur bei Verzeichnis-Inhalten berücksichtigt werden, wo die Verzeichnisse als ein Objekt auf den Zieldatenträger kopiert werden.
Aber wahrscheinlich würde das durchaus reichen, weil dann nur noch für die Datei- und Verzeichnis-Namen im Root-Verzeichnis des Zieldatenträgers zu früh neue Blöcke reserviert würden.
Und für UDF 2.01 wird ohnehin bereits die Anzahl von Dateien in einem Verzeichnis zur Bestimmung der Dateigröße herangezogen.

Würde pro Dateisystem mit eigenem Directory je Directory ein eigener Directory-Größen-Zähler verwaltet werden, müsste sich der richtige Moment für einen neuen bzw. zusätzlichen Directory-Block deutlich genauer bestimmen lassen.
Für die Dateisysteme gilt:
Dateisystem in FillBD2
Directories
FAT32
1
Joliet + Rock Ridge (inkl. ISO9960)
2
ISO9660 + UDF 1.02 2
Joliet + Rock Ridge (inkl. ISO9960) + UDF 1.02
3
UDF 2.01
1

Nach Implementierung der Änderungen bzgl. eines eigenen Directory-Größen-Zählers pro Dateisystem sank die ungenutzte Restkapazität.
Trotzdem blieb bei einigen Verzeichnissen unterhalb von meinem Download-Verzeichnis der Fehler bei ISO9660+UDF entschieden zu groß.
Erst nach Erstellung eines Scriptes, das die gesamte Verzeichnis-Struktur einzeln pro Datei kopiert und die jeweilige ISO-Größenänderung protokolliert hat, ist mir der Fehler aufgefallen: Im Protokoll wurden Dateien gelistet, die z.B. 86 Blöcke hätten belegen sollen, im ISO aber 0 Blöcke belegt haben.
All diese 0-Block-Dateien lagen in der Verzeichnisstruktur auf achter Ebene (also /1/2/3/4/5/6/7/datei).
Und in der MAN-Page zu genisoimage heißt es:
With all ISO9660 levels from 1 to 3, all filenames are restricted to uppercase letters, numbers  and underscores (_). Filenames are limited to 31 characters, directory nesting is limited to 8 levels, and pathnames are limited to 255 characters.
und auch wenn UDF 1.02 dieses Limit laut Spezifikation auf acht Level eigentlich nicht haben sollte, heißt es an anderer Stelle in der MAN-Page:
UDF support is currently in alpha status and for this reason, it is not possible to create UDF-only images.
Da kann ich ja lange nach einem Rechen- oder Denkfehler suchen, wenn genisoimage klammheimlich nicht alle Dateien kopiert und dementsprechend am Ende ungenutzte Kapazität auf dem Medium übrig bleibt.
Obwohl...wenn man genau guckt, liefert genisoimage in so einem Fall gleich als erste Meldung ein:
genisoimage: Directories too deep for '/ISOs/Downloads/.......' (7) max is 6; ignored - continuing.
Nur wird die Meldung sofort von über 1000 weiteren Zeilen weggescrollt und man sieht sie nicht.
Zum Glück lässt es sich mit der zusätzlichen Übergabe des Parameters -D beheben.
Und welch große Erleichterung: der -D ändert nix an den obigen Tabellen für UDF 1.02.