Création d'un noyau personnalisé

De nombreux débutants sur Linux demandent ce qui justifierait qu'ils créent leur propre noyau. Etant donné les progrès réalisés dans l'utilisation des modules de noyau, la réponse à cette question est qu'à moins de savoir exactement ce qui justifierait qu'ils le fissent, il est probablement inutile qu'ils le fassent. Ainsi, si vous n'avez pas de raison spécifique de créer un noyau personnalisé (ou si vous ne faites pas partie de la race des incorrigibles curieux), vous pouvez passer à la la section intitulée Sendmail.

Par le passé, l'ajout de nouveau matériel à un système entraînait systématiquement la recompilation du noyau. Autrement dit, le noyau était statique. Les améliorations apportées aux noyaux Linux 2.0.x ont permis la modularisation de bon nombre de pilotes de matériel en composants ne pouvant être insérés que sur demande. Toutefois, la cohabitation de plusieurs noyaux sur un système engendrait des problèmes majeurs. Ceux-ci ont été compilés en vue d'apporter les améliorations nécessaires (un bon exemple étant les noyaux SMP par rapport aux noyaux UP). D'autres améliorations avec la modularisation du noyau Linux 2.2.x ont facilité la coexistence de plusieurs noyaux (modules non partagés).

Pour plus de détails sur la manipulation des modules de noyau, voir la section intitulée Chargement de modules de noyau dans Chapitre 3. La plupart des modifications sont cachées, sauf lors de la recompilation d'un noyau personnalisé pour votre système.

Création d'un noyau modularisé

Ces instructions vous permettent de profiter de la puissance et de la flexibilité offertes par la modularisation du noyau. Si vous ne voulez pas utiliser la modularisation, consultez la section intitulée Création 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 sorti toutes les commandes du 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. 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 ressemble à mkbootdisk --device /dev/fd0 2.2.x . Cela fait, testez la disquette d'amorçage pour vous assurer qu'elle démarrera le système.

Il est important de commencer la création 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 création 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 de 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 menu. 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 de Red Hat Linux. Modifiez 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 sélectionnés à l'aide de la souris. De nouveau, sélectionnez Y (oui), N (non) ou M (module).
make oldconfig -- Il s'agit d'un script non interactif qui définit votre Makefile comme source des paramètres par défaut. Si vous utilisez le noyau Red Hat corrigé, il définira la configuration sur celle du noyau fourni pour votre boîte. Ceci est utile lorsque vous définissez pour votre noyau les paramètres par défaut connus pour fonctionner correctement et que vous désactivez 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étails) 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 créer 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 pour préparer l'arborescence source pour la création.

L'étape suivante de la création d'un noyau modularisé consiste simplement à éditer /usr/src/linux/Makefile et à compiler les composants du code source dans un programme 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. Pour plus de détails sur les autres possibilités, consultez le fichier Kernel-HOWTO ou le Makefile situé 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 permet de faire coexister simultanément sur votre système l'ancien et le nouveau noyau.
Créez le noyau avec make bzImage.
Créez 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 créé aucun) avec la commande make modules_install. Ceci installera les modules de noyau dans le chemin d'accès /lib/modules/ à l'aide de la chaîne spécifiée dans le Makefile . Dans notre exemple, ce serait /lib/modules/2.2.15-2.5.0sjs/.

Si vous disposez d'une carte SCSI et avez rendu votre pilote SCSI modulaire, créez une nouvelle image initrd (voir la section intitulée Création 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 raison de créer une image initrd , n'en créez pas et ne l'ajoutez pas à lilo.conf.

Pour disposer d'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 d'origine dans /boot, en copiant le nouveau noyau dans /boot, en ajoutant quelques lignes dans /etc/lilo.conf et en exécutant /sbin/lilo. Voici un exemple du fichier /etc/lilo.conf par défaut fourni avec Red Hat Linux :

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

Vous devez à présent mettre à jour /etc/lilo.conf. Si vous avez créé 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
default=linux
linear
image=/boot/vmlinuz-2.2.15-2.5.0
     label=linux
     initrd=/boot/initrd-2.2.15-2.5.0.img
     read-only
     root=/dev/hda8
image=/boot/vmlinuz-2.2.15-2.5.0sjs 
        label=test
	initrd=/boot/initrd-2.2.15-2.5.0sjs.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: de LILO, deux choix vous sont proposés :

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 de temporisation de LILO soit écoulé. Si vous voulez démarrer le nouveau noyau ( test), entrez test, puis appuyez sur la touche Entrée.

Voici un résumé de ces étapes :

Copiez le noyau compilé obtenu 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
Edit /etc/lilo.conf.
Créez un nouveau disque virtuel initial, une image initrd (reportez-vous à la la section intitulée Création d'une image initrd) si nécessaire.
Exécutez /sbin/lilo. Vous pouvez ajouter un indicateur -v à lilo pour obtenir un rapport plus détaillé si vous pensez qu'il pourrait 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é.

Création d'une image initrd

Une image initrd est nécessaire pour le chargement de 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 créer une image initrd appropriée pour votre ordinateur si les conditions suivantes sont satisfaites :

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 créer 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

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

Création d'un noyau monolithique

Pour créer un noyau monolithique, vous procédez de la même façon que pour créer 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 :
make modules make modules_install

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