next up previous contents
Next: 6. Installation de Linux [YB] Up: 5. Le kernel.2 Previous: 5.2 Structure interne

Sous-sections

  
5.3 Compilation [YB]

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.

5.3.1 Pour quoi faire ? [YB]

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\oeur 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.

5.3.2 Configuration : choisir ce que l'on va inclure ou exclure du kernel [YB]

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.

5.3.2.1 Les modules [YB]

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

5.3.2.2 Aspects généraux de la configuration du kernel [YB]

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 :

Naturellement, ces réponses sont à donner en anglais... Chacune des méthodes envisagées plus bas présente sa propre manière de répondre. De même, l'aide disponible, très complète, est entièrement en anglais. Munissez-vous d'un dictionnaire, si vous n'êtes pas familier de la langue de Shakespeare !

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 :

Prompt for developpement and/or incomplete code/drivers
Sauf avis contraire, n'activez pas cette option : ainsi, lors de la configuration, il ne vous sera pas laissée la possibilité d'activer des options correspondant à des éléments du kernel encore en phase de développement, donc relativement instables et sources de dysfonctionnements.
Loadable modules support
Même si vous ne comptez par utiliser de modules, activez les options de ce groupe : cela pourra vous rendre service, le cas échéant.
General setup / Networking support
Pour activer le support réseau. Même si vous ne comptez pas utiliser de réseau, activez cette option, nombre de programmes (notamment X-Window) en ont besoin.
Networking options / TCP/IP
Pour la même raison que précédemment, il vaut mieux activer cette option.
Filesystems
Dans les systèmes de fichiers que vous voulez voir reconnus par le kernel, activez toujours le ext2fs et le /proc, sans quoi votre système peut ne pas fonctionner correctement.
Kernel hacking
Pour mettre en place des éléments réservés aux développeurs, ou à ceux qui voudraient examiner comment le kernel fonctionne : à désactiver si telle n'est pas votre intention.

5.3.2.3 Configuration standard en mode texte [YB]

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

5.3.2.4 Configuration par menus en mode texte [YB]

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.


  
Figure 5.2: Configuration du kernel par menus en mode texte

\includegraphics{images/menuconfig.eps}


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.

Select
permet de rentrer dans le sous-menu sélectionné. Les sous-menus se distinguent des options par la présence d'une <<flèche>>, sous la forme <<-->>>, à la droite du titre des groupes d'options.
Exit
permet de sortir d'un sous-menu. Dans le menu principal, vous fait sortir de la configuration du kernel : répondez alors <<yes>> avec Entrée à la question qui suit, si vous êtes satisfait de votre configuration.
Help
affiche un message d'aide.
Vous pouvez passer d'un sous-menu à l'autre, ou d'un menu à l'autre, avec les flèches de déplacement haut et bas. C'est là le grand intérêt de cette méthode : vous pouvez revenir en arrière, la configuration n'est pas obligatoirement linéaire comme dans la méthode précédente.

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.

5.3.2.5 Configuration sous l'interface X-Window [YB]

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 :

Save and exit
sauvegarde la configuration lorsque vous l'avez terminée, et quitte le programme : vous pouvez alors compiler.
Quit without saving
pour quitter sans sauvegarder la configuration.
Store configuration to file
pour sauvegarder la configuration dans un fichier quelconque, dont le chemin complet vous est demandé. Cela permet de disposer de plusieurs configurations types, sans avoir à tout recommencer.
Load configuration from file
le pendant du bouton précédent, permet de récupérer une configuration précédemment sauvegardée dans un fichier.

  
Figure 5.3: Configuration du kernel sous X-Window

\includegraphics{images/xconfig.eps}


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 :

Main menu
ferme la fenêtre d'options, et retourne dans la fenêtre principale.
Next
pour passer au groupe d'options suivant.
Prev
pour passer au groupe d'options précédent.
Ainsi, bien qu'il soit possible de paramétrer individuellement chaque groupe d'options dans n'importe quel ordre, nous vous recommandons de commencer par le premier groupe (<<Code maturity level options>>) et de passer de l'un à l'autre avec le bouton <<Next>>.

5.3.3 Action ! [YB]

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 :

make zImage
Ceci va effectivement lancer la compilation, ce qui va générer un fichier nommé zImage dans le répertoire /usr/src/linux/arch/i386/boot, qui sera le kernel tout neuf.
make bzImage
Ressemble beaucoup à ce qui précède, mais le kernel va être compressé (un peu à la manière de gzip). Ceci est particulièrement intéressant si vous générez un kernel de grande taille, et que vous souhaitez le placer sur une disquette (voir la section suivante, sur l'activation d'un kernel qui vient d'être compilé).
make zdisk
Equivalent à <<make zImage>>, mais à la fin de la compilation le kernel est directement copié sur la disquette qui se trouve dans le premier lecteur de disquette : pensez donc à placer une disquette dans ce lecteur avant de lancer la compilation. Attention, le contenu de la disquette est irrémédiablement perdu !
Si vous disposez de beaucoup de mémoire, vous pouvez insérer l'option <<-j>> entre make et la méthode choisie : ceci va permettre une compilation <<parallèle>>, c'est-à-dire que plusieurs fichiers du code source seront compilés simultanément lorsque cela est possible. Mais attention, ceci utilise énormément de mémoire ! Cette option peut accélérer la compilation si vous disposez de plus de 64Mo de mémoire (96Mo sont recommandés pour les derniers kernels 2.2.x), mais la ralentir dramatiquement dans le cas contraire.

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.

5.3.4 Installation et activation d'un kernel compilé [YB]

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.

5.3.4.1 Test à partir d'une disquette vierge [YB]

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.

5.3.4.2 Test à partir de LILO [YB]

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 [*].

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

5.3.4.3 Installation définitive [YB]

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

5.3.5 Installation d'un nouveau kernel plus récent ou mise à jour par correction [YB]

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.

5.3.5.1 Cas d'un kernel complet et tout neuf [YB]

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

5.3.5.2 Utilisation des patchs [YB]

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.



Footnotes

...désoxyribonucléique5.4
de acide désoxyribonucléique, abrégé par A.D.N., la macro-molécule qui contient nos gênes.

next up previous contents
Next: 6. Installation de Linux [YB] Up: 5. Le kernel.2 Previous: 5.2 Structure interne
kafka.fr@linux-france.org