Linux-Kernel-Makefile erklärt

In der Softwareentwicklung kann der Prozess der Erstellung und Verwaltung großer Code-Repositorys sehr komplex werden.

Um diese Komplexität zu bewältigen und zu reduzieren, organisieren Softwareentwickler Code in kleinen Dateien, die mit bestimmten Modulen verknüpft sind. Entwickler können jede dieser Dateien separat kompilieren und sie dann miteinander verknüpfen, um eine endgültige ausführbare Software zu erstellen.

Ein Beispiel hierfür sind C-Projekte, die aus Quellcodedateien in .c Erweiterungen und Softwareschnittstellen in .h Erweiterungen. Jede Quelldatei wird zusammen mit den zu erstellenden Header-Dateien kompiliert. o Objekte, die über Bibliotheken miteinander verknüpft sind, wodurch ausführbare Dateien erstellt werden.

Um diesen Prozess durchzuführen, verwenden Softwareentwickler Tools wie Make, um den Build-Prozess und die erforderlichen Dateiabhängigkeiten zu automatisieren. Make verwendet Makefiles, um das Verhalten des Kompilierungsvorgangs zu verwalten.

Die GNU Make-Tools bieten eine Reihe von Regeln und Konventionen, die verwendet werden, um Makefiles zu erstellen und die Komplexität bei der Verbesserung der Effizienz zu reduzieren.

In diesem Tutorial werden wir insbesondere die Linux-Kernel-Makefiles besprechen Kconfig und Kbuild.

Bevor wir beginnen, ist es gut anzumerken, dass dieser Artikel nicht vorgibt, alles über das Kernel-Build-System zu lehren. Wir bieten jedoch einen allgemeinen Überblick über das Erstellen eines vmlinux-Images und -Module.

Wenn Sie Informationen benötigen, die über den Rahmen dieses Tutorials hinausgehen, empfehlen wir die folgende Ressource, um bessere Informationen zu erhalten:

https://linkfy.to/goMakefilesDocs

https://linkfy.zu/gnuMake

Kernel-Makefiles: Ein Überblick

Das Kernel-Build-System, auch Config-System genannt, ist ein unverzichtbares Werkzeug - für diejenigen, die es brauchen -, die es schon seit einiger Zeit gibt. Allerdings wird nicht jeder dieses System verwenden; selbst Treiber und andere Low-Level-Softwareentwickler verwenden es selten. Da Sie dies lesen, möchten Sie mehr über das Kernel-Build-System erfahren.

Daher werden wir besprechen, wie der Kernel kompiliert wird und das Kbuild- und Kconfig-System besprechen, damit Sie sie besser verstehen können.

Das Kernel Makefile hat fünf Kernkomponenten:

1. Makefile: Dies ist die oberste Make-Datei im Quell-Root.
2. arch/$(ARCH) Makefile: Dies ist das Arch-Makefile; es dient als Ergänzung zum Top Makefile.
3. .Konfiguration: Dies ist die Kernel-Konfigurationsdatei.
4. Skripte/Makefile.*: Dies definiert festgelegte Regeln für alle kbuild Makefiles.
5. Kbuild-Makefiles: Es gibt ungefähr 500 kbuild Makefiles, und sie sind nicht sehr einfach zu lesen. Betrachten Sie eine Datei wie:

https://elixier.Bootline.com/linux/latest/source/scripts/Kbuild.einschließen

Kconfig

Die Datei Kconfig enthält Module, die bei der Verwendung von make *config . helfen. Es hilft dem Kernel, selektive Konfigurationen vorzunehmen, wodurch Modularität und Anpassbarkeit für den Kernel-Build-Prozess geschaffen werden.

Es gibt verschiedene Konfigurationsziele, die vom Kconfig-System angegeben werden. Sie können die Make-Hilfe verwenden, um die verfügbaren Ziele anzuzeigen. Diese Ziele werden während des Build-Prozesses von verschiedenen Programmen verarbeitet, die vom Kernel bereitgestellt werden.

Einige der Kconfig-Ziele umfassen:

• Konfiguration: Dies wird verwendet, um die Kernel-Konfigurationsdatei mit dem Zeilenprogramm zu aktualisieren.
• Menükonfiguration: Dies ist eine Kconfig-Funktion oder ein Mechanismus, der menübasierten Zugriff auf Kernel-Optionen bietet. Um menuconfig und andere Kconfig-Funktionen zu starten, sollten Sie sich im Plattform-Projektverzeichnis befinden. Sie können Folgendes verwenden, um die Funktion Kconfig menuconfig zu starten. Sie können menuconfig jedoch auch mit anderen GUI-Linux-Kernel-Konfigurationsfunktionen wie xconfig und gconfig starten.
linux-windriver machen.menuconfig - Führt menuconfig in einer separaten Terminalsitzung aus.
• gconfig und xconfig: Gconfig aktiviert GUI-basierte Linux-Kernel-Funktionen. Gconfig verwendet die GTK- oder (X-basierte) basierte Benutzeroberfläche. Auf der anderen Seite verwendet Xconfig eine Qt-basierte Benutzeroberfläche. Verwenden Sie die folgenden Befehle, um gconfig bzw. xconfig zu starten:

linux-windriver machen.gconfig
linux-windriver machen.xconfig

HINWEIS: Um gconfig und xconfig zu verwenden, sollten die QT-Entwicklungstools auf dem Hostsystem installiert sein.

• Nconfig: Die Nconfig-Funktion führt die aktuelle Konfiguration (Buildtools) aus und gilt für das menügesteuerte Ncurses-Programm. Auf diese Weise können Sie beim Erstellen des Kernels die zu erstellenden Pakete auswählen, z. B. CPU, Treiber und Dateisystem. Verwenden Sie den Befehl: make nconfig.
• Alte Konfig: Mit der Funktion oldconfig können Sie neuere anwenden .config-Dateien zu älteren Kernel-Konfigurationsdateien. Zum Beispiel ein alter .config-Datei und eine neuere .config-Datei (neuere Kernel-Version) weist Unterschiede auf, was bedeutet, dass Sie die aktuelle Konfiguration vor dem Kernel-Build aktualisieren müssen. Sie können make oldconfig verwenden, um die alte Konfiguration interaktiv zu aktualisieren, indem Sie Optionen anwenden, die in der alten Konfigurationsdatei fehlen.
• Standardkonfiguration: Diese Funktion ermöglicht es dem Kernel-Build-System, eine neue Konfiguration hinzuzufügen, die von defconfig bereitgestellt wird .Konfigurationsdatei. Genauer gesagt überprüft das Kbuild-System alle Kconfig-Dateien. Wenn defconfig eine Option in der Datei angibt, verwendet das Kbuild-System den angegebenen Wert, um die Option zu der Datei hinzuzufügen .Konfiguration. Wenn die defconfig die Option nicht erwähnt, verwendet Kbuild Standardwerte in der .Konfiguration.

Folgendes berücksichtigen:

Defconfig-Code-Snapshot aus der folgenden Ressource:

https://elixier.Bootline.com/linux/v5.9/source/scripts/kconfig/Makefile#L98

1. defconfig: $(obj)/conf
2. ifneq ($(Platzhalter $(srctree)/arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG)),)
3. @$(kecho) "*** Die Standardkonfiguration basiert auf '$(KBUILD_DEFCONFIG)'"
4. $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
5. sonst
6. @$(kecho) "*** Die Standardkonfiguration basiert auf dem Ziel '$(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=$(Platzhalter $(srctree)/kernel/configs/$@ $(srctree)/arch/$(SRCARCH)/configs/$@)
14.
fünfzehn. %.config: $(obj)/conf
16. $(if $(call configfiles),, $(error Keine Konfiguration für dieses Ziel auf dieser Architektur vorhanden))
17. $(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sch -m .config $(Konfigurationsdateien)
18. $(Q)$(MAKE) -f $(srctree)/Makefile olddefconfig

Oldconfig-Code-Snapshot aus der folgenden Ressource:

https://elixier.Bootline.com/linux/v5.9/source/scripts/kconfig/conf.c#L694

1. Fall olddefconfig:
2. Standard:
3. Unterbrechung;
4.
5.
6. if (input_mode == savedefconfig)
7. if (conf_write_defconfig(defconfig_file))
8. fprintf(stderr, "n*** Fehler beim Speichern von defconfig in: %s\n\n",
9. defconfig_datei);
10. 1 zurückgeben;
11.
12. else if (input_mode != listnewconfig && input_mode != helpnewconfig)
13. wenn (!no_conf_write && conf_write(NULL))
14. fprintf(stderr, "\n*** Fehler beim Schreiben der Konfiguration.\n\n");
fünfzehn. Ausgang(1);
16.
17.
18. /*
19. * Auto erstellen.conf, wenn sie nicht existiert.
20. * Dies verhindert GNU Make 4.1 oder älter vom Emittieren
21. * "include/config/auto.conf: Keine solche Datei oder kein Verzeichnis"
22. * im Makefile der obersten Ebene
23. *
24. * syncconfig erstellt oder aktualisiert immer automatisch.conf weil es so ist
25. * während des Builds verwendet.
26. */
27. if (conf_write_autoconf(sync_kconfig) && sync_kconfig)
28. fprintf(stderr,
29. "\n*** Fehler beim Synchronisieren der Konfiguration.\n\n");
30. 1 zurückgeben;
31.
32.
33. 0 zurückgeben;
34.

• Savedefconfig: Diese Regel speichert den Strom .config in Form von ./defconfig, die als minimale Konfigurationsdatei angesehen wird. Verwenden Sie den Befehl: make savedefconfig
• ListeneueKonfiguration: Dies wird verwendet, um neue Optionen aufzulisten.
• Kvmconfig: Dadurch werden Optionen für die KVM-Unterstützung aktiviert. Verwenden Sie den Befehl: make kvm_guest.Konfiguration
• Allyesconfig: Dadurch wird eine neue Kernel-Konfigurationsdatei erstellt, in der alle Optionen auf yes gesetzt sind. Es ist das Gegenteil von allnoconfig.
• Allmodconfig: Dadurch wird eine neue Kernel-Konfiguration erstellt, mit der Module standardmäßig aktiviert sind.
• Randconfig: Dadurch wird eine neue Kernel-Konfigurationsdatei mit zufälligen Antworten auf alle Optionen erstellt.
• Tinyconfig: Das macht den kleinsten Kernel möglich.

Es gibt viele Ziele im Kconfig-System. Einige gängige sind config und menuconfig.

Wie bereits erwähnt, werden die Targets von verschiedenen Programmen in den Hostsystemen verarbeitet, die entweder eine GUI oder eine Befehlszeile bereitstellen. Sie finden die Kconfig-Tools in /scripts/Kconfig in der Kernel-Quelle.

https://elixier.Bootline.com/linux/latest/source/scripts/kconfig

https://elixier.Bootline.com/linux/latest/source/scripts/kconfig/Makefile

Der erste Vorgang besteht normalerweise darin, die Kconfig-Datei im Stammverzeichnis zu lesen, die zum Erstellen einer anfänglichen Konfigurationsdatenbank verwendet wird. Im weiteren Verlauf des Prozesses wird die Datenbank beim Lesen von Dateien in der folgenden Reihenfolge aktualisiert:

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

.config-Datei wird dann in syncconfig abgelegt, das die .Konfigurationsdatei als Eingabe as. Es verarbeitet die Datei und gibt Dateien aus, die dann in verschiedene Kategorien eingeteilt werden, wie zum Beispiel:

• autoconf.h: Dies wird für C-Quelldateien verwendet.
• Auto.conf und tristate.conf: Diese werden für die Makefile-Textverarbeitung verwendet.
• /includes/config: Dies sind leere Header-Dateien, die beim Abhängigkeits-Tracking verwendet werden.

Kbuild-Dateien

Fast alle Kernel-Dateien sind Kbuild-Makefiles, die die Kbuild-Infrastruktur verwenden, eine rekursive Make-Funktion. Rekursives Make ist eine Möglichkeit, das Make-Tool als Befehl in einem Makefile zu verwenden. Rekursion ist sehr nützlich, wenn Sie ein großes Projekt kompilieren.

Kbuild funktioniert, indem es auf alle Dateien verweist, die wir im obigen Abschnitt erwähnt haben.

Das Kbuild-System erstellt seine Komponenten mit dem obersten Makefile, das die arch-Makefiles mit dem Namen arch/$(ARCH)/Makefile in den Konfigurationsdateien enthält. Es steigt rekursiv in Unterverzeichnisse ab und ruft Make auf den Komponenten mit den Routinen in scripts/Makefile.*. Kbuild baut dann auf dem angrenzenden Objekt auf und verknüpft sie zu Objekten, wodurch vmlinux entsteht.

Weitere Informationen zur Syntax von Kbuild Makefiles finden Sie in der Dokumentation.

Betrachten Sie das folgende Skript.

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

Die o-Objektdateien, die zum Erstellen des vmlinux verwendet werden, werden zuerst in ihren jeweiligen integrierten . kompiliert .a-Dateien als var KBUILD_VMLINUX_INIT,MAIN,LIBS. Diese sind in vmlinux komponiert.

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

Fazit

In diesem Handbuch haben wir uns Kbuild- und Kconfig-Systeme im Kernel-Build-System und ihre Funktionsweise angeschaut. Wie zu Beginn des Tutorials erwähnt, sind die behandelten Themen breit gefächert und können nicht in einem einzigen Tutorial behandelt werden.