<!DOCTYPE LINUXDOC SYSTEM>
<linuxdoc>

<article>
<titlepag>
<title>De Loopback Root FileSystem HOWTO</title>
<author><name>door Andrew M. Bishop, 
<tt><htmlurl url="mailto:amb@gedanken.demon.co.uk" name="amb@gedanken.demon.co.uk"></tt>, <newline>
Vertaald door: Ellen Bokhorst, <htmlurl url="mailto:bokkie@nl.linux.org" name="bokkie@nl.linux.org"></name></author>
<date>v1.1, 24 september 1999</date>

<abstract>
In deze HOWTO wordt uitgelegd hoe het Linux loopback device kan worden
gebruikt voor een installatie in het Linux native bestandssysteemformaat
dat zonder opnieuw te partitioneren vanaf een DOS-partitie kan worden gedraaid.
Tevens worden andere gebruiken met dezelfde techniek besproken.
</abstract>
</titlepag>

<toc>

<sect><heading>Introductie</heading>

<sect1><heading>Copyright</heading>

<p>
De Loopback Root Filesystem HOWTO
Copyright (C) 1998,99  Andrew M. Bishop (amb@gedanken.demon.co.uk).</p>

<p>Deze documentatie is vrije documentatie; je kunt het herdistribueren en/of
wijzigen onder de voorwaarden van de GNU General Public Licentie zoals
gepubliceerd door de Free Software Foundation; &oacute;f versie 2 &oacute;f
(naar keuze) een eventuele latere versie.</p>

<p>Dit programma is gedistribueerd in de hoop dat het van nut zal zijn, maar
ZONDER GARANTIE; zonder zelfs de impliciete garantie van
VERKOOPBAARHEID of GESCHIKTHEID VOOR EEN BEPAALD DOEL. Zie de
GNU General Public Licentie voor meer details.</p>

<p>De GNU General Public Licentie is verkrijgbaar vanaf 
<htmlurl url="http://www.fsf.org/" name="http://www.fsf.org/">
of, schrijf naar de Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA</p>
</sect1>

<sect1><heading>Revisie Historie</heading>

<p>
<descrip>
<tag>Versie 1.0.0</tag><p>Initi&euml;le Versie (juni 1998)</p>
</descrip>

<descrip>
<tag>Versie 1.0.1-1.0.3</tag><p>Kleine wijzigingen, wijzigingen met betrekking
tot het wijzigen van de kernelversie, typfoutjes enz. (1998 - juli 1999)</p>
</descrip>
<descrip>
<tag>Versie 1.1</tag><p>Copyrightinformatie toegevoegd en opnieuw aangeleverd 
(september 1999)</p>
</descrip>
</p>
</sect1>
</sect>

<sect><heading>Grondbeginselen van Loopback Devices en Ramdisks</heading>

<p>
Als eerste zal ik een aantal van de algemene grondbeginselen beschrijven
die worden gebruikt bij het instellen van een loopback filesystem als
het root-device.</p>


<sect1><heading>Loopback Devices</heading>

<p>
Een <bf>loopback device</bf> onder Linux is een virtueel device dat net als
ieder ander media-device kan worden gebruikt.</p>

<p>
Voorbeelden van gewone media-devices zijn harddisk-partities zoals
<tt>/dev/hda1</tt>, <tt>/dev/hda2</tt>, <tt>/dev/sda1</tt>, of gehele
disks zoals het diskettestation
<tt>/dev/fd0</tt> enz. Het zijn allen devices die kunnen worden gebruikt om
bestanden en directory-structuren te bevatten. Ze kunnen met het benodigde
bestandssysteem (ext2fs, msdos, ntfs enz.) worden geformatteerd en 
vervolgens worden gemount.</p>

<p>
Het loopback filesystem associeert een bestand op een ander bestandssysteem
als een compleet device. Dit kan dan net als enig ander device worden
geformatteerd en gemount. Om dit te kunnen doen wordt het device genaamd
<tt>/dev/loop0</tt>, <tt>/dev/loop1</tt>, enz. geassocieerd met het bestand
en vervolgens wordt dit nieuwe virtuele device gemount.</p>
</sect1>

<sect1><heading>Ramdisk Devices</heading>

<p>
Onder Linux is ook een ander type virtueel device gemount als bestandssysteem
mogelijk, dit is het <bf>ramdisk device</bf>.</p>

<p>
In dit geval refereert het device niet naar fysieke hardware, maar naar
een deel van het geheugen dat voor dit doel is gereserveerd.
Het in beslag genomen geheugen wordt nooit naar disk geswapt, maar
blijft in de diskcache.</p>

<p>
Een ramdisk kan ten alle tijden worden aangemaakt door naar het ramdisk-device
<tt>/dev/ram0</tt> of <tt>/dev/ram1</tt> enz. te schrijven. Dit kan vervolgens
op dezelfde manier worden geformatteerd en gemount als het loopback-device.</p>

<p>
Wanneer een ramdisk wordt gebruikt om vanaf te booten (zoals vaak op 
Linux-installatiedisks of rescue-disks wordt gedaan), dan kan het disk-image
(de gehele inhoud van de disk als een enkel bestand) op de bootdisk in
gecomprimeerde vorm worden opgeslagen.
Dit wordt automatisch door de kernel herkend wanneer het boot en het
wordt voordat het wordt gemount naar ramdisk gedecomprimeerd.</p>
</sect1>

<sect1><heading>Het Initi&euml;le Ramdisk Device</heading>

<p>
Het <bf>initi&euml;le ramdisk</bf> device is onder Linux een ander belangrijk
mechanisme dat we nodig hebben om een loopback-device als een
root-bestandssysteem te kunnen gebruiken.</p>

<p>
Wanneer de initi&euml;le ramdisk wordt gebruikt, wordt het bestandssysteem
image naar het geheugen kopieerd en gemount zodat de bestanden erop kunnen
worden benaderd. Een programma op deze ramdisk (genaamd
<tt>/linuxrc</tt>) wordt uitgevoerd en wanneer het daarmee klaar is, wordt een
ander device als het root-bestandssysteem gemount.
De oude ramdisk is echter nog steeds aanwezig en is gemount op de directory
<tt>/initrd</tt> als dat er is of beschikbaar via het device
<tt>/dev/initrd</tt>.</p>

<p>
Dit is ongebruikelijk gedrag aangezien de normale bootreeks vanaf de
toegewezen root-partitie boot en het blijft draaien.
Met de initi&euml;le ramdisk-optie is het mogelijk dat de root-partitie
kan wijzigen voordat de hoofd-bootreeks is gestart.
</p>
</sect1>

<sect1><heading>Het Root Bestandssysteem</heading>

<p>
Het root-bestandssysteem is het device dat als eerste wordt gemount zodat
het na het booten verschijnt als de directory genaamd <tt>/</tt>.</p>

<p>
Er zijn een aantal complicaties met het root-bestandssysteem die te wijten
zijn aan het feit dat het alle bestanden bevat. 
Bij het booten worden de <tt>rc</tt> scripts uitgevoerd, dit zijn &oacute;f
de bestanden in <tt>/etc/rc.d</tt> of <tt>/etc/rc?.d</tt> afhankelijk van
de versie van het programma <tt>/etc/init</tt>.</p>

<p>
Wanneer het systeem is geboot, is het niet mogelijk de root-partitie te
unmounten of wijzigen, aangezien alle programma's het in zekere mate zullen
gebruiken. Daarom is de initi&euml;le ramdisk zo nuttig, omdat het zo kan
worden gebruikt dat de uiteindelijke root-partitie niet dezelfde is als
die tijdens het booten wordt geladen.</p>
</sect1>

<sect1><heading>De Linux Boot Reeks</heading>

<p>
Om te laten zien hoe de initi&euml;le ramdisk in de bootreeks opereert,
is de volgorde van gebeurtenissen hieronder weergegeven.</p>

<p>
<enum>
<item>De kernel wordt in het geheugen geladen, dit wordt bewerkstelligd door
<tt>LILO</tt> of <tt>LOADLIN</tt>. Je ziet de melding 
<tt>Loading...</tt> als dit gebeurt.</item>
<item>De ramdisk-image wordt in het geheugen geladen, weer wordt dit door
<tt>LILO</tt> of <tt>LOADLIN</tt> uitgevoerd. 
Je ziet de melding <tt>Loading...</tt> als dit gebeurt.</item>
<item>De kernel wordt ge&uml;nitialiseerd, inclusief de ontleding van de
commandoregel-opties en het instellen van de ramdisk als het root-device.</item>
<item>Het programma <tt>/linuxrc</tt> wordt op de initi&euml;le ramdisk 
uitgevoerd.</item>
<item>Het root-device wordt gewijzigd zoals gespecificeerd in de
kernelparameter.</item>
<item>Het init-programma <tt>/etc/init</tt> wordt uitgevoerd wat de 
gebruikersconfigurabele bootreeks uit zal voeren.</item>
</enum>
</p>

<p>Dit is slechts een vereenvoudigde versie van wat er plaatsvindt, maar het
is voldoende om uit te leggen hoe de kernel opstart en waar de initi&euml;le
ramdisk wordt gebruikt.
</p>
</sect1>
</sect>

<sect><heading>Hoe een Loopback Root Device aan te maken</heading>

<p>
Nu dat de algemene grondbeginselen zijn uitgelegd, kan de te gebruiken
methode voor het aanmaken van het loopback-device worden uiteengezet.
</p>


<sect1><heading>Benodigdheden</heading>

<p>
Om het loopback rootdevice aan te maken zijn een aantal dingen benodigd.</p>

<p>
<itemize>
<item>Een werkend Linux-systeem.</item>
<item>Een manier om grote bestanden naar de DOS-doelpartitie te kopi&euml;ren.
</item>
</itemize>
</p>

<p>Het belangrijkste is de toegang tot een ge&iuml;nstalleerd Linux-systeem.
Dit omdat het loop-device alleen onder Linux kan worden aangemaakt.
Dit betekent dat het niet mogelijk is een werkend systeem vanuit het niets
te booten. De benodigdheden van het Linux-systeem waar je gebruik van maakt
is dat je er een kernel op kunt compileren.
</p>

<p>
Als het loopback-device &eacute;&eacute;nmaal is aangemaakt, zal het
een groot bestand zijn. Ik heb bestanden van 80 MB gebruikt, maar ook al
was dit voldoende voor een X-terminal, mogelijk dat het niet genoeg is
als je het voor veel meer wilt gebruiken. Dit bestand moet naar de 
DOS-partitie worden gekopieerd, dus er moet &oacute;f van
een netwerk, &oacute;f van een heleboel diskettes gebruik worden gemaakt.
</p>

<p>
De benodigde software bestaat uit:

<itemize>
<item><tt>LOADLIN</tt> versie 1.6 of hoger</item>
<item>Een versie van <tt>mount</tt> welke loopback-devices ondersteunt</item>
<item>Een kernelversie welke de benodigde opties ondersteunt.</item>
</itemize>
</p>

<p>Dit zou voor recente Linux-installaties standaard aanwezig moeten zijn.</p>
</sect1>

<sect1><heading>Aanmaken van de Linux Kernel</heading>

<p>
Ik maakte het loopback-device met Linux-kernel versie 2.0.31, ook andere
versies zouden moeten werken, maar op z'n minst moeten de volgende opties
opgenomen zijn.</p>

<p>
De kernel-opties die je zal moeten activeren zijn:
<itemize>
<item>RAM disk support (<tt>CONFIG_BLK_DEV_RAM</tt>).</item>
<item>Initial RAM disk (initrd) support (<tt>CONFIG_BLK_DEV_INITRD</tt>).
</item>
<item>Loop device support (<tt>CONFIG_BLK_DEV_LOOP</tt>).</item>
<item>fat fs support (<tt>CONFIG_FAT_FS</tt>).</item>
<item>msdos fs support (<tt>CONFIG_MSDOS_FS</tt>).</item>
</itemize>
</p>

<p>De eerste twee zijn voor het RAM-diskdevice zelf en voor het initi&euml;le
ramdisk-device.
De volgende is de optie voor het loopback bestandssysteem. De laatste twee
bestaan uit de ondersteuning voor het msdos bestandssysteem welke nodig is
voor het mounten van de DOS-partitie.</p>

<p>
Een kernel compileren zonder modules is de eenvoudigste optie, alhoewel
het mogelijk zou moeten zijn als je modules wilt, ik heb het echter niet
geprobeerd. Als er modules worden gebruikt, dan zou je ervoor moeten zorgen
dat je de bovenstaande opties hebt meegecompileerd en niet als modules.
</p>

<p>
Mogelijk moet je afhankelijk van de door jouw gebruikte kernel een kernelpatch
toepassen. Het is een zeer eenvoudige patch die het je mogelijk maakt het
loopback-device als root-bestandssysteem te gebruiken.
<itemize>
<item>Kernelversies voor 2.0.0; hierover heb ik geen informatie.</item>
<item>Kernelversie 2.0.0 tot 2.0.34; je moet een kernelpatch toepassen voor
2.0.x kernels zoals hieronder wordt getoond.</item>
<item>Kernelversie 2.0.35 tot 2.0.x; een kernelpatch is niet nodig.</item>
<item>Kernelversie 2.1.x; je moet een kernelpatch toepassen voor 2.0.x of
2.2.x kernels zoals hieronder wordt getoond, afhankelijk van de exacte 2.1.x
versie.</item>
<item>Kernelversie 2.2.0 tot 2.2.10; je moet de kernelpatch toepassen voor
2.2.x kernels zoals hieronder getoond.</item>
<item>Kernelversie 2.3.x; je moet de kernelpatch toepassen voor 2.2.x kernels
zoals hieronder getoond.</item>
</itemize>
</p>

<p>
Bij 2.0.x kernels moet er in het bestand <tt>/init/main.c</tt> een enkele
regel worden toegevoegd zoals is weergegeven in de hieronder gewijzigde versie.
De regel met <tt>"loop", 0x0700</tt> is de regel die werd toegevoegd.</p>

<p>
<tscreen><verb>
static void parse_root_dev(char * line)
{
	int base = 0;
	static struct dev_name_struct {
		const char *name;
		const int num;
	} devices[] = {
		{ "nfs",     0x00ff },
		{ "loop",    0x0700 },
		{ "hda",     0x0300 },

...

		{ "sonycd",  0x1800 },
		{ NULL, 0 }
	};

...

}
</verb></tscreen>
</p>

<p>
Bij 2.2.x kernels moeten aan het bestand <tt>/init/main.c</tt> drie regels
worden toegevoegd zoals door de gewijzigde versie hieronder wordt getoond.
De regel waarin staat <tt>"loop",
0x0700</tt> en de regel ervoor en erna zijn degenen die moeten worden 
toegevoegd.</p>

<p>
<tscreen><verb>
static struct dev_name_struct {
	const char *name;
	const int num;
} root_dev_names[] __initdata = {
#ifdef CONFIG_ROOT_NFS
	{ "nfs",     0x00ff },
#endif
#ifdef CONFIG_BLK_DEV_LOOP
        { "loop",    0x0700 },
#endif
#ifdef CONFIG_BLK_DEV_IDE
	{ "hda",     0x0300 },

...

	{ "ddv", DDV_MAJOR << 8},
#endif
	{ NULL, 0 }
};
</verb></tscreen>
</p>

<p>Zodra de kernel is geconfigureerd, kan het worden gecompileerd waarmee
een bestand <tt>zImage</tt> wordt geproduceerd
(<tt>make zImage</tt>). Dit bestand zal na de compilatie te vinden zijn in
<tt>arch/i386/boot/zImage</tt>.</p>
</sect1>

<sect1><heading>Aanmaken van de Initi&euml;le Ramdisk Device</heading>

<p>
De initi&euml;le ramdisk wordt het eenvoudigst van het begin aangemaakt als een
loopback-device.
Je zal dit als root moeten doen. De commando's die je hiervoor uit zal moeten
voeren, staan hieronder. Er wordt vanuit gegaan dat ze vanuit de home-directory
van root (<tt>/root</tt>) worden opgestart.
</p>

<p>
<tscreen><verb>
mkdir /root/initrd
dd if=/dev/zero of=initrd.img bs=1k count=1024
mke2fs -i 1024 -b 1024 -m 5 -F -v initrd.img
mount initrd.img /root/initrd -t ext2 -o loop
cd initrd
[maak de bestanden aan]
cd ..
umount /root/initrd
gzip -c -9 initrd.img &gt; initrdgz.img
</verb></tscreen>
</p>

<p>Hier zijn een aantal stappen voor, en die kunnen als volgt worden
beschreven.
<enum>
<item>Maak een mountpoint voor de initi&euml;le ramdisk (een lege directory).
</item>
<item>Maak een leeg bestand van de benodigde grootte aan. Hier heb ik
1024kB gebruikt, mogelijk heb je afhankelijk van de inhoud meer of minder
nodig (de grootte is de laatste parameter).</item>
<item>Maak in het lege bestand een ext2 bestandssysteem aan.</item>
<item>Mount het bestand op het mountpoint, dit gebruikt het loopback-device.
</item>
<item>Ga naar het gemounte loopback-device.</item>
<item>Maak de benodigde bestanden aan (zie hieronder voor details).</item>
<item>Ga uit het gemounte loopback-device.</item>
<item>Unmount het device.</item>
<item>Maak een comprimeerde versie voor later gebruik.</item>
</enum>
</p>

<p><bf>Inhoud Van De Initi&euml;le Ramdisk</bf></p>

<p>De bestanden die je op de ramdisk nodig zult hebben, zijn de minimum
vereisten om commando's uit te kunnen voeren.

<itemize>
<item><tt>/linuxrc</tt> Het script dat wordt uitgevoerd om het msdos
bestandssysteem uit te voeren (zie hieronder).</item>
<item><tt>/lib/*</tt> De dynamische linker en library's voor de
programma's.</item>
<item><tt>/etc/*</tt> De cache die door de dynamische linker wordt
gebruikt (niet echt nodig, maar maakt dat het stopt foutmeldingen te
produceren).</item>
<item><tt>/bin/*</tt> Een shell-interpreter (<tt>ash</tt> omdat het kleiner
is dan <tt>bash</tt>. De <tt>mount</tt> en <tt>losetup</tt> programma's voor
het afhandelen van de DOS-disk en het instellen van de loopback-devices.</item>
<item><tt>/dev/*</tt> De devices die zullen worden gebruikt. Je hebt
<tt>/dev/zero</tt> voor <tt>ld-linux.so</tt> nodig, <tt>/dev/hda*</tt>
om de msdos-disk te mounten en <tt>/dev/loop*</tt> voor het loopback device.
</item>
<item><tt>/mnt</tt>Een lege directory om de msdos-disk op te mounten.</item>
</itemize>
</p>

<p>De initi&euml;le ramdisk die ik gebruikte, vind je hieronder. De inhoud
kwam uit op 800kB waarbij de overhead van het bestandssysteem is inbegrepen.</p>

<p>
<tscreen><verb>
total 18
drwxr-xr-x   2 root     root         1024 Jun  2 13:57 bin
drwxr-xr-x   2 root     root         1024 Jun  2 13:47 dev
drwxr-xr-x   2 root     root         1024 May 20 07:43 etc
drwxr-xr-x   2 root     root         1024 May 27 07:57 lib
-rwxr-xr-x   1 root     root          964 Jun  3 08:47 linuxrc
drwxr-xr-x   2 root     root        12288 May 27 08:08 lost+found
drwxr-xr-x   2 root     root         1024 Jun  2 14:16 mnt

./bin:
total 168
-rwxr-xr-x   1 root     root        60880 May 27 07:56 ash
-rwxr-xr-x   1 root     root         5484 May 27 07:56 losetup
-rwsr-xr-x   1 root     root        28216 May 27 07:56 mount
lrwxrwxrwx   1 root     root            3 May 27 08:08 sh -&gt; ash

./dev:
total 0
brw-r--r--   1 root     root       3,   0 May 20 07:43 hda
brw-r--r--   1 root     root       3,   1 May 20 07:43 hda1
brw-r--r--   1 root     root       3,   2 Jun  2 13:46 hda2
brw-r--r--   1 root     root       3,   3 Jun  2 13:46 hda3
brw-r--r--   1 root     root       7,   0 May 20 07:43 loop0
brw-r--r--   1 root     root       7,   1 Jun  2 13:47 loop1
crw-r--r--   1 root     root       1,   3 May 20 07:42 null
crw-r--r--   1 root     root       5,   0 May 20 07:43 tty
crw-r--r--   1 root     root       4,   1 May 20 07:43 tty1
crw-r--r--   1 root     root       1,   5 May 20 07:42 zero

./etc:
total 3
-rw-r--r--   1 root     root         2539 May 20 07:43 ld.so.cache

./lib:
total 649
lrwxrwxrwx   1 root     root           18 May 27 08:08 ld-linux.so.1 -&gt; ld-linux.so.1.7.14
-rwxr-xr-x   1 root     root        21367 May 20 07:44 ld-linux.so.1.7.14
lrwxrwxrwx   1 root     root           14 May 27 08:08 libc.so.5 -&gt; libc.so.5.3.12
-rwxr-xr-x   1 root     root       583795 May 20 07:44 libc.so.5.3.12

./lost+found:
total 0

./mnt:
total 0
</verb></tscreen>
</p>

<p>De enige complexe stappen hierbij zijn de devices in <tt>dev</tt>. Gebruik
het programma
<tt>mknod</tt> om ze aan te maken, gebruik de bestaande devices in <tt>/dev</tt>
als een template voor het verkrijgen van de benodigde parameters.</p>

<p>
<bf>Het bestand /linuxrc</bf>
</p>

<p>Het bestand <tt>/linuxrc</tt> op de initi&euml;le ramdisk is nodig voor
alle voorbereidingen zodat het loopback-device voor de root-partitie
kan worden gebruikt als 't be&euml;indigt.</p>
<p>
Het voorbeeld hieronder probeert <tt>/dev/hda1</tt> als een msdos-partitie
te mounten en als het daarin slaagt stelt het de bestanden <tt>/linux/linuxdsk.img</tt> als <tt>/dev/loop0</tt> en <tt>/linux/linuxswp.img</tt> als
<tt>/dev/loop1</tt> in.</p>

<p>
<tscreen><verb>
#!/bin/sh

echo INITRD: Probeer /dev/hda1 als msdos te mounten

if /bin/mount -n -t msdos /dev/hda1 /mnt; then

   echo INITRD: Mount OK
   /bin/losetup /dev/loop0 /mnt/linux/linuxdsk.img
   /bin/losetup /dev/loop1 /mnt/linux/linuxswp.img
   exit 0

else

   echo INITRD: Mount mislukt
   exit 1

fi
</verb></tscreen>
</p>

<p>Het eerste device <tt>/dev/loop0</tt> zal het root-device worden en het
tweede <tt>/dev/loop1</tt> device de swap-space.</p>

<p>
Als je waneer je klaar bent als niet-root gebruiker naar de DOS-partitie
wilt kunnen schrijven, dan kun je in plaats daarvan gebruik maken van
<tt>mount -n -t msdos /dev/hda1 /mnt -o uid=0,gid=0,umask=000,quiet</tt>. 
Hiermee zal alle toegang tot de DOS-partitie naar root worden ingedeeld
en zullen de permissies dienovereenkomstig worden ingesteld.</p>
</sect1>

<sect1><heading>Aanmaken van het Root Device</heading>

<p>
Het te gebruiken root-device is het bestand <tt>linuxdsk.img</tt>. Je zal
dit op dezelfde wijze, maar dan groter, aan moeten maken zoals de
initi&euml;le ramdisk werd aangemaakt. Je kunt iedere gewenste
Linux-installatie op deze disk installeren.</p>

<p>
De eenvoudigste manier zou kunnen zijn om er een bestaande Linux-installatie
naar te kopi&euml;ren. Een alternatief is er een nieuwe Linux-installatie
op te kopi&euml;ren.</p>

<p>
Ervan uitgaande dat je dit hebt gedaan, zijn er nog een paar kleine
wijzigingen nodig.</p>

<p>
Het bestand <tt>/etc/fstab</tt> moet naar de root-partitie en de swap
verwijzen door gebruik te maken van de twee loopback-devices die op de
initi&euml;le ramdisk zijn ingesteld.</p>

<p>
<tscreen><verb>
/dev/loop0     /      ext2   defaults 1 1
/dev/loop1     swap   swap   defaults 1 1
</verb></tscreen>
</p>

<p>Dit zal ervoor zorgen dat de kernel niet in de war zal raken waar
het root-device is als het echte root-device zal worden gebruikt.
Bovendien maakt het 't mogelijk de swap-space op dezelfde manier
toe te voegen zoals het gewoonlijk wordt gedaan.
Je zou iedere andere verwijzing naar een rootdisk-device of swap-partitie
moeten verwijderen.
</p>

<p>
Als je nadat Linux is opgestart de DOS-partitie wilt kunnen lezen, dan zal
je nog een aantal extra wijzigingen moeten maken.</p>

<p>
Maak een directory genaamd <tt>/initrd</tt> aan, hier zal de initi&euml;le
ramdisk worden gemount zodra het loopback root-bestandssysteem is gemount.</p>
<p>
Maak een symbolische link genaamd <tt>/DOS</tt> aan dat verwijst naar
<tt>/initrd/mnt</tt> waar de echte DOS-partitie zal worden gemount.</p>
<p>
Voeg een regel toe aan het rc bestand waarmee de disks worden gemount.
Hier zal het commando
<tt>mount -f -t msdos /dev/hda1 /initrd/mnt</tt> worden uitgevoerd, waarmee
een 'nep' mount van de DOS-partitie zal worden aangemaakt, waardoor alle
programma's (zoals <tt>df</tt>) zal weten dat de DOS-partitie is gemount en
waar het te vinden is. Als je andere opties gebruikte in het bestand
<tt>/linuxrc</tt> dan zou je die ook hier moeten gebruiken.</p>

<p>
Een Linux-kernel op dit root-device is niet nodig, aangezien dat reeds eerder
is geladen. Als je echter gebruik maakt van modules, dan zou je ze net als
anders op dit device in moeten voegen.</p>
</sect1>

<sect1><heading>Aanmaken van het Swap Device</heading>

<p>
Het root-device dat je zal gaan gebruiken, is het bestand
<tt>linuxswap.img</tt>. Het swap-device is zeer eenvoudig aan te maken.
Maak een leeg bestand aan zoals dit werd gedaan voor de initi&euml;le
ramdisk en start dan <tt>mkswap linuxswap.img</tt> op om het te
initialiseren.</p>

<p>
De grootte van de swap-space is afhankelijk van wat je van plan bent met
het ge&iuml;nstalleerde systeem, maar ik raad je een hoeveelheid RAM aan
tussen 8 MB en de hoeveelheid RAM dat je hebt.</p>
</sect1>

<sect1><heading>Aanmaken van de MSDOS-Directory</heading>

<p>
De bestanden die gebruikt gaan worden, moeten naar de DOS-partitie worden
verplaatst.</p>

<p>
Dit zijn de bestanden die nodig zijn in de DOS-directory genaamd
<tt>C:\LINUX</tt>:

<itemize>
<item><tt>LINUXDSK.IMG</tt>De disk-image dat het root-device wordt.
</item>
<item><tt>LINUXSWP.IMG</tt> De swap space.
</item>
</itemize>
</p>
</sect1>

<sect1><heading>Aanmaken van de opstartdiskette</heading>

<p>
De opstartdiskette die wordt gebruikt is slechts een gewone DOS geformatteerde
opstartdiskette.</p>
<p>
Deze wordt vanuit DOS met behulp van <tt>format a: /s</tt> aangemaakt.</p>

<p>
Op deze disk zal je een <tt>AUTOEXEC.BAT</tt> aan moeten maken (als hieronder)
en de kernel, gecomprimeerde initi&euml;le ramdisk en het uitvoerbare bestand
<tt>LOADLIN</tt> naar moeten kopi&euml;ren.

<itemize>
<item><tt>AUTOEXEC.BAT</tt> Het door DOS automatisch uitgevoerde batchbestand.
</item>
<item><tt>LOADLIN.EXE</tt> Het uitvoerbare programma <tt>LOADLIN</tt>.
</item>
<item><tt>ZIMAGE</tt> De Linux-kernel.
</item>
<item><tt>INITRDGZ.IMG</tt> De gecomprimeerde initi&euml;le ramdisk-image.
</item>
</itemize>
</p>

<p>In het bestand <tt>AUTOEXEC.BAT</tt> hoort slechts de volgende regel voor te 
komen.

<tscreen><verb>
\loadlin \zImage initrd=\initrdgz.img root=/dev/loop0 ro
</verb></tscreen>
</p>

<p>Hiermee wordt het te gebruiken kernel-image gespecificeerd, de initi&euml;le
ramdisk-image, het root-device nadat de initi&euml;le ramdisk klaar is en
dat de root-partitie read-only zal worden gemount.</p>
</sect1>
</sect>

<sect><heading>Het booten van het Systeem</heading>

<p>
Alles wat je nodig hebt om vanaf dit nieuwe root-device te booten, is dat
de diskette geprepareerd zoals hiervoor is beschreven in het diskettestation
is gedaan om vanaf te booten.</p>

<p>
Je zal de volgende reeks gebeurtenisssen te zien krijgen.
<enum>
<item>DOS boot
</item>
<item>AUTOEXEC.BAT start
</item>
<item>LOADLIN wordt uitgevoerd
</item>
<item>De Linux-kernel wordt naar het geheugen gekopieerd
</item>
<item>De initi&euml;le ramdisk wordt naar het geheugen gekopieerd
</item>
<item>De Linux-kernel is begonnen aan de uitvoering
</item>
<item>Het bestand <tt>/linuxrc</tt> op de initi&euml;le ramdisk wordt uitgevoerd
</item>
<item>De DOS-partitie is gemount en de root en swap-devices ingesteld
</item>
<item>De bootreeks continueert vanaf het loopback-device
</item>
</enum>
</p>

<p>Wanneer het systeem hiermee klaar is, kun je de opstartdiskette verwijderen
en het Linux-systeem gebruiken.</p>

<sect1><heading>Mogelijke Problemen Met Oplossingen</heading>

<p>
Er zijn een aantal fasen waarin dit proces zou kunnen mislukken, ik zal
proberen uit te leggen wat dat zijn en wat te controleren.</p>

<p>
Wanneer DOS boot is eenvoudig te herkennen door de melding <tt>MS-DOS
Starting ...</tt> op het scherm. Als deze melding niet verschijnt, dan is
de diskette &oacute;f niet opstartbaar of het systeem kan niet worden
opgestart vanaf het diskettestation.</p>

<p>
Wanneer de commando's in het <tt>AUTOEXEC.BAT</tt> bestand worden
uitgevoerd, zouden deze standaard naar het scherm moeten worden ge&euml;choot.
In dit geval gaat het slechts om een enkele regel waarmee
<tt>LOADLIN</tt> wordt opgestart.</p>

<p>
Wanneer <tt>LOADLIN</tt> wordt uitgevoerd, zal het twee zeer zichtbare
dingen doen, als eerste zal het de kernel in het geheugen laden, ten tweede
zal het de ramdisk naar het geheugen kopi&euml;ren.
Beiden zijn te herkennen aan een <tt>Loading...</tt> melding.</p>

<p>
De kernel begint zichzelf te comprimeren, hierdoor kunnen <bf>crs</bf>
fouten ontstaan als de kernel-image beschadigd is.
Vervolgens zal het de initilisatiereeks starten, welke zeer woordenrijk
met diagnostische meldingen is. Tijdens deze fase is
het laden van het initi&euml;le ramdisk-device ook zichtbaar.</p>

<p>
Tijdens de uitvoering van het bestand <tt>/linuxrc</tt> zijn er geen
diagnostische meldingen, maar die kun je zelf als hulp bij het debuggen
toevoegen. Als het in dit stadium niet lukt het loopback-device als het
root-device in te stellen, dan zie je wellicht een melding dat er
geen root-device is en breekt de kernel af.
</p>

<p>
De normale bootreeks van het nieuwe root-device zal nu verdergaan en
hierbij worden heel wat meldingen weergegeven.
Er kunnen problemen optreden met het read-write mounten van het root-device,
maar de commandoregel-optie '<tt>ro</tt>' van LOADLIN kan dit verhelpen.
Andere problemen die op kunnen treden bestaan daaruit dat de bootreeks
van slag is over waar het root-device is, dit is waarschijnlijk te wijten
aan een probleem met <tt>/etc/fstab</tt>.</p>

<p>
Wanneer de bootreeks is voltooid, blijft er nog een probleem over dat
programma's van slag zijn of de DOS-partitie wel of niet is gemount.
Daarom is het een goed idee het eerder beschreven nep mount commando
te gebruiken. Dit maakt 't leven er een stuk eenvoudiger op als je de
bestanden op het DOS-device wilt benaderen.</p>
</sect1>

<sect1><heading>Refererende Documenten</heading>

<p>
De documenten die ik gebruikte om mijn eerste loopback root-bestandssysteem
aan te maken, waren:


<itemize>
<item>De Linux kernelsource, in het bijzonder <tt>init/main.c</tt></item>
<item>De Linux kerneldocumentatie, in het bijzonder
<tt>Documentatie/initrd.txt</tt> en <tt>Documentation/ramdisk.txt</tt>.</item>
<item>De <tt>LILO</tt> documentatie.</item>
<item>De <tt>LOADLIN</tt> documentatie</item>
</itemize></p>
</sect1>
</sect>

<sect><heading>Andere Mogelijkheden met het Loopback Root Device</heading>

<p>
Nu het principe van het booten van een bestandssysteem in een bestand
op een DOS-partitie is bewezen, zijn er veel andere dingen die je nu kunt doen.
</p>


<sect1><heading>DOS Harddisk Installatie</heading>

<p>
Als het mogelijk is Linux vanaf een bestand op een DOS-harddisk te booten door
gebruik te maken van een opstartdiskette, dan is het uiteraard ook mogelijk
dit te doen door de harddisk zelf te gebruiken.</p>
<p>
Een configuratie bootmenu kan worden gebruikt met de optie om
<tt>LOADLIN</tt> vanuit <tt>AUTOEXEC.BAT</tt> uit te voeren.
Hierdoor zal de bootreeks sneller zijn, maar verder is het identiek.
</p>
</sect1>

<sect1><heading>LILO Boot Installatie</heading>

<p>
Het gebruik van <tt>LOADLIN</tt> is slechts &eacute;&eacute;n optie voor 
het booten van een Linux-kernel. Er is ook <tt>LILO</tt> dat vrijwel
hetzelfde doet maar zonder dat het DOS nodig heeft.</p>
<p>
In dit geval kan de voor DOS geformatteerde diskette worden vervangen door
&eacute;&eacute;n die met ext2fs is geformatteerd.
De details zijn anders zeer vergelijkbaar, met de kernel en de initi&euml;le
ramdisk bestanden op die disk.</p>
<p>
De reden dat ik koos voor de <tt>LOADLIN</tt> methode is dat de argumenten
die aan <tt>LILO</tt> moeten worden meegegeven wat complex zijn.
Ook is het vanzelfsprekender voor een terloopse waarnemer waar de
diskette voor is, aangezien het onder DOS kan worden ingelezen.</p>
</sect1>

<sect1><heading>VFAT / NTFS Installatie</heading>

<p>
Ik heb de NTFS-methode geprobeerd en had er geen problemen mee.
De driver voor het NTFS bestandssysteem is in versie 2.0.x geen standaard
kerneloptie, maar het is als een patch beschikbaar vanaf
<htmlurl url="http://www.informatik.hu-berlin.de/~loewis/ntfs/"
name="http://www.informatik.hu-berlin.de/~loewis/ntfs/">. Onder versie 2.2.x
is de NTFS driver standaard in de kernel opgenomen.</p>
<p>
De enige wijzigingen voor het VFAT- of NTFS-opties bestaan uit de initi&euml;le
ramdisk, het bestand <tt>/linuxrc</tt> moet in plaats van msdos een 
bestandssysteem van het type vfat of ntfs mounten.</p>
<p>
Ik zou niet weten waarom dit niet tevens op een VFAT-partitie zou werken.</p>
</sect1>

<sect1><heading>Linux zonder herpartitioneren installeren</heading>

<p>
Voor het proces waarbij Linux vanaf een standaarddistributie op een PC wordt
ge&iuml;nstalleerd, is een diskette nodig en het herpartitioneren van
de disk. Deze fase zou in plaats daarvan kunnen worden bewerkstelligd door
een bootdiskette, waarmee een leeg loopback-device en een swapbestand worden
aangemaakt. Hiermee zou het mogelijk worden de installatie als normaal
voort te zetten, maar zou in het loopbackdevice installeren in plaats van op
een partitie.</p>
<p>
Dit zou als alternatief voor een <tt>UMSDOS</tt> installatie kunnen worden
gebruikt, het zou effici&euml;nter in diskgebruik zijn, aangezien de
minimum inbeslaggenomen eenheid in het ext2 bestandssysteem 1kB is in plaats
van de tot aan 32kB op DOS-partities.
Het kan ook op VFAT en als NTFS geformatteerde disks worden gebruikt
welke anders een probleem zou zijn.</p>
</sect1>

<sect1><heading>Booten van een Niet-opstartbaar device</heading>

<p>
Deze methode kan ook worden gebruikt om een Linux systeem vanaf een device
te booten dat normaal gesproken niet opstartbaar is.</p>

<p>
<itemize>
<item>CD-Rom</item>
<item>Zip Disks</item>
<item>Parallelle poort diskdrives</item>
</itemize>
</p>

<p>Uiteraard zijn er nog vele andere devices die zouden kunnen worden gebruikt, 
NFS root filesystems zijn reeds in de kernel als een optie opgenomen, maar
in plaats daarvan zou ook de hier beschreven methode kunnen worden gebruikt.
</p>
</sect1>
</sect>
</article>
</linuxdoc>