Wanneer Lilo het systeem boot, maakt het daarbij gebruik van BIOS aanroepen om de Linux kernel van disk (IDE-disk, diskette of wat dan ook) te laden. Daarom moet de kernel op een lokatie voorkomen die door de bios kan worden benaderd.
Tijdens het booten, is Lilo niet in staat bestandssysteemgegevens te lezen,
en elke padnaam die je plaatst in /etc/lilo.conf
wordt gevonden tijdens het installeren (wanneer je /sbin/lilo
aanroept). Met tijdens het installeren wordt bedoeld de tijd dat het
programma de tabellen samenstelt waarin staat welke sectoren door de
bestanden worden gebruikt om het besturingssysteem te laden.
Als een gevolg daarvan moeten al die bestanden op een partitie voorkomen
die door de BIOS kan worden benaderd (de bestanden zijn gewoonlijk te
vinden in de directory /boot
wat betekent dat alleen de rootpartitie
van je Linux-systeem hoeft te kunnen worden benaderd via de BIOS.
Een ander gevolg van BIOS-gebaseerd zijn, is dat je de loader moet herinstalleren (d.w.z. je moet elke keer dat je de Lilo-setup aanpast, /sbin/lilo opstarten). Wanneer je de kernel opnieuw compileert, en je oude image overschrijft, dan moet je Lilo herinstalleren.
Met de boot=/
directive in /etc/lilo.conf
wordt Lilo aangegeven
waar het zijn primaire bootloader dient te plaatsen. Over het algemeen,
kun je of de master boot record
(/dev/hda
) opgeven of de rootpartitie van je Linux-installatie
(is gewoonlijk /dev/hda1
of /dev/hda2
).
Als er nog een ander besturingssysteem op je harddisk is geïnstalleerd, dan kun je Lilo maar beter installeren op de rootpartitie in plaats van de MBR. In dat geval, moet je de partitie als ``bootable'' (opstartbaar) markeren met de opdracht ``a'' van fdisk of de opdracht ``b'' van cfdisk. Als je de master bootsector niet overschrijft, dan zul je wanneer dat nodig is het makkelijker vinden de installatie van Linux en Lilo ongedaan te maken.
Uiteraard heb je altijd een manier om "regels" zoals bovenstaande, te
omzeilen. Je kunt Lilo zelfs in de MBR installeren als je daar reeds
een ander besturingssysteem hebt geïnstalleerd.
Als je bijvoorbeeld Windows NT 4.0 als het eerste besturingssysteem op je
machine installeerde, dan werd NT's bootloader geplaatst in de MBR, zodat
je zonder problemen NT kon booten. Nadat je Linux installeerde en er voor
koos Lilo in de MBR te installeren, herschreef Lilo NT's bootloader.
De volgende keer dat je je machine boot, zul je NT niet kunnen booten. Maar,
dat is geen probleem. Bewerk /etc/lilo.conf
en voeg een nieuw
record toe voor NT. De volgende keer dat je het systeem weer boot, zal er
een nieuw NT item onder je Lilo menu zijn toegevoegd. Hetzelfde gebeurde
toen ik Windows 2000 installeerde in plaats van Windows NT.
Ik maak persoonlijk geen gebruik van LBA of LARGE instellingen in de BIOS (maar ik draai alleen Linux); het zijn verschrikkelijke omzeilingen noodgedwongen door tekortkomingen in ontwerpen in de PC-wereld. Dit vereist dat de kernel in de eerste 1024 cylinders voorkomt, maar is geen probleem zolang je je harddisks partitioneert en root klein houdt (zoals je altijd zou moeten doen).
Als op je harddisk reeds een ander besturingssysteem is geïnstalleerd, dan zul je de BIOS instellingen niet kunnen aanpassen, anders zal het oude systeem niet meer werken. Alle recente Lilo distributies kunnen overweg met LBA en LARGE disk instellingen.
Het trefwoord "linear"
in /etc/lilo.conf
kan helpen
bij het afhandelen van problemen met betrekking tot de geometrie.
Dit trefwoord instrueert Lilo gebruik te maken van linear sector
adressen in plaats van het sector/head/cylinder model.
Conversie naar 3D adressen wordt uitgesteld tot uitvoeringstijd,
wat de setup meer immuun maakt voor problemen met betrekking tot de
geometrie.
Als je meer dan één harddisk hebt, en een aantal daarvan worden alleen door Linux gebruikt en zijn niet betrokken in het bootproces, dan kun je de BIOS opgeven dat ze niet zijn geïnstalleerd. Je systeem boot sneller en Linux zal alle disks automatisch detecteren. Ik verwissel vaak disks in mijn computers, maar ik doe nooit iets met de BIOS-configuratie.
Wanneer je de Lilo prompt ziet, kun je de <Tab> toets indrukken om een lijst te zien te krijgen met mogelijke keuzes. Als Lilo niet is geconfigureerd als interactief, druk kan de <Alt> of <Shift>-toets in voordat de ``LILO'' melding verschijnt.
Kies je ervoor een Linux kernel te booten, dan kun je opdrachtregelargumenten toevoegen nar de naam van het systeem dat je kiest. De kernel accepteert vele opdrachtregelargumenten. Alle argumenten staan opgesomd in de ``BootPrompt-HOWTO'' geschreven door Paul Gortmaker, en ik zal ze hier niet dupliceren. Een paar opdrachtregelargumenten echter zijn in het bijzonder van belang en waard hier te worden beschreven:
root=
: je kunt de Linux-kernel laten weten als root een andere
partitie te mounten dan die in /lilo.conf
is opgegeven. Op mijn
systeem bijvoorbeeld, bevindt zich een klein partitie met daarop een
minimale Linux-installatie, en na het per ongeluk ruïneren van mijn
rootpartitie was ik toch in staat mijn systeem te booten.init=
: versie 1.3.43 en nieuwer van de Linux-kernel kan
een andere opdracht uitvoeren in plaats van /sbin/init,
zoals opgegeven op de opdrachtregel. Ervaar je tijdens het
bootproces serieuze problemen, dan kun je een kaal systeem benaderen
door init=/bin/sh
op te geven (achter de shellprompt zul je
zeer waarschijnlijk je disks willen mounten: probeer
``mount -w -n -o remount /; mount -a'',
en denk eraan de opdracht ``umount -a'' te geven voordat
je de computer uitzet)./etc/inittab
en /etc/rc*.d
.
Wanneer Lilo een bootsector overschrijft, bewaart het een backup in
/boot/boot.
xxyy, waarbij xxyy staat voor de major en
minor nummers van het device, in hex. Je kunt de major en minor nummers
van je disk of partitie bekijken door het uitvoeren van
``ls -l /dev//device''. Bijvoorbeeld de eerste sector van
/dev/hda
(major 3, minor 0) zal worden bewaard in
/boot/boot.0300
, door het installeren van Lilo op /dev/fd0
wordt een bestand /boot/boot.0200
aangemaakt en het installeren op
/dev/sdb3
(major 8, minor 19) het bestand /boot/boot.0813
.
Lilo zal het bestand niet aanmaken als er al een dergelijk bestand is, dus
je hoeft je geen zorgen te maken over de backup als je Lilo ooit herinstalleert
(bijvoorbeeld na het hercompileren van de kernel). De backup te vinden
in /boot/
bestaan altijd uit een weergave van de situatie voordat
Lilo ooit werd geïnstalleerd.
Mocht je de installatie van Lilo ooit ongedaan willen maken (bijvoorbeeld,
als je de installatie van Linux ongedaan moet maken), dan hoef je alleen
de oorspronkelijke bootsector te herstellen. Is Lilo geïnstalleerd
in /dev/hda
, geef dan de opdracht
``dd if=/boot/boot.0300 of=/dev/hda bs=446 count=1''
(Ik geef zelf slechts de opdracht ``cat /boot/boot.0300 > /dev/hda'',
maar dit is geen veilige methode, aangezien het ook de oorspronkelijke
partitietabel zal herstellen,
die je in de tussentijd gewijzigd kunt hebben). Deze opdracht is veel
makkelijker uit te voeren dan een ``fdisk /mbr'' vanuit een
DOS-shell: het bied je de mogelijkheid om Linux zuiver van een disk
te verwijderen zonder ooit iets anders dan Linux te hoeven booten.
Denk eraan, na het verwijderen van Lilo,
Linux' fdisk uit te voeren om eventuele Linux partities
te verwijderen (DOS' fdisk is niet in staat niet-dos partities te verwijderen).
Installeerde je Lilo op je rootpartitie (b.v., /dev/hda2
) dan
hoeft er niets speciaals te worden gedaan om de installatie van Lilo ongedaan
te maken. Start gewoon Linux' fdisk op om de Linux-partities van
de partitietabel te verwijderen. Je moet daarbij ook de DOS-partitie als
bootable markeren.
Opmerking: Als je de volgende sectie moeilijk vindt te lezen, dan kun
je ook eens kijken op de webpagina:
http://surfer.nmr.mgh.harvard.edu/partition/ramdisk.html
waar je het "origineel" vindt van deze bijdrage...
door Tony Harris
16 Oct 2000
ram disk eenie-weenie HOWTO
Als je root bestandssysteem zich bevindt op een apparaat waarvoor je kernel
geen driver heeft ingecompileerd, dan zul je lilo
nodig hebben
om die driver zeer vroeg in de bootcyclus als een module te laden.
Hiervoor zijn slechts deze twee makkelijke stappen nodig:
lilo.conf
aan dat het verwijst naar het imageAls eerste cd ik naar /boot
:
System.map chain.b module-info-2.2.16-3ext3 System.map-2.2.16-3 initrd-2.2.16-3.img vmlinux-2.2.16-3 System.map-2.2.16-3ext3 vmlinux-2.2.16-3ext3 vmlinuz kernel.h boot.b map vmlinuz-2.2.16-3 bz.2.2.15.juke.Image module-info vmlinuz-2.2.16-3ext3 bzImage-2.2.14 module-info-2.2.16-3
Hier zie je dat ik een 2.2.16-3 kernel heb en dat ik een tweede kernel heb
toegevoegd met ext3 ondersteuning (vmlinuz-2.2.16-3ext3
). Voor mijn
eerste kernel bestaat reeds een ramdiskimage (initrd-2.2.16-3.img
)
Voor het maken van een nieuw image voor de tweede kernel, typ ik het volgende (wat ik typ is benadrukt weergegeven):
boot# mkinitrd initrd-2.2-16-3ext3.img 2.2.16-3ext3
mkinitrd
is een shellscript dat zoekt naar de modules die nodig zijn
voor mijn kernel en vervolgens een ext2 bestandssysteem aanmaakt met daarop
die modules. Als we het image van binnen bekijken dan zien we dat dit het
geval is:
boot# cat initrd-2.2.16-3ext3.img | gunzip > /tmp/myimage
boot# file /tmp/myimage
/tmp/myimage: Linux/i386 ext2 filesystem/
Je hoeft het image niet te bekijken. Alleen het aanmaken van het image en
het aanpassen van lilo.conf
zijn nodig.
Om het te kunnen bekijken, moet ik het image net als een bestandssysteem
mounten:
boot# mount /tmp/myimage /mnt/tmp -t ext2 -o loop=/dev/loop3
boot# ls /mnt/tmp
bin dev etc lib linuxrc
boot# find /mnt/tmp
/mnt/tmp
/mnt/tmp/lib
/mnt/tmp/lib/aic7xxx.o
/mnt/tmp/bin
/mnt/tmp/bin/sh
/mnt/tmp/bin/insmod
/mnt/tmp/etc
/mnt/tmp/dev
/mnt/tmp/dev/console
/mnt/tmp/dev/null
/mnt/tmp/dev/ram
/mnt/tmp/dev/systty
/mnt/tmp/dev/tty1
/mnt/tmp/dev/tty2
/mnt/tmp/dev/tty3
/mnt/tmp/dev/tty4
/mnt/tmp/linuxrc
Het belangrijkste onderdeel van dit ramdiskimage is aic7xxx.o
,
wat mijn scsi-module is.
Tenslotte ga ik verder met de laatste stap, namelijk het aanpassen van
/etc/lilo.conf
:
Hier is het record in lilo.conf
dat correspondeert met de kernel en
de image die ik zojuist aanmaakte:
image=/boot/vmlinuz-2.2.16-3ext3
label=linux.ext3
initrd=/boot/initrd-2.2.16-3ext3.img
read-only
root=/dev/hdb3
Dat was het. Start /lilo als root en herstart het systeem.
Mocht je problemen ondervinden, dan kun je de kernel HOWTO
raadplegen. Een aantal zaken moeten in orde zijn: kernelmodules moeten
zijn gecompileerd en deze moeten voorkomen in /etc/conf.modules
.