Linux -Kernel Makefile erklärte

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

Ein Beispiel hierfür sind C -Projekte aus Quellcode -Dateien in .c Erweiterungen und Software -Schnittstellen in .H Erweiterungen. Jede Quelldatei wird zusammen mit den zu erstellenden Header -Dateien zusammengestellt. o mit Bibliotheken verknüpfte Objekte, die miteinander verbunden sind, um ausführbare Dateien zu erstellen.

Um diesen Prozess auszuführen, verwenden Softwareentwickler Tools, z. B. machen, um den Erstellungsprozess und die erforderlichen Dateiabhängigkeiten zu automatisieren. Make verwendet Makefiles, um das Verhalten des Kompilierungsprozesses zu verwalten.

Die GNU -Tools liefern eine Reihe von Regeln und Konventionen, die zur Erstellung von Makefiles und zur Verringerung der Komplexität bei der Verbesserung der Effizienz verwendet werden.

In diesem Tutorial werden wir speziell die Linux -Kernel -Makefiles besprechen Kconfig Und Kbuild.

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

Wenn Sie Informationen über den Umfang dieses Tutorials hinaus möchten, empfehlen wir die folgende Ressource, um bessere Informationen zu erhalten:

https: // linkfy.an/gomakefilesdocs

https: // linkfy.zu/gnumake

Kernel Makefiles: Ein Überblick

Das Kernel-Build-System, auch das Konfigurationssystem genannt, ist ein wesentliches Werkzeug für diejenigen, die es brauchen-das gibt es schon seit einiger Zeit. Allerdings wird nicht jeder dieses System verwenden. Sogar Fahrer und andere Softwareentwickler auf niedriger Ebene verwenden es selten. Da Sie dies lesen, möchten Sie mehr über das Kernel -Build -System erfahren.

Daher werden wir diskutieren, wie der Kernel zusammengestellt wird, und das KBUILD- und KCONFIG -System diskutieren, damit Sie sie besser verstehen können.

Das Kernel Makefile verfügt über fünf Kernkomponenten:

1. Makefile: Dies ist die obere Datei, die sich im Quellstamm befindet.
2. Arch/$ (Arch) Makefile: Dies ist der Erzmakefile; Es wirkt als Ergänzung zum oberen 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: // elixir.Bootlin.com/linux/letztes/source/scripts/kbuild.enthalten

Kconfig

Die KConfig -Datei enthält Module, die bei der Verwendung der Made *config helfen. Es hilft dem Kernel, selektive Konfigurationen zu erstellen und Modularität und Anpassbarkeit für den Kernel -Build -Prozess zu erzeugen.

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

Einige der KConfig -Ziele umfassen:

• Konfiguration: Dies wird verwendet, um die Kernel -Konfigurationsdatei mit dem Zeilenprogramm zu aktualisieren.
• Menukonfig: Dies ist eine KConfig-Funktion oder ein Mechanismus, der einen Menüzugriff auf Kerneloptionen bietet. Um Menuconfig und andere KConfig -Funktionen zu starten, sollten Sie sich im Plattformprojektverzeichnis befinden. Sie können Folgendes verwenden, um die KConfig -Menuconfig -Funktion zu starten. Sie können jedoch auch Menuconfig 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) UI -basierte UI. Auf der anderen Seite verwendet Xconfig die qt-basierte UI. Verwenden Sie die folgenden Befehle, um GCONfig bzw. XConfig zu starten:

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

NOTIZ: Um GConfig und Xconfig zu verwenden, sollten Sie die QT -Entwicklungstools auf dem Host -System installieren lassen.

• Nconfig: Die NCONFIG-Funktion führt die aktuelle Konfiguration (Buildtools) aus und gilt für das Menügesteuerte NCURSSE-Programm. Auf diese Weise können Sie die zu erstellenden Pakete auswählen, z. B. CPU, Treiber und Dateisystem beim Erstellen des Kernels. Verwenden Sie den Befehl: Machen Sie NConfig.
• OldConfig: Mit der OldConfig -Funktion können Sie neuer anwenden .Konfigurationsdateien zu älteren Kernel -Konfigurationsdateien. Zum Beispiel ein altes .Konfigurationsdatei und eine neuere .Die Konfigurationsdatei (neuere Kernelversion) hat Unterschiede, dh Sie müssen die aktuelle Konfiguration vor dem Kernel -Build aktualisieren. Sie können OldConfig verwenden, um die alte Konfiguration interaktiv zu aktualisieren, indem Optionen angewendet werden, die in der alten Konfigurationsdatei fehlen.
• Defconfig: Mit dieser Funktion kann das Kernel -Build -System eine neue Konfiguration hinzufügen, die von Defconfig zu dem geliefert 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 dem 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: // elixir.Bootlin.com/linux/v5.9/Quelle/Skripte/kconfig/makefile#l98

1. Defconfig: $ (obj)/conf
2. IFNEQ ($ (Wildcard $ (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. anders
6. @$ (Kecho) "*** Die Standardkonfiguration basiert auf 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 = $ (Wildcard $ (srctree)/kernel/configs/$@ $ (srctree)/arch/$ (srCarch)/configs/$@)
14.
15. %.Konfiguration: $ (obj)/conf
16. $ (wenn $ (call configfiles) ,, $ (Fehler Keine Konfiguration für dieses Ziel in dieser Architektur))))
17. $ (Q) $ (config_shell) $ (srctree)/scripts/kconfig/merge_config.Sh -m .config $ (configfiles)
18. $ (Q) $ (MAKE) -F $ (SRCTREE)/MAKEFILE olddefConfig

OldConfig Code Snapshot aus der folgenden Ressource:

https: // elixir.Bootlin.com/linux/v5.9/Quelle/Skripte/kconfig/conf.C#L694

1. Fall OldDefconfig:
2. Standard:
3. brechen;
4.
5.
6. if (input_mode == savedefconfig)
7. if (conf_write_defconfig (defonfig_file))
8. fprintf (stderr, "n *** Fehler beim Speichern von Defconfig in: %s \ n \ n",
9. defonfig_file);
10. Rückkehr 1;
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 ");
15. Ausgang (1);
16.
17.
18. /*
19. * Auto erstellen.conf, wenn es nicht existiert.
20. * Dies verhindert, dass GNU 4 macht.1 oder älter vom Emission
21. * "Include/config/auto.conf: Keine solche Datei oder Verzeichnis "
22. * Auf der oberen Ebene Makefile
23. *
24. * Syncconfig erstellt oder aktualisiert immer automatisch.conf weil es ist
25. * Während des Builds verwendet.
26. */
27. if (conf_write_autoconf (sync_kconfig) && sync_kconfig)
28. fprintf (stderr,
29. "\ n *** Fehler während der Synchronisierung der Konfiguration.\ n \ n ");
30. Rückkehr 1;
31.
32.
33. Rückkehr 0;
34.

• SavedefConfig: Diese Regel spart den Strom .Konfiguration in Form von ./defonfig, das als minimale Konfigurationsdatei angesehen wird. Verwenden Sie den Befehl: Machen Sie SavedefConfig
• Listnewconfig: Dies wird verwendet, um neue Optionen aufzulisten.
• Kvmconfig: Dies ermöglicht Optionen für den KVM -Support. Verwenden Sie den Befehl: Machen Sie kvm_guest.Konfiguration
• Allyesconfig: Dadurch erstellt eine neue Kernel -Konfigurationsdatei mit allen Optionen auf Ja ein. Es ist das Gegenteil von Allnoconfig.
• Allmodconfig: Dies erstellt eine neue Kernel -Konfiguration, mit der Module standardmäßig aktiviert sind.
• Randconfig: Dies erstellt eine neue Kernel -Konfigurationsdatei mit zufälligen Antworten auf alle Optionen.
• TinyConfig: Dies macht den kleinsten Kernel möglich.

Es gibt viele Ziele im KConfig -System. Einige gemeinsame umfassen Konfiguration und Menuconfig.

Wie bereits erwähnt, werden die Ziele von verschiedenen Programmen in den Host -Systemen verarbeitet, wobei entweder eine GUI oder eine Befehlszeile bereitgestellt werden. In der Kernelquelle finden Sie KConfig -Tools in /script /kconfig.

https: // elixir.Bootlin.com/linux/letztes/source/scripts/kconfig

https: // elixir.Bootlin.com/linux/letztes/script/scripts/kconfig/makefile

Der erste Vorgang besteht in der Regel zum Lesen der KConfig -Datei im Stammverzeichnis, mit dem eine anfängliche Konfigurationsdatenbank erstellt wird. Im Laufe des Prozesses wird die Datenbank aktualisiert, wenn Dateien in der folgenden Reihenfolge gelesen werden:

.Konfiguration
/lib/modules/$ (Shell, uname-r)//.Konfiguration
/etc/kernel-config
/boot/config-$ (Shell, Uname-R)
Arch_defconfig
Arch/$ (Arch)/Defconfig

.Die Konfigurationsdatei wird dann auf Syncconfig fallen gelassen, was die akzeptiert .Konfigurationsdatei als Eingabe. Es verarbeitet die Datei und gibt Dateien aus, die dann in verschiedene Kategorien eingeteilt werden, wie z. B.:

• Autoconf.H: Dies wird für C -Sprachquelldateien verwendet.
• Auto.Conf and Tristate.conf: Diese werden für die Makefile -Textverarbeitung verwendet.
• /include/config: Dies sind leere Header -Dateien, die bei der Abhängigkeitsverfolgung verwendet werden.

KBUILD -Dateien

Fast alle Kernel -Dateien sind KBUILD MECEFILES, die die KBUILD -Infrastruktur verwenden, was eine rekursive Make -Funktion ist. Rekursive Made ist eine Möglichkeit, das Werkzeug als Befehl in einem Makefile zu verwenden. Rekursion ist sehr nützlich, wenn ein großes Projekt zusammengestellt wird.

KBUILD funktioniert, indem sie sich auf alle Dateien bezieht, die wir im obigen Abschnitt erwähnt haben.

Das KBUILD -System erstellt seine Komponenten mithilfe des obersten Makefile, das die Erzmakefiles mit dem Namen Arch/$ (Arch)/Makefile in den Konfigurationsdateien enthält. Es stützt sich rekursiv in Unterverzeichnisse, die in den Komponenten mithilfe der Routinen in Skripten/Makefile aufgerufen werden.*. KBUILD baut dann auf dem angrenzenden Objekt auf und verknüpft sie mit Objekten, wodurch Vmlinux erstellt wird.

Weitere Informationen zu der in KBUILD Makefiles verwendeten Syntax 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 .a Dateien als var kbuild_vmlinux_init, main, libs. Diese sind in vmlinux komponiert.

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

Abschluss

In diesem Leitfaden haben wir uns KBUILD- und KCONFIG -Systeme im Kernel -Build -System angesehen und wie es funktioniert. Wie wir zu Beginn des Tutorials erwähnt haben, sind die besprochenen Themen weit verbreitet und können nicht in einem einzigen Tutorial behandelt werden.