Compiler un noyau Linux pour Raspberry Pi avec support de LXC

La compilation d’un noyau pour Raspberry s’apparente à celle de n’importe quel noyau. Ici nous détaillerons les spécificités liées au matériel du Raspberry, tout en nous efforçant de conserver un noyau minimal.

Prérequis

Il est nécessaire de posséder une chaîne de « Cross Compiling », soit en l’installant directement via les dépôts de la distribution du système hôte, soit en la générant. Voir à cette effet l’article dédié.

Récupérer les sources

Les sources sont disponibles via git, sur les dépôts du projet Raspberrypi. Cloner la version du noyau que l’on souhaite exécuter. Des informations sont disponibles sur le site en ligne.

$ git clone -b rpi-3.11.y https://github.com/raspberrypi/linux.git rpi-3.11.y
$ cd rpi-3.11.y

Préparer son noyau

Quelqu’en soit l’état de vos tests, les commandes suivantes permettent de repartir sur une base propre :

$ make mrproper ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- bcmrpi_defconfig
$ make menuconfig ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-

Sélectionner les options suivantes dans le menu de configuration :

  | General -> Local version 
  | General -> Control Group Support -> Memory Resource Controller for Control Groups (*and its three child options*)
  | General -> Control Group Support -> cpuset support
  | Device Drivers -> Character Devices -> Support multiple instances of devpts
  | Device Drivers -> Network Device Support -> Virtual ethernet pair device

Préparer la compilation

Pour que la cross-compilation se passe bien, il faut apporter quelques modifications au fichier Makefile.

$ vim Makefile
 | HOSTCC       = gcc-4.7
 | CC              = $(CROSS_COMPILE)gcc-4.7

Construire le noyau

Le temps est venu de préparer et de compiler le noyau. L’argument -j indique le nombre de processus à utiliser lors de la compilation. Il est conseillé d’utiliser une valeur égale à « nombre de cœur plus 1 ».

$ make prepare ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j 5
$ make scripts ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j 5
$ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j 5

La compilation va prendre plusieurs minutes. Allez vous servir un café !

C’est fini ? Il faut maintenant générer les modules, et les installer vers notre carte SD, qui contient le système d’exploitation GNU/Linux.

$ make modules ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j 5
$ make modules_install ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/media/SD_CARD/
$ make headers_install ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_HDR_PATH=/media/SD_CARD/

Les modules sont installés. Il nous faut récupérer de ses dépôts git les outils pour générer un noyau adapté à la séquence de démarrage du Pi.

$ cd
$ git clone git://github.com/raspberrypi/tools.git
$ cd tools/mkimage
$ tools/mkimage
$ python ./imagetool-uncompressed.py ../../rpi-3.11.y/arch/arm/boot/Image
$ cp /media/SD_CARD/boot/kernel.img /media/SD_CARD/boot/kernel-old.img
$ cp kernel.img /media/boot/kernel.img

De même, il est nécessaire de copier le noyau fraîchement compilé vers la première partition FAT de la carte SD, pour remplacer celui existant.

Bien entendu, il est aussi possible de renommer le nouveau noyau avec quelque chose comme « kernel-my.img », il faut simplement qu’il ait le même nom sur les deux partitions, et le renseigner dans le fichier « config.txt » sur la partition FAT. Modifier ou ajouter la ligne suivante :

kernel=kernel-my.img

Normalement, votre Raspberry est prêt à démarrer sur le nouveau noyau. Vous êtes prêts à installer LXC.