Quando Lilo avvia il sistema usa le chiamate del BIOS per caricare il kernel Linux dal disco (disco IDE, floppy o altro). Perciò il kernel deve risiedere in un luogo a cui il BIOS possa accedere.
All'avvio Lilo non è in grado di leggere i dati del file system,
e ogni percorso inserito in /etc/lilo.conf viene risolto
durante l'installazione (quando si invoca /sbin/lilo). L'installazione
è il momento in cui il programma costruisce le tabelle che elencano quali settori sono
usati dai file usati per il caricamento del sistema operativo. La
conseguenza è che tutti questi file devono risiedere in una partizione accessibile
dal BIOS (questi file di solito risiedono nella directory /boot, il che significa che
il BIOS avrà bisogno di accedere solo alla partizione root del proprio sistema Linux).
Un'altra conseguenza dell'appoggiarsi al BIOS è che bisogna reinstallare il caricatore (cioè bisogna invocare nuovamente /sbin/lilo), ogni volta che si modifica la configurazione di Lilo. Ogni volta che si ricompila il kernel e si sovrascrive la vecchia immagine, bisogna reinstallare Lilo.
La direttiva boot= contenuta in /etc/lilo.conf dice a Lilo dove
installare il suo gestore di avvio primario. In generale si può specificare sia
il Master Boot Record (/dev/hda) che la partizione root
della propria installazione Linux (di solito /dev/hda1 o
/dev/hda2).
Se il proprio disco fisso contiene un altro sistema operativo, conviene installare Lilo sulla partizione root invece che sul Master Boot Record. In questo caso occorre marcare la partizione come ``avviabile'' usando il comando ``a'' di fdisk o il comando ``b'' di cfdisk. Se non si sovrascrive il Master Boot Sector sarà più facile disinstallare Linux e Lilo, se ce ne fosse bisogno.
Naturalmente c'è sempre un modo per eludere alcune "regole" come quelle precedenti.
Si potrebbe installare Lilo nell'MBR anche se c'è già un altro sistema operativo
presente. Per esempio, se si è installato Windows NT 4.0 come
primo sistema operativo sulla macchina, il suo gestore di avvio si sarà installato
nell'MBR per poter avviare NT senza problemi. Dopo aver installato
Linux, e aver scelto di installare Lilo nell'MBR, Lilo avrà riscritto il gestore di avvio di NT.
All'avvio successivo non sarà possibile avviare NT, ma non è un problema.
Basterà modificare il file /etc/lilo.conf e aggiungere una nuova
voce per NT. Al successivo riavvio del sistema ci sarà la nuova
voce per NT nel menu di Lilo. La stessa cosa succede installando Windows 2000
invece di Windows NT.
Personalmente nel BIOS preferisco non usare le impostazioni LBA o LARGE (ma io uso solo Linux): si tratta di orribili trucchetti introdotti a forza per coprire alcune deficienze progettuali nel mondo dei PC. Questo richiede che il kernel risieda nei primi 1024 cilindri del disco, ma non è un problema a patto che i dischi fissi siano partizionati e la partizione root rimanga piccola (il che andrebbe fatto comunque).
Se il proprio disco fisso contiene un altro sistema operativo, non si potranno modificare le impostazioni del BIOS perché altrimenti il vecchio sistema non funzionerà più. Tutte le distribuzioni recenti di Lilo sono in grado di gestire dischi impostati con LBA e LARGE.
Si noti che la parola chiave "linear" nel file /etc/lilo.conf può
essere d'aiuto nell'affrontare problemi di geometria. La parola chiave ordina a Lilo di
usare indirizzi di settore lineari al posto di tuple settore/testa/cilindro.
La conversione ad indirizzi 3D è posticipata alla fase di esecuzione, rendendo
l'impostazione maggiormente immune ai problemi di geometria.
Se si ha più di un disco rigido, e alcuni di essi sono usati solo da Linux senza far parte del processo di avvio, si può dire al BIOS che non sono installati. Il sistema si avvierà più velocemente e Linux riconoscerà automaticamente e velocemente tutti i dischi. Mi capita spesso di cambiare i dischi dei miei sistemi, senza mai toccare la configurazione del BIOS.
Quando appare il prompt di Lilo, premendo il tasto <Tab> si ottiene la lista di tutte le scelte possibili. Se Lilo non è configurato per interagire con l'utente, si può premere (e tenere premuto) il tasto <Alt> o il tasto <Shift> prima che appaia il messaggio ``LILO''.
Se si sceglie di avviare un kernel Linux è possibile passare dei parametri da linea di comando dopo il nome del sistema scelto. Il kernel accetta molti parametri da linea di comando, tutti elencati nel ``BootPrompt-HOWTO'' di Paul Gortmaker, documento che non verrà replicato in questa sede. Alcuni di questi parametri, comunque, sono particolarmente importanti e meritano di essere descritti:
root=: si può dire al kernel Linux di montare come root una
partizione diversa da quella che appare nel file lilo.conf. Per
esempio, nel mio sistema c'è una piccola partizione che ospita una
installazione minimale di Linux; grazie a questa sono stato in
grado di avviare il sistema dopo aver distrutto per
sbaglio la partizione root.
init=: la versione del kernel Linux 1.3.43 e successive possono
eseguire un altro comando al posto di /sbin/init,
come specificato dalla linea di comando. Se si verificano problemi
all'avvio, si può accedere al nudo sistema
specificando init=/bin/sh (arrivati al prompt della shell
probabilmente si dovranno montare i propri dischi: si provi con
``mount -w -n -o remount /; mount -a'', e ci si
ricordi di usare ``umount -a'' prima di spegnere il
computer).
/etc/inittab e
a /etc/rc*.d.Quando Lilo sovrascrive un settore di avvio, ne salva una copia di backup
in /boot/boot.xxyy, dove xxyy sono i numeri maggiore e minore
del dispositivo, in esadecimale. Si possono vedere i due numeri del proprio
disco o partizione usando ``ls -l
/dev//device''. Per esempio, il primo settore di
/dev/hda (numero maggiore 3, numero minore 0) verrà salvato in
/boot/boot.0300; installando Lilo su /dev/fd0 verrà creato
/boot/boot.0200, installandolo su /dev/sdb3 (numero
maggiore 8, numero minore 19) verrà creato /boot/boot.0813. Si noti che Lilo non
creerà il file se ce n'è già uno, quindi non occorre preoccuparsi
della copia di backup quando si reinstalla Lilo (per esempio dopo
aver ricompilato il kernel). Le copie di backup presenti in /boot/
sono sempre l'istantanea della situazione precedente all'installazione di Lilo.
Se mai fosse necessario disinstallare Lilo (per esempio nella malaugurata
ipotesi si decida di disinstallare Linux) basterà ripristinare il
settore di avvio originale. Se Lilo è installato su /dev/hda, basterà
eseguire ``dd if=/boot/boot.0300 of=/dev/hda bs=446 count=1''
(personalmente uso ``cat /boot/boot.0300 > /dev/hda'',
ma non è sicuro, in quanto ripristina anche la tabella delle partizioni originale
che potrebbe essere stata modificata nel frattempo). È molto più facile usare
questo comando che chiamare ``fdisk /mbr'' da una shell DOS:
permette di rimuovere in modo impeccabile Linux da un disco senza dover mai avviare
nient'altro che Linux. Dopo aver rimosso Lilo occorre ricordarsi di far girare il
comando fdisk di Linux per distruggere qualunque partizione Linux (il
comando fdisk del DOS non è in grado di cancellare partizioni non-dos).
Se Lilo è stato installato sulla partizione root (per esempio su /dev/hda2),
non occorrerà fare niente di particolare per disinstallare Lilo. Basterà usare il
programma fdisk di Linux per rimuovere le partizioni Linux dalla tabella
delle partizioni. Bisognerà anche marcare la partizione DOS come avviabile.
Avvertimento: se la prossima sezione fosse difficile da leggere, si veda
la pagina web
http://surfer.nmr.mgh.harvard.edu/partition/ramdisk.html,
dove è disponibile l'originale di questo contributo.
Di Tony Harris
16 Ottobre 2000
ramdisk eenie-weenie HOWTO
Se il proprio file system root si trova su un dispositivo senza che il kernel abbia
il relativo driver incorporato, si dovrà usare lilo per caricare quel driver
come modulo molto presto nel ciclo di avvio.
Ci sono solo due facili passi da seguire:
lilo.conf perché punti a questa immagine
Come prima cosa, usare cd per entrare nella directory /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
Come si può vedere io ho un kernel 2.2.16-3 al quale ho aggiunto un secondo kernel
con supporto per ext3 (vmlinuz-2.2.16-3ext3). C'è già un'immagine
per ramdisk per il primo kernel (initrd-2.2.16-3.img)
Per creare una nuova immagine per il secondo kernel usare quanto segue (la parte da digitare è in grassetto):
boot# mkinitrd initrd-2.2-16-3ext3.img 2.2.16-3ext3
mkinitrd è uno script per la shell che cerca i moduli necessari per
il kernel, poi crea un file system di tipo ext2 che li contiene.
Guardando all'interno dell'immagine si vedrà che è proprio così:
boot# cat initrd-2.2.16-3ext3.img | gunzip > /tmp/myimage
boot# file /tmp/myimage
/tmp/myimage: Linux/i386 ext2 filesystem/
Non è necessario guardare nell'immagine. I soli passi necessari sono creare l'immagine
e modificare lilo.conf. Comunque si fornisce una discussione sull'immagine
per ramdisk per scopi educativi.
Per guardare all'interno dell'immagine, è necessario montarla come se fosse un file system:
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/
La parte più importante di questa immagine per ramdisk è aic7xxx.o,
che è il modulo per il mio disco scsi.
Per finire l'ultimo passo, la modifica di /etc/lilo.conf:
Ecco la voce nel mio lilo.conf che corrisponde al kernel e
all'immagine appena creata:
image=boot/vmlinuz-2.2.16-3ext3/
label=linux.ext3
initrd=boot/initrd-2.2.16-3ext3.img/
read-only
root=dev/hdb3/
Ecco fatto. Eseguire /lilo come root e riavviare.
Se si verificano problemi, controllare il kernel HOWTO. Ci sono un paio di cose
di cui assicurarsi: è necessario avere i moduli per il kernel compilati,
e indicati in /etc/conf.modules.