Op dit punt heb je een kernel en een gecomprimeerd root-bestandssysteem. 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 root-bestandssysteem 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 bootdisk
kernel te booten. Het alternatief is de kernel direct naar de diskette te
kopiëren en zonder LILO te booten.
Het voordeel bij gebruik van LILO is dat het je de mogelijkheid biedt een
aantal parameters aan de kernel te leveren die mogelijk nodig zijn om je
hardware te initialiseren (Controleer op je systeem het bestand
/etc/lilo.conf. Als het voorkomt en er een regel in staat als
``append=...
'', heb je deze feature 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 zult een klein apart bestandssysteem
in moeten stellen, wat we het kernel bestandssysteem zullen noemen,
waarnaar we de kernel en een paar andere bestanden die LILO nodig heeft zullen
transporteren.
Lees verder, als je LILO gaat gebruiken; ga naar sectie Zonder gebruik van LILO als je de kernel direct gaat transporteren.
Het eerste wat je doen moet is een klein configuratiebestand voor LILO aanmaken. Het zou 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
Kijk in de gebruikersdocumentatie van LILO, voor een uitleg van deze parameters.
Je zal waarschijnlijk tevens een append=...
regel aan dit bestand toe
willen voegen vanaf je harddisk's bestand
/etc/lilo.conf.
Bewaar dit bestand als bdlilo.conf
.
Je zal nu een klein bestandssysteem aan moeten maken, wat we een kernel bestandssysteem zullen noemen, om het te onderscheiden van het root-bestandssysteem.
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 naar boven afgerond) en tel daar 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 als je dit wilt, of gewoon 50 gebruiken.
Als je een diskset bestaande uit twee disks aan het maken bent, kun je de
ruimte net zo goed te hoog ramen, aangezien de eerste disk toch slechts
alleen wordt gebruikt voor de kernel.
Noem dit aantal KERNEL_BLOCKS
.
Plaats een diskette in de drive (ter vereenvoudiging gaan we uit van /dev/fd0) en maak er een ext2 kernel bestandssysteem op aan:
mke2fs -i 8192 -m 0 /dev/fd0 KERNEL_BLOCKS
De ``-i 8192
'' geeft aan dat we één inode per 8192 bytes
willen. Mount vervolgens het bestandssysteem, verwijder de directory
lost+found
, en maak de dev
en boot
directory's voor LILO aan:
mount /dev/fd0 /mnt rm -rf /mnt/lost+found mkdir /mnt/{boot,dev}
Maak vervolgens de devices /dev/null en /dev/fd0 aan.
Je kunt in plaats van de device-nummers op te zoeken, ze vanaf je harddisk
kopiëren door gebruik te maken van de -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 dat je in de laatste sectie aanmaakte samen met je kernel. Beiden kunnen in de root-directory worden geplaatst:
cp bdlilo.conf KERNEL /mnt
Alle benodigdheden voor LILO bevinden zich nu op het kernel-bestandssysteem,
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 fout moeten draaien, waarna het kernel-bestandssysteem 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 disk nu in de drive en ga naar sectie Instellen van het ramdisk word.
Transporteer de kernel met het dd
-commanod als je geen
gebruik maakt van LILO:
% dd if=KERNEL of=/dev/fd0 bs=1k 353+1 records in 353+1 records out
In dit voorbeeld schreef dd
353 volledige records + 1 gedeeltelijk record
weg, dus de kernel neemt de eerste 354 blokken van de diskette in beslag.
Noem dit aantal KERNEL_BLOCKS
en denk er aan het in de volgende
sectie te gebruiken.
Stel het root-device 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
Wees voorzichting door de hoofdletter -R
te gebruiken in het
tweede rdev
commando.
Binnenin de kernel-image bevindt zich het ramdisk word dat
aangeeft waar het root-bestandssysteem te vinden is, samen met nog wat
andere opties. Het word kan worden benaderd en ingesteld via het commando
rdev
, en de inhoud ervan wordt als volgt geïnterpreteerd:
bits 0-10: Offset start ramdisk, in 1024 byte blokken bits 11-13: ongebruikt bit 14: Vlag aangevend dat ramdisk wordt geladen bit 15: Vlag aangevend een melding te geven alvorens rootfs te laden
Als bit 15 is ingesteld, zal je tijdens het booten worden gevraagd een nieuwe diskette in de drive te doen. Dit is nodig voor een uit twee disk bestaande bootset.
Er zijn twee situaties, afhankelijk van of je een enkele boot/root-diskette aan het bouwen bent of een dubbele ``boot+root'' diskette-set.
KERNEL_BLOCKS
). Bit 14 zal worden ingesteld op
1, en bit 15 zal nul zijn.
Stel bijvoorbeeld dat je een enkele disk aan het bouwen bent en dat het
root-bestandssysteem begint op blok 253 (decimaal).
De ramdisk word waarde zou 253 (decimaal) moeten zijn met bit 14 ingesteld
op 1 en bit 15 ingesteld op 0. Voor het berekenen van de waarde kun je
de decimale waarden eenvoudigweg bij elkaar optellen. 253 + (2^14) =
253 + 16384 = 16637. Als je niet geheel begrijpt waar dit nummer vandaan komt,
tik het dan in in een wetenschappelijk rekenmachine en converteer het naar
binair.
Stel het met rdev -r
in na het zorgvuldig te hebben berekend van de
waarde voor het ramdisk word. 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 dan de naam van het diskette-device (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 root-bestandssysteem.
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
dd if=rootfs.gz of=/dev/fd0 bs=1k
Gefeliciteerd, je bent klaar! Je zou een bootdisk voor dat je het opzijlegt voor een noodgeval altijd moeten proberen! Lees verder als het niet lukt ervan te booten.