Verder Terug Inhoud

6. Het bijelkaar plaatsen: Het aanmaken van de diskette(s).

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.

6.1 De kernel met LILO 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.

6.2 Transporteren van de kernel zonder LILO.

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.

6.3 Instellen van het ramdisk word.

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.

  1. Als je een enkele disk aan het bouwen bent, zal het gecomprimeerde root-bestandssysteem 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 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.
  2. Als je een diskset bestaande uit twee disks aan het bouwen bent, zal het root-bestandssysteem beginnen op blok nul van de tweede disk, dus zal het offset nul zijn. Bit 14 zal op 1 zijn ingesteld en bit 15 zal 1 zijn. De decimale waarde zal in dit geval 2^14 + 2^15 = 49152 zijn.

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.

6.4 Transporteren van het root-bestandssysteem

De laatste stap bestaat uit het transporteren van het root-bestandssysteem.

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.


Verder Terug Inhoud