LINUX

Compilation du kernel

 
 
  1 Généralités
 

Chaque fois que l'on change ou ajoute un nouveau composant matériel, une reconfiguration du kernel peut être nécessaire. Toute les données qui appartiennent au noyau se trouvent dans : 

/usr/src/linux
On y trouve un certain nombre de sous-répertoires contenant chacun une partie spécifique du kernel. Les principales composantes se trouvent dans : 
arch      Composants qui dépendent de l'architecture matérielle avec un sous-répertoire
          pour chacune : i386, alpha, mips, sparc, ...

drivers   Pilotes de périphériques.

fs        Fonctions pour les systèmes de fichiers avec un sous-répertoire pour
          chaque système de fichiers.

include   Headers contenant la définition des structures et constantes du
          kernel

ipc       Interprocess communication, shared memory, sémaphores, ...

kernel    Routines pour les tâches centrales : fork, exec, ...

mm        Routines de gestion de la mémoire

modules   Parties du noyau pouvant être chargées et déchargées en dynamique 

net       Pilotes de protocoles : TCP/IP, IPX/SPX, ...
Si l'on dispose de temps et de patience, il n'est pas inintéressant d'explorer les programmes en C qui se trouvent dans l'arborescence /usr/src/linux. Une remarque : seul root est habilité a compiler le kernel.

Un kernel qui ne comporte que les modules strictement nécessaires au boot occupera moins de place en mémoire et assurera un démarrage plus rapide du système. Certains modules de base sont à intégrer impérativement dans le kernel sous peine de ``kernel panic'' au boot. C'est le cas des modules qui gèrent les disques et le système de fichiers ext2 . Les modules annexes gagneront à être chargés en dynamique. On économise ainsi de la place en mémoire et on bénéficie d'une plus grande facilité de mise à jour, la compilation et l'installation d'un nouveau module est plus simple que celle du kernel. On considère qu'un module utilisé plus de 90 % du temps doit être intégré au kernel.

Dans le kernel 2.0.xx les modules étaients gérés par le serveur de modules kerneld, à partir du kernel 2.2.xx il sont gérés par kmod qui est un simple thread du kernel.
menu

2 Le kernel

2.1 Préparation

Pour une reconfiguration dans une même version, par exemple 2.2.13-7mdk vers 2.2.13 , les sources sont peut-être déja dans /usr/src. Sinon il faudra les y copier. (voir ci-après)

Dans /usr/src créer un sous répertoire pour le nouveau kernel. Par exemple s'il existe déjà /usr/src/linux-2.2.13-7mdk on peut créer un nouveau répertoire 

        cd /usr/src

        mkdir linux-2.2.13
Détruire le lien existant : linux -> linux-2.2.13-7mdk et le remplacer par un nouveau 
        rm linux 

        ln -s  linux-2.2.13  linux
Recopier le fichier .config dans le nouveau répertoire, il servira de modèle pour le nouveau .config 
        cp /usr/src/linux-2.2.13-7mdk/.config  /usr/src/linux-2.2.13
Pour un changement de version, par exemple de 2.2.9 vers 2.2.13 , procéder comme ci-dessus, puis copier l'archive des sources dans /usr/src , décompacter et désarchiver : 
        tar -xvzf linux-2.2.13.tar.gz
Le kernel est décompacté dans /usr/src/linux-2.2.13

Remarques :

Avec les anciennes distributions il était conseillé de mettre et décompresser l'archive dans /tmp , puis de recopier dans /usr/src/linux tout ce qui se trouvait dans /tmp/linux . Ceci à cause de l'incertitude sur la création des répertoires à la bonne place. Avec les distributions récentes il semble que ce soit inutile.

Pour pouvoir compiler il est bien entendu que le compilateur C (gcc, pgcc ou egcs) doit être présent sur la machine, ainsi que les librairies correspondantes. Les packages libc-dev, binutils et bin86 sont aussi nécessaires, ils font normalement partie de l'install standard des diverses distributions. Enfin, seul root dispose des permissions permettant de compiler le kernel.

2.2 Configuration

On se place dans le répertoire /usr/src/linux-2.2.13 . (alias linux)

Trois outils sont disponibles pour configurer : make config, make menuconfig et make xconfig . Ce dernier, lancé dans un xterm sous Xwindow, est le moyen de configuration le plus évolué, il est convivial et donne accès à un texte d'aide sommaire pour chaque module. Il suffit de se laisser guider par les menus et de faire les bons choix. On dispose pour chaque module de trois choix possibles : 

  Y   le module est intégré au kernel

  M   le module peut être chargé en dynamique

  N   le module ne sera pas utilisé
Après validation définitive, on sauvegarde la configuration dans 
        /root/linux-2.2.13.config
Ce fichier est éditable, il est donc possible d'y apporter des modifications sans reprendre toute la procédure xconfig.

2.3 Compilation

Toujours dans /usr/src/linux-2.2.13 entrer successivement les commandes : 

        make  dep
Cette commande exploite le fichier /usr/src/linux-2.2.13/.depend . Elle procède à la résolution des dépendances entre les différents modules et les intègre dans le Makefile. 
        make  clean
Supprime tout ancien fichier objet indésirable, résidu de compilations précédentes, et force une recompilation complète. 
        make bzImage
Lance la compilation-reconstruction du nouveau kernel, cela peut demander un certain temps. Après compilation, le kernel se trouve dans /usr/src/linux-2.2.13/arch/i386/boot/bzImage.

Un kernel courant peut avoir une taille d'environ 500 Kb. (Si le kernel est petit on peut utiliser la commande make zImage) . Il est toujours compacté et automatiquement décompacté lors du chargement en mémoire.

2.4 Installation

On se déplace alors dans /boot où on le copie 

        cd /boot

        cp /usr/src/linux-2.2.13/arch/i386/bzImage /boot/vmlinuz-2.2.13
On delete l'ancien lien symbolique 
        rm vmlinuz
On en crée un nouveau 
        ln -s vmlinuz-2.2.13  vmlinuz
De même pour le System.map: 
        cp /usr/linux-2.2.13/System.map   /boot/System.map-2.2.13

        ln -s System.map-2.2.13  System.map
Se déplacer dans /etc et vérifier que lilo.conf est conforme, ou y apporter les modifications nécessaires. En particulier la ligne : image=/boot/vmlinuz-2.2.13 ou bien image=/boot/vmlinuz si nous avons créé le lien vmlinuz -> vmlinuz-2.2.13 comme ci-dessus. Enfin lancer la commande : 
        lilo
... afin de réinstaller lilo dans sa nouvelle configuration, ceci n'étant nécessaire que si lilo.conf a été modifié .
menu

2 Les modules

3.1 Compilation-installation

Après avoir compilé le kernel, il faut compiler les modules chargeables en dynamique et les installer. Dans /lib/modules , pour éviter les problèmes si l'ancien et le nouveau kernel sont de la même version, détruire ou plûtot renommer l'ancien répertoire des modules : 

        mv 2.2.13-7mdk old-7mdk
Lancer la compilation des modules qui ont été sélectionnés : 
        make modules
Lancer l'installation des modules : 
        make modules_install
Ceci a pour effet d'installer les modules dans lib/modules/2.2.13 Un fichier /lib/modules/2.2.13/modules.dep est créé. Ce fichier semble être réécrit à chaque boot .

Pour bénéficier des fonctionalités du nouveau kernel, il ne reste plus qu'à lancer la commande 

        reboot
Ou bien, pour avoir la certitude que le umount des file-systems s'effectue correctement 
        shutdown -r now
Surveiller l'apparition d'éventuels messages d'erreur en cours de boot afin de localiser les scripts qui pourraient nécessiter des correctifs

3.2 Gestion des modules

Les commandes ci-après sont spécifiques de la gestion des modules. 

        lsmod
Liste les modules présents en mémoire. 
        insmod /lib/modules/2.2.13/net/3c509.o
Permet de charger manuellement un module. Indiquer le path complet, comme dans l'exemple ci-dessus. 
        rmmod 3c509
Permet de décharger manuellement un module . Inutile d'indiquer le path ni l'extension, le module étant chargé il est reconnu par rmmod . Si on a oublié son nom, utiliser lsmod pour l'dentifier. 
        depmod
Crée la liste des modules utilisables avec le kernel, dans : /lib/modules/2.2.13/modules.dep 
        modprobe
Permet de charger un module et toutes les dépendances qui lui sont associées.

La gestion des modules est assurée par le daemon /sbin/kerneld , lancé au boot, lequel les charge en fonction des besoins et les décharge après une période d'inactivité. Dans les distributions récentes il existe un script /etc/cron.d/kmod qui permet de paramètrer l'exécution d'un rmmod au bout d'un certain temps d'inactivité des modules. Quand un module est déchargé, la place qu'il occupait en mémoire est libérée.
menu
 

File : kernel_comp.html , Robert Billon, F3WM, 2000-02-29