Je hebt nu een kernel en een gecomprimeerd rootbestandssysteem. Controleer de grootte als je een boot/root-disk aan het maken bent om er zeker van te zijn dat ze beiden op één disk passen. Controleer het rootbestandssysteem als je er zeker van wilt zijn dat het op een enkele diskette past als je een uit twee disks bestaande boot+root set aan het maken bent.
Je zou een beslissing moeten nemen of je LILO wilt gebruiken om de bootdiskkernel te booten. Het alternatief is de kernel direct naar de diskette te kopiëren en zonder LILO te booten. Het voordeel van het gebruik van LILO is dat het je de mogelijkheid biedt een aantal parameters aan de kernel op te geven die mogelijk nodig zijn om je hardware te initialiseren. (Controleer het bestand /etc/lilo.conf op je systeem. Als het bestaat en er een regel als ``append=...''in voorkomt, heb je het waarschijnlijk nodig). Het nadeel van het gebruik van LILO is dat het bouwen van de bootdisk wat gecompliceerder is en wat meer ruimte in beslag neemt. Je zal een klein apart bestandssysteem in moeten stellen, wat we het kernelbestandssysteem zullen noemen, waarnaar we de kernel en een paar andere bestanden die LILO nodig heeft, zullen transporteren.
Lees verder als je LILO gaat gebruiken; als je de kernel direct gaat transporteren ga dan verder met Paragraaf 6.2.
Het eerste wat je moet doen is een klein configuratiebestand voor LILO aan te maken. Het zou er ongeveer zo uit moeten zien:
boot =/dev/fd0 install =/boot/boot.b map =/boot/map read-write backup =/dev/null compact image = KERNEL label = Bootdisk root =/dev/fd0Zie de gebruikersdocumentatie van LILO voor een uitleg van deze parameters. Je zal waarschijnlijk ook de regel append=... aan dit bestand tot 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 zou moeten zijn. Neem de grootte 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_BLOCKSDe ``-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 de devicenummers op te zoeken, ze vanaf je harddisk kopiëren door gebruik te maken van -R:
cp -R /dev/{null,fd0} /mnt/devLILO 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/bootKopieer tenslotte het configuratiebestand van LILO samen met je kernel die je in de laatste sectie aanmaakte. Beiden kunnen in de rootdirectory worden geplaatst:
cp bdlilo.conf KERNEL /mntAlle 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 /mntLILO zou zonder fouten moeten draaien, waarna het kernelbestandssysteem er ongeveer zo uit zou meoten 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 de drive en ga naar Paragraaf 6.3.
Transporteer de kernel met het dd als je LILO niet gebruikt:
% dd if=KERNEL of=/dev/fd0 bs=1k 353+1 records in 353+1 records outIn 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 0Let erop dat je de hoofdletter -R gebruikt in het tweede rdev commando.
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 het rdev commando, en de inhoud ervan wordt als volgt geïnterpreteerd:
Bit veld | Beschrijving |
---|---|
0-10 | Offset van start ramdisk, in 1024 byte blokken |
11-13 | ongebruikt |
14 | Vlag die aangeeft dat ramdisk wordt geladen |
15 | Vlag die aangeeft een melding te geven alvorens rootfs te laden |
Als bit 15 is ingesteld, zal tijdens de systeemstart worden aangegeven een nieuwe diskette in de drive te plaatsen. Dit is benodigd voor een uit twee disks bestaande bootset.
Er zijn twee situaties, afhankelijk van of je een enkele boot/root-diskette aan het bouwen bent, of een dubbele ``boot+root'' disketteset.
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.
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
Unmount de diskette nu als je LILO gebruikte.
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 de drive, en transporteert dan het rootbestandssysteem ernaar:
dd if=rootfs.gz of=/dev/fd0 bs=1k
Gefeliciteerd, je bent klaar!
Belangrijk: Je zou een bootdisk altijd moeten testen voordat je het opzij legt voor een noodgeval. Lees verder als het niet lukt ervan te booten.