Versie notities

Graham Chapman schreef de oorspronkelijke Bootdisk-HOWTO en hij ondersteunde het tot aan versie 3.1. Tom Fawcett begon als mede-auteur zo rond de tijd dat kernel v2 werd geïntroduceerd. Hij is de huidige beheerder van het document.

Deze informatie is bedoeld voor Linux op het Intel platform. Veel van deze informatie kan ook toepasbaar zijn voor Linux op andere processors, maar we hebben hiermee geen ervaring uit de eerste hand. Neem alsjeblieft contact met ons op als je ervaring hebt met bootdisks voor andere platformen.

Nog te doen

Enige vrijwilligers?

1. Beschrijf (of link naar een ander document dat beschrijft) hoe andere op opstartbare disk lijkende dingen, zoals CDROM's, ZIP-disks en LS110-disks te maken.

2. Beschrijf hoe om te gaan met de zeer grote libc.so shared library's. De opties zijn voornamelijk om oudere, kleinere library's te krijgen of bestaande library's kleiner te krijgen.

3. Heranalyseer distributie-bootdisks en werk de sectie "Hoe de Pro's het doen" bij.

4. Verwijder de sectie die beschrijft hoe bestaande distributie-bootdisks bij te werken. Dit geeft gewoonlijk meer problemen dan het waard is.

5. Herschrijf/stroomlijn de sectie Probleemoplossing.

Feedback en krediet

Ik verwelkom alle feedback, goed of slecht, over de inhoud van dit document. Ik/we heb(ben) mijn/onze best gedaan er zeker van te zijn dat de instructies en de informatie in dit document accuraat en betrouwbaar zijn. Laat het me alsjeblieft weten als je fouten vindt of als er iets ontbreekt. Geef alsjeblieft het versienummer van het document op waarnaar je refereert als je schrijft.

We bedanken de vele mensen die ons assisteerde met correcties en suggesties. Hun bijdragen hebben het veel beter gemaakt dan we het ooit alleen voor elkaar zouden kunnen hebben krijgen.

Stuur opmerkingen, correcties, en vragen naar de auteur via het bovenstaande e-mailadres. Het maakt me niet uit je proberen antwoord te geven op vragen, maar als je een specifieke vraag hebt over waarom je bootdisk niet werkt, lees dan alsjeblieft eerst de paragraaf Probleemoplossing .

Distributiebeleid

Copyright © 1995,1996,1997,1998,1999,2000 door Tom Fawcett en Graham Chapman. Dit document mag onder de voorwaarden uiteengezet in de Linux Documentation Project Licentie worden gedistribueerd. Neem alsjeblieft contact op met de auteurs als het je niet lukt aan de licentie te komen.

Dit is vrije documentatie. Het wordt gedistribueerd in de hoop dat het van nut zal zijn, maar zonder enige garantie ; zelfs zonder de impliciete garantie van verkoopbaarheid of geschiktheid voor een bepaald doel.

Het bootproces

Alle PC-systemen starten het bootproces door code in ROM (in het bijzonder de BIOS) uit te voeren om de sector vanaf sector 0, cylinder 0 van de bootdisk te laden. De bootdisk is gewoonlijk de diskette in het eerste diskettestation (toegekend als A: in DOS en /dev/fd0 onder Linux). De BIOS probeert dan deze sector uit te voeren. Op de meeste opstartbare disks, bevat sector 0, cylinder 0 zowel:

• code van een bootloader zoals LILO, die de kernel lokaliseert, het laadt en het uitvoert om de boot zuiver te starten als

• de start van een besturingssysteem zoals Linux.

Als een Linux-kernel raw naar diskette is gekopieerd, zal de eerste sector de eerste sector van de Linux-kernel zelf zijn. Deze eerste sector zal het bootproces vervolgen door de rest van de kernel vanaf het bootdevice te laden.

Zodra de kernel volledig is geladen, neemt het een basisinitialisatie van devices door. Het probeert vervolgens een root bestandssysteem vanaf een device te laden en mounten. Een rootbestandssysteem is gewoon een bestandssysteem dat is gemount als ``/''. De kernel moet worden verteld waar naar het rootbestandssysteem te zoeken; als het daar geen laadbaar image kan vinden, stopt het.

In een aantal bootsituaties - vaak wanneer van diskette wordt geboot - wordt het rootbestandssysteem in ramdisk geladen, dit is RAM die door het systeem als een disk wordt benaderd. Er zijn twee redenen waarom het systeem naar ramdisk laadt. Ten eerste is RAM verscheidene malen sneller dan een diskette, dus de werking van het systeem is snel; en ten tweede kan de kernel een gecomprimeerd bestandssysteem vanaf de diskette laden en het in de ramdisk decomprimeren, waardoor het mogelijk is meer bestanden op de diskette te persen.

Als het rootbestandssysteem éénmaal is geladen en gemount, zie je een melding als:

VFS: Mounted root (ext2 filesystem) readonly.

Hier vindt het systeem het programma init op het rootbestandssysteem (in /bin of /sbin) en voert het uit. init leest zijn configuratiebestand /etc/inittab in, zoekt naar een regel aangeduid met sysinit, en voert het in die regel genoemde script uit. Het sysinit script is gewoonlijk iets als /etc/rc of /etc/init.d/boot. Dit script bestaat uit een set shell-opdrachten waarmee basissysteemservices worden ingesteld, zoals:

• Het op alle disks uitvoeren van fsck,

• Het laden van de benodigde kernelmodules,

• Het starten van swappen,

• Het initialiseren van het netwerk,

• Het mounten van de disks vermeld in fstab.

Dit script roept vaak diverse andere scripts aan voor de modulaire initialisatie. In bijvoorbeeld de structuur van SysVinit, bevat de directory /etc/rc.d/ een complexe structuur aan subdirectory's waarvan de bestanden specificeren hoe de meeste systeemservices te activeren of af te sluiten. Op een bootdisk is het sysinit-script echter vaak heel simpel.

Wanneer het sysinit-script klaar is, geeft het de controle terug aan init, die dan overgaat op het standaard runlevel, met het sleutelwoord initdefault gespecificeerd in inittab. In de regel met het runlevel wordt gewoonlijk een programma als getty gespecificeerd, welke verantwoordelijk is voor het afhandelen van communicaties op de console en tty's. Het is het getty programma welke de bekende ``login:'' prompt afdrukt. Het getty programma roept op zijn beurt het programma login aan om de loginvalidatie af te handelen en gebruikerssessies in te stellen.

Disktypes

Na het basisbootproces te hebben geïnspecteerd, kunnen we nu diverse daarbij betrokken soorten disks definiëren. We classificeren disks in vier typen. Bij de bespreking in dit gehele document maken we, tenzij anders aangegeven, gebruik van de term ``disk'' om naar diskettes te refereren, alhoewel het meeste net zo goed ook voor harddisks zou kunnen gelden.

In het algemeen bedoelen we wanneer we het hebben over ``het bouwen van een bootdisk'', het aanmaken van zowel de boot (kernel) als de root (bestanden). Ze mogen zowel samen (een enkele boot-/rootdisk) als apart (boot + rootdisks) voorkomen. De meest flexibele benadering voor rescue-disks is waarschijnlijk het gebruik van boot- en rootdiskettes, en één of meer utility-diskettes voor datgene wat te veel is voor op deze disks.

Overzicht

Op een rootbestandssysteem moet al datgene voorkomen wat nodig is om een volledig Linux-systeem te ondersteunen. Hiervoor moeten op de disk de minimum-vereisten voor een Linux-systeem worden opgenomen:

• De basis bestandssysteemstructuuur,

• Minimum set directory's: /dev, /proc, /bin, /etc, /lib, /usr, /tmp,

• Basisset utility's: sh, ls, cp, mv, enz.,

• Minimumset config bestanden: rc, inittab, fstab, enz.,

• Devices: /dev/hd*, /dev/tty*, /dev/fd0, enz.,

• Runtime library om in basisfuncties die door de utility's worden gebruikt te voorzien.

Uiteraard is ieder systeem pas dan van nut als je er iets onder kunt draaien, en een rootdiskette komt meestal alleen van pas als je iets kunt doen als:

• Het controleren van een bestandssysteem op een andere disk, om bijvoorbeeld je rootbestandssysteem op een harddisk te controleren, moet je Linux van een andere disk kunnen booten, zoals je dat kan met een rootdiskettesysteem. Vervolgens kun je fsck dan uitvoeren op je oorspronkelijke rootdisk terwijl het niet is gemount.

• Het herstellen van je gehele of gedeeltelijke oorspronkelijke rootdisk vanaf een backup door gebruik te maken van archief- en compressie- utility's zoals cpio, tar, gzip en ftape.

We zullen beschrijven hoe een gecomprimeerd bestandssysteem op een ramdisk te bouwen. Het wordt zo genoemd omdat het op disk is gecomprimeerd en bij het booten op een ramdisk wordt gedecomprimeerd. Met een gecomprimeerd bestandssysteem kunnen er veel bestanden (bij benadering zes megabyte) op een standaard 1440K diskette. Omdat het bestandssysteem veel groter is dan een diskette, kan het niet op de diskette worden gebouwd. We moeten het elders bouwen, het comprimeren, en dan naar diskette kopiëren.

Aanmaken van het bestandssysteem

Om een dergelijk rootbestandssysteem te bouwen, heb je een reserve device nodig welke groot genoeg is alle bestanden voor compressie te bevatten. Je hebt een device nodig dat capabel is om ongeveer vier megabyte te bevatten. Je hebt verscheidene keuzes:

• Gebruik een ramdisk (DEVICE = /dev/ram0). In dit geval wordt geheugen gebruikt om een diskette te simuleren. De ramdisk moet groot genoeg zijn voor een bestandssysteem van passende grootte. Controleer je configuratiebestand (/etc/lilo.conf) op een regel als RAMDISK = nnn waarmee het maximum RAM dat in beslag kan worden genomen door een ramdisk als je gebruik maakt van LILO. De standaardwaarde is wat voldoende zou moeten zijn. Het is beter niet te proberen een dergelijke ramdisk te gebruiken op een computer met minder dan 8MB RAM. Controleer voor de zekerheid of je een device hebt als /dev/ram0, /dev/ram of /dev/ramdisk. Als dit niet zo is, maak /dev/ram0 dan aan met mknod (major nummer 1, minor 0).

• Als je een ongebruikte harddiskpartitie hebt die groot genoeg is (verscheidene megabytes) dan is dit acceptabel.

• Gebruik een loopback device, waarmee het mogelijk is een diskbestand als een device te laten fungeren. Door gebruik te maken van een loopback-device kun je op je harddisk een bestand van drie megabyte aanmaken en er het bestandssysteem op bouwen.

  Typ man losetup voor instructies over het gebruik van loopback devices. Als je losetup niet hebt, kun je het samen met compatibele versies van mount en unmount verkrijgen vanuit het package util-linux in de directory ftp://ftp.win.tue.nl/pub/linux/utils/util-linux/.

  Als je op je systeem geen loop-device (/dev/loop0 /dev/loop1, enz.) hebt, zal je het aan moeten maken met ``mknod /dev/loop0 b 7 0''. Zodra je deze speciale mount en umount binary's hebt geïnstalleerd, maak je op een hardisk met voldoende capaciteit een tijdelijk bestand aan (bv, /tmp/fsfile). Je kunt een opdracht gebruiken als:

  dd if=/dev/zero of=/tmp/fsfile bs=1k count=nnn

  om een nnn-blockbestand aan te maken.

  Gebruik hieronder dit bestand in plaats van DEVICE. Wanneer je een mount-opdracht aanroept, moet je de optie -o loop aan mount meegeven om aan te geven dat mount een loopback-device gebruikt. Bijvoorbeeld:

  mount -o loop -t ext2 /tmp/fsfile /mnt

  zal /tmp/fsfile via een loopback device op het mount point /mnt mounten. Een df zal dit bevestigen.

Nadat je voor één van deze opties hebt gekozen, prepareer je het DEVICE met:

dd if=/dev/zero of=DEVICE bs=1k count=4096

Deze opdracht vult het device op met nullen.

Het device met nullen opvullen is van groot belang omdat het bestandssysteem later zal worden gecomprimeerd, dus alle ongebruikte delen zouden met nullen moeten worden opgevuld om een maximum compressie te bereiken. Houd dit feit in gedachten wanneer je bestanden vanaf je rootbestandssysteem verwijdert. Het bestandssysteem zal de blokken correct vrijgeven, maar het vult ze niet weer met nullen op. Als je veel verwijdert en kopieert, kan je gecomprimeerde bestandssysteem uiteindelijk veel groter worden dan nodig is.

Maak vervolgens het bestandssysteem aan. De Linux-kernel herkent voor rootdisks twee typen bestandssystemen die automatisch naar ramdisk worden gekopieerd. Dit zijn minix en ext2, waarvan ext2 de voorkeur heeft. Als je ext2 gebruikt, vind je het wellicht handig de optie -i mee te geven om meer inodes dan de standaardwaarde op te geven; -i 2000 wordt aanbevolen zodat je geen inodes te kort komt. Als alternatief kun je op inodes besparen door veel van de onnodige /dev bestanden te verwijderen. mke2fs zal op een 1.44Mb diskette standaard 360 inodes aanmaken. Ik merkte dat 120 inodes op mijn huidige rescue rootdiskette ruim voldoende is, maar als je alle devices in de directory /dev opneemt, dan zal het de 360 makkelijk overschrijden. Het gebruik van een gecomprimeerd rootbestandssysteem maakt een groter bestandssysteem mogelijk, en vandaar standaard meer inodes, maar mogelijk moet je toch het aantal bestanden nog verminderen of het aantal inodes verhogen.

Dus de opdracht die je gaat gebruiken, ziet er ongeveer zo uit:

mke2fs -m 0 -i 2000 DEVICE

(Als je van een loopback-device gebruik maakt, moet DEVICE worden vervangen door het diskbestand).

De opdracht mke2fs zal automatisch de beschikbare ruimte detecteren en zichzelf dienovereenkomstig configureren. De parameter ``-m 0'' voorkomt dat er ruimte voor root wordt gereserveerd, en daardoor blijft er meer bruikbare ruimte op de disk over.

Mount dan het device:

mount -t ext2 DEVICE /mnt

(Je moet een mountpoint /mnt aanmaken als het nog niet voorkomt). In de hiernavolgende secties zal ervan worden uitgegaan dat alle namen van doeldirectory's zich relatief ten opzichte van /mnt bevinden.

Het bestandssysteem vullen

Hier is een redelijke minimumset directory's voor je rootbestandssysteem [1]:

• /dev -- Devices, vereist voor I/O

• /proc -- Directory stub vereist voor het proc-bestandssysteem

• /etc -- Systeemconfiguratiebestanden

• /sbin -- Kritieke systeembinary's

• /bin -- Essentiële binary's die worden aangemerkt als onderdeel van het systeem

• /lib -- Shared library's om te voorzien in run-time support

• /mnt -- Een mountpoint voor het beheer van andere disks

• /usr -- Extra utility's en applicaties

Drie van deze directory's zullen op het rootbestandssysteem leeg zijn, dus ze hoeven alleen met mkdir te worden aangemaakt. De directory /proc is eigenlijk een stub waaronder het proc-bestandssysteem wordt geplaatst. De directory's /mnt en /usr zijn slechts mountpoints voor gebruik nadat het boot/root systeem draait. Vandaar nogmaals, hoeven deze directory's alleen te worden aangemaakt.

De overblijvende vier directory's worden in de volgende secties beschreven.

---

/dev

Een /dev directory met voor alle devices een speciaal bestand om door het systeem te worden gebruikt is voor ieder Linux-systeem verplicht. De directory zelf is een normale directory en deze kan met mkdir op de gebruikelijke wijze worden aangemaakt. De speciale bestanden voor de devices moeten echter op een speciale manier, met de opdracht mknod worden aangemaakt.

Er is echter een kortere weg. Kopieer de inhoud van je bestaande /dev directory, en verwijder die bestanden die je niet wilt. Het enige waar je op moet letten is dat je de speciale bestanden voor de devices kopieert met de optie -R. Hiermee zal de directory worden gekopieerd zonder dat er zal worden geprobeerd de inhoud van de bestanden te kopiëren. Zorg ervoor dat je de hoofdletter R gebruikt. De opdracht is:

cp -dpR /dev /mnt

ervan uitgaande dat de diskette is gemount op /mnt. De dp switches zorgen ervoor dat symbolische links als links worden gekopieerd in plaats van dat het doelbestand wordt gebruikt en dat de oorspronkelijke bestandskenmerken blijven behouden, dus dat de informatie over de eigenaren blijft behouden.

Als je het op een moeilijke manier wilt doen, gebruik je ls -l om de major en minor device-nummers voor de gewenste devices weer te geven, en maak je ze aan op de diskette met mknod.

Alhoewel de devices zijn gekopieerd, loont het de moeite na te kijken dat alle door jou benodigde devices op de rescue-diskette zijn geplaatst. ftape maakt bijvoorbeeld gebruik van tape devices, dus zal je alle tape devices moeten kopiëren als je van plan bent je floppy tapedrive vanaf de bootdisk te benaderen.

Voor ieder speciaal apparaatbestand is een inode vereist, en inodes kunnen zo nu en dan een schaarse bron vormen, vooral op diskette bestandssystemen. Het heeft daarom zin alle niet benodigde speciale bestanden voor de devices uit de directory /dev van de diskette te verwijderen. Als je bijvoorbeeld geen SCSI-disks hebt, kun je alle apparaatbestanden te beginnen met sd gerust verwijderen. Op vergelijkbare wijze kunnen alle apparaatbestanden beginnend met cua worden verwijderd, als je niet van plan bent je seriële poort te gaan gebruiken.

Zorg er in ieder geval voor dat je de volgende bestanden in deze directory opneemt: console, kmem, mem, null, ram0 en tty1.

        ls -ltru

---

/bin en /sbin

De directory /bin is een prima plaats voor extra utility's die je nodig hebt voor de uitvoering van basisbewerkingen, utility's zoals ls, mv, cat en dd. Zie Aanhangsel C voor een voorbeeldlijst met bestanden die in de directory's bin en /sbin worden geplaatst. Hierin zijn geen utility's opgenomen die nodig zijn om gegevens vanaf een backup terug te zetten, zoals cpio, tar en gzip. Dat komt doordat ik die op een aparte utility-diskette plaats, om ruimte te besparen op de boot-/rootdiskette. Zodra de boot-/rootdiskette is geboot, wordt het naar de ramdisk gekopieerd waarbij het diskettestaion vrijkomt om een andere diskette, de utility-diskette te kunnen mounten. Ik mount deze gewoonlijk als /usr.

De aanmaak van een utility-diskette wordt hierna beschreven in de paragraaf Bouwen van een utility-disk. Waarschijnlijk is het wenselijk een kopie van dezelfde versie backuputitily's, die worden gebruikt om de backups te schrijven, te beheren, zodat je geen tijd verspilt bij het proberen te installeren van versies die je backuptapes niet in kunnen lezen.

Verzeker je ervan dat je de volgende programma's opneemt: init, getty of equivalent, login, mount, een shell die capabel is voor het uitvoeren van je rc-scripts, een link vanuit sh naar je shell.

Voorziening voor PAM en NSS

Mogelijk zijn er voor je systeem dynamisch laadbare library's nodig die niet zichtbaar zijn voor ldd. Als je hierin niet voorziet, kan het zijn dat je problemen krijgt bij het inloggen of het gebruiken van je bootdisk.

Modules

Als je een modulaire kernel hebt, overweeg dan welke modules je na het booten vanaf je bootdisk wilt laden. Wellicht dat je ftape en zftape modules op wilt nemen als je backuptapes op floppytape zijn, modules voor SCSI-devices als je ze hebt, en mogelijk modules voor PPP of SLIP ondersteuning als je het net in noodgeval wilt benaderen.

Deze modules kunnen in /lib/modules worden geplaatst. Je zou ook insmod, rmmod en lsmod op moeten nemen. En afhankelijk van of je modules automatisch wilt laden, ook modprobe, depmod en swapout. Als je kerneld gebruikt, neem het dan samen met /etc/conf.modules op.

Het belangrijkste voordeel bij het gebruik van modules is echter dat je niet kritieke modules naar een utility-disk kunt verplaatsen en ze kunt laden wanneer ze nodig zijn. Dus gebruik je minder ruimte op je rootdisk. Als je met veel verschillende devices te maken hebt, heeft deze benadering de voorkeur in vergelijking met het bouwen van één zeer grote kernel met veel ingebouwde drivers.

Om een gecomprimeerd ext2 bestandssysteem te kunnen booten, moet je ramdisk en ext2 ondersteuning hebben ingebouwd. Ze kunnen niet als modules worden toegevoegd.

Een paar laatste details

Een aantal systeemprogramma's, zoals login, produceert foutmeldingen als het bestand /var/run/utmp en de directory /var/log niet voorkomen. Dus:

        mkdir -p /mnt/var/{log,run{
        touch /mnt/var/run/utmp

Nadat je tenslotte alle benodigde library's hebt ingesteld, pas je ldconfig toe op /etc/ld.so.cache op het rootbestandssysteem opnieuw aan te maken. De cache vertelt de loader waar het de library's vindt. Roep de volgende opdrachten aan voor het opnieuw maken van ld.so.cache:

chdir /mnt; chroot /mnt /sbin/ldconfig

De chroot is noodzakelijk omdat ldconfig de cache voor het rootbestandssysteem altijd opnieuw aanmaakt.

Het samenstellen

Zodra je klaar bent met het construeren van het rootbestandssysteem, unmount je het, kopieer je het naar een bestand en comprimeer je het:

umount /mnt dd if=DEVICE bs=1k | gzip -v9 > rootfs.gz

Wanneer dit klaar is, heb je een bestand genaamd rootfs.gz. Dit is je gecomprimeerde rootbestandssysteem. Controleer de grootte ervan om er zeker van te zijn dat het op een diskette zal passen; als dit niet zo is, zal je terug moeten gaan en wat bestanden moeten verwijderen. In de paragraaf Terugbrengen van de grootte van het rootbestandssysteem staat diverse aanbevelingen voor het terugdringen van de omvang van het rootbestandssysteem.

Transporteren van de kernel met LILO

Het eerste wat je moet doen is een klein configuratiebestand voor LILO aanmaken. Het zal er ongeveer zo uit moeten komen te zien:

boot =/dev/fd0 install =/boot/boot.b map =/boot/map read-write backup =/dev/null compact image = KERNEL label = Bootdisk root =/dev/fd0

Zie de gebruikersdocumentatie van LILO voor een uitleg van deze parameters. Je zal waarschijnlijk ook de regel append=... aan dit bestand toe moeten voegen, kijk hiervoor in het bestand /etc/lilo.conf op je harddisk.

Bewaar dit bestand als bdlilo.conf.

Je zal nu een klein bestandssysteem aan moeten maken, wat we een kernelbestandssysteem zullen noemen, om het te onderscheiden van het rootbestandssysteem.

Zoek als eerste uit hoe groot het bestandssysteem zal moeten zijn. Neem de omvang van je kernel in blokken (de grootte weergegeven door ``ls -l KERNEL'' gedeeld door 1024 en afgerond naar boven) en tel hier 50 bij op. Vijftig blokken is bij benadering de ruimte die nodig is voor inodes plus nog wat andere bestanden. Je kunt dit aantal exact berekenen of gewoon 50 gebruiken. Als je een uit twee disks bestaande set gebruikt, kun je de ruimte net zo goed ruim nemen aangezien de kernel toch alleen voor de kernel wordt gebruikt. Noem dit aantal KERNEL_BLOCKS.

Plaats een diskette in de drive (ter vereenvoudiging gaan we uit van /dev/fd0) en maak hier een ext2 kernelbestandssysteem op aan:

mke2fs -i 8192 -m 0 /dev/fd0 KERNEL_BLOCKS

De ``-i 8192'' geeft aan de we één inode per 8192 bytes willen. Mount vervolgens het bestandssysteem, verwijder de directory lost+found en maak de directory's dev en boot voor LILO aan:

mount /dev/fd0 /mnt rm -rf /mnt/lost+found mkdir /mnt/{boot,dev}

Maak dan de devices /dev/null en /dev/fd0. Je kunt in plaats van het opzoeken van de devicenummers, ze vanaf je harddisk kopiëren door gebruik te maken van -R:

cp -R /dev/{null,fd0} /mnt/dev

LILO heeft een kopie van de bootloader boot.b nodig, die je van je harddisk kan halen. Het wordt gewoonlijk in de directory /boot bewaard.

cp /boot/boot.b /mnt/boot

Kopieer tenslotte het configuratiebestand van LILO samen met de kernel die je in de laatste sectie aanmaakte. Beiden kunnen in de rootdirectory worden geplaatst:

cp bdlilo.conf KERNEL /mnt

Alle benodigdheden voor LILO bevinden zich nu op het kernelbestandssysteem, dus je bent er klaar voor het uit te voeren. LILO's -r vlag wordt gebruikt voor het installeren van de bootloader op een andere root:

lilo -v -C bdlilo.conf -r /mnt

LILO zou zonder fouten moeten draaien, waarna het kernelbestandssysteem er ongeveer zo uit zou moeten zien:

total 361 1 -rw-r--r-- 1 root root 176 Jan 10 07:22 bdlilo.conf 1 drwxr-xr-x 2 root root 1024 Jan 10 07:23 boot/ 1 drwxr-xr-x 2 root root 1024 Jan 10 07:22 dev/ 358 -rw-r--r-- 1 root root 362707 Jan 10 07:23 vmlinuz boot: total 8 4 -rw-r--r-- 1 root root 3708 Jan 10 07:22 boot.b 4 -rw------- 1 root root 3584 Jan 10 07:23 map dev: total 0 0 brw-r----- 1 root root 2, 0 Jan 10 07:22 fd0 0 crw-r--r-- 1 root root 1, 3 Jan 10 07:22 null

Maak je geen zorgen als de bestandsgroottes bij jou iets anders uitpakken.

Laat de diskette nu in het diskettestation en ga naar de paragraaf Instellen van het ramdisk word.

Transporteren van de kernel zonder LILO

Transporteer de kernel met de opdracht dd als je LILO niet gebruikt:

% dd if=KERNEL of=/dev/fd0 bs=1k 353+1 records in 353+1 records out

In dit voorbeeld schreef dd 353 complete + 1 gedeeltelijk record weg, dus de kernel neemt de eerste 354 blokken van de diskette in beslag. Noem dit aantal KERNEL_BLOCKS en onthoud het voor gebruik in de volgende sectie.

Stel het rootdevice zo in dat het de diskette zelf is, en stel de root dan in dat het read/write zal worden geladen:

rdev /dev/fd0 /dev/fd0 rdev -R /dev/fd0 0

Let erop dat je de hoofdletter -R gebruikt in de tweede rdev opdracht.

Instellen van het ramdisk word

Binnenin de kernelimage bevindt zich het ramdisk word waarin wordt aangegeven waar het rootbestandssysteem is te vinden, plus nog wat andere opties. Het word kan worden benaderd en ingesteld via de rdev opdracht, en de inhoud ervan wordt als volgt geïnterpreteerd:

Als bit 15 is ingesteld, zal tijdens de systeemstart worden aangegeven een nieuwe diskette in het diskettestation te plaatsen. Dit is nodig voor een uit twee disks bestaande bootset.

Er zijn twee situaties, afhankelijk van of je een enkele boot-/rootdiskette aan het bouwen bent, of een dubbele ``boot+root'' disketteset.

1. Als je een enkele disk aan het bouwen bent, zal het gecomprimeerde rootbestandssysteem direct achter de kernel worden geplaatst, dus zal de offset het eerste vrije blok zijn (wat hetzelfde zou moeten zijn als KERNEL_BLOCKS). Bit 14 zal op 1 zijn gezet, en bit 15 op nul. Stel bijvoorbeeld dat je een enkele disk aan het bouwen bent en dat het rootbestandssysteem begint op blok 253 (decimaal). De waarde van het ramdisk word zou 253 (decimaal) moeten zijn met bit 14 op 1 gezet en bit 15 op 0. Voor het berekenen van de waarde kun je de decimale waarden eenvoudigweg bijelkaar optellen. 253 + (2^14) = 253 + 16384 = 16637. Als je het niet geheel begrijpt waar dit nummer vandaan komt, tik het dan in op een wetenschappelijke rekenmachine en converteer het naar binair.

2. Als je een diskset bestaande uit twee disks aan het bouwen bent, zal het rootbestandssysteem beginnen op blok nul van de tweede disk, dus zal de offset nul zijn. Bit 14 zal op 1 zijn gezet en bit 15 op 1. De decimale waarde zal in dit geval 2^14 + 2^15 = 49152 zijn.

Stel na het zorgvuldig te hebben berekend van de waarde voor het ramdisk word het in met rdev -r. Wees er zeker van de decimale waarde te gebruiken. Het argument aan rdev zou hier het gemounte kernel path,b.v. /mnt/vmlinuz moeten zijn als je LILO gebruikte; als je in plaats daarvan de kernel met dd kopieerde, gebruik je de naam van het diskettedevice (b.v., /dev/fd0).

rdev -r KERNEL_OR_FLOPPY_DRIVE VALUE

Bij gebruik van LILO unmount je nu de diskette.

Transporteren van het rootbestandssysteem

De laatste stap bestaat uit het transporteren van het rootbestandssysteem.

• Als het rootbestandssysteem op dezelfde disk zal worden geplaatst als de kernel, dan transporteer je het met behulp van dd met de optie seek, waarmee wordt opgegeven hoeveel blokken over te slaan:

  dd if=rootfs.gz of=/dev/fd0 bs=1k seek=KERNEL_BLOCKS

• Als het rootbestandssysteem op een tweede disk zal worden geplaatst, verwijder je de eerste diskette, doe je de tweede diskette in het diskettestation, en transporteert dan het rootbestandssysteem naar deze diskette:

  dd if=rootfs.gz of=/dev/fd0 bs=1k

Gefeliciteerd, je bent klaar!

Test een bootdisk altijd voordat je het opzij legt voor een noodgeval. Lees verder als het niet lukt ervan te booten.

Terugbrengen van de grootte van het rootbestandssysteem

Soms is een rootbestandssysteem zelfs na compressie te groot voor op een diskette. Hier zijn een aantal manieren om de grootte van het bestandssysteem terug te brengen:

1. Verhoog de dichtheid van de diskette. Standaard worden diskette op 1440K geformatteerd, maar er zijn hogere dichtheidsformaten beschikbaar. fdformat kan disks met de volgende omvang formatteren: 1600, 1680, 1722, 1743, 1760, 1840, en 1920. De meeste 1440K diskettestations ondersteunen 1722K, en dit is wat ik altijd voor bootdisks gebruik. Zie de manpage van fdformat en /usr/src/linux/Documentation/devices.txt.

2. Vervang je shell. Een aantal populaire shells voor Linux, zoals bash en tcsh, is nogal groot en deze shells vereisen veel library's. Er zijn lichtgewicht alternatieven, zoals ash, lsh, kiss en smash, die heel wat kleiner zijn en waarvoor minder (of geen) library's nodig zijn. De meeste vervangende shells zijn beschikbaar vanaf http://metalab.unc.edu/pub/Linux/system/shells/. Zorg er in ieder geval voor dat de shell die je kiest de opdrachten in alle rc bestanden op je bootdisk uit kan voeren.

3. Strip library's en binary's. Veel library's en binary's worden met debugging informatie gedistribueerd. Als dit zo is krijg je als uitvoer ``not stripped'' als je op deze bestanden de opdracht file toepast. Bij het kopiëren van binary's naar je rootbestandssysteem, is het een goede gewoonte gebruik te maken van:

   objcopy --strip-all FROM TO

   Gebruik bij het kopiëren van library's strip-debug in plaats van strip-all.

4. Als je bij het aanmaken van het rootbestandssysteem veel bestanden verplaatste of verwijderde, maak het dan opnieuw aan. Zie de NOOT HIERVOOR over het belang van het ontbreken van `dirty blocks' in het bestandssysteem.

5. Verplaats niet kritieke bestanden naar een utilitydisk. Als een aantal van je binary's na het booten of inloggen niet onmiddellijk nodig is, kun je ze naar een utilitydisk verplaatsen. Zie de paragraaf Bouwen van een utility-disk voor details. Je kunt ook in overweging nemen modules naar een utilitydisk te verplaatsen.

Niet-ramdisk rootbestandssystemen

In paragraaf Bouwen van een rootbestandssysteem werden instructies gegeven voor het bouwen van een gecomprimeerd rootbestandssysteem die bij het booten van het systeem naar ramdisk wordt geladen. Deze methode heeft veel voordelen en wordt daarom vaak gebruikt. Op een aantal systemen kun je je dit echter niet permitteren vanwege de benodigde RAM, en moet het rootbestandssysteem direct vanaf de diskette worden gemount.

Dergelijke bestandssystemen zijn in wezen eenvoudiger aan te maken dan gecomprimeerde rootbestandssystemen, omdat ze op een diskette kunnen worden gebouwd in plaats van op één of ander ander device, en ze niet hoeven te worden gedecomprimeerd. We zullen deze procedure in zoverre ze verschilt van de instructies hiervoor uiteenzetten. Houd in gedachten dat als je hiervoor kiest je veel minder ruimte beschikbaar zal hebben.

1. Bereken hoeveel ruimte je beschikbaar zal hebben voor rootbestanden. Als je een enkele boot-/rootdisk aan het bouwen bent, moeten alle blokken voor de kernel plus alle blokken voor het rootbestandssysteem op één disk passen.

2. Maak met behulp van mke2fs een rootbestandssysteem op een diskette van de van toepassing zijnde grootte aan.

3. Stel het bestandssysteem samen zoals eerder werd beschreven.

4. Unmount het bestandssysteem en transporteer het naar een diskbestand als je klaar bent, maar comprimeer het niet.

5. Transporteer, zoals eerder beschreven, de kernel naar een diskette. Stel bit 14 in op nul bij het berekenen van het ramdisk word om aan te geven dat het rootbestandssysteem niet naar ramdisk moet worden geladen. Voer zoals eerder beschreven de opdracht rdev uit.

6. Transporteer het rootbestandssysteem als voorheen.

Er zijn verscheidene kortere wegen te bewandelen. Als je een uit twee disks bestaande set aan het bouwen bent, kun je het complete rootbestandssysteem direct op de tweede disk bouwen en is het niet nodig het tijdelijk naar een harddiskbestand te transporteren. Ook kun je een enkel bestandssysteem met de kernel, LILO bestanden en rootbestanden op de gehele disk bouwen als je een enkele boot-/rootdisk aan het bouwen bent en LILO gebruikt en als laatste stap gewoon LILO opstarten.

Bouwen van een utility-disk

Het bouwen van een utility-disk is relatief gezien eenvoudig -- maak op een geformatteerde disk een bestandssysteem aan en kopieer er de bestanden naar. Mount het handmatig nadat het systeem is geboot bij gebruik met een bootdisk.

In de instructies hiervoor gaven we al aan dat de utility-disk als /usr zou kunnen worden gemount. In deze situatie zouden de binary's in de /bin directory op je utility-disk kunnen worden geplaatst, zodat het in je path plaatsen van /usr/bin ervoor zorgt dat ze kunnen worden benadert. Extra library's benodigd voor de binary's worden geplaatst in /lib op de utility-disk.

Er zijn bij het ontwerpen van een utility-disk een aantal aandachtspunten:

1. Plaats kritieke systeembinary's of library's niet op de utility-disk omdat het pas nadat het systeem is geboot te mounten zal zijn.

2. Je kunt een diskette en floppy tapedrive niet gelijktijdig benaderen. Dit betekent dat als je een floppy tapedrive hebt, je het niet zal kunnen benaderen als je utility-disk is gemount.

3. Toegang tot de bestanden op de utility-disk verloopt traag.

In de Aanhangsel D wordt een voorbeeld gegeven van bestanden op een utility-disk. Hier zijn een aantal ideeën betreft bestanden die je wellicht nuttig zal vinden: programma's voor het bestuderen en manipuleren van disks (format, fdisk) en bestandssystemen (mke2fs, fsck, debugfs, isofs.o), een lichtgewicht teksteditor (elvis, jove), comprimeer- en archiefutility's (gzip, bzip, tar, cpio, afio), tape utility's (mt, ftmt, tob, taper), communicatie utility's (ppp.o, slip.o, minicom) en utility's voor devices (setserial, mknod).