Linux Kernel Makefile forklarte

For å administrere og redusere denne kompleksiteten, organiserer programvareutviklere kode i små filer som lenker til spesifikke moduler. Utviklere kan kompilere hver av disse filene separat og deretter koble dem sammen for å lage en endelig programvare som kjøres.

Et eksempel på dette er C -prosjekter som består av kildekodefiler i .C -utvidelser og programvaregrensesnitt i .H -utvidelser. Hver kildefil blir samlet sammen med overskriftsfilene for å opprette. o Objekter koblet sammen ved hjelp av biblioteker, og oppretter dermed kjørbare filer.

For å utføre denne prosessen bruker programvareutviklere verktøy, for eksempel å lage, for å automatisere byggeprosessen og nødvendige filavhengigheter. Bruk bruksmakefiler for å håndtere oppførselen til kompilasjonsprosessen.

GNU lager verktøy gir et sett med regler og konvensjoner som brukes til å lage makefiler og redusere kompleksiteten i å forbedre effektiviteten.

I denne opplæringen vil vi diskutere Linux -kjernen Makefiles, spesielt Kconfig og Kbuild.

Før vi begynner, er det godt å merke seg at denne artikkelen ikke later som om de lærer alt om kjernebyggingssystemet. Vi gir imidlertid en oversikt på høyt nivå av å bygge et VMLinux-bilde og moduler.

Hvis du vil ha informasjon utover omfanget av denne opplæringen, anbefaler vi følgende ressurs for bedre informasjon:

https: // linkfy.til/gomakefilesdocs

https: // linkfy.til/gnumake

Kernel Makefiles: En oversikt

Kernelbyggesystemet, også kalt konfigurasjonssystemet, er et essensielt verktøy for de som trenger det-som har eksistert en stund. Imidlertid vil ikke alle bruke dette systemet; Selv sjåfører og andre programvareutviklere på lavt nivå bruker det sjelden. Siden du leser dette, betyr det at du vil vite mer om kjernebyggingssystemet.

Dermed vil vi diskutere hvordan kjernen blir samlet og diskutere Kbuild og Kconfig -systemet, slik at du kan forstå dem bedre.

Kjernen Makefile har fem kjernekomponenter:

1. Makefile: Dette er den øverste filen som ligger i kildroten.
2. Arch/$ (Arch) Makefile: Dette er Arch Makefile; det fungerer som et supplement til topp makefil.
3. .konfigurasjon: Dette er kjernemonfigurasjonsfilen.
4. Skript/makefile.*: Dette definerer SET -regler for alle KBuild Makefiles.
5. Kbuild Makefiles: Det er omtrent 500 kbuild makefiles, og de er ikke veldig lette å lese. Vurder en fil som:

https: // elixir.bootlin.com/linux/siste/kilde/skript/kbuild.inkludere

Kconfig

Kconfig -filen inneholder moduler som hjelper deg når du bruker Make *-konfigurasjonen. Det hjelper kjernen med å lage selektive konfigurasjoner, skape modularitet og tilpassbarhet for kjernebyggingsprosessen.

Det er forskjellige konfigurasjonsmål spesifisert av Kconfig -systemet. Du kan bruke Make Help til å se de tilgjengelige målene. Disse målene behandles av forskjellige programmer levert av kjernen under byggeprosessen.

Noen av Kconfig -målene inkluderer:

• Konfigurasjon: Dette brukes til å oppdatere Kernel Config -filen ved hjelp av linjeprogrammet.
• Menuconfig: Dette er en Kconfig-funksjon eller mekanisme som tilbyr menybasert tilgang til kjernealternativer. For å lansere Menuconfig og andre Kconfig -funksjoner, bør du være inne i plattformprosjektkatalogen. Du kan bruke følgende til å starte Kconfig Menuconfig -funksjonen. Imidlertid kan du også lansere Menuconfig med andre GUI Linux Kernel Config -funksjoner som Xconfig og Gconfig.

Lag Linux-Windriver.Menuconfig - Utfører Menuconfig i en egen terminaløkt.

• gconfig og xconfig: Gconfig aktiverer GUI-baserte Linux-kjernefunksjoner. Gconfig bruker GTK eller (X -basert) basert brukergrensesnitt. På den annen side bruker Xconfig QT-basert brukergrensesnitt. Bruk følgende kommandoer for å starte henholdsvis GCONFIG og XCONFIG:

Lag Linux-Windriver.gconfig
Lag Linux-Windriver.xconfig

MERK: For å bruke Gconfig og Xconfig, bør du ha QT -utviklingsverktøyene installert på vertssystemet.

• Nconfig: Nconfig-funksjonen kjører gjeldende konfigurasjon (buildtools) og søker for NCurses-meny-drevet program. Dette lar deg velge pakker du vil bygge, for eksempel CPU, drivere og filsystem når du bygger kjernen. Bruk kommandoen: Lag Nconfig.
• OldConfig: OldConfig -funksjonen lar deg bruke nyere .Konfigurer filer til eldre kjernekonfigurasjonsfiler. For eksempel en gammel .konfigurasjonsfil og en nyere .Konfigurasjonsfil (nyere kjerneversjon) vil ha forskjeller, noe som betyr at du må oppdatere den gjeldende konfigurasjonen før kjernen Build. Du kan bruke Make OldConfig for å oppdatere den gamle konfigurasjonen interaktivt ved å bruke alternativer som mangler i den gamle konfigurasjonsfilen.
• Defconfig: Denne funksjonen lar kjernebyggingssystemet legge til en ny konfigurasjon levert av DefConfig til .konfigurasjonsfil. Mer presist sjekker Kbuild -systemet alle Kconfig -filene. Hvis DefConfig spesifiserer et alternativ i filen, bruker KBUild -systemet den spesifiserte verdien for å legge til alternativet til .konfigurasjon. Hvis defconfig ikke nevner alternativet, bruker Kbuild standardverdier i .konfigurasjon.

Vurder følgende:

DefConfig Code Snapshot fra følgende ressurs:

https: // elixir.bootlin.com/linux/v5.9/Source/Scripts/Kconfig/Makefile#L98

1. defconfig: $ (obj)/conf
2. IFNEQ ($ (Wildcard $ (SRCTree)/Arch/$ (Srcarch)/Configs/$ (KBUILD_DEFCONFIG)),),),),)
3. @$ (Kecho) "*** Standardkonfigurasjon er basert på '$ (kbuild_defconfig)'"
4. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. ellers
6. @$ (Kecho) "*** Standardkonfigurasjon er basert på Target '$ (kbuild_defconfig)'"
7. $ (Q) $ (make) -f $ (srctree)/makefile $ (kbuild_defconfig)
8. slutt om
9.
10. %_defconfig: $ (obj)/conf
11. $ (Q) $< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
12.
1. 3. ConfigFiles = $ (Wildcard $ (SRCTree)/Kernel/Configs/$@ $ (SRCTree)/Arch/$ (SRCARCH)/Configs/$@)
14.
15. %.Config: $ (OBJ)/Conf
16. $ (hvis $ (Call ConfigFiles) ,, $ (Feil ingen konfigurasjon eksisterer for dette målet på denne arkitekturen))
17. $ (Q) $ (config_shell) $ (srctree)/scripts/kconfig/merge_config.sh -m .Config $ (ConfigFiles)
18. $ (Q) $ (make) -f $ (srctree)/makefile olddefconfig

OldConfig Code Snapshot fra følgende ressurs:

https: // elixir.bootlin.com/linux/v5.9/Source/Scripts/Kconfig/Conf.C#L694

1. case olddefconfig:
2. misligholde:
3. gå i stykker;
4.
5.
6. if (input_mode == SAVEDEFCONFIG)
7. if (conf_write_defconfig (defconfig_file))
8. fprintf (stderr, "n *** feil mens du lagrer defconfig til: %s \ n \ n",
9. defconfig_file);
10. retur 1;
11.
12. annet hvis (input_mode != listNewConfig && input_mode != helpNewConfig)
1. 3. hvis (!no_conf_write && conf_write (null))
14. fprintf (stderr, "\ n *** feil under skriving av konfigurasjonen.\ n \ n ");
15. Avslutt (1);
16.
17.
18. /*
19. * Lag auto.Conf hvis den ikke eksisterer.
20. * Dette forhindrer at GNU gjør 4.1 eller eldre fra å sende ut
21. * "Inkluder/konfigurasjon/auto.Conf: Ingen slik fil eller katalog "
22. * I toppnivå makefil
23. *
24. * SyncConfig oppretter alltid eller oppdateringer Auto.Konf fordi det er
25. * brukt under byggingen.
26. */
27. if (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "\ n *** feil under synkronisering av konfigurasjonen.\ n \ n ");
30. retur 1;
31.
32.
33. retur 0;
34.

• SAVEDEFCONFIG: Denne regelen lagrer strømmen .konfigurere i form av ./defconfig, som blir sett på som en minimal konfigurasjonsfil. Bruk kommandoen: Lag SavedefConfig
• ListNewConfig: Dette brukes til å liste opp nye alternativer.
• KVMconfig: Dette muliggjør alternativer for KVM -støtte. Bruk kommandoen: lage kvm_guest.konfigurasjon
• Allyesconfig: Dette bygger en ny kjernekonfigurasjonsfil med alle alternativer satt til ja. Det er det motsatte av allnoconfig.
• Allmodconfig: Dette bygger en ny kjernekonfigurasjon som moduler er aktivert som standard.
• Randconfig: Dette bygger en ny kjernekonfigurasjonsfil med tilfeldige svar på alle alternativer.
• Tinyconfig: Dette gjør den minste kjernen mulig.

Det er mange mål i Kconfig -systemet. Noen vanlige inkluderer Config og Menuconfig.

Som nevnt blir målene behandlet av forskjellige programmer i vertssystemene, enten gir en GUI eller kommandolinje. Du kan finne Kconfig -verktøy i /skript /kconfig i kjernekilden.

https: // elixir.bootlin.com/linux/siste/kilde/skript/kconfig

https: // elixir.bootlin.com/linux/siste/kilde/skript/kconfig/makefile

Den første prosessen er vanligvis å lese kconfig -filen i rotkatalogen, som brukes til å bygge en innledende konfigurasjonsdatabase. Når prosessen fortsetter, oppdateres databasen når du leser filer i følgende rekkefølge:

.konfigurasjon
/lib/modules/$ (shell, uname-r)/.konfigurasjon
/etc/kjernekonfigurasjon
/boot/config-$ (shell, uname-r)
Arch_defconfig
Arch/$ (Arch)/DefConfig

.konfigurasjonsfilen blir deretter droppet til SyncConfig, som godtar .konfigurasjonsfil som input. Den behandler fil- og utdanningsfilene, som deretter klassifiseres i forskjellige kategorier som:

• AutoConf.h: Dette brukes til C -språkkildefiler.
• bil.konf og tristat.konf: Disse brukes til makefile tekstbehandling.
• /Inkluderer/konfigurasjon: Dette er tomme overskriftsfiler som brukes i avhengighetssporing.

Kbuild filer

Nesten alle kjernefiler er kbuild makefiles som bruker Kbuild -infrastrukturen, som er en rekursiv Make -funksjon. Rekursivt er en måte å bruke Make Tool som en kommando i en makefil. Rekursjon er veldig nyttig når du sammenstiller et stort prosjekt.

Kbuild fungerer ved å referere til alle filene vi nevnte i delen ovenfor.

Kbuild -systemet bygger sine komponenter ved å bruke den øverste makefilen som inkluderer Arch Makefiles med navnet Arch/$ (Arch)/Makefile i konfigurasjonsfilene. Den kommer rekursivt ned i underkataloger som påkaller på komponentene ved å bruke rutinene i skript/makefil.*. Kbuild bygger deretter på det tilstøtende objektet og kobler dem til objekter, og lager VMLinux.

For å lære mer om syntaksen som brukes i kbuild makefiles, se dokumentasjonen.

Tenk på følgende skript.

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

O-objektfilene som brukes til å opprette VMLinux er først sammenstilt i deres respektive innebygde .a filer som var kbuild_vmlinux_init, main, libs. Disse er sammensatt i Vmlinux.

https: // github.com/torvalds/linux/blob/master/manus/makefile.bygge

Konklusjon

I denne guiden tok vi en titt på Kbuild og Kconfig -systemer i Kernel Build -systemet og hvordan det fungerer. Som vi nevnte i begynnelsen av opplæringen, er temaene som diskuteres brede og kan ikke dekkes i en enkelt tutorial.