Linux Kernel Makefile uitgelegd

Bij softwareontwikkeling kan het proces van het maken en beheren van grote coderepository's gemakkelijk zeer complex worden.

Om deze complexiteit te beheren en te verminderen, organiseren softwareontwikkelaars code in kleine bestanden die linken naar specifieke modules. Ontwikkelaars kunnen elk van deze bestanden afzonderlijk compileren en ze vervolgens aan elkaar koppelen om een ​​definitief software-uitvoerbaar bestand te maken.

Een voorbeeld hiervan zijn C-projecten die bestaan ​​uit broncodebestanden in .c extensies en software-interfaces in .h extensies. Elk bronbestand wordt samen met de te maken headerbestanden gecompileerd. o objecten aan elkaar gekoppeld met behulp van bibliotheken, waardoor uitvoerbare bestanden worden gemaakt.

Om dit proces uit te voeren, gebruiken softwareontwikkelaars tools, zoals Make, om het bouwproces en de vereiste bestandsafhankelijkheden te automatiseren. Make gebruikt Makefiles om het gedrag van het compilatieproces te beheren.

De GNU Make-tools bieden een reeks regels en conventies die worden gebruikt om Makefiles te maken en de complexiteit bij het verbeteren van de efficiëntie te verminderen.

In deze tutorial zullen we specifiek de Linux Kernel Makefiles bespreken: Kconfig en Kbuild.

Voordat we beginnen, is het goed om op te merken dat dit artikel niet pretendeert alles te leren over het Kernel Build-systeem. We bieden echter een overzicht op hoog niveau van het bouwen van een vmlinux-image en modules.

Als u informatie wilt die buiten het bestek van deze zelfstudie valt, raden we de volgende bron aan voor betere informatie:

https://linkfy.to/goMakefilesDocs

https://linkfy.to/gnuMake

Kernel Makefiles: een overzicht

Het Kernel Build-systeem, ook wel het configuratiesysteem genoemd, is een essentieel hulpmiddel - voor degenen die het nodig hebben - dat al een tijdje bestaat. Niet iedereen zal dit systeem echter gebruiken; zelfs stuurprogramma's en andere softwareontwikkelaars op laag niveau gebruiken het zelden. Aangezien u dit leest, betekent dit dat u meer wilt weten over het Kernel Build-systeem.

We zullen dus bespreken hoe de kernel wordt gecompileerd en het Kbuild- en Kconfig-systeem bespreken, zodat u ze beter kunt begrijpen.

De Kernel Makefile heeft vijf kerncomponenten:

1. Makefile: Dit is het bovenste make-bestand in de root van de bron.
2. arch/$(ARCH) Makefile: Dit is de boog Makefile; het fungeert als een aanvulling op de bovenste Makefile.
3. .configuratie: Dit is het kernelconfiguratiebestand.
4. Scripts/Makefile.*: Dit definieert ingestelde regels voor alle kbuild Makefiles.
5. Kbuild Makefiles: Er zijn ongeveer 500 kbuild Makefiles, en ze zijn niet erg gemakkelijk te lezen. Denk aan een bestand zoals:

https://elixir.bootlin.com/linux/latest/source/scripts/Kbuild.omvatten

Kconfig

Het Kconfig-bestand bevat modules die helpen bij het gebruik van de make *config. Het helpt de Kernel om selectieve configuraties te maken, waardoor modulariteit en aanpasbaarheid wordt gecreëerd voor het Kernel-bouwproces.

Er zijn verschillende configuratiedoelen gespecificeerd door het Kconfig-systeem. U kunt de make-help gebruiken om de beschikbare doelen te bekijken. Deze doelen worden verwerkt door verschillende programma's die door de kernel worden geleverd tijdens het bouwproces.

Enkele van de Kconfig-doelen zijn:

• Configuratie: Dit wordt gebruikt om het kernelconfiguratiebestand bij te werken met behulp van het lijnprogramma.
• Menuconfiguratie: Dit is een Kconfig-functie of -mechanisme dat op menu's gebaseerde toegang biedt tot kernelopties. Om menuconfig en andere Kconfig-functies te starten, moet u zich in de platformprojectdirectory bevinden. U kunt het volgende gebruiken om de Kconfig menuconfig-functie te starten:. U kunt menuconfig echter ook starten met andere GUI Linux Kernel-configuratiefuncties zoals xconfig en gconfig.
maak linux-windriver.menuconfig - Voert menuconfig uit in een aparte terminalsessie.
• gconfig en xconfig: Gconfig activeert GUI-gebaseerde Linux Kernel-functies. Gconfig maakt gebruik van de GTK of (X-gebaseerde) gebruikersinterface. Aan de andere kant maakt Xconfig gebruik van op Qt gebaseerde gebruikersinterface. Gebruik de volgende opdrachten om respectievelijk gconfig en xconfig te starten:

maak linux-windriver.gconfig
maak linux-windriver.xconfig

OPMERKING: Om gconfig en xconfig te gebruiken, moet u de QT-ontwikkeltools op het hostsysteem hebben geïnstalleerd.

• Nconfig: De Nconfig-functie voert de huidige configuratie uit (Buildtools) en is van toepassing op het Ncurses-menugestuurde programma. Hiermee kunt u de te bouwen pakketten selecteren, zoals CPU, stuurprogramma's en bestandssysteem bij het bouwen van de Kernel Kern. Gebruik het commando: make nconfig.
• Oude configuratie: Met de functie oldconfig kunt u nieuwer toepassen .config-bestanden naar oudere kernelconfiguratiebestanden. Bijvoorbeeld een oude .config-bestand en een nieuwer .config-bestand (nieuwere kernelversie) zal verschillen hebben, wat betekent dat u de huidige configuratie moet bijwerken voordat de kernel wordt gebouwd. U kunt make oldconfig gebruiken om de oude configuratie interactief bij te werken door opties toe te passen die ontbreken in het oude configuratiebestand.
• Defconfig: Met deze functie kan het kernel-buildsysteem een ​​nieuwe configuratie, geleverd door defconfig, toevoegen aan de .config-bestand. Om precies te zijn, het Kbuild-systeem controleert alle Kconfig-bestanden. Als defconfig een optie specificeert in het bestand, gebruikt het Kbuild-systeem de gespecificeerde waarde om de optie toe te voegen aan de .configuratie. Als de defconfig de optie niet vermeldt, gebruikt Kbuild standaardwaarden in de .configuratie.

Stel je de volgende situatie voor:

Defconfig-codemomentopname van de volgende bron:

https://elixir.bootlin.com/linux/v5.9/source/scripts/kconfig/Makefile#L98

1. defconfig: $(obj)/conf
2. ifneq ($(jokerteken $(srctree)/arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)),)
3. @$(kecho) "*** Standaardconfiguratie is gebaseerd op '$(KBUILD_DEFCONFIG)'"
4. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. anders
6. @$(kecho) "*** Standaardconfiguratie is gebaseerd op doel '$(KBUILD_DEFCONFIG)'"
7. $(Q)$(MAKE) -f $(srctree)/Makefile $(KBUILD_DEFCONFIG)
8. stop als
9.
10. %_defconfig: $(obj)/conf
11. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configfiles=$(jokerteken $(srctree)/kernel/configs/$@ $(srctree)/arch/$(SRCARCH)/configs/$@)
14.
15. %.config: $(obj)/conf
16. $(if $(call configfiles),, $(error Er bestaat geen configuratie voor dit doel op deze architectuur))
17. $(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sh -m .config $ (configuratiebestanden)
18. $(Q)$(MAKE) -f $(srctree)/Makefile olddefconfig

Momentopname van Oldconfig-code uit de volgende bron:

https://elixir.bootlin.com/linux/v5.9/source/scripts/kconfig/conf.c#L694

1. geval olddefconfig:
2. standaard:
3. breken;
4.
5.
6. if (input_mode == savedefconfig)
7. if (conf_write_defconfig(defconfig_file))
8. fprintf(stderr, "n*** Fout bij het opslaan van defconfig naar: %s\n\n",
9. defconfig_file);
10. retour 1;
11.
12. else if (input_mode != lijstnieuweconfig && input_mode != helpnewconfig)
13. als (!no_conf_write && conf_write(NULL))
14. fprintf(stderr, "\n*** Fout tijdens het schrijven van de configuratie.\n\n");
15. uitgang(1);
16.
17.
18. /*
19. * Automatisch aanmaken.conf als het niet bestaat.
20. * Dit voorkomt GNU Make 4.1 of ouder van emissie
21. * "include/config/auto".conf: Geen dergelijk bestand of map"
22. * in het Makefile op het hoogste niveau
23. *
24. * syncconfig maakt of werkt altijd automatisch bij.conf omdat het zo is
25. * gebruikt tijdens de bouw.
26. */
27. if (conf_write_autoconf(sync_kconfig) && sync_kconfig)
28. fprintf(stderr,
29. "\n*** Fout tijdens synchronisatie van de configuratie.\n\n");
30. retour 1;
31.
32.
33. retourneer 0;
34.

• Savedefconfig: Deze regel slaat de huidige .config in de vorm van ./defconfig, dat wordt beschouwd als een minimaal configuratiebestand. Gebruik het commando: make savedefconfig
• Lijstnieuweconfig: Dit wordt gebruikt om nieuwe opties weer te geven.
• Kvmconfig: Dit maakt opties voor KVM-ondersteuning mogelijk. Gebruik het commando: make kvm_guest.configuratie
• Allyesconfig: Dit bouwt een nieuw kernelconfiguratiebestand op met alle opties ingesteld op ja. Het is het tegenovergestelde van allnoconfig.
• Allmodconfig: Dit bouwt een nieuwe kernelconfiguratie waarmee modules standaard zijn ingeschakeld.
• Randconfiguratie: Dit bouwt een nieuw kernelconfiguratiebestand op met willekeurige antwoorden op alle opties.
• Tinyconfig: Dit maakt de kleinste Kernel mogelijk.

Er zijn veel doelen in het Kconfig-systeem. Enkele veelvoorkomende zijn config en menuconfig.

Zoals vermeld, worden de doelen verwerkt door verschillende programma's in de hostsystemen, ofwel met een GUI of een opdrachtregel. Je kunt Kconfig-tools vinden in /scripts/Kconfig in de kernelbron.

https://elixir.bootlin.com/linux/latest/source/scripts/kconfig

https://elixir.bootlin.com/linux/latest/source/scripts/kconfig/Makefile

Het eerste proces is meestal om het Kconfig-bestand in de hoofdmap te lezen, dat wordt gebruikt om een ​​initiële configuratiedatabase te bouwen. Naarmate het proces vordert, wordt de database bijgewerkt bij het lezen van bestanden in de volgende volgorde:

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

.config-bestand wordt vervolgens gedropt naar syncconfig, dat de . accepteert .config-bestand als invoer. Het verwerkt het bestand en voert bestanden uit, die vervolgens worden ingedeeld in verschillende categorieën, zoals:

• autoconf.h: Dit wordt gebruikt voor C-taalbronbestanden.
• auto.conf en tristate.conf: Deze worden gebruikt voor Makefile-tekstverwerking.
• /inclusief/config: Dit zijn lege headerbestanden die worden gebruikt bij het bijhouden van afhankelijkheid.

Kbuild-bestanden

Bijna alle kernelbestanden zijn Kbuild Makefiles die de Kbuild-infrastructuur gebruiken, wat een recursieve make-functie is. Recursive Make is een manier om de Make-tool te gebruiken als een opdracht in een Makefile. Recursie is erg handig bij het samenstellen van een groot project.

Kbuild werkt door te verwijzen naar alle bestanden die we in de bovenstaande sectie hebben genoemd.

Het Kbuild-systeem bouwt zijn componenten met behulp van de bovenste Makefile die de boog bevat Makefiles met de naam arch/$(ARCH)/Makefile in de configuratiebestanden. Het daalt recursief af in submappen en roept Make aan op de componenten met behulp van de routines in scripts/Makefile.*. Kbuild bouwt dan voort op het aangrenzende object en koppelt ze aan objecten, waardoor vmlinux . ontstaat.

Raadpleeg de documentatie voor meer informatie over de syntaxis die wordt gebruikt in Kbuild Makefiles.

Overweeg het volgende script:.

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

De o-objectbestanden die worden gebruikt om de vmlinux te maken, worden eerst gecompileerd in hun respectievelijke ingebouwde .a bestanden als de var KBUILD_VMLINUX_INIT,MAIN,LIBS. Deze zijn samengesteld in vmlinux.

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

Conclusie

In deze handleiding hebben we gekeken naar Kbuild- en Kconfig-systemen in het Kernel-buildsysteem en hoe het werkt. Zoals we aan het begin van de tutorial vermeldden, zijn de besproken onderwerpen breed en kunnen ze niet in één tutorial worden behandeld.