Voir la source de LILO

[[Catégorie:Administration système]]

= Configuration de LILO : LInux LOader (le chargeur de Linux) =

par [[Utilisateur:Fred|Fred]]

Entrez dans le monde fantastique des détails de configuration du premier programme chargé par votre PC.


== 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 <span style="font-weight: bold;">spécifique à l'architecture x86</span> (que pour les PC !, pas les Mac (qui utilisent <span style="font-style: italic;">yaboot</span>), 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). <br /> 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. <br /> 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 <span class="code">/sbin/lilo</span>, 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 <span style="font-style: italic;">première</span> installation.

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

Voilà un fichier de configuration de LILO (<span class="code">/etc/lilo.conf</span>) typique :

<div class="code">boot=/dev/hda <br /> prompt <br /> other=/dev/hda1 <br />         label=windows <br />         table=/dev/hda <br /> image=/boot/vmlinuz-2.2.14 <br />         label=linux <br />         root=/dev/hda2 <br />         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 <span class="code">/dev/hda</span> et comme c'est <span class="code">/dev/hda</span> et non <span class="code">/dev/hda<span style="font-style: italic; font-weight: bold;">x</span></span>, 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" (<span class="code">label</span>) peut etre démarré en lançant le premier secteur de la partition 1 du disque maitre de la première nape IDE (<span class="code">/dev/hda1</span>).
* les quatre lignes suivantes informent LILO de démarrer le noyau Linux qui se trouve dans <span class="code">/boot/vmlinuz-2.2.14</span> nommé "linux", la racine (<span class="code">root</span>) de cette installation (c'est à dire les fichiers de démarrage : les répertoire <span class="code">/bin</span> et <span class="code">/sbin</span> etc...) se trouvent sur <span class="code">/dev/hda2</span>, et il faut que la racine soit (dans un premier temps) montée en lecture seulement (<span class="code">read-only</span>).

== 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"><span style="font-weight: bold;">[root@xwing home]#</span> lilo <br /> Added windows * <br /> Added linux</div>

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

<div class="note">Remarque 1 : (obsolète, conservé pour l'historique) <br /> Vous pouvez, si vous avez un gros disque dur obtenir quelque chose du genre : <div class="code">[root@xwing home]# lilo <br /> Added windows * <br /> Warning: device 0x0303 exceeds 1024 cylinder limit <br /> 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<sup>ème</sup> cylindre.
# vous devez ajouter la ligne : <div class="code">lba32</div> avant la première section <span class="code">image</span> ou <span class="code">other</span> du fichier de configuration <span class="code">/etc/lilo.conf</span> pour que LILO puisse activer un noyau linux qui se trouve après le 1024<sup>ème</sup> 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<sup>ème</sup> 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 : <br /> 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 <br />         label=linux <br />         root=/dev/hda2 <br />         read-only</div>

du fichier /etc/lilo.conf une deuxième fois en faisant en sorte de changer le <span style="font-weight: bold;">label</span> (é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 <br /> prompt <br /> other=/dev/hda1 <br />         label=windows <br />         table=/dev/hda <br /> image=/boot/vmlinuz-2.2.14 <br />         label=linux <br />         root=/dev/hda2 <br />         read-only <br /> image=/boot/vmlinuz-2.4.0 <br />         label=linux24 <br />         root=/dev/hda2 <br />         read-only</div>

et de relancer la commande <span class="code">lilo</span>. Vous pouver avoir jusqu'a 16 systèmes d'exploitation lancé par lilo.

<div class="note">Un conseil : n'enlevez <span style="font-weight: bold;">jamais</span> 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> 

<br />

== 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 <span class="code">lilo.conf</span> 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 <span class="code">/etc/lilo.conf</span> ? C'est simple il suffit d'ajouter, avant la première section <span class="code">image</span> ou <span class="code">other</span>, une ligne :

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

ou <span class="code"><label></span> est le label d'une section <span class="code">image</span> ou <span class="code">other</span> 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 <span class="code">image</span> ou <span class="code">other</span> :

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

ou <span class="code"><valeur></span> est le nombre de <span style="font-style: italic;">millisecondes</span> après lequel LILO doit démarrer automatiquement.

<div class="note">Si vous mettez 0 comme <tt>timeout</tt>, vous ne pourrez alors plus modifier la ligne de commande du kernel et ainsi empêcher de modifier (par exemple) la variable <tt>init</tt>. </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 <span class="code">vga</span> :

<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 <span class="code"><nombre></span> pour résolution. (Utilisez <span class="code">vga=ask avant pour savoir quels sont les modes disponibles...) </span>

Vous pouvez utiliser une option <span class="code">vga</span> différente pour chaque section image, ou une seule globale.

Voici une liste de mode courant que vous pourrez utiliser :

{| border="1"
| <br />
! 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 <span class="code"><nom-de-fichier-complet></span> est un fichier texte pur (sans rien d'autre) qui devra servir d'invite.

<div class="note">Note : l'invite habituelle "<span class="code">boot :</span>"  apparaîtra juste après le dernier caractère de votre fichier.</div><div class="note">Note : voir <span class="code">[#bonus lilomsg.pl]</span>.</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 <span class="code"><mot-de-passe></span> 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 <span style="font-weight: bold;">il faut que <span class="code">/etc/lilo.conf</span> ne soit lisible que par l'administrateur.</span> Ce qui n'est pas le cas par défaut. <br /> Dans ce cas, n'oubliez donc pas de faire un :

<div class="code"><span style="font-weight: bold;">[root@xwing home]#</span> chown root:root /etc/lilo.conf <br /><span style="font-weight: bold;">[root@xwing home]#</span> 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 <span class="code">boot</span> de <span class="code">/etc/lilo.conf</span> 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 <span class="code">/dev/hda</span> comme option boot, mais plutôt une partition comme <span class="code">/dev/hda2</span> ! Bien sur pour que le MBR original puisse démarrer sur cette partition, celle-ci doit être marquée active par <span class="code">fdisk</span> !

<u>Exemple</u> : supposons que vous ayez Windows sur la partition <span class="code">/dev/hda1</span> et la racine de votre installation Linux sur <span class="code">/dev/hda2</span>. 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 boot est :

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

et vous devez marquer comme active cette partition avec <span class="code">fdisk</span>. Pour changer de système actif au boot vous devez utiliser <span class="code">fdisk</span>, ou mettre une clause <span class="code">other</span> pour démarrer Windows sur <span class="code">/dev/hda1</span> et laisser <span class="code">/dev/hda2</span> 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 boot devient :

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

(notez l'absence de numéro dans <span class="code">/dev/hda</span>, 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 <span class="code">other</span> dans <span class="code">/etc/lilo.conf</span> 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é <span class="code">initrd</span>. 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 <span class="code">ext2</span> en module, ou toute autre raison qui vous est personnelle. Pour cela il faut savoir créer un tel fichier <span class="code">initrd</span>. 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 <span class="code">/lib/modules/2.2.15</span> 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 <span class="code">/boot</span> un fichier nommé <span class="code">initrd-2.2.15.img</span> qui contient tous les modules de <span class="code">/lib/modules/2.2.15</span> (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>

à <span class="code">/etc/lilo.conf</span> dans la section <span class="code">image</span> correspondante (celle qui charge ce noyau 2.2.15). N'oubliez pas de relancer la commande <span class="code">lilo</span> 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 : "<span class="code">boot :</span>" , c'est en fait une invite pour choisir quelle section de <span class="code">/etc/lilo.conf</span> 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 <span class="code">linux2214</span> le paramètre <span class="code">ram=128</span> (en vue de signifier au noyau que vous avez 128Mo de Ram), alors à l'invite il faut taper :

<div class="code">boot: <span style="font-weight: bold;">linux2214 ram=128</span></div>

et voilà, ce n'est pas la mer à boire. <br /> 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: <span style="font-weight: bold;">linux2214 3</span></div>

==== Dans <span class="code">/etc/lilo.conf</span> ====

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 <span class="code">append</span>, 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émarrage, 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 <span class="code">keytable</span> 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"><span style="font-weight: bold;">keytab-lilo.pl</span> /usr/lib/kbd/keymaps/i386/qwerty/<span style="font-weight: bold;">us</span>.kmap.gz \ <br />     /usr/lib/kbd/keymaps/i386/azerty/<span style="font-weight: bold;">fr-latin1</span>.kmap.gz \ <br />     <span style="font-weight: bold;">> /boot/fr-latin1.ktl</span></div><br /> (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 <span class="code">fr-latin1</span> vers <span class="code">us</span> et stocke la table dans <span class="code">/boot/fr-latin1.klt</span>.
# il faut ajouter la ligne suivant à <span class="code">/etc/lilo.conf</span> : <div class="code"><span style="font-weight: bold;">keytable</span> /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 <br /> 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 ;). <br />

== 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é : <span class="code">/dev/hda</span>
# le disque esclave de la nappe 1 est nommé : <span class="code">/dev/hdb</span>
# le disque maître de la nappe 2 est nommé : <span class="code">/dev/hdc</span>
# le disque esclave de la nappe 2 est nommé : <span class="code">/dev/hdd</span>
# 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 : <span class="code">/dev/sda</span>
# 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 : <span class="code">/dev/sdb</span>
# 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 <span class="code">devfs</span> (ce qui limite le nombre d'entrées dans <span class="code">/dev</span>). 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 <span class="code">/dev/scsi</span> et les disques ide(ou atapi) sont dans <span class="code">/dev/ide</span>. 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é : <span class="code">host0</span>, <span class="code">host1</span>, ... <span class="code">host<span style="font-style: italic;">n</span></span>. 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 <span class="code">host0</span>.

Chaque répertoire <span class="code">/dev/(ide|scsi)/host<span style="font-style: italic;">n</span>/</span>, contient une ou plusieurs entrées (qui sont des répertoires) : <span class="code">bus<span style="font-style: italic;">n</span></span>. 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<br /> +-+ ide/<br /> | +-+ host0/<br /> | +-+ bus0/ (controleur ide primaire)<br /> | | +-+ ...<br /> | +-+ bus1/ (controleur ide secondaire)<br /> | +-+ ...<br /> +-+ scsi/<br /> +-+ host0/<br /> +-+ bus0/ (premier controleur scsi, premier canal<br /> +-+ ...<br /> </div>

Chacun des <span class="code">bus<span style="font-style: italic;">n</span></span> contient la liste des périphériques (disque dur, cdrom, graveur, zip, etc...). Chaque disque est numéroté : <span class="code">target<span style="font-style: italic;">n</span></span>, en commençant par <span style="font-style: italic;">n</span> = 0. Par exemple, le disque esclave (target1) sur la première nappe ide (bus0) du premier contrôleur ide (host0) s'appelle : <span class="code">/dev/ide/host0/bus0/target1/</span>.

Chaque périphérique peut contenir plusieurs disques (par exemple un jukebox peut contenir 5 cdroms), ils sont repérés par un "<span class="code">lun</span>" différent, pour un disque dur, on aura donc toujours <span class="code">lun0</span>, 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 : <span class="code">/dev/ide/host0/bus0/target1/lun0</span>.

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

Pour les cdrom, le <span class="code">lun</span> contient un unique fichier nommé <span class="code">cd</span>, un cdrom s'appellera par exemple <span class="code">/dev/ide/host0/bus1/target1/lun0/cd</span>.

=== 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 <span class="code"><nowiki>;)</nowiki></span>. 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é. <br />[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 :

* <tt>/dev/hda1</tt> : un premier linux, on va dire une Mandrake, monté sur la Mandrake sur /, et sur la Gentoo sur /mnt/mdk.
* <tt>/dev/hda2</tt> : 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<br /> prompt<br /> image=/boot/vmlinuz-2.2.18-6mdk<br /> label=mandrake<br /> root=/dev/hda1<br /> read-only<br /> image=/mnt/gentoo/boot/vmlinuz-2.4.0<br /> label=gentoo<br /> root=/dev/hda2<br /> 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<br /> prompt<br /> image=/mnt/mdk/boot/vmlinuz-2.2.18-6mdk<br /> label=mandrake<br /> root=/dev/hda1<br /> read-only<br /> image=/boot/vmlinuz-2.4.0<br /> label=gentoo<br /> root=/dev/hda2<br /> read-only </div>

Maintenant en tapant <tt>lilo</tt> 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 <tt>chroot</tt> :

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

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

<br />  



== Bonus : <span class="code">lilomsg.pl</span> (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 <span class="code">/etc/lilo.conf</span> et <span class="code">/boot/message.modele</span> et génère un fichier <span class="code">/boot/message</span> (que vous pouvez ajouter à LILO via l'option <span class="code">message=/boot/message</span>). 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><br /> # <br /> # lit les fichiers /etc/lilo.conf et /boot/message.modele pour <br /> # créer un fichier /etc/message en vue de l'utiliser depuis la <br /> # commande message=/boot/message de lilo

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

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

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

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

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

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

<nowiki># bugs connus : </nowiki>

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

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

open(LILO,"/etc/lilo.conf") ; <br /> open(MODELE,"/boot/message.modele") ; <br /> 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 <br />             201 205 187 186 186 200 205 188 <br />             213 205 184 179 179 212 205 190 <br />             214 196 183 186 186 211 196 189 <br />             218 196 191 179 179 212 205 190 <br />             213 205 184 179 179 192 196 217 <br />             214 196 191 186 179 211 196 217 <br />             218 196 183 179 186 192 196 189 <br /> ) ;

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

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

    $len1 = length($start) ; <br />     $len2 = length($msg) ;

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

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

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

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

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

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

close MESSAGE ; <br /> close MODELE ; <br /> close LILO ;

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

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

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

 </div>

=== Mode d'emploi. ===

 Créer un fichier <span class="code">/boot/message.modele</span> du style : <br /><div class="code"><font color="#ff0000">$border</font><font color="#ff9900">{</font><font color="#ff0000">$4</font> Lilo demarrera la configuration\<br />  <font color="#ff0000">$default$iftimeout</font><font color="#ff9900">{</font>, dans <font color="#ff0000">$timeout</font> secondes<font color="#ff9900">}</font>. <font color="#ff9900">}<br /><br /> </font>Vous pouvez choisir l'une des configurations suivantes :<br /><br />    - <font color="#ff0000">$configs<br /><br /> </font>Votre choix de</div><br /> (les deux premières lignes sont en fait sur une seule ligne, sans le '\' final) et vous lancez <span class="code">lilomsg.pl</span> 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) : <br /><div class="code"><br />      +-------------------------------------------------------------+ <br />      | Lilo demarrera la configuration linux2214, dans 5 secondes. | <br />      +-------------------------------------------------------------+ 

Vous pouvez choisir l'une des configurations suivantes :

        - floppy <br />         - linux <br />         - linux2214 <br />         - windows

Votre choix de boot :

 </div>

Remarquez que LILO à rajouté "<span class="code">boot :</span>" à 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>

<br/>
<br/>
'''<b>[[Admin-index|@ Retour à la rubrique Administration système]]</b>'''
<br/>

<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>

{{Copy|01/05/2000|[[Utilisateur:Fred|Fr&eacute;d&eacute;ric Bonnaud]]|CC-BY-SA}}