• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 23/12/2019

Prenez en main votre environnement Buildroot

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Je vous propose d'utiliser Buildroot comme outil pour générer notre GNU/Linux dédié. Il a l'avantage d'être simple à mettre en place et à utiliser, et il est pleinement compatible avec la Raspberry PI.

Installez l'environnement Buildroot

Buildroot est un outil en ligne de commande permettant de générer sa propre image de GNU/Linux optimisée pour l'embarqué. 

Commencez par installer les dépendances nécessaires à l'utilisation de Buildroot :

sudo apt-get install libncurses5-dev bc

 Clonez maintenant les sources de l'outil Buildroot dans votre dossier de développement :

cd ~/Development-tools
git clone https://github.com/buildroot/buildroot.git
Installation de buildroot
Installation de Buildroot

Le dossier Buildroot créé contient les répertoires suivants, voici une description des principaux dossiers :

  • docs : une documentation au format texte ;

  • package : les fichiers de configuration et de compilation (Makefile) pour les applications fournies avec Buildroot ;

  • project : les fichiers de configuration et de compilation pour la création de projet. Un projet permet de générer automatiquement un système cible ;

  • board : les fichiers de configuration pour les différentes cartes supportées par Buildroot ;

  • configs : les fichiers de configuration pour le noyau spécifique à la carte (Raspberry...) ;

  • arch : les fichiers de configuration pour le noyau spécifique à l'architecture (ARM...) ;

  • target/linux : contiendra le noyau recompilé ;

  • target/<fstype> : contiendra l'image du système racine (le contenu de notre carte SD, dans notre cas)

  • toolchain : la chaine de cross-compilation générée par Buildroot.

Support pour Raspberry fourni par Buildroot

Vérifions tout d'abord que Buildroot est bien compatible avec notre carte Raspberry PI. Pour cela, listez les dossiers disponibles dans le dossier board, afin de vérifier que notre carte Raspberry est présente.

cd ~/Development-tools/buildroot/
ls board/ | grep rasp

Vous devez obtenir ceci :

Configuration disponible pour raspberry
Carte disponible pour Raspberry

Comme vous pouvez le voir, plusieurs dossiers existent pour les Raspberry PI 1 à 3, les Raspberry PI Zero, et une version 64 bits pour la Raspberry PI 3.

Examinez maintenant le contenu du fichier board/raspberrypi/genimage-raspberrypi3.cfg :

image boot.vfat {
 vfat {
 files = {
 "bcm2710-rpi-3-b.dtb",
 "bcm2710-rpi-3-b-plus.dtb",
 "bcm2710-rpi-cm3.dtb",
 "rpi-firmware/bootcode.bin",
 "rpi-firmware/cmdline.txt",
 "rpi-firmware/config.txt",
 "rpi-firmware/fixup.dat",
 "rpi-firmware/start.elf",
 "rpi-firmware/overlays",
 "zImage"
  }
 }
 size = 32M
}

image sdcard.img {
 hdimage {
 }

 partition boot {
 partition-type = 0xC
 bootable = "true"
 image = "boot.vfat"
 }

 partition rootfs {
 partition-type = 0x83
 image = "rootfs.ext4"
 }
}

Ce fichier décrit comment gérer la carte SD pour une Raspberry pI 3. Ainsi, deux partitions seront créées pour obtenir une image de la carte SD :

  • boot.vfat : qui sera la première partition de 32 Mo au format FAT32, et qui sera marquée comme bootable. Les fichiers nécessaires au démarrage de la carte seront copiés sur cette partition. Les fichiers .dtb contenant le descriptif matériel de la carte, les fichiers nécessaires au démarrage (bootloader.bin, start.elf), le noyau (zImage) et son fichier de configuration du noyau (cmdline.txt). Le fichier config.txt permet de configurer les périphériques de sa Raspberry PI (sortie graphique, wi-fi, Bluetooth...) ;

  • sdcard.img : cette seconde partition utilisera un système de fichiers ext4, et correspondra à la racine du système de fichiers Linux (rootfs).

Le répertoire configs contient les fichiers de préconfiguration de Buildroot et du noyau, pour les différentes cartes supportées par Buildroot. Vérifions que notre Raspberry Pi est bien présente :

cd ~/Development-tools/buildroot
ls configs/raspberrypi* 

Vous devez obtenir une liste de fichiers correspondant aux différentes versions de Raspberry PI. Notez qu'il y a deux fichiers pour la Raspberry PI 3, un pour un système 32 bits, et le second pour un système 64 bits.

Configuration disponible pour raspberry
Configuration disponible pour Raspberry

Examinez le contenu du fichier configs/raspberrypi3_defconfig. Ce fichier permet de générer un noyau pour une architecture ARM et un processeur Cortex A53, en se basant sur la configuration générique pour le SoC BCM2709. La configuration active le système de fichier EXT4 par défaut dans le  noyau.

BR2_arm=y
BR2_cortex_a53=y
BR2_ARM_FPU_NEON_VFPV4=y

BR2_TOOLCHAIN_BUILDROOT_CXX=y

BR2_SYSTEM_DHCP="eth0"

# Linux headers same as kernel, a 4.14 series
BR2_PACKAGE_HOST_LINUX_HEADERS_CUSTOM_4_14=y

BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_CUSTOM_TARBALL=y
BR2_LINUX_KERNEL_CUSTOM_TARBALL_LOCATION="$(call github,raspberrypi,linux,83b36f98e1a48d143f0b466fcf9f8c4e382c9a1c)/linux-83b36f98e1a48d143f0b466fcf9f8c4e382c9a1c.tar.gz"
BR2_LINUX_KERNEL_DEFCONFIG="bcm2709"

# Build the DTB from the kernel sources
BR2_LINUX_KERNEL_DTS_SUPPORT=y
BR2_LINUX_KERNEL_INTREE_DTS_NAME="bcm2710-rpi-3-b bcm2710-rpi-3-b-plus bcm2710-rpi-cm3"

BR2_PACKAGE_RPI_FIRMWARE=y

# Required tools to create the SD image
BR2_PACKAGE_HOST_DOSFSTOOLS=y
BR2_PACKAGE_HOST_GENIMAGE=y
BR2_PACKAGE_HOST_MTOOLS=y

# Filesystem / image
BR2_TARGET_ROOTFS_EXT2=y
BR2_TARGET_ROOTFS_EXT2_4=y
BR2_TARGET_ROOTFS_EXT2_SIZE="120M"
# BR2_TARGET_ROOTFS_TAR is not set
BR2_ROOTFS_POST_BUILD_SCRIPT="board/raspberrypi3/post-build.sh"
BR2_ROOTFS_POST_IMAGE_SCRIPT="board/raspberrypi3/post-image.sh"
BR2_ROOTFS_POST_SCRIPT_ARGS="--add-pi3-miniuart-bt-overlay"

Générez votre première image

Vous pouvez maintenant générer votre première image minimale de GNU/Linux à partir de Buildroot. Afin de ne pas perdre notre configuration ni le système généré à chaque test, nous allons créer des dossiers Buildroot différents en fonction de la carte et du système cible (QEMU ou Raspberry PI). Ainsi, nous nommerons les dossiers Buildroot sous la forme buildroot-{qemu,carte}-{architecture}.

Commencez par créer un dossier afin de générer une image que vous testerez dans QEMU pour un système ARM 64 bits, typiquement pour une Raspberry PI 3. Pour cela, dupliquez le dossier buildroot en buildroot-qemu-aarch64 :

cd ~/Development-tools
cp -R buildroot buildroot-qemu-aarch64
 

Pour ce premier test, utilisez la configuration fournie par Buildroot. Ainsi, générer un système ne requiert que 3 commandes. Tout d'abord, placez-vous dans le dossier de Buildroot correspondant a votre système. Puis configurez Buildroot pour le système cible, en utilisant un fichier defconfig fourni. Finalement, lancez la génération du système :

cd buildroot-qemu-aarch64
make qemu_aarch64_virt_defconfig
make

 La commande make lance la génération du système, c'est-à-dire : 

  • la génération de la chaîne de cross-compilation pour l'architecture demandée ;

  • la compilation, via la chaîne de cross-compilation, des applications/services afin de générer le système ;

  • la compilation du noyau ;

  • la génération du rootfs en créant une image disque (rootfs.ext4), et en recopiant le système cross-compilé.

Lorsque votre système est complètement généré, vous obtenez ceci :

Générer sa première image
Générer sa première image

À l'issue de la génération, vous obtenez 2 fichiers dans le dossier output/Images/. Le noyau correspond à l'Image et le système racine au fichier rootfs.ext4 (qui est un lien vers rootfs.ext2). 

Taille de l'image obtenu
Taille de l'image obtenue

Testez votre image

Testons maintenant cette nouvelle image avec QEMU. Utilisez pour cela la commande qemu-system-aarch64 afin d'émuler un système ARM 64 bits avec un processeur Cortex A57 monocœur et une carte réseau Ethernet. Vous démarrez sur le noyau et l'image disque que vous venez d'obtenir.

qemu-system-aarch64 -M virt \
                    -cpu cortex-a57 \
                    -nographic \
                    -smp 1 \
                    -kernel output/images/Image \
                    -append "root=/dev/vda console=ttyAMA0" \
                    -netdev user,id=eth0 -device virtio-net-device,netdev=eth0 \
                    -drive file=output/images/rootfs.ext4,if=none,format=raw,id=hd0 \
                    -device virtio-blk-device,drive=hd0

À la fin du démarrage, vous obtenez le message "Welcome to Buildroot" qui vous indique que votre image est fonctionnelle.

Démarrage de notre image
Démarrage de notre image

Vous pouvez désormais vous authentifier en tant qu'utilisateur root et sans mot de passe.

Regardons rapidement les empreintes mémoire et disque de cette image. La commande free -m permet d'afficher l'occupation de la RAM, et la commande df -h celle du disque. Ainsi, notre Linux utilise 15 Mo de RAM, et même si nous avons généré un disque de 60 Mo, il n'utilise réellement que 2,9 Mo.  

Première connection
Première connexion

Faites le même test sur la Raspbian et comparez.

Exemple de certificat de réussite
Exemple de certificat de réussite