Semaine Athens Linux Device Drivers


Les sources du noyau

Sources officielles

Les versions officielles du noyau Linux sont téléchargeables depuis https://www.kernel.org. La page d'accueil permet un accès rapide à :

Note : le cycle de développement et de support du noyau sera étudié plus tard dans le cours.

Les sources peuvent être récupérées sous forme d'une archive contenant une version donnée (format .tar.xz). Une fois décompressées, les sources d'une version prennent près de 900 Mio (887 Mio pour la version 4.13.9 lors de l'écriture de cette page).

Il est également possible (et même conseillé si on veut développer), de récupérer directement le dépôt git officiel incluant tout l'historique (depuis que les développeurs du noyau utilisent git !) :

$ git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

ou bien (par exemple si un pare-feu paranoïaque bloque l'accès au protocole git (port TCP 9418)) :

$ git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

En août 2018, une copie du dépôt git officiel prend environ 2,1 Gio.

Sources alternatives

De nombreux fabricants maintiennent leurs propres versions des sources du noyau incluant le support pour leurs produits quand il n'est pas encore intégré aux versions officielles.

Par exemple, les sources du noyau Linux pour les FPGA SoC d'Altera sont disponibles ici : https://github.com/altera-opensource/linux-socfpga. C'est à partir de ce dépôt qu'a été compilé le noyau utilisé sur la carte de TP.

De même, certaines distributions maintiennent des versions divergentes du noyau pour diverses raisons.

Configuration et compilation du noyau

Note préliminaire : les commandes contenues dans cette section sont données à titre d'exemple et ne sont pas à exécuter sauf indication contraire explicite.

Configuration

Le noyau Linux est extrêmement versatile (il est conçu pour fonctionner sur de nombreuses architectures, depuis un petit système embarqués jusqu'à de gros supercalculateurs, il gère de très nombreux périphériques différents, de nombreux protocoles réseaux, etc.). Il dispose donc d'un système de configuration permettant d'adapter le noyau aux besoins de l'utilisateur en ne sélectionnant que ce qui est nécessaire.

Outils de gestion de la configuration

Plusieurs cibles du Makefile principal du noyau permettent de créer et de modifier cette configuration :

Si aucun fichier de configuration n'existe (ce qui est le cas lorsque l'on récupère les sources officielles), ces outils vont chercher s'il existe un fichier dont le nom est de la forme /boot/config-* et le prendre comme base. Sinon, les valeurs par défaut des paramètres sont choisies.

Si vous disposez déjà d'un fichier de configuration, issu par exemple d'une version précédente du noyau, la commande make oldconfig peut se révéler très utile. Elle supprime les options qui n'existent plus et demande l'avis de l'utilisateur uniquement pour les nouvelles options.

Syntaxe et signification de la configuration

La configuration est stockée, sous un format textuel simple (cle=valeur), dans le fichier .config.

Plusieurs types sont possibles pour une valeur :

Des options peuvent dépendre d'autres options (exemple : le support des périphériques de stockage USB (mass storage device) dépend du support de l'USB).

Pour les types bool ou tristate, la valeur a la signification suivante :

Voici un extrait d'un fichier de configuration du noyau :

#
# USB Host Controller Drivers
#
# CONFIG_USB_C67X00_HCD is not set
CONFIG_USB_XHCI_HCD=m
# CONFIG_USB_XHCI_PLATFORM is not set
CONFIG_USB_EHCI_HCD=m
CONFIG_USB_EHCI_ROOT_HUB_TT=y
CONFIG_USB_EHCI_TT_NEWSCHED=y
CONFIG_USB_EHCI_PCI=m

Travail à faire

  1. D'où proviennent les fichiers /boot/config-* ? Dans quels cas sont-ils utiles ?
  2. Lancez un des outils de configuration et baladez-vous dans la configuration, regardez quelques options, consultez l'aide d'une option, cherchez des dépendances entre options, etc.

    Pour cela, à la racine des sources du noyau, tapez :

    $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- O=build menuconfig

    L'explication de la présence des variables ARCH, CROSS_COMPILE et O sera donnée plus bas.

Compilation du noyau

Compilation native

Pour compiler le noyau pour une architecture identique à celle sur laquelle est lancée le compilateur, il suffit de lancer la commande make à la racine du noyau.

Il est possible de faire en sorte que tous les fichiers produits lors de la compilation soient stockés dans un autre répertoire (par exemple si les sources sont en lecture seule pour l'utilisateur ou si on ne veut pas les polluer) :

$ make O=/home/toto/build menuconfig
$ make O=/home/toto/build

Plusieurs fichiers sont produits par la compilation dont notamment :

Installation du noyau et des modules

L'installation du noyau se fait à l'aide de la cible install du Makefile :

# make install

ou, si vous avez compilé le noyau en utilisant un répertoire à part :

# make O=/home/toto/build install

Cette commande effectue les opérations suivantes :

L'accès en écriture au répertoire /boot n'étant normalement pas possible pour un utilisateur normal, la commande make a besoin des privilèges administrateurs pour pouvoir réaliser l'installation.

L'installation des modules se fait à l'aide de la cible modules_install du Makefile :

# make modules_install

Elle installe les modules (fichiers *.ko ainsi que les informations de dépendance entre modules, de table des symboles et d'alias) dans /lib/modules/<version>.

Compilation croisée (Cross-compilation)

Il est parfois nécessaire de compiler le noyau pour une architecture différente de celle sur laquelle s'effectue la compilation. On parle alors de cross-compilation ou compilation croisée.

Deux variables sont utilisées par le Makefile pour permettre la compilation croisée :

Ces deux variables doivent être passées à chaque invocation d'une cible du Makefile, soit en les spécifiant sur la ligne de commande, soit en les exportant en tant que variables d'environnement.

$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-

ou bien :

$ export ARCH=arm
$ export CROSS_COMPILE=arm-linux-gnueabihf-
$ make menuconfig
$ make

Des fichiers de configuration par défaut pour certaines cartes embarquées sont fournis avec le noyau. Leur liste est disponible grâce à la cible help du Makefile. Il est alors possible de les utiliser pour générer un fichier .config de base (adaptable par la suite) :

$ make socfpga_defconfig
$ make menuconfig
$ make

Note : Dans la suite de la semaine, vous allez faire de la cross-compilation. Vous écrirez vos modules sur le PC et vous les compilerez pour la carte sur le PC. Cette méthode est utilisée pour plusieurs raisons : il est plus pratique de développer sur le PC (interface graphique notamment) et la compilation y est beaucoup plus rapide.

Nettoyage des sources

Trois cibles du Makefile sont disponibles pour permettre le nettoyage des sources :

Exploration du noyau

Maintenant que vous avez récupéré les sources du noyau, que vous savez comment le configurer, le compiler et l'installer, nous allons maintenant commencer à l'explorer.

Travail à faire

  1. Promenez-vous un peu dans les sources du noyau
  2. Cherchez à quoi correspondent tous les fichiers et les répertoires à la racine des sources du noyau
  3. Calculez la taille de chacun des répertoires à la racine (indice : utilisez la commande du). Qu'en pensez-vous ?

Outils pour l'exploration du code source

Le noyau Linux est un très gros projet (près de 22.000 fichiers .c). Il est donc nécessaire de disposer d'outils pour naviguer dans le code source, rechercher la définition d'un symbole, chercher toutes les fonctions utilisant une variable, etc. Plusieurs outils sont disponibles à cette fin.

LXR

LXR (pour LXR Cross Referencer) est un outil, initialement développé pour le noyau Linux, qui permet d'indexer du code et qui fournit une interface de navigation web.

L'outil est disponible à l'adresse http://lxr.sourceforge.net. Vous pouvez l'installer vous même mais sa configuration requiert un peu de temps.

Deux sites utilisant LXR sont disponibles pour naviguer dans le code source du noyau Linux :

Gardez ces liens, vous les utiliserez intensivement durant tout le cours.

Autres outils

D'autres outils sont disponibles et utilisables en local, parmi eux :

Une fois installés et configurés, ils s'intègrent dans la plupart des éditeurs de texte, notamment vi et emacs.

Travail à faire

  1. Prenez en main un des sites web LXR indiqués ci-dessus, naviguez dans le code, testez les fonctionnalités de recherche, etc.

Style de codage

Les développeurs du noyau s'astreignent à un style de codage particulier afin d'obtenir une certaine homogénéité dans le code. Ces règles, importantes notamment si vous voulez un jour soumettre un patch officiel au noyau, sont décrites dans le document Documentation/process/coding-style.rst.

Travail à faire

  1. Prenez le temps de lire le document ci-dessus et essayez, dans la mesure du possible, d'appliquer les règles mentionnées tout au long de la semaine.

Retour au sommaire du cours


© Copyright 2017 Guillaume Duc. Le contenu de cette page est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International (à l'exception des exemples de code tirés du noyau Linux et qui sont distribués sous leurs licences d'origine).

Licence
Creative Commons