Compilation et Configuration du noyau Linux

Objectifs

Les nouveaux noyaux offrent plus de facilité pour communiquer avec plus de configurations matérielles (c'est à dire qu'ils gèrent plus de périphériques). L'amélioration de l'ordonnancement des taches, la correction des erreurs dans les précédentes versions du noyau sont autant de points qui peuvent expliquer une recompilation de noyau.

A la fin de ce cours, les apprenants seront capables de :

• Configurer l'environnement logiciel de leurs matériel en vue d'une recompilation
• Recompiler leurs noyaux avec la gestion des modules
• Tnterroger le noyau pour connaître les différents modules charges.

Seuls les noyaux 2.4.xx seront couverts.

Le noyau ou kernel joue le rôle d'intermédiaire entre vos programmes (logiciels) et votre matériel. Premièrement, il gère la mémoire pour tous les programmes en cours d'exécution (processus) et s'assurent qu'ils occupent tous une part équitable ou non du temps processeur (ordonnancement des tâches). En plus, il fournit une interface (API) simple aux programmes pour communiquer avec votre matériel (appels système).

Le noyau linux est le coeur du système Linux mais isolé, il n'est pas d'une grande utilité. Ainsi on peut décomposer un système Linux en 4 parties:

Décomposition d'un système Linux en sous-systèmes majeurs

Applications Utilisateurs : l'ensemble des applications utilisées sur un système Linux (Les exemples typiques sont un traitement de texte ou un navigateur)>

Services O/S: Il y a des services qui sont typiquement considérés comme faisant partie du système opératoire (système de fenêtrage, commande Shell). En plus, l'interface de programmation du noyau est inclus dans ce sous-système.

Noyau Linux: c'est la couche d'abstraction permettant l'accès aux ressources : périphériques (disque dur, écran, clavier, lecteur disquette ...), processeur et mémoire vive (RAM).

Contrôleurs matériels: ce sous-système comprend tous les périphériques d'accès physiques (généralement liste des fichiers dans /dev)

La compilation du noyau est une des spécificités des systèmes dits libres (disponibilité des sources). Le simple fait de vouloir un noyau plus petit et adapté à son système, fut une des principales raisons pour recompiler.

Aujourd'hui avec la gestion des modules dynamiques, la principale cause de compilation/recompilation réside dans le support de nouveaux matériels, une amélioration technique ou une correction de failles (assez rare).

La compilation du noyau nécessite de disposer des sources officielles (vérifier les md5sums) et d'un compilateur compatible.

Certains compilateurs (gcc par exemple) comportent des optimisations incompatibles avec certaines constructions du noyau. Procurez vous egcs si vous avez ce type de compilateur.

L'opération de compilation du noyau n'est pas difficile mais nécessite de répondre correctement aux questions de configuration. Les erreurs sont souvent fatales (arrêt de la compilation).

Les sources peuvent être téléchargées sur le site officiel du noyau (http://www.kernel.org). Il est possible de récupérer les sources complètes sous la forme d'un archive compressée tar.gz (environ 30Mo). Toutefois, si on dispose déjà des sources complètes, il est envisageable de ne télécharger que les patchs.

Installer les sources du noyau dans /usr/src/linux-/ et éditer un lien symbolique vers ce répertoire sous le nom /usr/src/linux. Ceci permet d'avoir plusieurs jeux de sources du noyau.

Il nous reste maintenant à décompresser et 'désarchiver' les sources du noyau.

Si l'on dispose déjà d'une version complète des sources, et que l'on désire appliquer une rustine (patch), il faut décompresser le fichier de rustine puis l'appliquer avec l'option -p0

Ces commandes doivent être lancées à partir du répertoire /usr/src/ et supposent que les sources sont dans ./linux.

Si les sources sont localisées ailleurs, jouez sur l'option -px (x étant un nombre pour designer le niveau du sous répertoire relatif au répertoire courant. Consultez la page de manuel de patch pour plus d'options sur cette commande.

Vous pouvez aussi lancer le script ./linux/scripts/patch-kernel, qui recherchera automatiquement les rustines en comparant les versions et les appliquera.

Les distributions apportent quelques fois des modifications qui empêchent une bonne application des rustines. Privilégiez les sources officielles sous format tarball (http://kernel.org).

Avant de lancer l'outil de configuration, il faudra vérifier que l'environnement de compilation est propre. i.e: aucun fichier d'extension .o ne subsiste.

La commande suivante permet de nettoyer le répertoire de compilation :

On a le choix entre une configuration à l'ancienne avec la commande:

Une interface newt (mode texte)

Et une interface en TCL/Tk (mode graphique de l'interface texte) :>

Quelque soit la méthode utilisée, il faut répondre par 'Y' (pour Yes), 'N' (pour No) ou 'M' (Module) lorsque c'est possible.

'Y' ou 'M' incluent la fonctionnalité dans le kernel alors que 'N' la supprime. 'M' permet d'utiliser la fonctionnalité en tant que module. L'utilisation des modules permet d'alléger le noyau puisque les fonctionnalités sont chargées et déchargées à la demande (dynamiquement).

Cependant les fonctionnalités nécessaires au démarrage de Linux, comme les gestionnaires de systèmes de fichiers ou le gestionnaire de disques par exemple, ne doivent en aucun cas être placées dans les modules sous peine d'avoir un système qui ne démarre pas.

Ne pas hésiter à consulter l'aide présente dans l'outil de configuration pour décider du choix de l'option.

L'étape de la configuration est obligatoire même si le changement de versions du noyau est mineur.>

Deux commandes permettent de construire un noyau:

Génerez correctement les dépendances entre les fichiers avec make dep:>

Puis construisez l'image compressée du nouveau noyau (Compilation + Edition de liens) avec :

Au cas ou certaines fonctionnalités ont été prises en tant que modules, deux commandes supplémentaires permettent de les incorporer:

Puis :

Un supplément d'informations sur l'utilisation des modules se trouve dans ./linux/Documentation/modules.txt

Une fois la compilation achevée, la nouvelle image du noyau doit être installée pour qu'on puisse l'utiliser au prochain démarrage. Il faudra s'assurer de sa bonne fonction et conserver l'ancien noyau (avec ses modules bien sur).

Déplacez le nouveau noyau (./linux/arch/i386/boot/bzImage) dans le répertoire ou les noyaux sont généralement stockes (/boot pour les distributions Linux en général) en le renommant vmlinuz.

Il faudra auparavant renommer l'ancien noyau pour éviter de l'écraser :

puis :

Le plus simple est de créer des liens symboliques comme on l'a fait avec le répertoire de compilation /usr/src/linux.

Il suffit maintenant d'indiquer au gestionnaire d'amorçage l'emplacement des noyaux et les changements effectues sur leurs noms.

Dans le cas de lilo, il faudra :

- Editer le fichier /etc/lilo.conf.

- Ajouter une nouvelle entrée en copier/coller de l'ancienne

- changer le nom de l'ancienne image (vmlinuz-old)

- Exécuter /sbin/lilo pour réécrire la table d'amorçage.

- Vérifier que tout est ok (pas de messages d'erreurs de la part de lilo)

- Redémarrer (avec la commande reboot par exemple)

Si vous voulez démarrer sur une disquette, il suffit de copier l'image du noyau sur cette disquette en utilisant la commande dd

mkbootdisk est une commande plus simple pour créer des disquettes de démarrage (man mkbootdisk).

Les commandes lsmod, rmmod , insmod et depmod permettent de gérer les modules de maniére dynamique. Le lecteur consultera les pages de manuel de ces commandes pour plus d'informations.

Les modules du noyau X se trouvent dans /lib/modules/X

1) Kernel Source: $KERNEL_SOURCE/README

2) Kernel Source: $KERNEL_SOURCE/Documentation/

3) Conceptual Architecture of the Linux Kernel