Le noyau

Révision 3

1.1 Les concepts

Il existe deux types de noyaux Linux :

Monolithique
Le noyau monolithique contient tous les drivers nécessaires pour gérer le matériel, le
réseau et les systèmes de fichiers compilés dans un seul fichier.

Modulaire
Avec un noyau modulaire nous avons une partie des modules compilés dans des fichiers
séparés – des fichiers objets. Ces modules peuvent être chargés et déchargés par le
noyau en cas de besoin. Les modules chargeables se trouvent sous /lib/modules.

L’avantage d’un noyau modulaire est qu'il n’est pas nécessaire de le recompiler chaque
fois que l’on ajoute ou remplace un périphérique du système. Les noyaux monolithiques
démarrent un peu plus rapidement que les noyaux modulaires mais la performances
après le démarrage du système n’est pas différente.

Le noyau modulaire

Un grand nombre des composants de Linux peuvent être compilés sous la forme de
modules et chargés et déchargés dynamiquement en cas de besoin.

Les modules pour une certaine version du noyau se trouvent sous l'arborescence /
lib/modules/<version-du-noyau>.
Il est préférable de compiler comme modules des parties du noyau dont on n’a pas besoin
au démarrage.
Les modules du noyau sont gérés par des outils du paquetage modutils :

• lsmod
• rmmod
• insmod
• modprobe
• modinfo

Certains modules dépendent d’autres modules. La commande depmod crée une base de
données des dépendances entre les modules - /lib/modules/<version-du-
noyau>/modules.dep. Cette commande est exécutée au démarrage par le script
rc.sysinit.

La commande modprobe chargera tous les modules passés en arguments ainsi que
toutes les dépendances de modules.dep.
Le fichier /etc/modules.conf contient des paramètres pour les modules mais aussi leurs
‘aliases’ (synonymes). Ces synonymes peuvent être utilisés par les applications pour
appeler le matériel d’un type donné par le même nom. Par exemple la première carte
ethernet et toujours appelée eth0 et non par le nom du module correspondant au matériel
particulier.

Exemple de fichier /etc/modules.conf:

alias eth0 e100

alias usb-core usb-uhc
alias sound-slot-0 i810_audio
alias char-major-108 ppp_generic
alias ppp-compress-18 ppp_mppe

# 100Mbps full duplex

options eth0 e100_speed_duplex=4

1.2 Recompilation du noyau

Obtenir et décompresser les sources

Normalement les sources du noyau sont stockées sous /usr/src/linux qui est un lien
symbolique vers /usr/src/linux-(version-du-noyau). Lorsque l'on décompresse une
nouvelle version des sources du noyau il est recommandé de supprimer le lien vers la
version précédente :

rm linux

Les sources du noyau que l’on installe à partir de paquetage, comme RPM ou DEB créent
souvent des liens nommés (pour la version 2.4 par exemple) linux-2-4.

Kernel sources which have been packaged as an RPM often create a

link called linux-2-4

Après avoir téléchargé (par exemple de http://www.kernel.org/pub/linux/kernel/v2.4/linux-

2.4.20.tar.bz2) l’archive de la version désirée du noyau il est nécessaire de
décompresser les sources :

tar xjf linux-2.4.20.tar.bz2

Note : Les archives de la version 2.2 du noyau créent un répertoire nommé linux au lieu
de linux-2.2. C’est pourquoi il est important de supprimer d’abord le lien précédent qui
porte déjà ce nom. Sinon il est possible d’écraser les anciennes sources. Les noyaux de
la version 2.4 et les plus récents respectent la forme précédente 'linux-version_du_noyau'.
Puis on crée un lien symbolique vers le nouveau répertoire :

ln -s linux-2.4.20 linux

Le noyau est prêt à être configuré. Il est préférable de s’assurer que les fichiers binaires
issus des compilations précédentes sont bien effacés. Cette opération est possible soit
avec la commande make mrproper soit avec make clean.

1.3 Configuration du noyau

Il faut tout d’abord modifier le fichier Makefile pour s’assurer que la variable
“EXTRAVERSION” est différente que la version déjà installée :
VERSION = 2
PATCHLEVEL = 4
SUBLEVEL = 20
EXTRAVERSION = -test

Le noyau est maintenant réellement prêt à être configuré. Configurer le noyau consiste à
créer le fichier nommé .config. Au lieu de faire cela en éditant un fichier, nous disposons
de trois différents outils :

make menuconfig (mode texte)

make xconfig (mode semi-graphique)
make config (mode graphique)

Toutes ces méthodes sauvegardent la configuration sous /usr/src/linux/.config

Il est souvent plus facile de configurer le noyau à partir d’une configuration déjà existante.
Pour cela, on utilise la commande make oldconfig. Cette commande va proposer à
l’utilisateur les nouvelles fonctionnalités du noyau qeulement.

Note : Certaines distributions comme Redhat contiennent un sous-répertoire nommé

configs. Il contient des fichiers de type .config prédéfinis.

Pour choisir parmi les options à intégrer (avec menuconfig) il faut naviguer parmi les
catégories à l’aide des flèches et de la touche ‘Entrée’ (pour entrer dans une certaine
catégorie). À l’aide de la touche ‘Espace’ nous sommes capables de modifier le choix de
certaines fonctionnalités.

Les trois possibilités sont :

• supported (compilée dans le noyau) [*]
• modular (compilée comme module dynamique) [M]
• not supported [ ]

Le même choix est disponible avec les autres éditeurs de configuration – config et
xconfig.
1.4 Compilation du noyau

make dep
Cette commande nous permet de mettre à jour la configuration des sous-répertoires
contenant les sources du noyau d’après la configuration sauvegardée dans le fichier .
config. Elle va créer des fichiers nommés .depends contenant les chemins d’accès aux
fichiers-entêtes (header files) que l’on trouve normalement sous /usr/src/linux/include.

make clean
La commande make va compiler les fichiers d’après les règles du fichier Makefile. Si
certains fichiers compilés sont déjà présents, la commande make peut les utiliser en l'état
(sans les recompiler). Ils s’agit surtout des fichier *.o. Pour être sûr que les nouvelles
configurations sont prises en charge il faut ‘nettoyer’ d’abord (supprimer tous les fichier
*.o). Cela se fait à l’aide de la commande make clean.

Le noyau même est compilé avec une des commandes suivantes :

make
make zImage
make bzImage

Si la commande se termine sans erreurs sous /usr/src/linux/ on trouvera un fichier

nommé vmlinux. Ceci contient le noyau non-compressé.

Les deux dernières commandes enregistrent un fichier supplémentaire sous /

usr/src/linux/arch/i386/boot/ nommé zImage ou bzImage respectivement. Ces fichiers
correspondent à une version du noyau compressé avec gzip ou bzip2.

make modules
Cette commande permet de compiler les modules dynamiques.

make modules_install
Après avoir compilé les modules il reste à les installer à l’endroit approprié – un sous-
répertoire de /lib/modules. Cette opération est faite simplement à l’aide de la commande
make modules_install.

En résumé, la séquence classique des commandes de compilation du noyau est la

suivante :

make dep
make clean
make bzImage
make modules
make modules_install
1.5 Installation du noyau

Le noyau compilé se trouve sous /usr/src/linux/arch/i386/boot/bzImage. i386

correspond à l’architecture de la machine et sera différent pour d’autre plate-formes. Ce
fichier doit être copié dans le répertoire /boot et nommé en utilisant la forme vmlinuz-
<version-complète-du-noyau>

# cp /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-
<version-complète-du-noyau>

L'étape suivante consiste à modifier le fichier de configuration /etc/lilo.conf, ou /

boot/grub/grub.conf le cas échéant, pour ajouter notre nouveau noyau dans le menu de
démarrage. Le plus facile est de copier la section « image » existante pour ajouter une
section correspondant à la nouvelle version du noyau :

Modification du fichier /etc/lilo.conf

prompt
timeout=50
message=/boot/message

image=/boot/vmlinuz
label=linux
root=/dev/hda6 section
existante
read-only

image=/boot/vmlinuz-<full-kernel-version>
label=linux-new nouvelle section
root=/dev/hda6
read-only

Nous pouvons aussi copier la table des symboles du système dans le répertoire /boot :

cp /usr/src/linux/System.map /boot/System.map-<version-complète-
du-noyau>

La version complète du noyau

Nous pouvons obtenir la version complète du noyau courant par la commande

uname -r

Cette version est aussi affichée sur les terminaux virtuels par l’option \k du fichier /
etc/issue.
Exécuter LILO
Il ne faut pas oublier d’exécuter lilo après chaque modification du fichier de configuration /
etc/lilo.conf.

1.6 Exercices

Avant de commencer les exercices il faut s’assurer qu’il n’existe pas une version existante
des sources du noyau dans /usr/src/. Si c’est le cas il faut vérifier vers quel répertoire
pointe le lien symbolique /usr/src/linux/.

Recompiler et installer une nouvelle version du noyau. Prendre soin de compiler le

pilote de la carte réseau comme module dynamique.

Objectifs :
• savoir décompresser les sources au bon endroit
• être capable de configurer l noyau avec les options nécessaires
• être capable d'installer la nouvelle version du noyau et configurer LILO pour démarrer à
partir de cette version

Solution :
1. Décompresser les sources du noyau
Supposons que vous avez téléchargé l'archive du noyau sous /tmp/linux-2.4.31.tar.bz2
Exécutez les commandes suivantes :

$ cd /usr/src
$ ls -l
$ rm linux
$ tar xjf /tmp/linux-2.4.31.tar.bz2
$ ls -l
$ ln -s linux-2.4.31 linux
$ ls -l

2. Configurer le nouveau noyau

$ cd linux
$ make menuconfig

A ce stade, choisissez les options correspondant à votre configuration. Configurer le pilote

correspondant à votre carte réseau pour qu'il soit compilé comme module. Par exemple,
supposons que le pilote en question soit 'forcedeth.o'.
3. Compiler le noyau
Une fois que les paramètres du noyau sont configurés, notamment le choix de compiler le
pilote pour notre carte réseau comme module, la compilation du noyau s'effectue avec la
séquences de commandes suivantes :
$ make dep
$ make bzImage
$ make modules

4. Installer le noyau et les modules

Voici la méthode d'installation du noyau 'à la main' :

$ su
# cp arch/i386/boot/bzImage /boot/vmlinuz-2-4-31
# make modules_install

Il est nécessaire alors de modifier le fichier /etc/lilo.conf pour configurer le démarrage à

partir du nouveau noyau. Il est prudent de conserver le noyau courant sous un autre nom
(par exemple linux-old). Cela permettra de démarrer à partir de l’ancien noyau en cas de
problèmes avec le nouveau.

Il ne faut pas oublier de lancer la commande lilo pour mettre à jour le programme de
démarrage à partir du fichier /etc/lilo.conf

5. Installer le noyau et les modules

Après avoir fait la compilation et l'installation du noyau et des modules correspondant,

redémarrer la machine pour tester la nouvelle configuration.

Configurer un alias eth0 vers le module correspondant à la carte réseau.

Solution :
Supposons que le module qui gère notre carte réseau est toujours 'forcedeth.o'. Nous
allons ajouter dans /etc/modules.conf la ligne suivante :

alias eth0 forcedeth.o

Maintenant nous somme capable d’insérer le module simplement par la commande :

modprobe eth0

Installer et désinstaller 'à la main' le module de la carte réseau.

Objectifs :
savoir installer et désinstaller des modules
savoir s’informer sur les modules installés et sur le processus d’installation

Solution :
Reprenons toujours le même exemple –supposons que le module de la carte réseau et
forcedeth.o et qu'un alias eth0 vers ce module est déjà créé.

Utilisez les commandes suivantes pour installer, désinstaller, obtenir la liste des modules
installés, obtenir de l’information sur l’installation des modules etc. :

modprobe
insmod
rmmod
lsmod
dmesg