6.1 Compiler un noyau personnalisé

• 6.1.1 Compiler un noyau modulaire
• 6.1.2 Créer une image initrd
• 6.1.3 Compiler un noyau monolithique

La notion de compilation de noyau personnalisé a été largement modifiée depuis l'apparition des noyaux modulaires (présents depuis la version Linux 2.0.x). Auparavant, vous étiez obligé de compiler un noyau en y incluant tous les supports requis par votre système. Pour certaines configurations matérielles, le noyau pouvait très rapidement atteindre une taille disproportionnée. Certains supports n'étant que périodiquement utilisés, les ressources du système n'étaient pas correctement gérées. Depuis la version 2.0.x du noyau, vous pouvez charger dynamiquement les différents supports ou systèmes de fichiers que vous souhaitez utiliser. Pour plus d'informations, consultez le chapitre 9, section 9.6.

6.1.1 Compiler un noyau modulaire

Seules les plates-formes Intel et SPARC supportent les noyaux modulaires, pour les plates-formes Alpha vous ne pouvez utiliser d'un noyau monolithique (consultez la section 6.1.3).

Cette section contient un certain nombre d'informations, qui vous permettront de tirer profit de la puissance et de la flexibilité des noyaux modulaires. Si vous ne voulez pas utiliser les noyaux modulaires, reportez vous à la section 6.1.3 qui vous explique comment créer et installer un noyau monolithique. Nous supposons que vous avez installé les packages kernel-headers et kernel-source et que toutes les commandes seront exécutées depuis le répertoire /usr/src/linux.

Avant la création d'un noyau, il est important d'avoir une arborescence source en bon état. Il est donc recommandé d'utiliser la commande make mrproper. Les fichiers de configuration et tout ce qui concerne les anciennes compilations seront supprimés de l'arborescence. Vous devez maintenant créer un fichier de configuration qui déterminera les différents composants à inclure dans le noyau. Suivant votre matériel et vos préférences personnelles, trois

méthodes sont disponibles pour configurer le noyau.

* make config : programme texte interactif. Les composants vous sont présentés et pour chacun d'entre eux vous devez répondre par Y (Yes), N (No), ou M (Module).

* make menuconfig : programme graphique. Les composants sont présentés dans un menu, contenant plusieurs catégories, et vous pouvez les sélectionner en utilisant la même procédure que celle utilisée lors de l'installation. Pour chaque item, vous avez le choix entre Y (Yes), N (No), ou M (Module).

* make xconfig : programme X Window. Les composants sont présentés dans différents menus et sous menus. Vous pouvez sélectionner les items avec la souris et pour chacun d'entre eux, vous avec le choix entre trois Y (Yes), N (No), ou M (Module).

Note : si vous compilez un noyau Linux/Intel sur une machine qui utilise un processeur clone (Cyrix ou AMD par exemple), il est recommandé de choisir 386 comme type de processeur.

Si vous voulez compiler un noyau avec un fichier de configuration (/usr/src/linux/.config) déjà créé avec une des méthodes précédentes, vous pouvez ignorer les commandes make mrproper et make config. Utilisez la commande make dep suivie de la commande make clean pour préparer l'arborescence source.

L'étape suivante permet de compiler le code source en un programme directement utilisable par la machine au démarrage. La méthode décrite ici est relativement simplifiée, pour plus de renseignements consultez le Kernel-HOWTO ou le Makefile de votre système Linux qui se trouve dans le /usr/src/linux.

* Compilez le noyau avec make boot.

* Compilez les modules que vous avez configurés avec make modules.

* Déplacez les anciens modules avec les commandes :

rm -rf /lib/modules/2.0.29-old

mv /lib/modules/2.0.29 /lib/modules/2.0.29-old

* Si vous avez effectué une mise à jour du noyau, remplacez 2.0.29 par la version que vous utilisez.

* Installez les nouveaux modules avec la commande :

make modules_install

Pour éviter tout problème, nous vous conseillons de conserver une copie de votre ancien noyau. Ajouter un noyau au menu LILO est aussi simple que de renommer le noyau original dans /boot, copiez le nouveau noyau dans /boot, ajoutez quelques lignes à /etc/lilo.conf et exécutez /sbin/lilo. Voici un exemple du fichier /etc/lilo.conf par défaut contenu dans Red Hat Linux :

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=100
image=/boot/vmlinuz
label=linux
root=/dev/hda1
read-only

Vous devez maintenant mettre à jour /etc/lilo.conf. Si vous avez compilé une nouvelle image initrd, vous devez dire à LILO de l'utiliser. Dans l'exemple de /etc/lilo.conf nous avons ajouté quatre lignes en fin de fichier pour préciser l'autre noyau à utiliser. Nous avons renommé /boot/vmlinuz en /boot/vmlinuz.old et changé son label en old. Nous avons aussi ajouté une ligne initrd pour le nouveau noyau :

boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=100
image=/boot/vmlinuz
label=linux
initrd=/boot/initrd
root=/dev/hda1
read-only
image=/boot/vmlinuz.old
label=old
root=/dev/hda1
read-only

Lorsque le système démarre et lorsque vous appuyez sur la touche Tab au prompt LILO boot: deux choix vous seront proposés :

LILO boot:
linux old

Pour utiliser le nouveau noyau (linux) appuyez simplement sur Entrée ou attendez la fin du décompte. Pour utiliser l'ancien noyau (old), tapez old suivi de Entrée.

Voici un résumé des différentes étapes :

* mv /boot/vmlinuz /boot/vmlinuz.old
* cp /usr/src/linux/arch/i386/boot/zImage /boot/vmlinuz
* éditez /etc/lilo.conf
* exécutez /sbin/lilo

6.1.2 Créer une image initrd

Vous aurez besoin d'une image initrd pour charger vos modules SCSI au démarrage. Le shell script /sbin/mkinitrd peut facilement créer une image initrd pour votre système, à condition que :

* Le périphérique loopback block soit disponible

* Le fichier /etc/conf.modules contienne une ligne pour votre adaptateur SCSI, exemple :

* alias scsi_hostadapter BusLogic

/sbin/mkinitrd /boot/newinitrd-image 2.0.12

/boot/newinitrd-image est le fichier à utiliser pour la nouvelle image et 2.0.12 est le noyau dont les modules (issus de /lib/modules) doivent être utilisés dans l'image initrd (ce n'est pas forcément la même version que celui actuellement utilisé).

6.1.3 Compiler un noyau monolithique

Pour compiler un noyau monolithique, la procédure à suivre est la même que celle proposée précédemment à quelques exceptions près.

* Lors de la configuration du noyau, ne répondez que par Yes ou par No (n'utilisez pas de module).

* Vous pouvez sauter les commandes :

make modules
make modules_install

* Editez le fichier /etc/rc.d/rc.sysinit, et mettez en commentaire la ligne depmod -a en insérant le caractère # en début de ligne.