Buildroot — partie 1. Informations générales, construction d'un système minimal, configuration via le menu

Introduction

Dans cette série d'articles, je souhaite examiner le système de construction du distributeur buildroot et partager mon expérience de sa personnalisation. Il s'agira d'une expérience pratique de création d'un petit système d'exploitation avec une interface graphique et une fonctionnalité minimale.

Tout d'abord, il ne faut pas confondre le système de construction et le distributeur. Buildroot peut assembler un système à partir d'un ensemble de packages qui lui sont proposés. Buildroot est basé sur des fichiers make et possède donc d'énormes possibilités de personnalisation. Remplacer un package par une autre version, ajouter son propre package, modifier les règles de construction d'un package, personnaliser le système de fichiers après l'installation de tous les packages ? Tout cela est possible avec buildroot.

En Russie, buildroot est utilisé, mais à mon avis, il y a peu d'informations en russe pour les débutants.

L'objectif de ce travail est de construire un distributeur avec un chargement live, une interface icewm et un navigateur. La plateforme cible est virtualbox.

Pourquoi construire son propre distributeur ? Souvent, un fonctionnement limité est nécessaire avec des ressources limitées. Encore plus souvent, dans l'automatisation, il est nécessaire de créer des firmwares. Adapter un distributeur générique, en éliminant les packages superflus et en le transformant en firmware est un processus beaucoup plus laborieux que de construire un nouveau distributeur. L'utilisation de Gentoo a également ses limites.

Buildroot est un système très puissant, mais il ne fera rien à votre place. Il peut seulement offrir des possibilités et automatiser le processus de construction.

Les systèmes de construction alternatifs (yocto, open build system et autres) ne sont pas examinés ni comparés.

Où les trouver et comment commencer

Site du projet — buildroot.org. Ici, vous pouvez télécharger la version actuelle et lire le manuel. Vous pouvez également rejoindre la communauté, il y a un système de suivi des bugs, des listes de diffusion et un canal IRC.

Buildroot utilise des defconfig pour la carte cible de construction. Le defconfig est un fichier de configuration qui ne stocke que les options n'ayant pas de valeur par défaut. C'est lui qui détermine ce qui sera assemblé et comment. Il est possible de configurer séparément les configs busybox, linux-kernel, uglibc, et les chargeurs u-boot et barebox, mais tous seront liés à la carte cible.
Après avoir décompressé l'archive téléchargée ou cloné depuis git, nous obtenons un buildroot prêt à l'emploi. Une description détaillée de la structure des répertoires peut être trouvée dans le manuel, mais je vais parler des éléments les plus importants :

board — un catalogue de fichiers spécifiques pour chaque carte. Cela peut inclure des scripts pour créer des images système (iso, sdcart, cpio, etc.), un répertoire overlay, la configuration des noyaux, et plus encore.
configs — le defconfig de la carte. Le defconfig est une configuration incomplète de la carte. Il contient uniquement les paramètres qui diffèrent des paramètres par défaut.
dl — un répertoire contenant les fichiers/source codes téléchargés pour la compilation.
output/target — le système de fichiers créé de l'OS reçu. C'est de là que sont créées les images pour le chargement/l'installation.
output/host — utilitaires hôtes pour la compilation.
output/build — paquets compilés.

La configuration de la compilation se fait via KConfig. Ce même système est utilisé pour compiler le noyau Linux. Voici une liste des commandes les plus couramment utilisées (à exécuter dans le répertoire buildroot) :

• make menuconfig — lancer la configuration de la compilation. Il est également possible d'utiliser une interface graphique (make nconfig, make xconfig, make gconfig).
• make linux-menuconfig — lancer la configuration du noyau.
• make clean — nettoyer les résultats de la compilation (tout ce qui est stocké dans output).
• make — compiler le système. Cela n'effectue pas la recompilation des processus déjà compilés.
• make defconfig_name — changer de configuration pour un defconfig spécifique.
• make list-defconfigs — afficher la liste des defconfigs.
• make source — uniquement télécharger les fichiers d'installation, sans compilation.
• make help — afficher la liste des commandes possibles.

Remarques importantes et conseils utiles.

Buildroot ne recompilera pas les paquets déjà compilés ! Par conséquent, il peut se créer une situation où une recompilation complète est nécessaire.

On peut recompiling un paquet spécifique avec la commande make packagename-rebuild. Par exemple, on peut recompiler le noyau Linux :

make linux-rebuild.

Buildroot garde la trace de l'état de tout paquet en créant des fichiers .stamp dans le répertoire output/build/$packagename.

Par conséquent, il est possible de recompiler root-fs et d'images sans recompilation des paquets :

rm output/build/host-gcc-final-*/.stamp_host_installed; rm -rf output/target; find output/ -name ".stamp_target_installed" | xargs rm -rf; make.

Variables utiles.

Dans buildroot, il existe un ensemble de variables pour faciliter la configuration.

• $TOPDIR — le répertoire racine de buildroot.
• $BASEDIR — le répertoire OUTPUT.
• $HOST_DIR, $STAGING_DIR, $TARGET_DIR — répertoires de compilation pour host fs, staging fs, target fs.
• $BUILD_DIR — le répertoire avec les paquets décompressés et compilés.

Visualisation

Dans buildroot, il est possible de visualiser. On peut créer un schéma de dépendances, un graphique des temps de compilation, un graphique de la taille des paquets dans le système final. Les résultats se présentent sous forme de fichiers pdf (les options incluent svn, png) dans le répertoire output/graph.

Exemples de commandes de visualisation :

• make graph-depends. construire un arbre de dépendances
• make -graph-depends construire l'arbre de dépendances d'un paquet spécifique
• BR2_GRAPH_OUT=png make graph-build construire un graphique du temps de compilation avec une sortie en PNG
• make graph-size construire un graphique de la taille des paquets

Scripts utiles

Dans le répertoire buildroot, il y a un sous-répertoire utils avec des scripts utiles. Par exemple, il y a un script qui vérifie la validité de la description des paquets. Cela peut être utile lors de l'ajout de vos propres paquets (je le ferai plus tard). Un fichier utils/readme.txt décrit ces scripts.

Construisons une distribution de base

Il est important de rappeler que toutes les opérations se font au nom d'un utilisateur standard, pas root.
Toutes les commandes sont exécutées à la racine de buildroot. La distribution buildroot comprend déjà un ensemble de configurations pour de nombreuses cartes courantes et la virtualisation.

Voyons la liste des configurations :

Passons à la configuration qemu_x86_64_defconfig

make qemu_x86_64_defconfig

Et lançons la compilation

make

La compilation se termine avec succès, voyons les résultats :

Buildroot a construit des images qui peuvent être lancées dans Qemu et dont nous pouvons vérifier qu'elles fonctionnent.

qemu-system-x86_64 -kernel output/images/bzImage -hda output/images/rootfs.ext2 -append "root=/dev/sda rw" -s -S

Le résultat – un système tournant dans qemu :

Création de la configuration d'une carte personnalisée

Ajout de fichiers de carte

Voyons la liste des configurations :

Dans la liste, nous voyons pc_x86_64_efi_defconfig. Nous allons créer notre propre carte en la copiant à partir de la configuration :

cp configs/pc_x86_64_bios_defconfig configs/my_x86_board_defconfig

Créons immédiatement un répertoire pour la carte pour stocker nos scripts, rootfs-overlay et d'autres fichiers nécessaires :

mkdir board/my_x86_board

Passons à ce defconfig :

make my_x86_board_defconfig

Ainsi, maintenant la configuration de compilation (stockée dans .config à la racine du répertoire buildroot) correspond à la machine cible x86-64 legacy(bios) au démarrage.

Copions la configuration linux-kernel (elle sera utile plus tard) :

cp board/pc/linux.config board/my_x86_board/

Configuration des paramètres de compilation via KConfig

Lançons la configuration :

make menuconfig 

Une fenêtre KConfig s'ouvrira. Il est possible de configurer avec une interface graphique (make nconfig, make xconfig, make gconfig) :

Entrons dans la première section Options Cibles. Ici, vous pouvez choisir l'architecture cible pour laquelle la compilation sera effectuée.

Options de compilation – ici, il y a divers paramètres de compilation. Vous pouvez indiquer les répertoires des codes sources, le nombre de threads de compilation, les miroirs pour télécharger les sources et d'autres paramètres. Gardons les paramètres par défaut.

Toolchain – ici, l'outil de compilation lui-même est configuré. Nous en parlerons plus en détail.

Type de chaîne d'outils – le type de chaîne d'outils à utiliser. Cela peut être une chaîne intégrée dans Buildroot ou une chaîne externe (vous pouvez spécifier un répertoire avec une version déjà compilée ou une URL pour le téléchargement). Pour différentes architectures, des options supplémentaires sont disponibles. Par exemple, pour arm, vous pouvez simplement choisir la version de la chaîne d'outils externe Linaro.

Bibliothèque C – choix de la bibliothèque C. Cela impacte le fonctionnement de tout le système. En général, glibc est utilisée, car elle prend en charge toutes les fonctionnalités possibles. Mais elle peut être trop volumineuse pour un système embarqué, donc on choisit souvent uClibc ou musl. Nous choisirons glibc (cela sera nécessaire pour utiliser systemd).

Headers du noyau et série des Headers du noyau personnalisés – doit correspondre à la version du noyau qui sera dans le système à compiler. Pour les headers du noyau, vous pouvez également spécifier le chemin vers une tarball ou un dépôt git.

VERSIONS DU COMPILATEUR GCC – choix de la version du compilateur à utiliser pour la compilation.
Activer le support C++ – choisissons de compiler avec le support des bibliothèques C++ dans le système. Cela nous sera utile par la suite.

Options gcc supplémentaires – vous pouvez spécifier des options supplémentaires pour le compilateur. Nous n'en avons pas besoin pour l'instant.

La configuration du système permet de définir les paramètres futurs du système créé :

La plupart des éléments sont clairs d'après leur nom. Portons notre attention sur les éléments suivants :
Chemin vers les tables d'utilisateurs — tableau avec les utilisateurs créés (https://buildroot.org/downloads/manual/manual.html#makeuser-syntax).

Exemple de fichier. Un utilisateur user sera créé avec le mot de passe admin, gid/uid automatiquement, shell /bin/sh, groupe par défaut user, membre du groupe root, commentaire Foo user

[alexey@alexey-pc buildroot ]$ cat board/my_x86_board/users.txt 
user -1 user -1 =admin /home/user /bin/sh root Foo user

Répertoires de superposition du système de fichiers racine — répertoire superposé au système cible compilé. Ajoute de nouveaux fichiers et remplace les existants.

Scripts personnalisés à exécuter avant de créer des images du système de fichiers — scripts exécutés juste avant la compression du système de fichiers en images. Nous laisserons le script vide pour l'instant.

Passons à la section Noyau

Ici, les paramètres du noyau sont définis. Le noyau lui-même est configuré via make linux-menuconfig.
La version du noyau peut être spécifiée de plusieurs façons : choisir parmi les versions proposées, entrer la version manuellement, spécifier un dépôt ou une tarball prête à l'emploi.

Configuration du noyau — chemin vers la configuration du noyau. Vous pouvez choisir la configuration par défaut pour l'architecture sélectionnée ou un defconfig de Linux. Dans les sources de Linux, il y a un ensemble de defconfigs pour différents systèmes cibles. Vous pouvez en trouver un ici, en regardant directement dans les sources ici. Par exemple, pour la carte Beagle Bone Black, vous pouvez. choisir la configuration.

La section Target packages permet de choisir quels paquets seront installés dans le système à construire. Pour l'instant, laissons-le sans modifications. Nous ajouterons nos paquets dans cette liste plus tard.
Les images de système de fichiers — liste des images de systèmes de fichiers qui seront assemblées. Ajoutons l'image iso.

Bootloaders — choix des bootloaders à assembler. Choisissons isolinix.

Configuration de Systemd

Systemd devient l'une des colonnes vertébrales de linux, au même titre que le noyau et glibc. C'est pourquoi j'ai isolé sa configuration dans un point séparé.

Il se configure via make menuconfig, ensuite Target packages → System tools → systemd. Ici, vous pouvez indiquer quels services systemd seront installés et lancés au démarrage du système.

Sauvegarde de la configuration système

Nous sauvegardons cette configuration via KConfig.

Après quoi nous sauvegarderons notre defconfig :

make savedefconfig

Configuration du noyau Linux

La configuration du noyau linux s'appelle avec la commande suivante :

make linux-menuconfig

Ajoutons le support de la carte graphique Virtualbox.

Ajoutons le support d'intégration de Virtualbox Guest.

Sauvegardons et sortons. IMPORTANT: la configuration sera sauvegardée dans output/build/linux-$version/config, mais pas dans board/my_x86_board/linux.config

Il faut donc copier manuellement la configuration à son emplacement de stockage :

cp output/build/linux-4.19.25/.config board/my_x86_board/linux.config

Après quoi nous effectuerons une reconstruction complète de tout le système. Étant donné que buildroot ne reconstruit pas ce qui a déjà été assemblé, il faut indiquer manuellement les paquets à reconstruire. Pour ne pas perdre de temps et de nerfs, il est plus facile de reconstruire un petit système en entier :

make clean;make

À la fin de la construction, lançons VirtualBox (testé sur les versions 5.2 et 6.0) avec le démarrage à partir du CD. Paramètres du système :

Démarrage depuis l'iso assemblé :

Liste des matériaux utilisés

1. Manuel de Buildroot

Source : habr.com