Phenquestions
För att hantera och minska denna komplexitet organiserar programutvecklare kod i små filer som länkar till specifika moduler. Utvecklare kan sammanställa var och en av dessa filer separat och sedan koppla ihop dem för att skapa en slutlig programkörbar körning.
Ett exempel på detta är C-projekt som består av källkodsfiler i .c tillägg och mjukvarugränssnitt i .h-tillägg. Varje källfil sammanställs tillsammans med rubrikfilerna för att skapa. o objekt länkade ihop med hjälp av bibliotek, vilket skapar körbara filer.
För att utföra denna process använder programvaruutvecklare verktyg som Make för att automatisera byggprocessen och nödvändiga filberoende. Make använder Makefiles för att hantera sammanställningsprocessen.
GNU Make-verktygen tillhandahåller en uppsättning regler och konventioner som används för att skapa Makefiles och minska komplexiteten för att förbättra effektiviteten.
I denna handledning diskuterar vi specifikt Linux Kernel Makefiles Kconfig och Kbuild.
Innan vi börjar är det bra att notera att den här artikeln inte låtsas lära allt om Kernel Build-systemet. Vi ger dock en högnivåöversikt över hur man bygger en vmlinux-avbildning och moduler.
Om du vill ha information utanför ramen för denna handledning rekommenderar vi följande resurs för bättre information:
https: // linkfy.till / goMakefilesDocs
https: // linkfy.till / gnuMake
Kernel Makefiles: En översikt
Kernel Build-systemet, även kallat konfigurationssystemet, är ett viktigt verktyg - för dem som behöver det - som har funnits ett tag. Men inte alla kommer att använda detta system; även drivrutiner och andra programutvecklare på låg nivå använder det sällan. Eftersom du läser detta betyder det att du vill veta mer om Kernel Build System.
Således kommer vi att diskutera hur Kärnan sammanställs och diskutera Kbuild och Kconfig-systemet så att du kan förstå dem bättre.
Kernel Makefile har fem kärnkomponenter:
- Makefile: Det här är den översta märkesfilen som finns i källroten.
- arch / $ (ARCH) Makefile: Detta är bågen Makefile; det fungerar som ett komplement till den bästa Makefile.
- .konfigurera: Detta är Kernel-konfigurationsfilen.
- Skript / Makefile.*: Detta definierar fastställda regler för alla kbuild Makefiles.
- Kbuild Makefiles: Det finns cirka 500 kbuild Makefiles, och de är inte så lätta att läsa. Tänk på en fil som:
https: // elixir.bootlin.com / linux / senaste / källa / skript / Kbuild.omfatta
Kconfig
Kconfig-filen innehåller moduler som hjälper till när du använder make * config. Det hjälper kärnan att göra selektiva konfigurationer, vilket skapar modularitet och anpassningsbarhet för Kernel-byggprocessen.
Det finns olika konfigurationsmål som anges av Kconfig-systemet. Du kan använda hjälp för att visa tillgängliga mål. Dessa mål bearbetas av olika program som tillhandahålls av kärnan under byggprocessen.
Några av Kconfigs mål inkluderar:
- Konfigurera: Detta används för att uppdatera kärnkonfigurationsfilen med hjälp av linjeprogrammet.
- Menukonfiguration: Detta är en Kconfig-funktion eller -mekanism som erbjuder menybaserad åtkomst till Kernel-alternativ. För att starta menuconfig och andra Kconfig-funktioner bör du vara inne i plattformens projektkatalog. Du kan använda följande för att starta funktionen Kconfig menuconfig. Du kan dock också starta menuconfig med andra GUI Linux Kernel-konfigurationsfunktioner som xconfig och gconfig. gör linux-windriver.menuconfig - Kör menuconfig i en separat terminalsession.
- gconfig och xconfig: Gconfig aktiverar GUI-baserade Linux Kernel-funktioner. Gconfig använder det GTK- eller (X-baserade) gränssnittet. Å andra sidan använder Xconfig Qt-baserat gränssnitt. Använd följande kommandon för att starta gconfig respektive xconfig:
gör linux-windriver.xconfig
NOTERA: För att använda gconfig och xconfig bör du ha QT-utvecklingsverktygen installerade på värdsystemet.
- Nconfig: Nconfig-funktionen kör den nuvarande konfigurationen (Buildtools) och gäller för det Ncurses menystyrda programmet. Detta låter dig välja paket som ska byggas, till exempel CPU, drivrutiner och filsystem när du bygger kärnan. Använd kommandot: gör nconfig.
- Oldconfig: Med oldconfig-funktionen kan du använda nyare .konfigurationsfiler till äldre konfigurationsfiler för kärnan. Till exempel en gammal .konfigurationsfil och en nyare .konfigurationsfilen (nyare kärnversion) kommer att ha skillnader, vilket innebär att du måste uppdatera den aktuella konfigurationen innan kärnan byggs. Du kan använda make oldconfig för att uppdatera den gamla konfigurationen interaktivt genom att använda alternativ som saknas i den gamla konfigurationsfilen.
- Defconfig: Den här funktionen gör det möjligt för kernel build-systemet att lägga till en ny konfiguration från defconfig till .konfigurationsfil. Mer exakt kontrollerar Kbuild-systemet alla Kconfig-filer. Om defconfig anger ett alternativ i filen använder Kbuild-systemet det angivna värdet för att lägga till alternativet i .konfigurera. Om defconfig inte nämner alternativet använder Kbuild standardvärden i .konfigurera.
Tänk på följande:
Defconfig-kod ögonblicksbild från följande resurs:
https: // elixir.bootlin.com / linux / v5.9 / source / scripts / kconfig / Makefile # L98
1. defconfig: $ (obj) / conf2. ifneq ($ (jokertecken $ (srctree) / arch / $ (SRCARCH) / configs / $ (KBUILD_DEFCONFIG)),)
3. @ $ (kecho) "*** Standardkonfiguration baseras på '$ (KBUILD_DEFCONFIG)'"
4. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. annan
6. @ $ (kecho) "*** Standardkonfigurationen baseras på målet '$ (KBUILD_DEFCONFIG)'"
7. $ (Q) $ (MAKE) -f $ (srctree) / Makefile $ (KBUILD_DEFCONFIG)
8. endif
9.
10. % _defconfig: $ (obj) / conf
11. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
13. configfiles = $ (jokertecken $ (srctree) / kernel / configs / $ @ $ (srctree) / arch / $ (SRCARCH) / configs / $ @)
14.
15. %.config: $ (obj) / conf
16. $ (om $ (call configfiles) ,, $ (fel Det finns ingen konfiguration för detta mål i den här arkitekturen))
17. $ (Q) $ (CONFIG_SHELL) $ (srctree) / skript / kconfig / merge_config.sh -m .config $ (configfiles)
18. $ (Q) $ (MAKE) -f $ (srctree) / Makefile olddefconfig
Oldconfig kod ögonblicksbild från följande resurs:
https: // elixir.bootlin.com / linux / v5.9 / källa / skript / kconfig / conf.c # L694
1. fall olddefconfig:2. standard:
3. ha sönder;
4.
5.
6. om (input_mode == sparadefconfig)
7. om (conf_write_defconfig (defconfig_file))
8. fprintf (stderr, "n *** Fel när defconfig sparades till:% s \ n \ n",
9. defconfig_file);
10. retur 1;
11.
12. annat om (input_mode != listnewconfig && input_mode != helpnewconfig)
13. om (!no_conf_write && conf_write (NULL))
14. fprintf (stderr, "\ n *** Fel vid skrivning av konfigurationen.\ n \ n ");
15. utgång (1);
16.
17.
18. / *
19. * Skapa auto.conf om det inte finns.
20. * Detta förhindrar GNU Make 4.1 eller äldre från att släppa ut
21. * "include / config / auto.conf: Ingen sådan fil eller katalog "
22. * i Makefile på toppnivå
23. *
24. * syncconfig skapar eller uppdaterar alltid automatiskt.conf eftersom det är
25. * används under byggnaden.
26. * /
27. om (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "\ n *** Fel under konfigurationen.\ n \ n ");
30. retur 1;
31.
32.
33. returnera 0;
34.
- Savedefconfig: Denna regel sparar strömmen .konfigurera i form av ./ defconfig, som betraktas som en minimal konfigurationsfil. Använd kommandot: gör sparadefconfig
- Listnewconfig: Detta används för att lista nya alternativ.
- Kvmconfig: Detta möjliggör alternativ för KVM-stöd. Använd kommandot: gör kvm_guest.konfigurera
- Allyesconfig: Detta bygger en ny kärnkonfigurationsfil med alla alternativ inställda på ja. Det är motsatsen till allnoconfig.
- Allmodconfig: Detta bygger en ny kärnkonfiguration med vilka moduler är aktiverade som standard.
- Randconfig: Detta bygger en ny kärnkonfigfil med slumpmässiga svar på alla alternativ.
- Tinyconfig: Detta gör den minsta kärnan möjlig.
Det finns många mål i Kconfig-systemet. Några vanliga inkluderar config och menuconfig.
Som nämnts bearbetas målen av olika program i värdsystemen, antingen som en GUI eller en kommandorad. Du hittar Kconfig-verktyg i / scripts / Kconfig i kärnkällan.
https: // elixir.bootlin.com / linux / senaste / källa / skript / kconfig
https: // elixir.bootlin.com / linux / senaste / källa / skript / kconfig / Makefile
Den första processen är vanligtvis att läsa Kconfig-filen i rotkatalogen, som används för att bygga en initial konfigurationsdatabas. När processen fortsätter uppdateras databasen när du läser filer i följande ordning:
.konfigurera/ lib / modules / $ (shell, uname-r) /.konfigurera
/ etc / kernel-config
/ boot / config - $ (shell, uname-r)
ARCH_DEFCONFIG
arch / $ (ARCH) / defconfig
.config-filen släpps sedan till syncconfig, vilket accepterar .konfigurationsfil som inmatning. Den behandlar filen och matar ut filer, som sedan klassificeras i olika kategorier som:
- autokonf.h: Detta används för C-språkkällfiler.
- bil.conf och tristate.conf: Dessa används för Makefile-textbehandling.
- / inkluderar / konfigurerar: Dessa är tomma rubrikfiler som används i beroendesspårning.
Kbuild Files
Nästan alla Kernel-filer är Kbuild Makefiles som använder Kbuild-infrastrukturen, vilket är en rekursiv make-funktion. Rekursivt Make är ett sätt att använda verktyget Make som ett kommando i en Makefile. Rekursion är mycket användbart när man sammanställer ett stort projekt.
Kbuild fungerar genom att hänvisa till alla filer som vi nämnde i ovanstående avsnitt.
Kbuild-systemet bygger sina komponenter med den översta Makefile som innehåller arch Makefiles med namnet arch / $ (ARCH) / Makefile i konfigurationsfilerna. Det faller rekursivt ner i underkataloger som anropar Make på komponenterna med hjälp av rutinerna i skript / Makefile.*. Kbuild bygger sedan på det intilliggande objektet och länkar dem till objekt och skapar vmlinux.
Mer information om syntaxen som används i Kbuild Makefiles finns i dokumentationen.
Tänk på följande manus.
https: // github.com / torvalds / linux / blob / master / scripts / link-vmlinux.sh
O-objektfilerna som används för att skapa vmlinux sammanställs först i respektive inbyggda .a filer som var KBUILD_VMLINUX_INIT, MAIN, LIBS. Dessa är sammansatta i vmlinux.
https: // github.com / torvalds / linux / blob / master / scripts / Makefile.bygga
Slutsats
I den här guiden tittade vi på Kbuild- och Kconfig-system i Kernel-byggsystemet och hur det fungerar. Som vi nämnde i början av handledningen är de diskuterade ämnena breda och kan inte behandlas i en enda handledning.
