LILO

2005-11-10T14:08:16Z

Dupont : /* Configuration de LILO : LInux LOader (le chargeur de Linux) */

[[Category:Gestion du boot et du démarrage]]
[[Catégorie:Bootloader]]
= Configuration de LILO : LInux LOader (le chargeur de Linux) =

<div class="leatitre">Configuration de LILO : LInux LOader (le chargeur de Linux)</div><div class="leapar">par [mailto:fred%20chez%20lea%20tiret%20linux%20point%20org Fred]</div><div class="leadesc">Entrez dans le monde fantastique des détails de configuration du premier programme chargé par votre PC.</div>
----

== Qu'est-ce que LILO. ==

LILO est un chargeur de systèmes d'exploitation spécialement conçu pour démarrer Linux, mais ses capacités sont bien plus grandes : il est capable de démarrer presque tout type de système d'exploitation. C'est grâce à lui que vous pourrez, si le coeur vous en dit, autoriser le [[admin-admin_boot-LILO#Ajouter un second noyau.|MULTI BOOT]] (le démarrage potentiel de plusieurs systèmes d'exploitation sur votre PC), mettre un [[admin-admin_boot-LILO#Password|mot de passe]], [[admin-admin_boot-LILO#Timeout|démarrer automatiquement après un certain temps]], etc... Il faut savoir que LILO fonctionnant à un très bas niveau, il est spécifique à l'architecture x86 (que pour les PC !, pas les Mac (qui utilisent yaboot), pas les Alpha (qui utilisent MILO), etc...).

LILO autorise à [[admin-admin_boot-LILO#Passer des paramètres au noyau Linux.|passer des arguments]] au système d'exploitation que vous souhaitez démarrer (pour modifier son comportement par défaut). Il autorise à [[admin-admin_boot-LILO#VGA|choisir la résolution de démarrage]] du système d'exploitation, etc.

Mais comment ça marche ?

Ce n'est pas très compliqué à comprendre. Lorsque votre PC démarre (ou en tout cas peu après) le BIOS essaie de trouver un système d'exploitation sur l'un des périphériques sur lesquels il est autorisé à démarrer (on dit BOOTER, à ne pas confondre avec il faut bouter l'anglais hors de france...) : en général un disque dur. Pour ce faire il lit ce que l'on appelle le MASTER BOOT RECORD (le secteur de boot maitre... ou secteur de démarrage ou encore [[admin-admin_boot-LILO#LILO et MBR|MBR]] ; c'est le tout premier secteur du périphérique de démarrage, il fait 512 octets de long). LILO peut jouer le role de MBR mais ce n'est pas obligé, dans le cas du MBR par défaut (celui installé par DOS...), le processus de démarrage recherche une partition marquée comme ACTIVE et lance le programme qui se trouve au debut de la dite partition (dans le secteur de boot de cette partition), LILO peut aussi se trouver à cet endroit, mais aussi le chargeur de NT ou celui de DOS ou celui de n'importe quel système d'exploitation.

Donc, après le chargement du MBR en mémoire, le BIOS lance l'exécution de celui-ci. Le MBR étant très petit (512 octets), cela ne suffit pas pour faire tenir le noyau de Linux (500 Ko mini), ni le chargeur lui-même (la deuxième partie de LILO fait environ 5 Ko). Si le MBR est celui de LILO, il lance la deuxième partie de LILO, sinon, il lance le MBR de LILO qui se trouve sur la partition active. Celui-ci lance à son tour la deuxième partie de LILO. Bref, nous voilà dans la deuxième partie de LILO. C'est elle qui affiche le prompt "boot:", le menu de démarrage de LILO, etc. et qui va enfin charger et lancer le noyau de Linux et lui passer la main.

LILO est donc un chargeur de système d'exploitation (dédié surtout à Linux) mais aussi un programme de MASTER BOOT RECORD. C'est aussi le programme /sbin/lilo, qui installe le MBR de LILO.

== Restauration du MBR. ==

Le MBR est donc vital pour le fonctionnement de votre PC. Voyons d'abord comment, en cas ce problème, restaurer le MBR par défaut de votre PC. Il suffit de booter avec une disquette DOS (FreeDOS fait très bien l'affaire) contenant FDISK.EXE. On boote avec cette disquette et à l'invite on tape :

<div class="code">A:\>FDISK /MBR</div>

Voilà, votre MBR est celui par défaut du DOS.

Ou depuis Linux :

<div class="code">lilo -U</div>

Cette commande désinstalle LILO en copiant dans le MBR la copie de sauvegarde que LILO a faite lors de sa première installation.

== Un exemple de fichier de configuration de base. ==

Voilà un fichier de configuration de LILO (/etc/lilo.conf) typique :

<div class="code">boot=/dev/hda prompt other=/dev/hda1 label=windows table=/dev/hda image=/boot/vmlinuz-2.2.14 label=linux root=/dev/hda2 read-only</div>

Voyons ces premières lignes pour comprendre un peu ce que ça veut dire.

* La première ligne signifie que LILO va être installé sur le disque /dev/hda et comme c'est /dev/hda et non /dev/hdax, LILO jouera la role de [#lilo_mbr MBR].
* La seconde signifie que LILO autorisera le choix de la partition ou de l'image de démarage.
* Les trois lignes qui suivent informent LILO qu'un système appelé "windows" (label) peut etre démarré en lançant le premier secteur de la partition 1 du disque maitre de la première nape IDE (/dev/hda1).
* les quatre lignes suivantes informent LILO de démarrer le noyau Linux qui se trouve dans /boot/vmlinuz-2.2.14 nommé "linux", la racine (root) de cette installation (c'est à dire les fichiers de démarrage : les répertoire /bin et /sbin etc...) se trouvent sur /dev/hda2, et il faut que la racine soit (dans un premier temps) montée en lecture seulement (read-only).

== Mise en place de LILO. ==

Bon, maintenant que nous avons vu un fichier de configuration (simplissime), il s'agit d'installer LILO. Cela ne peut pas être plus simple, il suffit de taper (en étant root, l'installation d'un nouveau MBR n'est pas à laisser entre toutes les mains) :

<div class="code">[root@xwing home]# lilo Added windows * Added linux</div>

LILO nous signale que deux systèmes ont été ajoutés avec succès : windows qui est le système qui sera booté par défaut (l'astérisque nous le signale) et linux.

<div class="note">Remarque 1 : (obsolète, conservé pour l'historique) Vous pouvez, si vous avez un gros disque dur obtenir quelque chose du genre : <div class="code">[root@xwing home]# lilo Added windows * Warning: device 0x0303 exceeds 1024 cylinder limit Fatal: geo_comp_addr: Cylinder number is too big (1101 > 1023)</div> Cela signifie que :

# vous devez installer une version récente de LILO (postérieure à 21.4.2) qui supporte de démarrer une image qui se trouve après le 1024ème cylindre.
# vous devez ajouter la ligne : <div class="code">lba32</div> avant la première section image ou other du fichier de configuration /etc/lilo.conf pour que LILO puisse activer un noyau linux qui se trouve après le 1024ème cylindre (il faut pour cela que votre BIOS soit relativement récent : postérieur à 1998)
# ou alors, il faut que vous copiiez votre noyau (/boot/vmlinuz-2.2.14) avant le 1024ème cylindre : par exemple sur le disque windows dans le cas précédent, et que vous montiez CE disque avant de lancer LILO. Cette solution est la seule qui soit à votre disposition si vous installez une distribution depuis un CD qui ne possède pas un LILO à jour (toutes les distributions récentes sont à jour).

</div><div class="note">Remarque 2 : Vous pouvez lancer LILO autant de fois que vous voulez. En conséquence, au moindre doute sur le fait que votre configuration de LILO soit à jour, n'hésitez jamais à relancer LILO (par exemple si vous utilisez, bien que cela ne soit pas très utilisé sur une partition ext2, un défragmenteur de disque pour Linux, relancez LILO à la fin de son travail car celui-ci aura sans aucun doute modifié la place de vos noyaux).</div>

== Ajouter un second noyau. ==

Pour ajouter un second noyau, c'est enfantin, il suffit de recopier la section :

<div class="code">image=/boot/vmlinuz-2.2.14 label=linux root=/dev/hda2 read-only</div>

du fichier /etc/lilo.conf une deuxième fois en faisant en sorte de changer le label (évidemment sinon comment voulez vous pouvoir dire à LILO quel noyau vous chargez) et d'adapter le nom du noyau à celui que vous voulez charger.

Si, par exemple, vous désirez tester le tout nouveau noyau vmlinuz-2.4.0 ;-) il suffit de modifier /etc/lilo.conf pour qu'il devienne :

<div class="code">boot=/dev/hda prompt other=/dev/hda1 label=windows table=/dev/hda image=/boot/vmlinuz-2.2.14 label=linux root=/dev/hda2 read-only image=/boot/vmlinuz-2.4.0 label=linux24 root=/dev/hda2 read-only</div>

et de relancer la commande lilo. Vous pouver avoir jusqu'a 16 systèmes d'exploitation lancé par lilo.

<div class="note">Un conseil : n'enlevez jamais l'entrée image que votre distribution a installée par défaut, de cette façon, même si vous avez un problème avec un nouveau noyau, rien ne vous empêchera de démarrer avec un ancien noyau dont vous savez qu'il fonctionne parfaitement.</div>

 

== Les options de lilo.conf. ==

Comment faire pour que LILO s'adapte très précisément à ce que nous voulons ? La réponse : les options de lilo.conf permettent, sinon de faire tout ce que l'on souhaiterait, du moins de modifier son comportement de manière très précise :

=== Default ===

Vous souhaitez choisir l'image qui sera bootée par défaut par LILO, mais vous ne souhaitez pas devoir modifier l'ordre des section de /etc/lilo.conf ? C'est simple il suffit d'ajouter, avant la première section image ou other, une ligne :

<div class="code">default=<label></div>

ou <label> est le label d'une section image ou other que vous souhaitez booter par défaut.

=== Timeout ===

Si vous souhaitez que LILO démarre automatiquement (sans confirmation) au bout de 2,5 secondes, c'est très simple précisez, avant la première section image ou other :

<div class="code">timeout=<valeur></div>

ou <valeur> est le nombre de millisecondes après lequel LILO doit démarrer automatiquement.

<div class="note">Si vous mettez 0 comme <code>timeout</code>, vous ne pourrez alors plus modifier la ligne de commande du kernel et ainsi empêcher de modifier (par exemple) la variable <code>init</code>. </div>

=== VGA ===

Vous aimeriez que Linux démarre automatiquement avec une résolution différente des 80x25 habituels car cela vous ennuie d'avoir un écran de 21 pouces, mais d'être incapable de lire les messages du noyau ? Utilisez l'option vga :

<div class="code">vga=extended</div>

ou :

<div class="code">vga=ext</div>

pour utilisez le mode 80x50,

<div class="code">vga=ask</div>

pour que LILO vous demande au démarage de choisir la résolution

<div class="code">vga=<nombre></div>

pour utiliser le mode <nombre> pour résolution. (Utilisez vga=ask avant pour savoir quels sont les modes disponibles...) 

Vous pouvez utiliser une option vga différente pour chaque section image, ou une seule globale.

Voici une liste de mode courant que vous pourrez utiliser :

{| border="1"
| 
! 640x480
! 800x600
! 1024x768
! 1280x1024
|-
| 8 bits
| vga=769
| vga=771
| vga=773
| vga=775
|-
| 16 bits
| vga=785
| vga=788
| vga=791
| vga=794
|-
| 32 bits
| vga=786
| vga=789
| vga=792
| vga=795
|}

Merci à Ovh du forum

=== Message ===

Vous trouvez que l'invite de LILO est pour le moins spartiate ? Utilisez l'option message :

<div class="code">message=<nom-de-fichier-complet></div>

ou <nom-de-fichier-complet> est un fichier texte pur (sans rien d'autre) qui devra servir d'invite.

<div class="note">Note : l'invite habituelle "boot :" apparaîtra juste après le dernier caractère de votre fichier.</div><div class="note">Note : voir [#bonus lilomsg.pl].</div>

=== Password ===

C'est bien joli, de pouvoir démarrer 16 noyaux différents, mais certains d'entre-eux ne doivent pas être démarrés sans la présence de l'administrateur ? Qu'à cela ne tienne, vous n'avez qu'à mettre un mot de passe !

<div class="code">password=<mot-de-passe></div>

ou <mot-de-passe> est un mot de passe en clair et tenant compte des différences majuscule/minuscule. Comme le mot de passe est en clair dans le fichier de configuration de LILO il faut que /etc/lilo.conf ne soit lisible que par l'administrateur. Ce qui n'est pas le cas par défaut. Dans ce cas, n'oubliez donc pas de faire un :

<div class="code">[root@xwing home]# chown root:root /etc/lilo.conf [root@xwing home]# chmod 600 /etc/lilo.conf</div>

=== compact ===

Si lors du chargement de lilo vous observez un certain temps de latence avant d'accéder au démarrage du système, cette option est faite pour vous ! Elle permet de réduire considérablement le temps lors de cette étape du boot, au moment du chargement du kernel. Attention : testez-en le bon fonctionnement au préalable, tous les bios ne supportent pas cette option.

Elle est à ajouter dans la section principale de lilo.conf :

<div class="code">compact</div>

== Configuration avancée. ==

=== LILO et MBR ===

Nous avons vu que l'option install de /etc/lilo.conf permet de choisir sur quel disque LILO doit être installé en tant que MASTER BOOT RECORD, mais cette option ne sert pas qu'à cela. On peut avec cette option faire en sorte que LILO ne touche pas à notre MBR (soit parce qu'on ne lui fait pas confiance, soit parce que LILO n'est pas capable de démarrer correctement tel ou tel système d'exploitation - je crois savoir que c'est le cas de OS/2 pour certaines versions. Dans ce cas on ne va pas préciser un disque comme /dev/hda comme option install, mais plutôt une partition comme /dev/hda2 ! Bien sur pour que le MBR original puisse démarrer sur cette partition, celle-ci doit être marquée active par fdisk !

Exemple : supposons que vous ayez Windows sur la partition /dev/hda1 et la racine de votre installation Linux sur /dev/hda2. Vous avez deux solutions pour le multiboot : soit vous laissez le MBR par défaut (option la moins dangeureuse pour Windows), soit vous installez LILO en tant que MBR.

Si vous choisissez de ne pas installez LILO comme MBR, la directive install est :

<div class="code">install=/dev/hda2</div>

et vous devez marquer comme active cette partition avec fdisk. Pour changer de système actif au boot vous devez utiliser fdisk, ou mettre une clause other pour démarrer Windows sur /dev/hda1 et laisser /dev/hda2 active (je vous recommande cette dernière option, qui fonctionne dès que votre racine Linux n'est pas sur une partition étendue).

Si vous choisissez d'installez LILO comme MBR, la directive install devient :

<div class="code">install=/dev/hda</div>

(notez l'absence de numéro dans /dev/hda, cela signifie que l'on désigne un disque et non plus une partition particulière). Si vous souhaitez booter Windows il faut ajouter une clause other dans /etc/lilo.conf et relancer LILO.

=== Disque virtuel initial (INITial Ram Disk : initrd) ===

Vous avez sans doute remarqué que votre distribution utilise un fichier en complément du noyau, fichier nommé initrd. Ce fichier est en fait "une image de disque" contenant le plus souvent les modules que vous souhaitez rendre utilisable dès le démarrage de votre noyau (avant le montage de la racine) par exemple parce que vous utilisez un disque dur SCSI dont le driver n'est disponible qu'en module, ou bien vous avez mis le support IDE ou ext2 en module, ou toute autre raison qui vous est personnelle. Pour cela il faut savoir créer un tel fichier initrd. C'est très simple : supposons que vous ayez compilé un noyau 2.2.15 et que les modules soient installés (ce sera le cas par défaut) dans /lib/modules/2.2.15 la commande à lancer pour créer un tel disque virtuel initial est :

<div class="code">mkinitrd /boot/initrd-2.2.15.img 2.2.15</div>

et c'est tout. Maintenant vous avez dans /boot un fichier nommé initrd-2.2.15.img qui contient tous les modules de /lib/modules/2.2.15 (en fait même l'arborescence est conservée). Comment dire à LILO (c'est ce qui nous intéresse ici) de charger cet initrd ? C'est encore très simple, il suffit d'ajouter la ligne :

<div class="code">initrd=/boot/initrd-2.2.15.img</div>

à /etc/lilo.conf dans la section image correspondante (celle qui charge ce noyau 2.2.15). N'oubliez pas de relancer la commande lilo après cette modification.

=== Passer des paramètres au noyau Linux. ===

Il peut être intéressant, voire vital, de passer des paramètres au noyau de Linux pour modifier son comportement par défaut. Pour cela vous avez deux solutions :

==== Par la ligne de commande de LILO ====

Au moment du démarrage de LILO vous avez dû remarquer l'invite : "boot :" , c'est en fait une invite pour choisir quelle section de /etc/lilo.conf démarrer. Mais c'est aussi une invite pour passer des paramètres au noyau. Supposons (voir le [http://www.freenix.org/unix/linux/HOWTO/BootPrompt-HOWTO.html BootPrompt-HOWTO]) que vous désiriez passer au noyau linux2214 le paramètre ram=128 (en vue de signifier au noyau que vous avez 128Mo de Ram), alors à l'invite il faut taper :

<div class="code">boot: linux2214 ram=128</div>

et voilà, ce n'est pas la mer à boire. De même, si vous voulez démarrer en mode texte (runlevel 3), parce que X est momentanément hors service par exemple, tapez :

<div class="code">boot: linux2214 3</div>

==== Dans /etc/lilo.conf ====

On peut aussi faire en sorte qu'une image soit toujours chargée avec les mêmes paramètres passés au noyau sans être obligé de les taper à chaque fois. C'est simple il faut les préciser au paramétre append, par exemple ajoutez la ligne suivante comme option d'une image particulière :

<div class="code">append="3"</div>

pour forcer cette image à démarrer en mode texte plutot qu'en mode graphique.

=== Clavier AZERTY. ===

C'est bien de pouvoir choisir l'image au démarage, mais si vous avez mis windows comme label pour l'une d'elle, vous avez dû remarquer que vous êtes obligés de taper zindozs pour la sélectionner ! C'est pénible ! La solution est simple c'est le paramètre keytable qui permet de choisir une table de translation des touches tapées.

# il faut générer cette table par la commande : <div class="code">keytab-lilo.pl /usr/lib/kbd/keymaps/i386/qwerty/us.kmap.gz \ /usr/lib/kbd/keymaps/i386/azerty/fr-latin1.kmap.gz \ > /boot/fr-latin1.ktl</div> (normalement il devrait suffir de passer seulement fr-latin1 au script mais chez moi ça ne marche pas à cause de la compression de ces tables avec la Mandrake) qui génère les conversions du clavier fr-latin1 vers us et stocke la table dans /boot/fr-latin1.klt.
# il faut ajouter la ligne suivant à /etc/lilo.conf : <div class="code">keytable /boot/fr-latin1.ktl</div>

puis n'oubliez pas de relancer LILO.

=== Rebooter une configuration spécifique. ===

Si (et seulement si !) vous avez utilisé un timeout de 0, vous vous demandez sans doute comment rebooter sous (horreur!) windows, c'est simple, tapez :

<blockquote>lilo -R windows reboot</blockquote>

et c'est tout ! Ceci permet par exemple de ne pas autoriser de choix au boot de LILO, mais uniquement après, pour bénéficier de la sécurité de Linux (n'oubliez pas dans ce cas de supprimer les lecteurs de disquette et de CDROM de votre PC ;). 

== Annexes. ==

=== Numérotation des disques avec LILO et Linux. ===

Avec Linux (et LILO) les disques ne sont pas repérés par une lettre (i.e. C: , D: etc...) mais par un nom. Ces noms reflètent très exactement votre configuration. Les disques qui sont branchés sur une nappe IDE (ou ATA, Ultra ATA etc...) sont numérotés de la manière suivante :

# le disque maître de la nappe 1 est nommé : /dev/hda
# le disque esclave de la nappe 1 est nommé : /dev/hdb
# le disque maître de la nappe 2 est nommé : /dev/hdc
# le disque esclave de la nappe 2 est nommé : /dev/hdd
# etc... pour les nappes IDE suivantes.

Pour les disques SCSI le principe est le même, sauf que là, il n'y a pas désignation de maître ou d'esclave, donc :

# le premier disque SCSI du premier controleur scsi est : /dev/sda
# le second disque SCSI du premier controleur (ou le premier disque du second contrôleur s'il n'y a qu'un disque sur le premier contrôleur) est : /dev/sdb
# etc... pour les disques suivants.

Pour les autres types de disque, le principe est le même.

Le système de partitionnement retenu n'autorise que 4 partitions principales (a priori ce sont les seules bootables avec le MBR par défaut) dont l'une peut être une partition dite étendue qui peut contenir des partitions secondaires. Au maximun vous pouvez avoir 16 partitions sur un disque IDE et 7 sur un disque SCSI. Les quatre partitions principales (que les quatre soient là ou pas) se nomment : /dev/$$$1 /dev/$$$2 /dev/$$$3 et /dev/$$$4 où $$$ est le nom du disque sur lequel se trouve la partition. Les partitions secondaires sont numérotées à partir de 5 de la même façon.

=== Numérotation des disques avec LILO et Linux (version devfs). ===

A partir des noyaux 2.4.x, linux peut utiliser devfs (ce qui limite le nombre d'entrées dans /dev). Le problème, c'est qu'alors la numérotation des disques change (même si un systéme de compatibilité est parfois présent sur les distributions).

Les disques scsi sont dans /dev/scsi et les disques ide(ou atapi) sont dans /dev/ide. Ce sont (lorsque qu'ils sont présents) tous les deux des répertoires. Chacun de ces répertoires contient un sous répertoire par controleur de ce type, numéroté : host0, host1, ... hostn. En général vous ne possédez qu'un seul controleur de chaque type (si vous avez les deux types...), et donc chacun de ces répertoire ne contient qu'un seul répertoire host0.

Chaque répertoire /dev/(ide|scsi)/hostn/, contient une ou plusieurs entrées (qui sont des répertoires) : busn. Chaque entrée correspond à un "canal" de communication (pour les périphériques ide, elles correspondent soit au controleur primaire (bus0) soit au controleur secondaire (bus1); pour les périphériques scsi chaque bus correspond à un canal (chanel) scsi), en général vous aurez l'arboressence suivante :

<div class="code">+/dev +-+ ide/ | +-+ host0/ | +-+ bus0/ (controleur ide primaire) | | +-+ ... | +-+ bus1/ (controleur ide secondaire) | +-+ ... +-+ scsi/ +-+ host0/ +-+ bus0/ (premier controleur scsi, premier canal +-+ ... </div>

Chacun des busn contient la liste des périphériques (disque dur, cdrom, graveur, zip, etc...). Chaque disque est numéroté : targetn, en commençant par n = 0. Par exemple, le disque esclave (target1) sur la première nappe ide (bus0) du premier contrôleur ide (host0) s'appelle : /dev/ide/host0/bus0/target1/.

Chaque périphérique peut contenir plusieurs disques (par exemple un jukebox peut contenir 5 cdroms), ils sont repérés par un "lun" différent, pour un disque dur, on aura donc toujours lun0, et ce sera presque toujours le cas pour les autres types de périphérique. Donc, dans l'exemple précédant, on accédera au disque par : /dev/ide/host0/bus0/target1/lun0.

Pour les disques durs, chaque lun contient un fichier nommé disc (vers lequel un lien est mis dans /dev/discs) qui correspond au périphérique lui-même, et un fichier partn par partition de ce disque. Donc, dans l'exemple précédant, le disque lui-même s'appelle : /dev/ide/host0/bus0/target1disc/, et la première partition s'appelle : /dev/ide/host0/bus0/target1/part1.

Pour les cdrom, le lun contient un unique fichier nommé cd, un cdrom s'appellera par exemple /dev/ide/host0/bus1/target1/lun0/cd.

=== Mieux vaut prévenir que guérir. ===

Pour être sûr de pouvoir toujours booter Linux (même après une corruption de votre MBR), je vous conseille de copier votre dernier noyau à jour ainsi que l'initrd correspondant dans un répertoire de votre partition Windows (si vous en avez une <nowiki>;)</nowiki>. ainsi que loadlin.exe. Ainsi en cas de problème, vous pouvez booter sur votre partition Windows et lancer votre Linux par :

<div class="code">C:\LINUX> loadlin vmlinuz-2.2.15 root=/dev/hda2 initrd=initrd-2.2.15.img</div>

Pensez aussi à vous créer un disquette de boot contenant le noyau par :

<div class="code">[root@becane boot]# dd if=vmlinuz-2.2.15 of=/dev/fd0 bs=1k</div>

Attention cette façon de faire permet juste de booter si le reste du système n'est pas planté ! Car cette disquette de boot ne contient pas de système de fichier, seulement un noyau qui suppose que la racine est votre installation de Linux, elle ne fonctionnera pas forcément sur une autre machine. Pour ce qui est des disquettes de secours contenant de quoi remettre votre système en ordre, je vous conseille de voir du côté de :

<blockquote>[http://www.toms.net/rb/home.html tomsrtbt] : une distribution linux contenant un maximun d'utilitaires pour réparer une installation qui a planté. [http://sunsite.auc.dk/mulinux/ muLinux] : une autre distribution Linux minimale tenant sur une disquette.</blockquote>

Il y en a beaucoup d'autres (chacune remplissant une fonctionnalité particulière).

=== Plusieurs Linux ===

Pour installer plusieurs distributions Linux et proposer le choix au démarrage de LILO, c'est assez technique. Je vais exposer un cas particulier. La configuration est la suivante :

* <code>/dev/hda1</code> : un premier linux, on va dire une Mandrake, monté sur la Mandrake sur /, et sur la Gentoo sur /mnt/mdk.
* <code>/dev/hda2</code> : un second linux, on va dire une Gentoo, monté sur la Gentoo sur /, et sur la Mandrake sur /mnt/gentoo.

J'ai donc deux /etc/fstab : un dans /dev/hda1 et un dans /dev/hda2. Depuis la Mandrake, ils s'appellent respectivement : /etc/fstab et /mnt/gentoo/etc/fstab. Depuis la Gentoo, ils s'appellent respectivement : /mnt/mdk/etc/fstab et /etc/fstab.

J'ai aussi deux kernels Linux : un pour la Mandrake (depuis la Mandrake:/boot/vmlinuz-2.4.18-6mdk ou depuis la Gentoo:/mnt/mandrake/boot/vmlinuz-2.4.18-6mdk), et un pour la Gentoo (depuis la Mandrake:/mnt/gentoo/vmlinuz-2.4.18 ou depuis la Gentoo:/boot/vmlinuz-2.4.18)

De la même façon j'ai deux /etc/lilo.conf. Il convient de les synchroniser. C'est à dire de mettre les mêmes sections "image" dans les deux.

Voici le /etc/lilo.conf de la Mandrake (ie: /etc/lilo.conf depuis la Mandrake, /mnt/mdk/etc/lilo.conf depuis la Gentoo) :

<div class="code"> boot=/dev/hda prompt image=/boot/vmlinuz-2.2.18-6mdk label=mandrake root=/dev/hda1 read-only image=/mnt/gentoo/boot/vmlinuz-2.4.0 label=gentoo root=/dev/hda2 read-only </div>

Voici le /etc/lilo.conf de la Gentoo (ie: /mnt/gentoo/etc/lilo.conf depuis la Mandrake, /etc/lilo.conf depuis la Gentoo) :

<div class="code"> boot=/dev/hda prompt image=/mnt/mdk/boot/vmlinuz-2.2.18-6mdk label=mandrake root=/dev/hda1 read-only image=/boot/vmlinuz-2.4.0 label=gentoo root=/dev/hda2 read-only </div>

Maintenant en tapant <code>lilo</code> depuis l'une ou l'autre des deux distributions vous installez le lilo de cette distribution mais qui tient compte de l'autre.

Le procédé est le même pour installer plus deux deux Linux.

On peut même activer le lilo de la Mandrake depuis la Gentoo, en utilisant <code>chroot</code> :

<div class="code"> [root@gentoo ~] # chroot /mnt/mdk [root@gentoo /] # lilo Added mandrake * Added gentoo [root@gentoo /] # exit [root@gentoo ~] # _</div>

Bien sûr, on peut procéder de même pour installer le Lilo de la Gentoo depuis la Mandrake.

 

<div class="note" style="font-size: 8px;">

== Bonus : lilomsg.pl (obsolète). ==

Cette section est maintenant largement obsolète, car les distributions modernes ont de très jolis menus de démarrage, souvent graphiques. Mais comme elle a une portée pédagogique, elle est conservée.

Voici en bonus un script qui lit les fichiers /etc/lilo.conf et /boot/message.modele et génère un fichier /boot/message (que vous pouvez ajouter à LILO via l'option message=/boot/message). L'idée est la suivante : l'invite de LILO n'est pas très sympatique car elle ne précise pas les images bootables via lilo (à moins de presser pas la touche de tabulation). Le script suivant permet celà.

=== Le script. ===

<div class="code"> #!/usr/bin/perl

<nowiki># utilisation : lilomsg.pl </nowiki> # # lit les fichiers /etc/lilo.conf et /boot/message.modele pour # créer un fichier /etc/message en vue de l'utiliser depuis la # commande message=/boot/message de lilo

<nowiki># dans le fichier /boot/message.modele on peut trouver les </nowiki> # commandes suivantes (le caractère "$" est significatif) :

<nowiki># $iftimeout{chaine de caractère} : </nowiki> # la "chaine de caractère" ne sera affichée que s'il existe # un timeout dans /etc/lilo.conf

<nowiki># $timeout : </nowiki> # la valeur du timeout de /etc/lilo.conf en secondes # (dans /etc/lilo.conf elle est en milisecondes)

<nowiki># $config : </nowiki> # les entrées (label) triées de /etc/lilo.conf # ce qui se trouve avant et après $config sur la ligne est # recopié pour chaque entrée à la meme place, cela permet d'avoir # des "puces"

<nowiki># $border{$type chaine de caractère} </nowiki> # la "chaine de caractère" est affichée avec une bordure autour # d'elle. $type est soit : $0, $1, $2 ... $7 ou rien # # $0 : bordure simple # $1 : bordure double # $2 : bordure horizontale double, verticale simple # $3 : bordure horizontale simple, verticale double # $4 : bordure simple, double en bas # $5 : bordure simple, double en haut # $6 : bordure simple, double à gauche # $7 : bordure simple, double à droite

<nowiki># attention, il faut modifier le source pour pourvoir ajouter des </nowiki> # types $10, etc... 

<nowiki># bugs connus : </nowiki>

<nowiki># avec $border : il ne peut y avoir qu'une seule bordure par </nowiki> # ligne ! les autres sont tout bonnement ignorées.

<nowiki># dans toutes les options il est impossible de passer un </nowiki> # caractère "}" car ce caractère détermine la fin des options 

open(LILO,"/etc/lilo.conf") ; open(MODELE,"/boot/message.modele") ; open(MESSAGE,">/boot/message") ;

$default = "" ;

@configs =() ;

$timeout = "" ;

<nowiki># codes ascii (inaffichables sous linux...) semi graphique </nowiki>

@cadre = qw(218 196 191 179 179 192 196 217 201 205 187 186 186 200 205 188 213 205 184 179 179 212 205 190 214 196 183 186 186 211 196 189 218 196 191 179 179 212 205 190 213 205 184 179 179 192 196 217 214 196 191 186 179 211 196 217 218 196 183 179 186 192 196 189 ) ;

sub draw_cadre { local ($start,$msg,$type,$len1,$len2) = @_ ;

<nowiki># affiche la chaine $msg dans un cadre en commençant après </nowiki> # la chaine $start

$len1 = length($start) ; $len2 = length($msg) ;

<nowiki># utilisation de l'opérateur x : multiplication d'une chaine </nowiki> # par un scalaire : c'est à dire répétition !

print MESSAGE $start.chr($cadre[$type+0]). (chr($cadre[$type+1]) x $len2). chr($cadre[$type+2])."\n" ; print MESSAGE (" " x $len1).chr($cadre[$type+3]). $msg.chr($cadre[$type+4])."\n" ; print MESSAGE (" " x $len1).chr($cadre[$type+5]). (chr($cadre[$type+6]) x $len2).chr($cadre[$type+7]) ; }

<nowiki># on récupère les entrées de /etc/lilo.conf </nowiki> # le timeout # les labels # le label par défaut

while (<LILO>) { if (/timeout\s*=\s*(.*)/) { $timeout=$1/10 ; } if (/label\s*=\s*(.*)/) { if ($default eq "") { $default = $1 ; } push(@configs,$1) ; } if (/default\s*=\s*(.*)/) { $default = $1 ; } }

<nowiki># on parse /boot/message.modele à la recherche de quelques </nowiki> # mots clefs : # $iftimeout{} # $timeout # $configs # $default # $border{}

while ($line = <MODELE>) { $line =~ s/\$default/$default/g ; $line =~ s/\$timeout/$timeout/g ; if ($timeout eq "") { $line =~ s/\$iftimeout\{.*?\}//g ; } else { $line =~ s/\$iftimeout\{(.*?)\}/$1/g ; } if ($line =~ /\$configs/) { $start = $` ; $end = $' ; foreach (sort @configs) { print MESSAGE "$start$_$end" ; } } else { if ($line =~ /\$border\{(.*)\}/) { $start = $` ; $end = $' ; $msg = $1 ; if ($msg =~ /^\$(\d)/) { $msg = $' ; $typ = $1 ; } else { $typ = 0 ; # type par défaut : $0 } draw_cadre($start,$msg,$typ*8) ; print MESSAGE $end ; } else { print MESSAGE $line; } } }

close MESSAGE ; close MODELE ; close LILO ;

<nowiki># on affiche le résultat et on demande confirmation ! </nowiki>

system("cat /boot/message"); print "boot :\n" ; do { print "\nCe message vous convient-il ? Je lance LILO ? " ; $rep = <STDIN> } until ($rep =~ /^(yes|oui|non|no|n|y|o)$/i) ;

if ($rep =~ /^(y|o)/i) { # ok ! system("/sbin/lilo") ; }

</div>

=== Mode d'emploi. ===

Créer un fichier /boot/message.modele du style : <div class="code">$border{$4 Lilo demarrera la configuration\ $default$iftimeout{, dans $timeout secondes}. } Vous pouvez choisir l'une des configurations suivantes : - $configs Votre choix de</div> (les deux premières lignes sont en fait sur une seule ligne, sans le '\' final) et vous lancez lilomsg.pl qui vous demandera si cet ecran de démarrage vous convient (attention les caractères du cadre ne sont pas ceux seront affichés au boot, ceux affichés au boot seront vraiment des caractères d'encadrement...). Ce modèle vous donnera l'invite suivante (ou ressemblante) : <div class="code"> +-------------------------------------------------------------+ | Lilo demarrera la configuration linux2214, dans 5 secondes. | +-------------------------------------------------------------+

Vous pouvez choisir l'une des configurations suivantes :

- floppy - linux - linux2214 - windows

Votre choix de boot :

</div>

Remarquez que LILO à rajouté "boot :" à la fin du modèle.

Vous pouvez utilisez ce script en lieu et place de lilo (qui d'ailleurs est appelé - après confirmation - par le script).

<div class="note">Note : le parseur de modèle est simpliste, si quelqu'un se sent l'envie de l'améliorer, pour autoriser les cadres sur plusieurs lignes, l'ajout de paramètres de type "}" dans les options, utiliser quelque chose de plus clair que $0 .. $7 comme type de bordures etc... libre à lui, il serait sympa de m'envoyer ses modifications.</div> </div><div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Frédéric Bonnaud le 01/05/2000.</div>

= Copyright =
Copyright © 01/05/2000, Frédéric Bonnaud
{{CC-BY-NC-SA}}

Lea Linux - Contributions [fr]

LILO