Le code source du kernel étant disponible, vous avez bien entendu la possibilité de recréer un nouveau kernel à partir de ce code source : c'est ce que l'on désigne par la compilation du kernel.
On peut en effet s'interroger sur l'intérêt de compiler un kernel, c'est-à-dire,
en fait, ni plus ni moins recréer et changer le c
ur du système Linux à
partir de son code source. D'autant plus que bien souvent, les kernels installés
par les différentes distributions sont construits de telle façon qu'ils conviennent
pour la plupart des situations.
Mais dans certains cas, une telle opération peut être intéressante, voire nécessaire.
D'une manière générale, il est préférable d'utiliser un kernel aussi petit que possible : cela économise de la mémoire, et limite grandement les risques de conflits entre différentes parties du kernel (ce risque étant de toute façon très réduit). L'idée est donc de n'inclure que les éléments dont on a besoin : inutile d'intégrer au kernel le support SCSI, si vous ne possédez aucun matériel de ce type.
Par ailleurs, les kernels installés par les distributions sont le plus souvent conçus pour utiliser les processeurs de type 80386, ce qui leur permet de fonctionner sur tout processeur plus récent de la même famille (80486, Pentium, K6...) Mais si vous cherchez à obtenir les meilleures performances possibles, il peut être intéressant d'optimiser le kernel pour votre processeur. Par exemple, les processeurs Pentium connaît le même jeu d'instructions que les processeurs 80386, plus quelques autres plus puissantes : le code du kernel devrait donc <<tourner>> plus vite, s'il est optimisé pour ce processeur. Mais ne vous attendez pas à des gains très sensibles...
Enfin, la compilation du kernel peut être nécessaire si vous souhaitez utiliser un nouveau matériel (par exemple, une carte réseau dont vous venez de faire l'acquisition), ou si vous êtes particulièrement concerné par les aspects sécurité. Mais encore une fois, les kernels standards peuvent convenir dans la plupart des situations.
Avant de compiler un kernel, il est nécessaire d'indiquer ce que l'on va compiler, et de quelle manière. Différentes possibilités sont offertes pour cela, que nous allons évoquer maintenant. Nous resterons toutefois dans les généralités : une description exhaustive de toutes les options proposées nécessiterait un ouvrage entier, et le kernel est tellement évolutif qu'une telle description présente le risque d'être rapidement périmée.
Dans ce qui suit, nous supposerons que le répertoire courant est /usr/src/linux, et que vous êtes connecté en tant que root.
Un module, du point de vue du kernel, n'est rien d'autre qu'une partie de celui-ci, mais qui ne lui est pas intégrée : elle est stockée dans un fichier à part, généralement dans /lib/modules.
L'intérêt de ce procédé, est de ne conserver en mémoire que ce dont on a besoin à un instant donné : les modules sont chargés à la demande, et déchargés lorsque devenus inutiles. Rassurez-vous, ces opérations se font automatiquement, vous n'avez en général pas à vous en soucier. De là une économie de mémoire, au faible coùt d'un léger ralentissement occasionnel.
Un autre intérêt est de disposer ainsi d'un kernel relativement petit, mais qui peut aisément s'adapter de lui-même à un grand nombre de situations. Ainsi les kernels installés par les distributions sont-ils fortement modularisés : le nombre de modules est très grand, c'est pourquoi ces kernels conviennent pour bien des situations.
Naturellement, tout dans le kernel ne peut pas être compilé en tant que module : il existe une sorte de <<noyau dur>>, minimum indispensable au fonctionnement du système. De même, il vaut mieux inclure dans le kernel les éléments nécessaires au démarrage : si la partie qui vous permet d'utiliser votre disque dur est en module, le système a peu de chances de démarrer, puisqu'alors, ne reconnaissant pas le disque dur, il lui sera impossible de charger le module pour le reconnaître...
La configuration se fait en répondant à une longue série de questions, chacune correspondant à une partie particulière du kernel. Les réponses possibles sont :
Afin de clarifier la configuration, les options sont regroupées par <<affinité>> : ainsi les options permettant l'utilisation des cartes réseau sont-elles séparées des options concernant les systèmes de fichiers...
Parmis les options proposées, en voici quelques-unes avec une réponse qui nous semble indispensable dans pratiquement tous les cas :
C'est la méthode la plus ancienne, la plus sûre, qui marche toujours, et la moins agréable...
Elle s'obtient en exécutant la commande :
make config
Vient alors une longue suite de questions, dont les réponses possibles vous sont indiquées à la fin sous la forme :
[N/y/m/?]
...où 'n' est pour <<non>>, 'y' pour <<oui>>, 'm' pour <<module>>, et '?' pour <<aide>>. La lettre en majuscule indique quelle sera la réponse retenue si vous appuyez simplement sur Entrée.
Le principal inconvénient de cette méthode, en dehors de son aspect peu esthétique, est que si vous faites une erreur, il vous faudra tout recommencer depuis le début. Mais il est bon de l'utiliser au moins une fois dans sa vie, cela vous fera apprécier d'autant plus les deux méthodes qui suivent...
Voilà une méthode déjà plus avenante. On la lance avec la commande :
make menuconfig
Un menu apparaît alors (en couleur avec un peu de chance...), avec les différents groupes d'options disponibles, telle que montré par la figure 5.2.
Dans le bas de la fenêtre ainsi ouverte, vous voyez trois <<boutons>> qui chacun corresponde à une action. Vous pouvez passer de l'un à l'autre avec les flèches de déplacement gauche et droite, et les activez avec la touche Entrée.
Enfin, lorsqu'une option est sélectionnée, il suffit de presser l'une des touches <<y>>, <<n>> ou <<m>> pour respectivement l'inclure, l'exclure ou en faire un module. Lorsque les crochets <<[ ]>> contiennent une étoile (<<*>>), c'est que l'option est incluse, un <<M>> signale un module, et le vide indique que l'option est exclue.
La méthode sans doute la plus agréable, puisque presque tout peut se faire à l'aide de la souris. Pour l'activer :
make xconfig
Attention, cette méthode nécessite que le langage de programmation Tcl/Tk soit installé sur votre système.
Une haute fenêtre apparaît, que l'on voit en arrière-plan sur la figure 5.3. Notez que l'exemple montré ici est un kernel 2.0.36, l'aspect de la fenêtre principale peut différer sur votre système si vous configurez un kernel plus récent ou plus ancien.
Le sens des quatre boutons en bas de la fenêtre est :
Chacun des larges boutons au-dessus des quatre du bas permet d'accéder aux options d'un groupe donné, qui se présentent alors tel que montré sur la fenêtre en avant-plan (moins haute) sur la figure 5.3. Nous retrouvons l'habituel choix sur la gauche : il vous suffit de cliquer sur <<y>>, <<m>> ou <<n>> pour inclure, modulariser ou exclure une option. Le bouton <<Help>> sur la droite donne l'aide concernant l'option sur la ligne du bouton.
Lorsqu'une option apparaît en grisé, c'est qu'elle n'est pas disponible : soit elle entre en conflit avec une autre option, soit d'autres options qui lui sont nécessaires n'ont pas été activées. Notez la première ligne, <<Quota support>> : le <<m>> seul est en grisé, ce qui indique que cette option ne peut être compilée en tant que module.
Les trois boutons en bas de la fenêtre sont :
Bien, maintenant que votre kernel est configuré, il va vous falloir le compiler. Afin de vérifier la cohérence de l'ensemble et éviter les perturbations dûes à une éventuelle compilation précédente, il est nécessaire d'exécuter la ligne suivante :
make dep ; make clean
...qui va <<faire le ménage>>. Ce n'est pas encore la compilation, simplement la préparation pour qu'elle se passe dans de bonnes conditions.
Enfin, l'instant crucial. Encore une fois, il existe plusieurs manière de compiler un kernel, voici les principales :
Une fois le kernel compilé, il faut compiler et installer les modules. Cela ce fait avec la ligne :
make modules ; make modules_install
Si vous êtes sûr de vous, vous pouvez tout faire en une seule ligne :
make dep ; make clean ; make -j bzImage ; make modules ; make modules_intall
La compilation d'un kernel dépend fortement de la puissance générale de votre ordinateur, et peut aller de quelques minutes à plusieurs heures...
Et voilà, le kernel est compilé ! Voyont comment profiter de tout ce travail.
Premier principe fondamental : toujours tester si le nouveau kernel fonctionne, avant de le <<valider>> et de l'installer en lieu et place de l'ancien ! On ne sait jamais ce qui peut se passer lors de la compilation, et mieux vaut un kernel qui fonctionne sans faire tout ce dont on a besoin, qu'un kernel qui fait tout ce qu'on veut mais de façon imparfaite.
Méthode la plus simple, celle que personnellement je préfère. Insérez une disquette vierge et formatée dans le premier lecteur de disquettes, et exécutez simplement :
cp arch/i386/boot/zImage /dev/fd0
Si vous avez compilé votre kernel avec <<make bzImage>>, remplacez zImage par bzImage dans la commande précédente.
Il vous suffit ensuite normalement de redémarrer la machine (avec <<reboot>>, par exemple) : celle-ci va démarrer à partir de la disquette, et exécuter le nouveau kernel. Prenez alors soin de vérifier que ce qui doit fonctionner, fonctionne effectivement. En cas de problème, enlevez la disquette du lecteur et redémarrez la machine, pour retrouver votre ancin kernel.
Ceci est également valable pour faire cohabiter plusieurs kernels, ce qui peut
parfois être intéressant. Pour plus de détails concernant LILO, voyez la section
6.4 page ![[*]](cross_ref_motif.gif)
.
Si ce n'est déjà fait, copier votre nouveau kernel dans un emplacement réservé à cet effet, de préférence dans le même répertoire que l'ancien kernel (souvent /boot), en lui affectant un nom clair.
Par exemple, si vous venez de compiler un kernel 2.0.36 le 29 avril de l'an de grâce 1999, utilisez la commande :
cp arch/i386/boot/zImage /boot/vmlinuz-2.0.36-29.04.1999
Si vous avez compilé votre kernel avec <<make bzImage>>, remplacez zImage par bzImage dans la commande précédente.
Cela fait, éditez le fichier /etc/lilo.conf avec votre éditeur de texte préféré. Normalement, il doit contenir (au moins) une section qui débute par une ligne commençant par <<image=...>> et faisant référence à votre ancien kernel. Cette section s'étend jusqu'à la permière ligne suivante commençant par <<image=...>> ou <<other=...>>. Recopiez cette section à la fin du fichier.
Puis, modifiez la ligne <<image=...>> que vous venez de recopier de façon à ce que le fichier référencé après le signe égal ('=') soit celui contenant votre nouveau kernel. Pour reprendre l'exemple précédent, cela devrait donner :
image=/boot/vmlinuz-2.0.36-29.04.1999
Enfin, juste après cette ligne (ou peu s'en faut), doit figurer une ligne ressemblant à <<label=linux>>. Remplacez <<linux>> par autre chose, par exemple <<test>> - le choix du mot n'a pas d'importance, alors autant éviter d'en prendre un trop compliqué : <<désoxyribonucléique5.4>> fonctionne aussi, mais n'est guère conseillé...
Toutes ces modifications effectuées et le fichier /etc/lilo.conf sauvegardé, exécutez la commande :
lilo -C /etc/lilo.conf
puis redémarrez votre machine, par exemple avec <<reboot>>.
Lorsque vous verrez apparaître la ligne <<LILO boot: _>>, au lieu de simplement appuyez sur Entrée, tapez auparavant le label que vous venez de définir (appuyez sur la touche Tabulation si vous l'avez oublié), <<test>> dans notre exemple. Le nouveau kernel sera alors lancé.
Rien de plus simple.
Copiez d'abord le fichier du kernel comme indiqué plus haut.
Il suffit ensuite d'éditer le fichier /etc/lilo.conf, de repérer la section commençant par <<image=...>> et contenant une ligne <<label=linux>>. Modifiez la ligne <<image=...>> de façon à ce qu'elle référence votre nouveau kernel, et exécutez la commande :
lilo -C /etc/lilo.conf
Au prochain démarrage de la machine, procédez comme habituellement, le nouveau kernel devrait être lancé.
C'est là une situation qui peut survenir, si vous souhaitez mettre à jour vote noyau Linux sans attendre qu'il soit intégré à votre distribution préférée.
Les kernels les plus récents sont disponibles sur nombre de sites Internet, tels que www.kernel.org. En général, le fichier téléchargé depuis l'un de ces sites est de la forme <<linux-x.y.z.tar.gz>>, où <<x.y.z>> est le numéro du kernel : copiez-le dans le répertoire /usr/src. Ensuite, il faut décompacter les fichiers du code source du kernel.
Première chose à faire, vérifier dans quel répertoire les fichiers vont se décompacter. Utilisez la commande :
tar ztvf linux-x.y.z.tar.gz | more
et regardez le chemin des fichiers.
Si ce chemin commence simplement par <<linux/>>, alors il convient de procéder aux opérations suivantes, pour ne pas écraser le kernel existant :
rm linux pour détruire le lien linux qui se trouve dans /usr/src ;
tar zxvf linux-x.y.z.tar.gz pour décompacter les fichiers du kernel ;
mv linux linux-x.y.z pour nommer le répertoire avec le numéro de kernel ;
ln -s linux-x.y.z linux pour recréer le lien linux.
Par exemple, si vous disposez déjà d'un kernel 2.0.36, et que vous souhaitez installer un kernel 2.2.5, dans le répertoire /usr/src le lien linux fait référence au répertoire linux-2.0.36. Les manipulations précédentes permettent d'installer le nouveau kernel, sans pour autant perdre l'ancien (ce qui est une précaution, on ne sait jamais...)
Si le chemin ne commence par aucun répertoire particuliers dont le nom contient linux, alors il vous faut créer manuellement le répertoire :
mkdir linux-x.y.z
cd linux-x.y.z
tar zxvf ../linux-x.y.z.tar.gz
cd ..
rm linux
ln -s linux-x.y.z linux
Enfin, si le chemin commence par <<linux-x.y.z>>, alors pas de problème, vous pouvez décompacter directement et fixer le lien :
tar zxvf linux-x.y.z.tar.gz
rm linux
ln -s linux-x.y.z linux
Les patchs sont des fichiers qui contiennent des corrections à effectuer dans d'autres fichiers, pour mettre à jour un kernel. Cela permet par exemple de <<monter>> d'un kernel 2.2.0 à un kernel 2.2.5, simplement en appliquant les corrections. L'intérêt de cela est que les patchs sont des fichiers relativement petits.
Supposons que vous disposiez d'un kernel 2.2.0, et que vous vouliez le mettre à jour en un kernel 2.2.1. Le fichier patch s'appellera généralement patch-2.2.1.gz. Copiez-le dans le répertoire /usr/src, et décompactez-le avec :
gzip -d patch-2.2.1.gz
Puis appliquez le patch avec la commande :
patch -p 1 -i patch-2.2.1
Vous disposez alors d'un kernel 2.2.1.
