Guide pratique des disquettes d'amorçage

Tous les PC démarrent en exécutant du code situé en mémoire morte (à savoir, le BIOS) afin de charger le secteur situé au secteur 0, cylindre 0 du disque d'amorce. Celui-ci est habituellement le premier lecteur de disquette (appelé A: sous DOS et /dev/fd0 sous Linux). Le BIOS essaye alors d'exécuter ce secteur. Sur la plupart des disques d'amorce, le secteur 0, cylindre 0 contient :

Si un noyau Linux a été copié directement sur une disquette, le premier secteur du disque sera le premier secteur du noyau Linux lui-même. Ce premier secteur continuera le démarrage en chargeant le reste du noyau depuis le périphérique d'amorce.

Une fois que le noyau est complètement chargé, il effectue certaines initialisations de périphériques ainsi que de ses données internes. Une fois qu'il est complètement initialisé, il consulte un endroit particulier dans son image appelé le mot disque mémoire. Ce mot précise comment et où trouver le système de fichiers racine. Un système de fichiers racine est simplement celui qui est monté en tant que « / ». Il faut dire au noyau où trouver ce système racine ; s'il ne peut trouver d'image à charger, il s'arrête.

Dans certains cas au démarrage (souvent lors du démarrage depuis une disquette), le système de fichiers racine est chargé dans un disque mémoire, auquel le système accède ensuite en mémoire comme s'il s'agissait d'un vrai disque. Il y a deux raisons à un tel chargement en mémoire. Premièrement, la mémoire vive est de plusieurs ordres de magnitude plus rapide qu'une disquette, et le système est donc rapide ; deuxièmement, le noyau peut charger un système de fichiers compressé depuis la disquette et le décompresser en mémoire, permettant ainsi de stocker plus de fichiers sur la disquette.

Une fois le système de fichiers racine chargé et monté, vous voyez un message tel que :

VFS: Mounted root (ext2 filesystem) readonly.

À ce moment, le système trouve le programme init dans le système racine (dans /bin ou /sbin) et l'exécute. init lit sa configuration dans /etc/inittab, cherche une ligne nommée sysinit, et exécute le script indiqué. Le script sysinit est en général un fichier du genre /etc/rc ou /etc/init.d/boot. Le script est un ensemble de commandes shell qui mettent en place les services de base du système, tels que :

Ce script appelle lui-même souvent nombre d'autres scripts pour réaliser une initialisation modulaire. Par exemple, dans la structure SysVinit habituelle, le répertoire /etc/rc.d/ contient une structure complexe de sous-répertoires dont les fichiers indiquent comment lancer et arrêter la plupart des services du système. En revanche, sur un disque d'amorce, le script sysinit est souvent très simple.

Quand le script sysinit se termine, le contrôle revient à init, qui entre alors dans le niveau d'exécution par défaut, spécifié dans inittab par le mot clé initdefault. La ligne du niveau d'exécution indique en général un programme tel que getty, responsable de la gestion des communications par la console ou les tty. C'est le programme getty qui affiche l'invite habituelle login:. Lui-même exécute à son tour le programme login pour gérer la validation du login et mettre en place la session de l'utilisateur.

Ensuite, créez le système de fichiers. Le noyau Linux sait charger automatiquement deux types de système de fichiers dans un disque mémoire : minix et ext2, avec une préférence pour ext2. Si vous le choisissez, vous voudrez peut-être utiliser l'option -i afin de créer plus d'i-nœuds que par défaut ; -i 2000 est une bonne valeur qui vous évitera de tomber à court d'i-nœuds. Vous pouvez sinon économiser des i-nœuds en supprimant pas mal de fichiers /dev/ inutiles. mke2fs crée par défaut 360 i-nœuds sur une disquette de 1,44 Mo. Je trouve 120 i-nœuds largement suffisants pour ma disquette racine de secours, mais si vous conservez tous les périphériques dans le répertoire /dev vous dépasserez facilement les 360. L'utilisation d'un système racine compressé permet de créer un système de fichiers plus grand, contenant donc plus d'i-nœuds par défaut, mais vous pourrez quand même vouloir réduire le nombre de fichiers ou augmenter le nombre d'i-nœuds.

Vous allez donc taper une commande du genre :

mke2fs -m 0 -i 2000 PÉRIPHÉRIQUE

(Si vous utilisez un périphérique de boucle, le fichier que vous utilisez doit être indiqué à la place de ce PÉRIPHÉRIQUE. mke2fs vous demandera alors si vous voulez vraiment faire cela ; répondez oui.)

La commande mke2fs détectera automatiquement l'espace disponible et se configurera selon ce dernier. Le paramètre -m 0 permet de ne pas réserver d'espace pour root, et laisse donc plus d'espace disponible sur le disque.

Ensuite, montez le périphérique :

mount -t ext2 PÉRIPHÉRIQUE /mnt

(Vous devez créer un point de montage /mnt s'il n'existe pas encore.) Dans les sections suivantes, tous les répertoires destination sont supposés relatifs à /mnt.

Trois de ces répertoires resteront vides sur les systèmes racine, il suffit donc de les créer avec mkdir. Le répertoire /proc n'est qu'une base sous laquelle le système proc est placé. /mnt et /usr ne sont que des points de montage utilisés une fois que le système amorce/racine tourne. Encore une fois, il suffit de créer ces répertoires.

Les quatre autres répertoires sont décrits dans les sections suivantes.

Ces modules doivent être placés dans /lib/modules. Vous devez aussi inclure insmod, rmmod et lsmod. Si vous souhaitez charger les modules automatiquement, prenez modprobe, depmod et swapout. Et si vous utilisez kerneld, prenez le avec son fichier de configuration /etc/conf.modules.

Néanmoins, le principal avantage d'utiliser les modules est que vous pouvez déplacer les modules non essentiels sur un disque utilitaire et ne les charger que lorsque c'est nécessaire, ce qui prend alors moins de place sur le disque racine. Si vous devez gérer beaucoup de périphériques, il vaut mieux procéder de cette manière plutôt que de construire un seul gros noyau contenant tous les gestionnaires.

Attention, pour démarrer avec un système de fichiers ext2 compressé, vous devez avoir inclus le support pour disque mémoire et ext2. Ils ne peuvent être installés par des modules.

Donc :

mkdir -p /mnt/var/{log,run}
touch /mnt/var/run/utmp

Enfin, après avoir installé toutes les bibliothèques dont vous avez besoin, lancez ldconfig pour refabriquer /etc/ld.so.cache sur le système racine. Le cache indique au loader où trouver les bibliothèques. Pour refabriquer ld.so.cache, lancez la commande suivante :

ldconfig -r /mnt

La première chose à faire est de vérifier que vous avez une version récente de LILO. Ensuite, il faut créer un petit fichier de configuration pour LILO. Il doit ressembler à :

boot      =/dev/fd0
install   =/boot/boot.b
map       =/boot/map
read-write
backup    =/dev/null
compact
image     = NOYAU
label     = Bootdisk
root      =/dev/fd0

Pour la signification de ces paramètres, voir la documentation utilisateur de LILO. Il vous faudra probablement aussi rajouter une ligne append=… à ce fichier, comme dans le fichier /etc/lilo.conf de votre disque dur.

Sauvez-le en tant que bdlilo.conf.

Vous devez maintenant créer un petit système de fichier, que nous appellerons système noyau, pour le différencier du système racine.

Tout d'abord, calculez la taille que celui-ci doit faire. Prenez la taille de votre noyau en blocs (la taille donnée par ls -s NOYAU et ajoutez 50. Cinquante blocs sont en gros la taille nécessaire aux i-nœuds ainsi qu'aux autres fichiers. Vous pouvez calculer le nombre exact si vous voulez, ou simplement utiliser 50. Si vous créez un ensemble avec deux disques, vous pouvez carrément surestimer l'espace nécessaire puisque le disque n'est utilisé que par le noyau de toute manière. Appelez ce nombre BLOCS_NOYAU.

Mettez une disquette dans le lecteur (pour simplifier, supposons qu'il s'agit de /dev/fd0) et créez le système noyau ext2 dessus :

mke2fs -N 24 -m 0 /dev/fd0 BLOCS_NOYAU

L'option -N 24 indique que l'on souhaite 24 i-nœuds, ce qui est largement suffisant pour ce système de fichiers. Ensuite, montez le système, supprimez le répertoire lost+found et créez des répertoire dev et boot pour LILO :

mount /dev/fd0 /mnt
rm -rf /mnt/lost+found
mkdir /mnt/{boot,dev}

Ensuite, créez les périphériques /dev/null et /dev/fd0. Au lieu de chercher leurs numéros de périphériques, vous pouvez simplement les copier depuis votre disque dur avec l'option -R :

cp -R /dev/{null,fd0} /mnt/dev

LILO a besoin d'une copie de son chargeur d'amorce, boot.b, que vous pouvez trouver sur votre disque dur. Il est d'habitude dans le répertoire /boot.

cp /boot/boot.b /mnt/boot

Enfin, copiez le fichier de configuration de LILO que vous avez créé précédemment avec votre noyau. Les deux peuvent être placés dans le répertoire racine :

cp bdlilo.conf NOYAU /mnt

Tout ce dont LILO a besoin est maintenant sur le système noyau, vous pouvez donc le lancer. Le paramètre -r de LILO est utilisé pour installer le chargeur sur une autre racine que la courante :

lilo -v -C bdlilo.conf -r /mnt

LILO doit s'exécuter sans erreur, après quoi le système noyau devrait ressembler à :

total 361
  1 -rw-r--r--   1 root     root          176 Jan 10 07:22 bdlilo.conf
  1 drwxr-xr-x   2 root     root         1024 Jan 10 07:23 boot/
  1 drwxr-xr-x   2 root     root         1024 Jan 10 07:22 dev/
358 -rw-r--r--   1 root     root       362707 Jan 10 07:23 vmlinuz
boot:
total 8
  4 -rw-r--r--   1 root     root         3708 Jan 10 07:22 boot.b
  4 -rw-------   1 root     root         3584 Jan 10 07:23 map
dev:
total 0
  0 brw-r-----   1 root     root       2,   0 Jan 10 07:22 fd0
  0 crw-r--r--   1 root     root       1,   3 Jan 10 07:22 null

Ne vous inquiétez pas si la taille des fichiers n'est pas exactement la même que la votre.

Enfin, indiquez que le périphérique racine doit être la disquette elle-même, et que le noyau doit être chargé en lecture/écriture.

        rdev /dev/fd0 /dev/fd0
        rdev -R /dev/fd0 0

Attention à bien utiliser un -R majuscule dans la seconde commande rdev.

Après avoir bien calculé la valeur du mot disque mémoire, écrivez-le avec rdev -r. Attention à utiliser la valeur décimale. Si vous utilisez LILO, l'argument de rdev doit être le chemin d'accès au noyau monté, c'est à dire /mnt/vmlinuz ; si vous avez copié le noyau avec dd, utilisez à la place le nom du périphérique du lecteur de disquette (c'est à dire /dev/fd0).

rdev -r NOYAU_OU_LECTEUR_DE_DISQUETTE VALEUR

Si vous avez utilisé LILO, démontez maintenant la disquette.

Et lorsque vous copiez des bibliothèques :

objcopy --strip-debug ORIGINE DESTINATION