Dit document geeft uitleg over:

1. Wat is een sector en wat is formatteren?
2. Wat is een diskblok (disk block)?
3. Wat is een bestand (file)?
4. Wat is een bestandssysteem (file system)?
5. Wat is een apparaatbestand (device file)?
6. Wat is een disk partitie (disk partition)?
7. Wat is aankoppelen (mount)?

Tip:

Oefen actief mee met de voorbeelden!
Ervaar zelf wat het resultaat is van de door u uitgevoerde command's!
Gebruik voor de oefeningen een lege 1,44 MB floppy disk.

Opslagmedia zoals harde schijf (harddisk) en floppydisk, cdrom en USB-stick zijn geformatteerd in sectoren. Een sector is een afgebakend stukje van de disk, dat gevuld kan worden met een vaste hoeveelheid informatie (data). Een gangbare sectorgrootte voor harddisks, floppydisks is 512 byte. Lezen en schrijven van en naar de disk vindt plaats in exacte eenheden van 512 byte.

Wie in de tachtiger jaren een nieuwe harde schijf in zijn computer wilde gaan gebruiken, moest die schijf eerst nog formatteren. De schijf kwam geheel blanco uit de fabriek. Tijdens het formatteren wordt een soort raamwerk op de disk geschreven. De lees- en schrijfkop trekt denkbeeldige sporen (tracks) op het magnetiseerbare oppervlak, waarbij in elk spoor een structuur van opbergvakjes wordt gecreëerd, de sectoren Dit proces wordt ook wel een “Low Level Format” genoemd.

Moderne harde schijven zijn in de fabriek voorgeformatteerd. Zij mogen over het algemeen niet door de gebruiker opnieuw geformatteerd worden! Moderne harde schijven zitten heel intelligent in elkaar. De trucages van de fabrikant kunnen we niet zelf meer naspelen. De sporen aan de buitenkant hebben bijv. meer sectoren dan de sporen meer naar binnen toe. De sporen aan de buitenkant van de schijf hebben immers een grotere omtrek en bieden dus meer ruimte.

Floppydisks mogen we wel opnieuw formatteren. Opnieuw formatteren maakt een niet goed werkende floppydisk vaak weer bruikbaar. Uiteraard gaat bij het formatteren wel alle informatie die op de floppydisk stond verloren!

Onderstaande opdracht formatteert een 3,5 inch 1,44MB floppydisk in station A. Merk op, dat de prompt hier een “#” is. Een format operatie is in principe voorbehouden aan de superuser “root”!
Zie ook: Wat is een apparaatbestand (device file)?
Voor technische uitleg over “/dev/fd0u1440” zie: /usr/share/doc/fdutils/Fdutils.html

# fdformat /dev/fd0u1440
Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.
Formatting ... done
Verifying ... done

Een cdrom wordt geformatteerd tijdens het branden van de data. Na het branden is een cdrom een “alleen lezen” (read-only) disk.

Een USB-stick is een electronisch geheugen, dat door de fabrikant zo is geprogrammeerd, dat het een harde schijf nabootst, inclusief zogenaamde sporen en sectoren. Het besturingssysteem behandelt een USB-stick als een harde schijf. De snelheid van lezen en schrijven is wel veel lager, dan van een echte harde schijf.
Een foto geheugenkaartje (SD-card) is technisch vergelijkbaar met een USB-stick.

Een diskblok is een groep van één of meer sectoren. Linux gebruikt op de harddisk meestal een blokgrootte van 4K (4096 byte), ofwel steeds acht sectoren van 512 byte samen. Voor het besturingssysteem (operating system) is een diskblok de kleinste eenheid van lezen of schrijven.
Bij DOS/Windows wordt vaak over clusters gesproken van een aantal sectoren. Een DOS/Windows cluster is dus een diskblok.

Een bestand (file) is een verzameling bij elkaar horende diskblokken, gekoppeld aan een bestandsnaam (file name). Een bestand is een container voor informatie (data). De inhoud kan van alles en nog wat zijn: tekst, een plaatje, een programma, etc.

Het commando “file” in Linux onderzoekt de informatie in een bestand. Bijvoorbeeld:

$ file /bin/ls
/bin/ls: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV),
for GNU/Linux 2.2.0, dynamically linked (uses shared libs), stripped

In dit voorbeeld herkent “file” de informatie in het bestand “/bin/ls” als executable code, ofwel een programma.

Daarnaast kunnen we in de naamgeving al duidelijk maken, wat voor inhoud een bestand heeft. Wanneer we een bestandsnaam bijvoorbeeld op “.png” laten eindigen, bedoelen hiermee aan te geven, dat de inhoud grafische informatie is van het type “Portable Network Graphics”. Voorbeeld: “tux4u.png”

$ file tux4u.png
tux4u.png: PNG image data, 150 x 179, 8-bit/color RGB, non-interlaced

De tekens achter de punt in de bestandsnaam heten de “extensie”. Voor MS-Windows gebruikers zijn extensies wellicht nieuw. Standaard verbergt MS-Windows namelijk de extensie van bestandsnamen. Achter de schermen maakt MS-Windows juist hevig gebruik van extensies. Wie een MS-Windows gebruiker een bestand stuurt met bijv. als naam “planning.deel1”, zal waarchijnlijk als reactie ontvangen, dat dit bestand niet geopend kon worden. MS-Windows kent de extensie “.deel1” niet. Tja, wat nu??

Hieronder enkele voorbeelden van veelgebruikte extensies. Geen extensie ingevuld, betekent: hoort hier niet thuis. Dus bijv. “.doc” kunnen we (tot groot verdriet van Microsoft) tegenwoordig heel goed openen met OpenOffice in Linux, maar de applicatie Microsoft Word hoort thuis in MS-Windows. Programma's (executables) in Linux hebben geen extensie. Er staat daarom “-” ingevuld.

Een bestandssysteem is een administratie van diskblokken. Een bestandssysteem maakt het mogelijk om met bestanden te werken, zonder dat de gebruiker hoeft bij te houden in welke diskblokken zijn informatie staat opgeslagen.

De belangrijkste taken van een bestandssysteem zijn:

1. Van elk bestand vastleggen welke diskblokken het bestand bezet.
2. Bijhouden welke blokken vrij zijn.

Daarnaast kan een bestandssysteem (afhankelijk van de technische uitvoering) van alles en nog wat bijhouden. Bijv.

• Datum van laatste wijziging van elk bestand
• Welke gebruikers een bestand mogen openen
• Bestandstypen, bijv.: programma, directory, gegevensbestand
• Hoeveel ruimte alle bestanden samen in beslag nemen

De administratieve informatie in een bestandssysteem noemen we de “Meta Data”. De gewone data in de bestanden zelf noemen we de “User data”.
(Zie diagram: What is a File System?)

In de tabel hierboven staan enkele veel voorkomende bestandssystemen. Waarom zijn er verschillende bestandssystemen? Dat is net zo iets, als de vraag waarom er verschillende auto's zijn. Een deel van het antwoord is: technische ontwikkeling. Het Microsoft FAT bestandssysteem dateert uit de beginjaren '80. De eerste versie van het UDF bestandssysteem verscheen in 1996 voor gebruik in DVD video disks.
Daarnaast speelt de concurrentie tussen computerbedrijven een rol. Of men mag bepaalde ontwikkelingen niet overnemen (patenten, licenties), of men wil ontwikkelingen niet overnemen. Dit laatste staat ook wel bekend als het “Niet door ons bedacht” syndroom (Not invented by us).

Een bestandssysteem ontstaat niet vanzelf. Wanneer we op een nieuw opslagmedium met bestanden willen werken, moeten we dit medium eerst van een leeg bestandssysteem voorzien.
Dit proces wordt ook wel een “High Level Format” genoemd.

De volgende opdracht creëert een leeg bestandssysteem van het type “VFAT” op een floppydisk in Linux:

# mkfs -t vfat /dev/fd0

Merk op, dat eventuele informatie op het opslagmedium door deze operatie gewist zal worden! In die zin is dit dus een gevaarlijke operatie. Over het algemeen is een dergelijke operatie dan ook voorbehouden aan de systeembeheerder (root).

De volgende opdracht creëert een leeg bestandssysteem van het type “VFAT” op een floppydisk in MS-DOS/Windows:

C> format A:

Ook hier geldt, dat eventuele informatie op het opslagmedium door deze operatie gewist zal worden!

Bestanden zijn de dragers van onze informatie. Het omgaan met bestanden is dan ook een belangrijk onderdeel van vrijwel iedere applicatie. Wat zou bijv. het nut zijn van een tekstverwerkings programma, wanneer het een tekst niet zou kunnen opslaan?

Gezien door de ogen van een programmeur zijn de belangrijkste operaties op bestanden:

• Openen
• Lezen
• Schrijven
• Sluiten

Een tekstverwerkings programma bijv. kan een bestand openen, hieruit een opgeslagen tekst lezen en later de gewijzigde tekst terugschrijven. Wanneer het bestand niet meer nodig is, sluit het programma het bestand.

Naast bestanden moeten vrijwel alle programma's om kunnen gaan met invoer- en uitvoerapparaten, bijv. een toetsenbord of een printer. Van oudsher in de ontwikkeling van de computer beschikte de programmeur daarvoor over aparte in- en uitvoeroperaties.

De makers van het besturingssysteem “Multics” (1969, voorloper van Unix en Linux) zagen echter overeenkomsten tussen bestanden en in- en uitvoerapparaten. Informatie opvragen van bijv. een toetsenbord (invoer) lijkt op lezen van informatie uit een bestand. Het uitprinten van informatie (uitvoer) lijkt op het schrijven naar een bestand. De makers van het besturingssysteem “Multics” bedachten een truc. Ze schaften de aparte in- en uitvoer operaties af. In plaats daarvan kwamen er “apparaatbestanden”.

Apparaatbestanden zijn in feite geen bestanden. Er is wel een bestandsnaam in het bestandssysteem, maar een apparaatbestand heeft geen diskblokken en heeft dus geen data. Wanneer we een apparaatbestand openen, worden we verbonden met ondersteunende functies van het besturingssysteem, de “Device Drivers”.

De idee van apparaatbestanden is in vele besturingssystemen overgenomen. Hieronder enkele voorbeelden van apparaatbestanden in Linux en MS-DOS/Windows.

^*) MS-DOS en MS-Windows gebruikt namen als “A:” en “C:” zowel voor het apparaatbestand als voor het aankoppelpunt (mountpoint), afhankelijk van het commando:
(Zie verder bij: Wat is aankoppelen (mount)?)

C> format A:     Formatteer floppydisk A (apparaatbestand)
C> dir A:        Toon bestanden van bestandssysteem gekoppeld aan A:

Harde schijven bieden een grote opslagruimte. Deze grote opslagruimte roept vragen op als:

• Kan ik twee besturingssystemen op één disk installeren?
• Kan ik mijn gebruikersdata apart van het besturingssysteem opslaan?

Het antwoord op dit soort vragen is: Ja:

1. Verdeel de disk in afgebakende stukken (partities).
2. Beschouw iedere partitie als een apart diskje.

Om een veelzijdig gebruik van de ruimte mogelijk te maken, worden harde schijven dan ook sinds jaar en dag gepartitioneerd. Technisch gezien is partitioneren niets anders dan het bijhouden van een administratie. In zijn eenvoudigste vorm is die administratie een tabel, die van elke partitie de toegewezen diskruimte vermeldt. Toen IBM begin jaren '80 de “IBM Personal Computer XT” uitbracht, voorzag IBM de harde schijf meteen van een partitietabel. Voor deze tabel gebruikte IBM de eerste sector van de disk (Master Boot Record).

MS-Windows, Linux en andere besturingssystemen kunnen vandaag de dag nog steeds overweg met de IBM partitietabel, al is er aan technische opzet heel wat gesleuteld. De eerste IBM hard disk was 10MB. Tegenwoordig zijn harde schijven 250GB en groter. Een dergelijke groei in opslagcapaciteit was niet voorzien en noopte tot creatieve oplossingen, zoals LBA (Logical Block Addressing).

# fdisk -l /dev/hda

Disk /dev/hda: 82.3 GB, 82348277760 bytes
255 heads, 63 sectors/track, 10011 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/hda1               1        1020     8193149+   c  W95 FAT32 (LBA)
/dev/hda2   *        1021        2040     8193150   83  Linux
/dev/hda3            2041        3060     8193150   83  Linux
/dev/hda4            3061       10011    55833907+   5  Extended
/dev/hda5            3061        3188     1028159+  82  Linux swap
/dev/hda6            3189        3201      104422   83  Linux
/dev/hda7            3202        4476    10241437   fd  Linux raid autodetect
/dev/hda8            4477        8301    30724312   fd  Linux raid autodetect
/dev/hda9            8302        8332      248976   83  Linux

De beeldschermuitvoer hierboven toont als illustratie een partitie indeling van een Linux systeem. De kolommen “Start” en “End” geven de eerste, resp. de laatste “cylinder” van de partitie aan. Een cylinder is een denkbeeldig begrip. Harde schijven bestaan meestal uit een aantal magnetiseerbare ronde platen, boven elkaar gemonteerd op een as. Elke plaat heeft een lees/schrijf-kop aan de bovenkant en aan de onderkant. Een cylinder is een bepaald spoor (track) van alle lees/schrijfkoppen van de platen samen. (Zie foto van een moderne hard disk beneden)

De kolom “Blocks” is het aantal diskblokken (1024 byte) van de partitie. Een plus geeft aan, dat de partitie 1 sector groter is. De kolom “id” is een code, die het besturingssysteem informeert over het type informatie op de partitie. Partitie 2 heeft in dit voorbeeld code “83”, afgesproken als “Linux bestandssysteem”. Of partitie 2 werkelijk een Linux bestandssysteem bevat, kunnen we niet zeggen. Een partitietabel “kijkt” niet in de diskblokken van de partities!

Partitie 4 is iets bijzonders. De code is “Extended”. De oorspronkelijke IBM XT partitietabel kon slechts 4 partities bevatten. Om meer partities mogelijk te maken, is later een uitbreiding bedacht. De “Extended” partitie bevat zelf weer een nieuwe partitietabel. Merk op dat de cylinders 3061 t/m 8332 van de partities 5 t/m 9 binnen de ruimte van partitie 4 vallen.

Foto van een moderne SCSI hard disk
(www.storagereview.com)

Aankoppelen (mount) is het openen van een bestandssysteem (file system) op een opslagmedium. Een opslagmedium kan zijn een harddisk, CDROM, floppydisk, USB-stick, geheugenkaartje, enz. In Linux openen we een bestandssysteem met het commando “mount”. Laten we als voorbeeld een bestandssysteem van het type VFAT op een floppydisk openen:

# mount -t vfat /dev/fd0 /floppy
mount: wrong fs type, bad option, bad superblock on /dev/fd0

Achter het commando “mount” zien we de optie “-t” voor “type” met daarachter het type bestandssysteem “vfat”. Vervolgens komt het apparaatbestand “/dev/fd0” dat toegang geeft tot de diskblokken van het bestandssysteem. Als laatste zien we op de commandoregel de directory die - na een succesvolle mount - toegang zal geven tot het bestandssysteem en daarmee tot de bestanden van het opslagmedium. Merk op, dat de prompt hier een “#” is. Een mount operatie is in principe voorbehouden aan de superuser “root”!
Zie verder: man mount

Is de mount operatie in dit voorbeeld succesvol? Nee, helaas niet! Mount heeft klachten, waarbij we als foutoorzaken mogen kiezen uit een verkeerd filesystem type, een verkeerde optie, of een corrupt “superblock”. Het “superblock” is het eerste diskblok van het bestandssysteem. Het is een soort wegwijzer naar de rest van de administratieve structuur van het bestandssysteem. Wanneer het superblock corrupt is, kan het bestandssysteem niet worden geopend. We zijn immers de weg kwijt!

In dit voorbeeld is de foutoorzaak een corrupt superblock. Dat kan ik makkelijk zeggen, want ik heb het probleem hier zelf moedwillig veroorzaakt! Hieronder staat wat ik heb misdaan:

Zo eenvoudig is het om het gehele bestandssysteem op /dev/fd0 te vernietigen:

# cp my_document.txt /dev/fd0

Bovenstaande opdracht lijkt op het eerste gezicht onschuldig: Copieer het bestand “my_document.txt” naar de floppydisk. Copieert deze opdracht het bestand “my_document.txt” dan niet naar de floppydisk?? Oh, ja, absoluut! En er komt geen foutmelding, dus kennelijk is het copiëren ook prima gelukt!
De vraag is alleen: Waar is de data van het bestand “my_document.txt” op de floppydisk terechtgekomen? Het antwoord is heel eenvoudig: Op het eerste diskblok van het opslagmedium en verder! Dus over het superblock van het bestandssysteem en, afhankelijk van hoe groot het bestand “my_document.txt” is, over nog een aantal blokken, die al dan niet door het bestandssysteem in gebruik waren.

Het is dus wel logisch, dat na deze grove “wals er overheen” operatie het niet meer mogelijk is het bestandssysteem te openen.
Is het erg dat we het bestandssysteem nu niet meer kunnen “mounten”? Ja, heel erg! Dit is een van de leukste dingen die je in Linux fout kunt doen, behalve wanneer het jouw documenten waren, die op het opslagmedium stonden!

Dat het bestandssysteem defect is, wil op zich nog niet zeggen dat ook alle diskblokken van de bestanden verloren zijn gegaan. Dat is afhankelijk van hoeveel diskblokken we hebben overschreven. Wanneer het bestandssysteem onbruikbaar is geworden, hebben we echter geen idee meer hoe we de diskblokken van een bestand kunnen vinden. Het enige dat we nog kunnen doen, is naar de inhoud van diskblokken kijken met behulp van gereedschappen zoals “od” (Octal dump) of “lde” (Linux Disk Editor). Vinden we diskblokken met interessante informatie, dan kunnen we deze diskblokken naar een bestand copiëren.

Uiteindelijk kunnen we niets anders doen dan een nieuw bestandssysteem op het medium schrijven. Alle eventuele data op het opslagmedium beschouwen we daarmee als verloren. Als voorbeeld leggen we een nieuw “VFAT” bestandssysteem aan op de floppy in station A:
(Dit proces wordt ook wel een “High Level Format” genoemd.)
(Zie ook: Low Level Format)

# mkfs -t vfat /dev/fd0

DRINGEND ADVIES:

Werk alleen als root wanneer het nodig is!
Bovenstaand voorbeeld geeft aan hoe gevaarlijk werken als root kan zijn voor wie niet goed weet hoe het Linux besturingssysteem in elkaar zit!
En ook een ervaren Linux systeembeheerder kan (in de haast) een fout maken.
Log daarom bij voorkeur in als een gewone gebruiker en klim tijdelijk op de troon van de “superuser” root wanneer het nodig is:

$ su -
Password:
# id
uid=0(root) gid=0(root) groups=0(root)

Als het copiëren van data naar een apparaatbestand zulke vernietigende gevolgen heeft, waarom staat Linux dit dan toe?

• Ten eerste staat een goed geconfigureerd Linux systeem het de gewone gebruiker niet toe om naar apparaatbestanden zoals “/dev/fd0” te schrijven. Dit is alleen toegestaan aan de systeembeheerder (root).
  (Zie opmerking hierboven.)
• Ten tweede is lezen en schrijven van en naar apparaatbestanden ook erg handig. Het onderstaande commando copieert een floppy in station A naar het bestand “my_floppy.img”:

  # dd if=/dev/fd0 of=my_floppy.img

  Op deze manier kunnen we diverse floppies bewaren op de harde schijf. Wat voor informatie of wat voor bestandssysteem er op de floppy staat; het doet er niet toe! De gehele floppy wordt naar een bestand geschreven van het eerste t/m het laatste diskblok. Zo'n bestand wordt een “image” genoemd. Hebben we op een bepaald moment de betreffende floppy nodig, dan nemen we een lege geformatteerde floppy, en copiëren het image-bestand naar deze floppy. Deze nieuwe floppy zal dan een blok voor blok identieke copie zijn van de oorspronkelijke floppy.

  # dd if=my_floppy.img of=/dev/fd0

WAARCHUWING!!

Schrijf nooit naar het apparaatbestand van een gemount bestandssysteem!
Overschrijven van een gemount bestandssysteem kan leiden tot:

• Een corrupt bestandsysteem
• Een crash van het besturingssysteem

We mounten het nieuw aangelegde bestandssysteem:

# mount -t vfat /dev/fd0 /floppy

Geen bericht is goed bericht! Wanneer het mount commando niet klaagt, is de mount in principe succesvol. Succesvol mounten van een bestandssysteem vereist:

1. Een consistent “superblock”
2. Ondersteuning van het bestandssysteem
3. Een “mountpoint” directory

Een succesvolle mount operatie vereist een consistent superblock". Een consistent superblock wil echter nog niet zeggen, dat het gehele bestandssysteem consistent is. Wanneer we daaraan twijfelen, kunnen we het bestandssysteem controleren met “fsck” (File System Checker). Controleren van het bestandssysteem met “fsck” is ook het eerste wat we doen wanneer we niet kunnen mounten! Misschien kan “fsck” het bestandssysteem weer consistent maken …
Uiteraard mogen we “fsck” alleen gebruiken op een unmounted bestandssysteem. Loskoppelen van een bestandssysteem doen we in Linux met het commando “umount”. (Nee, niet: unmount!)

# umount /dev/fd0

# fsck -t vfat /dev/fd0
fsck 1.37 (21-Mar-2005)
dosfsck 2.11, 12 Mar 2005, FAT32, LFN
/dev/fd0: 2 files, 2/2847 clusters

# mount -t vfat /dev/fd0 /floppy

Zie verder: man fsck

Een bestandssysteem bestaat aan de ene kant uit een administratieve structuur op het opslagmedium, en aan de andere kant uit slimme programmatuur, die die administratieve structuur begrijpt. Mounten kan alleen, indien er in het besturingssysteem ondersteuning zit voor dit type bestandssysteem. Er moet in de “Linux kernel” support aanwezig zijn voor alle gebruikte typen bestandssystemen. De “kernel” is de kern (het hart) van het besturingssysteem.

# mount -t reiserfs /dev/fd0 /floppy
mount: unknown filesystem type 'reiserfs'

Bovenstaand voorbeeld laat zien dat een mount in dit geval niet mogelijk is, omdat de support voor het “reiserfs” bestandssysteem ontbreekt.
In de praktijk zal dit probleem niet snel voorkomen. De Tux4u®/Penguin Suite ondersteunt alle gangbare Linux, MS-Windows en CDROM bestandssystemen.

Het Linux besturingssysteem geeft - na een succesvolle mount - toegang tot het bestandssysteem via een directory (map). Deze directory heet het “mountpoint”. Het mount commando maakt de “mountpoint” directory niet automatisch aan. Wanneer de “mountpoint” directory nog niet bestaat, moet deze vooraf gecreëerd worden:

# mkdir /floppy

Het eenvoudigste commando om te zien wat er in een systeem gemount is, is “df” (Disk Free). In dit voorbeeld is te zien dat “/dev/fd0” gemount is op mountpoint directory “/floppy”.

$ df

Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/hda2              8064304   2175684   5478964  29% /
/dev/hda1              8177144    903964   7273180  12% /C
/dev/hda7             10080520     32828   9535624   1% /lhome
/dev/hda8             30241960     32828  28672920   1% /cdimg
/dev/hda9               241116     11807    216861   6% /var/tmp
tmpfs                   128460        96    128364   1% /tmp
/dev/fd0                  1424         1      1423   1% /floppy

Tijdens het mounten ondergaat een mountpoint directory een gedaanteverwisseling. Vóór het mounten is de directory “/floppy” een subdirectory van het bestandssysteem op “/dev/hda2”. Ná het mounten is de directory “/floppy” de toegang tot het bestandssysteem op “/dev/fd0”!

# cd /floppy
# pwd
/floppy
# ls -l
total 0
# cal > calendar.out
# ls -l
total 1
-rwxr-xr-x  1 root root 142 Nov 20 13:24 calendar.out

# more calendar.out
   November 2006
Su Mo Tu We Th Fr Sa
          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 29 30

# umount /dev/fd0
umount: /floppy: device is busy

# cd
# umount /dev/fd0
# ls -l /floppy
total 0

In bovenstaande voorbeelden creëert het “cal” (calendar) commando het bestandje “calendar.out” op de gemounte floppy. De directory listing van “/floppy” en het “more” commando tonen aan, dat dit gelukt is. Wanneer we vervolgens “/dev/fd0” willen unmounten, gaat dit niet: “umount: /floppy: device is busy”. Dit komt doordat we nog in de mountpoint directory “/floppy” staan. Zolang er nog applicaties zijn, die het bestandssysteem gebruiken, kunnen we dit bestandssysteem niet sluiten!

We zien dat na het unmounten de directory “/floppy” leeg is. Nadat het bestandssysteem is afgekoppeld, verandert de mountpoint directory “/floppy” weer in een subdirectory van het bestandssysteem “/dev/hda2”.

BELANGRIJK

Verwijder een gemount opslagmedium niet!
Verwijderen van een gemount opslagmedium kan tot een corrupt bestandssysteem en/of verlies van data leiden. Tijdens het werken met een gemount bestandssysteem buffert het Linux besturingssysteem “Meta data” en “User Data” in het werkgeheugen. Wanneer een applicatie data naar het bestandssysteem schrijft, wordt de data eerst in het werkgeheugen geschreven. Later schrijft het besturingssysteem de gebufferde data naar het opslagmedium. Deze “disk caching” versnelt het werken met een relatief traag opslagmedium aanzienlijk! Wanneer het bestandssysteem wordt afgekoppeld (umount) schrijft het besturingssysteem alle gebufferde data naar het opslagmedium en sluit vervolgens het bestandssysteem. Daarna kan het opslagmedium veilig worden verwijderd.

Waarom hoef ik bij MS-DOS/Windows de floppy niet te unmounten? MS-DOS/Windows doet geen “disk caching” op een floppy. Iedere keer dat een applicatie naar de floppy schrijft, schrijft MS-DOS/Windows alle “User Data” en “Meta data” naar de floppy. Wanneer het lampje uit is, is het bestandssysteem volledig bijgewerkt, en mag de floppy dus worden verwijderd. Bij het verwijderen van de floppy unmount MS-DOS/Windows het bestandssysteem.

• Is het mogelijk om tijdens de startup bestandssystemen automatisch te mounten?
• Hoe geef ik gebruikers het recht om een floppy te mounten?
• Kan ik voorkomen, dat gebruikers programma's op een floppy uitvoeren? (security!)

Het antwoord op deze vragen is: “/etc/fstab” (File System Table)

Voorbeeld van een “/etc/fstab”:

# /etc/fstab: static file system information.
#
# <file system>	<mount point>	<type>	<options>		<dump>	<pass>
/dev/hda2	/		ext3	errors=remount-ro	0	1
/dev/hda1	/C		vfat	umask=0,fmask=111	0	0
/dev/hda5	none		swap	sw			0	0
/dev/hda7	/lhome		ext3	noexec,errors=remount-ro  0	2
/dev/hda8	/cdimg		ext3	noexec,errors=remount-ro  0	2
/dev/hda9	/var/tmp	ext3	noexec,errors=remount-ro  0	2
tmpfs		/tmp		tmpfs	mode=1777,noexec,nosuid,nodev 0 0
proc		/proc		proc	defaults		0	0
none		/proc/bus/usb	usbfs	defaults		0	0
/dev/fd0	/floppy		auto	user,noauto,noexec	0	0
/dev/cdrom	/cdrom		iso9660	ro,user,noauto,noexec	0	0

Toelichting:

1. Regels, die beginnen met een “#” zijn commentaar.
2. Een regel met type “swap” is niet een te mounten bestandssysteem, maar “swap space”. (Swap space is een overloop van het werkgeheugen (RAM).)
   De “/etc/fstab” regelt dus ook het activeren van swap space tijdens de systeem start!
3. Met de optie “noauto” wordt het bestandssysteem tijdens de startup niet gemount.
   Dit is met name van belang bij verwisselbare media, zoals CDROM en floppy. Zonder medium valt er immers geen bestandssysteem te openen!
4. De optie “user” geeft gebruikers het recht het bestandssysteem te mounten.
5. Wanneer de optie “noexec” is gezet, kunnen op het gemounte bestandssysteem geen programma's uitgevoerd worden.
   Hiermee kan bijvoorbeeld voorkomen worden, dat van Internet gedownloade programma's (malware?) worden uitgevoerd.

Zie verder: man fstab, man mount

• Linux biedt op twee manieren toegang tot een oplagmedium:

• Gewone gebruikers werken normaliter via het bestandssysteem, dus via een mountpoint directory.
  
• Aan- en afkoppelen (mount/umount) van een bestandssysteem is in principe voorbehouden aan de systeembeheerder (root).
  
• Een gemount (geopend) verwisselbaar medium (floppy, USB-stick,etc,) mag niet worden verwijderd. Dit kan leiden tot een corrupt bestandssysteem en/of verlies van data, omdat er nog data in cache (geheugen) kan staan.
  
• Het direct werken met het apparaatbestand biedt de systeembeheerder bijzondere mogelijkheden, zoals een bestandssysteem blok voor blok copieeren.
  De gewone gebruiker dient echter in principe geen toegang te hebben tot apparaatbestanden van disks, floppydisk, USB-stick, etc.
  Toegang tot het apparaatbestand kan leiden tot:
  • Schade aan het bestandssysteem (ondeskundig gebruik)
  • Omzeilen van de security van het bestandssysteem (hacken)

Copyright © 2011 Integrated Services
Author: Marjan Waldorp; bestandssysteem_nl 2011-03-30