Construction d'un noyau personnalisé

Construction d'un noyau modularisé

Ces instructions vous permettent de profiter de la puissance et de la flexibilité disponibles par le biais d'une modularisation du noyau. Si vous ne voulez pas tirer parti de la modularisation, consultez la section intitulée Construction d'un noyau monolithique pour obtenir une explication sur les différents aspects de la création et de l'installation d'un noyau monolithique. Vous êtes supposé avoir déjà installé les paquetages kernel-headers et kernel-source et avoir émis toutes les commandes depuis le répertoire /usr/src/linux.

L'étape la plus importante consiste à vous assurer que vous disposez d'une disquette d'amorçage d'urgence qui fonctionne au cas où vous commettriez une erreur mentionnée ci-dessous. Si vous n'avez pas créé de disquette d'amorçage durant l'installation, utilisez la commande mkbootdisk pour en créer une. La commande standard est similaire à mkbootdisk --device /dev/fd0 2.2.x, où 2.2.x est la version complète de votre noyau (par exemple, 2.2.14-5.0). Cela fait, testez la disquette d'amorçage pour vous assurer qu'elle démarrera le système.

Il est important de commencer la construction d'un noyau avec l'arborescence source en situation connue. C'est pourquoi il est conseillé de commencer par la commande make mrproper. Celle-ci supprime tous les fichiers de configuration en même temps que les restes de toute construction précédente qui pourraient avoir été éparpillés autour de l'arborescence source. Vous devez à présent créer un fichier de configuration qui déterminera quels composants inclure dans le nouveau noyau. Les méthodes disponibles pour la configuration du noyau sont énumérées ci-dessous :

• make config — Programme en mode texte interactif. Les composants sont présentés et vous répondez par Y (yes), N (no), ou M (module).

• make menuconfig — Programme graphique, piloté par menus. Les composants sont présentés dans un menu de catégories. Vous les sélectionnez de la manière utilisée dans le programme d'installation Red Hat Linux. Commutez l'étiquette correspondant à l'élément que vous voulez inclure ; Y (oui), N (non) ou M (module).

• make xconfig — Programme du système X Window. Les composants sont répertoriés dans différents niveaux de menus et peuvent être sélectionnés à l'aide d'une souris. De nouveau, sélectionnez Y (oui), N (non) ou M (module).

• make oldconfig — Il s'agit d'un script non interactif qui configure votre Makefile pour qu'il fasse office de paramètres par défaut. Si vous utilisez le noyau Red Hat corrigé, il définira la configuration de manière à ce qu'elle soit celle du noyau fourni pour votre boîte. Ceci est utile lorsque vous définissez votre noyau afin de connaître les paramètres de travail par défaut et de désactiver les fonctions dont vous ne voulez pas.

	Remarque
	Pour utiliser kmod (reportez-vous à la la section intitulée Chargement de modules de noyau dans Chapitre 3 pour plus de détail) et les modules de noyau, vous devez répondre Yes à kmod support et module version (CONFIG_MODVERSIONS) support lors de la configuration.

Si vous voulez compiler un noyau avec un fichier de configuration (/usr/src/linux/.config — ce fichier est créé une fois que l'une des méthodes ci-dessus a été appliquée) déjà créé avec l'une des méthodes ci-dessus, vous pouvez omettre les commandes make mrproper et make config et utiliser la commande make dep, suivie de make clean, afin de préparer l'arbre source pour la compilation.

L'étape suivante de création d'un noyau modularisé consiste simplement à éditer /usr/src/linux/Makefile et compiler les composants du code source dans un programme de travail que l'ordinateur peut utiliser pour démarrer. La méthode décrite ici est celle offrant la meilleure garantie de récupération en cas de mésaventure. Si vous vous intéressez à d'autres possibilités, vous trouverez plus de détails dans le Kernel-HOWTO ou dans le Makefile figurant dans le répertoire /usr/src/linux de votre système Linux.

• Editez le Makefile et modifiez la ligne : EXTRAVERSION = pour la faire correspondre à un nom "unique" (par exemple, par l'ajout d'initiales à la fin de la chaîne, comme dans EXTRAVERSION = -2.5.0sjs). Ceci vous permet d'avoir en fonction, en même temps, sur votre système, l'ancien et le nouveau noyau.

• Construisez le noyau avec make bzImage.

• Construisez tous les modules que vous avez configurés à l'aide de la commande make modules.

• Installez les nouveaux modules (même si vous n'en avez construit aucun) avec la commande make modules_install. Cette opération installera les modules du noyau dans le répertoire /lib/modules/ à l'aide du nom de chemin d'accès spécifié dans le Makefile. Notre exemple serait /lib/modules/2.2.15-2.5.0sjs/.

Si vous disposez d'une carte SCSI et avez rendu votre pilote SCSI modulaire, construisez une nouvelle image initrd (voir la section intitulée Réalisation d'une image initrd ; notez qu'il y a peu de raisons pratiques de rendre le pilote SCSI modulaire dans un noyau personnalisé). A moins d'avoir une excellente raison de créer une image initrd, n'en créez pas et ne l'ajoutez pas à lilo.conf.

Pour fournir une source de démarrage redondante afin d'offrir une protection contre une erreur possible dans un nouveau noyau, conservez le noyau d'origine disponible. L'ajout d'un noyau au menu LILO est aussi facile que de renommer le noyau original dans /boot, en copiant le nouveau noyau vers /boot, en ajoutant quelques lignes dans /etc/lilo.conf et en exécutant /sbin/lilo. Voici un exemple de fichier/etc/lilo.conf par défaut possible livré avec Red Hat Linux :

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
message=/boot/message
linear
default=linux
image=/boot/vmlinuz-2.2.16-12
        label=linux
        initrd=/boot/initrd-2.2.16-12.img
        read-only
	root=/dev/hda8
other=/dev/hda1 
        label=dos

Vous devez à présent mettre à jour /etc/lilo.conf. Si vous avez construit une nouvelle image initrd, vous devez indiquer à LILO de l'utiliser. Dans cet exemple de /etc/lilo.conf, nous avons ajouté quatre lignes au milieu du fichier pour indiquer un autre noyau à partir duquel démarrer. Nous avons renommé /boot/vmlinuz en /boot/vmlinuz.old, et modifié son étiquette en old. Nous avons également ajouté une ligne initrd pour le nouveau noyau :

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
message=/boot/message
linear
default=linux
image=/boot/vmlinuz-2.2.16-12
label=linux
initrd=/boot/initrd-2.2.16-12.img
read-only
root=/dev/hda8
image=/boot/vmlinuz-2.2.16-12.sjs 
label=test
initrd=/boot/initrd-2.2.16-12sjs.img
read-only
root=/dev/hda8
other=/dev/hda1
label=dos
	

Désormais, lorsque le système démarre et que vous appuyez sur Tab à l'invite boot:, les choix disponibles seront

LILO boot:
linux  test  dos
        

Pour démarrer l'ancien noyau (linux), appuyez simplement sur la touche Entrée, ou attendez que le délai d'attente de LILO soit écoulé. Si vous voulez démarrer le nouveau noyau (test), tapez test, puis appuyez sur la touche Entrée.

Voici un résumé de ces étapes :

• Copiez le noyau compilé qui en résulte dans votre répertoire /boot en utilisant le nom résultant des modifications antérieures apportées au Makefile. Voici un exemple :

  cp -p /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.2.15-2.5.0sjs /usr/src/linux/System.map /boot/System.map-2.2.15-2.5.0sjs

• Edit /etc/lilo.conf.

• Créez un nouveau disque virtuel initial, image initrd (voir la la section intitulée Réalisation d'une image initrd) si nécessaire.

• Exécutez /sbin/lilo (vous pouvez commencer par utiliser /sbin/lilo -t — cette commande testera votre fichier lilo.conf sans réellement écrire de nouveau secteur de démarrage ou fichier de configuration). Vous pouvez ajouter un indicateur -v à lilo pour obtenir un rapport plus détaillé si vous pensez qu'il risque d'y avoir un problème.

Vous pouvez commencer par tester votre nouveau noyau en redémarrant l'ordinateur et en observant les messages pour vous assurer qu'il est correctement détecté.

Réalisation d'une image initrd

Une image initrd est nécessaire pour charger votre module SCSI au démarrage. Si vous n'avez pas besoin d'une image initrd, n'en créez pas et n'éditez pas lilo.conf pour inclure cette image.

Le script shell /sbin/mkinitrd peut construire une image initrd propre pour votre machine si les conditions suivantes sont réunies :

• Le périphérique bloc loopback est disponible.

• Le fichier /etc/conf.modules contient une ligne concernant votre carte SCSI ; Par exemple :

  alias scsi_hostadapter BusLogic

Pour construire la nouvelle image initrd, exécutez /sbin/mkinitrd à l'aide de paramètres tels que celui-ci :

/sbin/mkinitrd /boot/newinitrd-image 2.2.15-2.5.0sjs
	

Où /boot/newinitrd-image est le fichier à utiliser pour votre nouvelle image, et 2.2.15 le noyau dont les modules (à partir de /lib/modules) doivent être utilisés dans l'image initrd (pas nécessairement le même que le numéro de version du noyau en cours d'exécution).

Construction d'un noyau monolithique

Pour construire un noyau monolithique, vous procédez de la même façon que pour construire un noyau modularisé, à quelques exceptions près.

• Lors de la configuration du noyau, répondez uniquement Yes et No aux questions (ne faites rien de modulaire). Vous pouvez également répondre No à kmod support et module version (CONFIG_MODVERSIONS) support dans la configuration.

• Omettez les étapes :

  créer des modules créer modules_install

• Editez lilo.conf et ajoutez la ligne append=nomodules.