Makefile du noyau Linux expliqué

Dans le développement de logiciels, le processus de création et de gestion de grands référentiels de code peut facilement devenir très complexe.

Pour gérer et réduire cette complexité, les développeurs de logiciels organisent le code dans de petits fichiers qui renvoient à des modules spécifiques. Les développeurs peuvent compiler chacun de ces fichiers séparément, puis les lier ensemble pour créer un exécutable logiciel final.

Un exemple de ceci est les projets C constitués de fichiers de code source dans .c extensions et interfaces logicielles dans .h extensions. Chaque fichier source est compilé avec les fichiers d'en-tête pour créer. o objets liés entre eux à l'aide de bibliothèques, créant ainsi des fichiers exécutables.

Pour effectuer ce processus, les développeurs de logiciels utilisent des outils, tels que Make, pour automatiser le processus de génération et les dépendances de fichiers requises. Make utilise des Makefiles pour gérer le comportement du processus de compilation.

Les outils GNU Make fournissent un ensemble de règles et de conventions utilisées pour créer des Makefiles et réduire la complexité en améliorant l'efficacité.

Dans ce tutoriel, nous discuterons des Makefiles du noyau Linux, en particulier Kconfig et Kbuild.

Avant de commencer, il est bon de noter que cet article ne prétend pas tout apprendre sur le système Kernel Build. Cependant, nous fournissons un aperçu de haut niveau de la création d'une image et de modules vmlinux.

Si vous souhaitez obtenir des informations dépassant le cadre de ce didacticiel, nous vous recommandons la ressource suivante pour de meilleures informations :

https://linkfy.to/goMakefilesDocs

https://linkfy.à/gnuMake

Makefiles du noyau : un aperçu

Le Kernel Build System, également appelé système de configuration, est un outil essentiel - pour ceux qui en ont besoin - qui existe depuis un certain temps. Cependant, tout le monde n'utilisera pas ce système ; même les pilotes et autres développeurs de logiciels de bas niveau l'utilisent rarement. Puisque vous lisez ceci, cela signifie que vous voulez en savoir plus sur le Kernel Build System.

Ainsi, nous discuterons de la façon dont le noyau est compilé et discuterons du système Kbuild et Kconfig afin que vous puissiez mieux les comprendre.

Le Kernel Makefile a cinq composants principaux :

Makefile : C'est le premier fichier make situé à la racine source.
arch/$(ARCH) Makefile : C'est le Makefile arch; il agit comme un complément au top Makefile.
.configuration : Ceci est le fichier de configuration du noyau.
Scripts/Makefile.* : Cela définit les règles définies pour tous les Makefiles de kbuild.
Fichiers Makefile de Kbuild : Il y a environ 500 Makefiles kbuild, et ils ne sont pas très faciles à lire. Considérons un fichier tel que :

https://élixir.démarrage.com/linux/latest/source/scripts/Kbuild.inclure

Kconfig

Le fichier Kconfig contient des modules qui aident lors de l'utilisation du make *config. Il aide le noyau à effectuer des configurations sélectives, créant une modularité et une personnalisation pour le processus de construction du noyau.

Il existe différentes cibles de configuration spécifiées par le système Kconfig. Vous pouvez utiliser l'aide make pour afficher les cibles disponibles. Ces cibles sont traitées par divers programmes fournis par le noyau pendant le processus de construction.

Certaines des cibles de Kconfig incluent :

Configuration : Ceci est utilisé pour mettre à jour le fichier de configuration du noyau à l'aide du programme en ligne.
Configuration du menu : Il s'agit d'une fonctionnalité ou d'un mécanisme de Kconfig qui offre un accès basé sur des menus aux options du noyau. Pour lancer menuconfig et d'autres fonctionnalités de Kconfig, vous devez être dans le répertoire du projet de la plate-forme. Vous pouvez utiliser ce qui suit pour lancer la fonctionnalité de menuconfig de Kconfig. Cependant, vous pouvez également lancer menuconfig avec d'autres fonctionnalités de configuration du noyau Linux GUI telles que xconfig et gconfig.
gconfig et xconfig : Gconfig active les fonctionnalités du noyau Linux basées sur l'interface graphique. Gconfig utilise l'interface utilisateur basée sur GTK ou (basée sur X). D'autre part, Xconfig utilise une interface utilisateur basée sur Qt. Utilisez les commandes suivantes pour lancer respectivement gconfig et xconfig :

faire linux-windriver.gconfig
faire linux-windriver.xconfig

REMARQUE: Pour utiliser gconfig et xconfig, vous devez avoir les outils de développement QT installés sur le système hôte.

Nconfig : La fonction Nconfig exécute la configuration actuelle (Buildtools) et s'applique au programme piloté par menu Ncurses. Cela vous permet de sélectionner les packages à construire, tels que le processeur, les pilotes et le système de fichiers lors de la construction du noyau. Utilisez la commande : make nconfig.
Ancienne configuration : La fonctionnalité oldconfig vous permet d'appliquer de nouvelles .fichiers de configuration vers les anciens fichiers de configuration du noyau. Par exemple, un vieux .fichier de configuration et un plus récent .config (nouvelle version du noyau) aura des différences, ce qui signifie que vous devez mettre à jour la configuration actuelle avant la construction du noyau. Vous pouvez utiliser make oldconfig pour mettre à jour l'ancienne configuration de manière interactive en appliquant les options manquantes dans l'ancien fichier de configuration.
Defconfig : Cette fonctionnalité permet au système de construction du noyau d'ajouter une nouvelle configuration fournie par defconfig au .fichier de configuration. Plus précisément, le système Kbuild vérifie tous les fichiers Kconfig. Si defconfig spécifie une option dans le fichier, le système Kbuild utilise la valeur spécifiée pour ajouter l'option au .configuration. Si le defconfig ne mentionne pas l'option, Kbuild utilise les valeurs par défaut dans le .configuration.

Considérer ce qui suit:

Instantané de code Defconfig à partir de la ressource suivante :

https://élixir.démarrage.com/linux/v5.9/source/scripts/kconfig/Makefile#L98

1. defconfig : $(obj)/conf
2. ifneq ($(wildcard $(srctree)/arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)),)
3. @$(kecho) "*** La configuration par défaut est basée sur '$(KBUILD_DEFCONFIG)'"
4. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. autre
6. @$(kecho) "*** La configuration par défaut est basée sur la cible '$(KBUILD_DEFCONFIG)'"
7. $(Q)$(MAKE) -f $(srctree)/Makefile $(KBUILD_DEFCONFIG)
8. fin si
9.
dix. %_defconfig : $(obj)/conf
11. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configfiles=$(wildcard $(srctree)/kernel/configs/$@ $(srctree)/arch/$(SRCARCH)/configs/$@)
14.
15. %.configuration : $(obj)/conf
16. $(if $(call configfiles),, $(error Aucune configuration n'existe pour cette cible sur cette architecture))
17. $(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sh -m .config $(fichiers de configuration)
18. $(Q)$(MAKE) -f $(srctree)/Makefile olddefconfig

Instantané de code Oldconfig à partir de la ressource suivante :

https://élixir.démarrage.com/linux/v5.9/source/scripts/kconfig/conf.c#L694

1. cas olddefconfig :
2. défaut:
3. Pause;
4.
5.
6. if (input_mode == saveefconfig)
7. if (conf_write_defconfig(defconfig_file))
8. fprintf(stderr, "n*** Erreur lors de l'enregistrement de defconfig dans : %s\n\n",
9. defconfig_file);
dix. retour 1 ;
11.
12. else if (mode_entrée != listnewconfig && input_mode != helpnewconfig)
13. si (!no_conf_write && conf_write(NULL))
14. fprintf(stderr, "\n*** Erreur lors de l'écriture de la configuration.\n\n");
15. sortie(1);
16.
17.
18. /*
19. * Créer automatiquement.conf s'il n'existe pas.
20. * Cela empêche GNU Make 4.1 ou plus d'émettre
21. * "include/config/auto.conf : aucun fichier ou répertoire de ce type"
22. * dans le Makefile de niveau supérieur
23. *
24. * syncconfig crée ou met toujours à jour automatiquement.conf parce que c'est
25. * utilisé lors de la construction.
26. */
27. if (conf_write_autoconf(sync_kconfig) && sync_kconfig)
28. fprintf(stderr,
29. "\n*** Erreur lors de la synchronisation de la configuration.\n\n");
30. retour 1 ;
31.
32.
33. renvoie 0 ;
34.

Savedefconfig : Cette règle enregistre le courant .configuration sous la forme de ./defconfig, qui est considéré comme un fichier de configuration minimal. Utilisez la commande : make saveefconfig
Listnewconfig : Ceci est utilisé pour lister les nouvelles options.
Kvmconfig : Cela active des options pour la prise en charge KVM. Utilisez la commande : make kvm_guest.configuration
Allyesconfig : Cela crée un nouveau fichier de configuration du noyau avec toutes les options définies sur oui. C'est le contraire de allnoconfig.
Allmodconfig : Cela crée une nouvelle configuration de noyau avec laquelle les modules sont activés par défaut.
Randconfig : Cela crée un nouveau fichier de configuration du noyau avec des réponses aléatoires à toutes les options.
Petite configuration : Cela rend le plus petit noyau possible.

Il y a beaucoup de cibles dans le système Kconfig. Certains courants incluent config et menuconfig.

Comme mentionné, les cibles sont traitées par divers programmes dans les systèmes hôtes, fournissant soit une interface graphique, soit une ligne de commande. Vous pouvez trouver des outils Kconfig dans /scripts/Kconfig dans la source du noyau.

https://élixir.démarrage.com/linux/latest/source/scripts/kconfig

https://élixir.démarrage.com/linux/latest/source/scripts/kconfig/Makefile

Le premier processus consiste généralement à lire le fichier Kconfig dans le répertoire racine, qui est utilisé pour créer une base de données de configuration initiale. Au fur et à mesure que le processus se poursuit, la base de données est mise à jour lors de la lecture des fichiers dans l'ordre suivant :

.configuration
/lib/modules/$(shell,uname-r)/.configuration
/etc/kernel-config
/boot/config-$(shell,uname-r)
ARCH_DEFCONFIG
arch/$(ARCH)/defconfig

.config est ensuite déposé dans syncconfig, qui accepte le .fichier de configuration en entrée. Il traite le fichier et produit des fichiers, qui sont ensuite classés en différentes catégories telles que :

autoconf.h : Ceci est utilisé pour les fichiers source du langage C.
auto.conf et tristate.conf : Ceux-ci sont utilisés pour le traitement de texte Makefile.
/includes/config : Ce sont des fichiers d'en-tête vides utilisés dans le suivi des dépendances.

Fichiers Kbuild

Presque tous les fichiers Kernel sont des Makefiles Kbuild qui utilisent l'infrastructure Kbuild, qui est une fonctionnalité make récursive. Recursive Make est un moyen d'utiliser l'outil Make en tant que commande dans un Makefile. La récursivité est très utile lors de la compilation d'un grand projet.

Kbuild fonctionne en se référant à tous les fichiers que nous avons mentionnés dans la section ci-dessus.

Le système Kbuild construit ses composants en utilisant le Makefile supérieur qui inclut les Makefiles arch avec le nom arch/$(ARCH)/Makefile dans les fichiers de configuration. Il descend récursivement dans des sous-répertoires en invoquant Make sur les composants en utilisant les routines dans les scripts/Makefile.*. Kbuild s'appuie ensuite sur l'objet adjacent et les lie en objets, créant vmlinux.

Pour en savoir plus sur la syntaxe utilisée dans Kbuild Makefiles, reportez-vous à la documentation.

Considérez le script suivant.

https://github.com/torvalds/linux/blob/master/scripts/link-vmlinux.sh

Les fichiers d'objet o utilisés pour créer le vmlinux sont d'abord compilés dans leur fichier intégré respectif .a fichiers comme var KBUILD_VMLINUX_INIT,MAIN,LIBS. Ceux-ci sont composés en vmlinux.

https://github.com/torvalds/linux/blob/master/scripts/Makefile.construire

Conclusion

Dans ce guide, nous avons examiné les systèmes Kbuild et Kconfig dans le système de construction du noyau et leur fonctionnement. Comme nous l'avons mentionné au début du didacticiel, les sujets abordés sont vastes et ne peuvent pas être traités dans un seul didacticiel.