MADE LINUX MAIS

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

Un exemple de ceci est C projets composé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 ensemble à 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 construction et les dépendances de fichiers requises. Faire des usages MakeFiles pour gérer le comportement du processus de compilation.

Les outils de fabrication GNU fournissent un ensemble de règles et de conventions utilisées pour créer des makefiles et réduire la complexité de l'amélioration de l'efficacité.

Dans ce didacticiel, nous discuterons des mobilières du noyau Linux, en particulier Kconfig et Kbuild.

Avant de commencer, il est bon de noter que cet article ne prétend pas enseigner tout sur le système de construction du noyau. Cependant, nous fournissons un aperçu de haut niveau de la construction d'une image et de modules VMLinux.

Si vous souhaitez des informations au-delà de la portée de ce tutoriel, nous recommandons la ressource suivante pour de meilleures informations:

https: // linkfy.à / gomakefilesdocs

https: // linkfy.à / gnumake

Maké de noyau: un aperçu

Le système de construction du noyau, é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 système de construction du noyau.

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

Le noyau Makefile a cinq composants centraux:

1. Makefile: Ceci est le fichier de marque supérieur situé dans la racine source.
2. Arch / $ (Arch) Makefile: Ceci est le makefile arc; il agit comme un complément au maquillage supérieur.
3. .config: Ceci est le fichier de configuration du noyau.
4. Scripts / makefile.*: Cela définit les règles des ensembles pour tous les makefiles kbuild.
5. KBuild Makefiles: Il y a environ 500 kbuild makefiles, et ils ne sont pas très faciles à lire. Considérez un fichier tel que:

https: // elixir.coffre.com / linux / dernier / source / scripts / kbuild.inclure

Kconfig

Le fichier kconfig contient des modules qui aident lors de l'utilisation de la configuration de Make *. Il aide le noyau à effectuer des configurations sélectives, créant une modularité et une personnalisation du 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 à afficher les cibles disponibles. Ces objectifs sont traités par divers programmes fournis par le noyau pendant le processus de construction.

Certaines cibles de Kconfig comprennent:

• Config: Ceci est utilisé pour mettre à jour le fichier de configuration du noyau à l'aide du programme de ligne.
• Menuconfig: Il s'agit d'une fonction ou d'un mécanisme Kconfig qui offre un accès basé sur un menu aux options du noyau. Pour lancer Menuconfig et d'autres fonctionnalités KConfig, vous devez être dans le répertoire du projet Platform. Vous pouvez utiliser ce qui suit pour lancer la fonction Kconfig Menuconfig. Cependant, vous pouvez également lancer Menuconfig avec d'autres fonctionnalités de configuration du noyau GUI Linux telles que XConfig et GConfig.

faire linux-windriver.Menuconfig - Exécute Menuconfig dans une session de terminal distincte.

• gconfig et xconfig: GConfig active les fonctionnalités du noyau Linux basé sur l'interface graphique. GConfig utilise l'interface utilisateur basée sur GTK ou (basée sur X). D'un autre côté, 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

NOTE: Pour utiliser GConfig et XConfig, vous devriez faire installer les outils de développement QT sur le système hôte.

• Nconfig: La fonctionnalité NConfig exécute la configuration actuelle (BuildTools) et s'applique au programme axé sur le menu NCurses. Cela vous permet de sélectionner les packages à construire, comme le processeur, les pilotes et le système de fichiers lors de la construction du noyau. Utilisez la commande: faites nconfig.
• OldConfig: La fonction OldConfig vous permet d'appliquer plus récent .Files de configuration vers les fichiers de configuration du noyau plus ancien. Par exemple, un vieux .Fichier de configuration et un plus récent .Le fichier de configuration (version plus récente 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 des options manquantes dans l'ancien fichier de configuration.
• Defconfig: Cette fonction 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 à l'option .configurer. Si le defconfig ne mentionne pas l'option, KBuild utilise des valeurs par défaut dans le .configurer.

Considérer ce qui suit:

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

https: // elixir.coffre.com / linux / v5.9 / source / scripts / kconfig / makefile # l98

1. defconfig: $ (obj) / confr
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) / confr
11. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configFiles = $ (Wildcard $ (srctree) / noyau / configs / $ @ $ (srctree) / arch / $ (srcarch) / configs / $ @)
14.
15. %.config: $ (obj) / confre
16. $ (if $ (appel de configuration) ,, $ (erreur aucune configuration n'existe pour cet objectif sur cette architecture))
17. $ (Q) $ (config_shell) $ (srctree) / scripts / kconfig / merge_config.sh -m .config $ (configFiles)
18. $ (Q) $ (make) -f $ (srctree) / makefile olddefconfig

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

https: // elixir.coffre.com / linux / v5.9 / source / scripts / kconfig / confre.C # L694

1. Case olddefconfig:
2. défaut:
3. casser;
4.
5.
6. if (input_mode == SAVEDEFCONFIG)
7. if (conf_write_defconfig (defconfig_file))
8. fprintf (stderr, "N *** Erreur tout en enregistrant defconfig à:% s \ n \ n",
9. defConfig_file);
dix. retour 1;
11.
12. else if (input_mode != listNewConfig && input_mode != HelpNewConfig)
13. si (!no_conf_write && conf_write (null))
14. Fprintf (Stderr, "\ n *** Erreur lors de la rédaction de la configuration.\ n \ n ");
15. sortie (1);
16.
17.
18. / *
19. * Créer une auto.confr s'il n'existe pas.
20. * Cela empêche GNU de faire 4.1 ou plus de l'émission
21. * "Inclure / config / auto.conf: pas de tel fichier ou répertoire "
22. * Dans le makefile de niveau supérieur
23. *
24. * SyncConfig crée ou met à jour automatique.conf parce que c'est
25. * Utilisé pendant la construction.
26. * /
27. if (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "\ n *** Erreur pendant la synchronisation de la configuration.\ n \ n ");
30. retour 1;
31.
32.
33. retour 0;
34.

• SAVEDEFCONFIG: Cette règle sauve le courant .configuration sous la forme de ./ Defconfig, qui est considéré comme un fichier de configuration minimal. Utilisez la commande: faites de SAVEDEFCONFIG
• ListNewConfig: Ceci est utilisé pour répertorier de nouvelles options.
• Kvmconfig: Cela permet les options de support KVM. Utilisez la commande: faites kvm_guest.configurer
• AllyesConfig: Cela construit un nouveau fichier de configuration du noyau avec toutes les options définies sur oui. C'est l'opposé de AllNoConfig.
• AllModconfig: Cela construit une nouvelle configuration de noyau avec laquelle les modules sont activés par défaut.
• Randconfig: Cela construit un nouveau fichier de configuration du noyau avec des réponses aléatoires à toutes les options.
• TinyConfig: Cela rend le plus petit noyau possible.

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

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

https: // elixir.coffre.com / linux / dernier / source / scripts / kconfig

https: // elixir.coffre.com / linux / dernier / 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 fil du processus, la base de données est mise à jour lors de la lecture de fichiers dans l'ordre suivant:

.configurer
/ lib / modules / $ (shell, uname-r) /.configurer
/ etc / kernel-config
/ boot / config - $ (shell, uname-r)
Arch_defconfig
arch / $ (arch) / defconfig

.Le fichier de configuration est ensuite déposé à SyncConfig, qui accepte le .Fichier de configuration comme entrée. Il traite les fichiers de fichiers et de sortie, qui sont ensuite classés en différentes catégories telles que:

• autoconf.H: Ceci est utilisé pour les fichiers source de langue C.
• auto.conf et tristate.conf: Ceux-ci sont utilisés pour le traitement de texte MakeFile.
• / inclut / config: Ce sont des fichiers d'en-tête vides utilisés dans le suivi des dépendances.

Fichiers kbuild

Presque tous les fichiers du noyau sont des morsures KBuild qui utilisent l'infrastructure KBuild, qui est une fonctionnalité récursive. La marque récursive est un moyen d'utiliser l'outil de fabrication comme commande dans un makefile. La récursivité est très utile lors de la compilation d'un grand projet.

KBuild fonctionne en faisant référence à tous les fichiers que nous avons mentionnés dans la section ci-dessus.

Le système KBuild construit ses composants à l'aide du makefile supérieur qui inclut l'arc makefiles avec le nom arch / $ (arch) / makefile dans les fichiers de configuration. Il descend récursivement en sous-répertoires invoquant la marque sur les composants en utilisant les routines dans les scripts / makefile.*. KBuild s'appuie ensuite sur l'objet adjacent et les relie 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 / maître / scripts / link-vmlinux.shot

Les fichiers d'objet O utilisés pour créer le VMLinux sont compilés en premier dans leur intégré respectif .un fichiers comme var kbuild_vmlinux_init, main, libs. Ceux-ci sont composés dans vmlinux.

https: // github.com / torvalds / linux / blob / maître / 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 comment il fonctionne. Comme nous l'avons mentionné au début du tutoriel, les sujets abordés sont larges et ne peuvent pas être couverts dans un seul tutoriel.