Die Entwicklung eines benutzerdefinierten Linux-Kernels für spezialisierte Engineering-Hardware ist eine komplexe, aber zutiefst lohnende Aufgabe, die Ingenieuren eine präzise Kontrolle über Systemleistung, Sicherheit und Kompatibilität gibt. Im Gegensatz zu Allzweck-Distributionen kann ein benutzerdefinierter Kernel so getrimmt werden, dass unnötige Module ausgeschlossen werden, mit Echtzeit-Erweiterungen für deterministisches Verhalten gepatcht und auf einzigartige Hardware-Schnittstellen zugeschnitten werden, die möglicherweise nicht von Haupttreibern abgedeckt werden. Dieses Handbuch bietet eine zuverlässige, schrittweise Lösung des gesamten Prozesses - von der Anforderungsanalyse und der Einrichtung der Umgebung bis hin zum Erstellen, Testen und Pflegen eines produktionsbereiten Kernels für spezialisierte Engineering-Anwendungen.

Verstehen der Anforderungen und Hardware-Spezifikationen

Bevor Sie eine einzelne Zeile Code berühren, müssen Sie eine gründliche Analyse der Zielhardware und ihrer Betriebsbeschränkungen durchführen. Spezialisierte Engineering-Hardware beinhaltet oft nicht standardmäßige Peripheriegeräte, proprietäre Busse oder Echtzeit-Steuerschleifen. Beginnen Sie mit der Dokumentation:

Prozessorarchitektur – ARM64, x86 64, RISC‐V oder ein benutzerdefiniertes SoC. Dies bestimmt die erforderlichen Compiler-, Toolchain- und Kernelkonfigurationen.
Speicher- und Speicherlayout – Eingebettete Systeme können einen begrenzten RAM-, NOR/NAND-Flash- oder eMMC-Speicher haben.
Peripheriegeräte und Schnittstellen – Benutzerdefinierte FPGA-angehängte Geräte, CAN-Busse, GPIO-Erweiterer oder Hochgeschwindigkeits-Datenerfassungskarten. Jede Peripherie benötigt möglicherweise einen Kerneltreiber oder eine Benutzer-Raum-Bibliothek.
Realzeitanforderungen – Latenzgrenzen, Interrupt-Responsezeiten und Jittertoleranz. Diese steuern Entscheidungen über Preemptionsmodelle, Interrupt-Handling und ob der PREEMPT RT-Patchsatz angewendet werden soll.
Leistungs- und Wärmegrenzen - Lüfterlose oder batteriebetriebene Hardware kann dynamische Frequenzskalierung, CPUidle-Begrenzer und thermische Drosselung erfordern.

Erstellen Sie ein Hardwarespezifikationsdokument, das mit vorgelagerter Linux-Treiberunterstützung auf jede Komponente verweist. Wenn ein Treiber nicht vorhanden oder unvollständig ist, listen Sie die erforderlichen benutzerdefinierten Entwicklungsaufgaben auf. Dieses Dokument wird zur Grundlage Ihrer Kernelkonfiguration.

Einrichtung des Entwicklungsumfelds

Auswahl eines Host-Systems und einer Toolchain

Verwenden Sie eine stabile Linux-Distribution auf Ihrem Entwicklungshost - Ubuntu 22.04 LTS oder Debian 12 sind eine gute Wahl.

sudo apt update
sudo apt install build-essential git ncurses-dev bison flex libssl-dev libelf-dev

Für die Cross-Compilation (allgemein, wenn das Ziel ein ARM- oder RISC-V-Gerät ist) ist die entsprechende Cross-Toolchain zu installieren.

sudo apt install gcc-aarch64-linux-gnu

Alternativ können Sie eine Toolchain aus Arms offiziellen Repositories oder ein dediziertes Embedded Build-System wie Buildroot oder das Yocto-Projekt für eine komplexere Integration verwenden.

Klonen der Kernelquelle

Besorgen Sie sich den offiziellen Linux-Kernel-Quellcode von kernel.org und verwenden Sie die neueste Langzeitversion (LTS) für Produktionssysteme oder einen Release-Kandidaten, wenn Sie Funktionen benötigen, z. B.:

git clone --depth 1 --branch v6.6-linux-next git://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git

Wenn Sie nur den letzten Commit (Tiefe 1) klonen, wird der erste Download beschleunigt.

Versionskontrolle und Patch Management

Verfolgen Sie Ihre Änderungen in einem lokalen Git-Zweig. Wenn Sie Patches anwenden möchten (z. B. PREEMPT RT, Out-of-tree-Treiber), pflegen Sie einen Satz von Quilt-Stacks oder verwenden Sie die Funktion von Git am. Tools wie oder helfen, Änderungen zu visualisieren.

Konfigurieren des Kernels für spezialisierte Hardware

Interaktive Konfiguration mit menuconfig

Die gebräuchlichste Methode zur Anpassung von Kerneloptionen ist . Mit dieser TUI (Terminal User Interface) können Sie durch Tausende von Optionen nach Kategorien gruppiert navigieren.

export ARCH=arm64
export CROSS_COMPILE=aarch64-linux-gnu-
make menuconfig

Schlüsselbereiche zur Konfiguration:

Allgemeine Einrichtung – Wählen Sie Ihr Präemptionsmodell ( oder ]), Kontrollgruppenunterstützung und systemweite Protokollierung.
Prozessortyp und Funktionen – Aktivieren oder Deaktivieren von CPU-Familien, symmetrischem Multithreading (SMT), Unterstützung für große Seiten und gegebenenfalls NUMA.
Power Management und ACPI – Feintune CPU-Idle-States, Cpufreq-Governors und Suspend/Resume-Unterstützung.
Gerätetreiber – Deaktivieren Sie Treiber, die Sie nicht benötigen (Wi‐Fi, Bluetooth, die meisten GPU-Treiber), um die Kernelgröße und Angriffsfläche zu reduzieren.
File systems – Beinhalte nur die Dateisysteme, die auf dem Ziel verwendet werden (z. B. ext4, Squashfs für Nur-Lese-Rootfs oder UBIFS für Roh-Flash).
Netzwerkunterstützung – Viele Engineering-Geräte benötigen Industrial Ethernet (z. B. PROFINET, EtherCAT) oder CAN-Bus.

Speichern Sie nach der Auswahl Ihre Konfiguration als und führen Sie aus, um eine minimale Defconfig zu generieren, die nur nicht standardmäßige Optionen aufzeichnet – dies ist ideal für die Versionskontrolle, insbesondere wenn Sie im gesamten Team teilen.

Verwendung von Kernelfragmenten

Bei komplexer Hardware mit mehreren Overlays verwenden Sie Konfigurationsfragmente. Eine Fragmentdatei enthält nur die Optionen, die Sie überschreiben möchten.

./scripts/kconfig/merge_config.sh -O obj_dir base_defconfig fragment.config

Dieser Ansatz ist sauberer als das manuelle Bearbeiten von .config und ermöglicht das Verketten vieler Fragmente (z. B. , ).

Anpassen von Kernel-Funktionen und Schreiben von Treibern

Real-Time Patches ermöglichen

Für garantiertes deterministisches Verhalten wenden Sie den PREEMPT RT-Patchset an, mit dem der Kernel in ein vollständig vorwegzunehmendes Echtzeit-Betriebssystem umgewandelt wird.

Laden Sie die Patch-Datei herunter, die Ihrer Kernel-Version entspricht.
Bewerben Sie sich mit .
In , unter Allgemeine Einrichtung → Preemption Model, wählen Sie “Fully Preemptible Kernel (Real-Time)”.
Ermöglicht und

Test mit zyklischem Test (aus dem Paket rt-tests) zur Messung der Worst-Case-Latenz; auf gut konfigurierter Hardware ist einstelliger Mikrosekundenjitter zu erwarten.

Schreiben von Custom Kernel Modules

Wenn Ihre Hardware keinen Mainline-Treiber hat, müssen Sie einen schreiben. Beginnen Sie mit einem minimalen "Hallo World" -Modul, um die Build-Infrastruktur zu überprüfen, und erweitern Sie dann die Handhabung von Interrupts, Memory-mapped I/O, DMA und Dateioperationen. Eine typische Struktur:

/* my_device_driver.c */
#include <linux/module.h>
#include <linux/platform_device.h>

static int my_probe(struct platform_device *pdev)
{
 // request_mem_region, ioremap, register irq
 return 0;
}

static int my_remove(struct platform_device *pdev)
{
 // cleanup
 return 0;
}

static struct platform_driver my_driver = {
 .probe = my_probe,
 .remove = my_remove,
 .driver = { .name = "my_device" },
};
module_platform_driver(my_driver);

Fügen Sie die Quelldatei Ihres Treibers in das Verzeichnis des Kernelbaums hinzu und aktualisieren Sie die entsprechenden und , wodurch sie über die Menükonfiguration ausgewählt werden können.

Anpassen des Speichermanagements

Spezialisierte Hardware erfordert oft große zusammenhängende Speicherzuweisungen für DMA-Buffer, beispielsweise in der Bildverarbeitung oder im softwaredefinierten Radio. Aktivieren Sie (Contiguous Memory Allocator) und legen Sie seine Größe über die Kernel-Befehlszeile fest ().

Aufbau des Kernels und der Module

Compilation für die Target-Architektur

Legen Sie Umgebungsvariablen fest und führen Sie den Build aus.

export ARCH=arm64
export CROSS_COMPILE=aarch64-linux-gnu-
make -j4 Image.gz modules dtbs

Dadurch wird ein komprimiertes Kernel-Image (), ladbare Module () und Gerätebaum-Blobs () erzeugt. Wenn Ihre Hardware einen abgeflachten Gerätebaum (FDT) verwendet, stellen Sie sicher, dass die korrekte -Datei kompiliert wird – Sie müssen möglicherweise ein boardspezifisches DTS hinzufügen oder ändern.

Bauen mit Out-of-Tree Modulen

Wenn Sie ein Modul außerhalb des Kernelbaums entwickeln (z. B. aus dem SDK eines FPGA-Anbieters), verwenden Sie das Ziel des Kernel-Build-Systems gegen einen zuvor erstellten Kernel:

export KERNEL_SRC=/path/to/kernel
make -C $KERNEL_SRC M=$PWD modules

Zusammenstellen des Device Tree Blob

Stellen Sie sicher, dass der Gerätebaum korrekt erstellt wird, indem Sie ausführen.

Testen und Debuggen des Custom Kernels

Startprüfung

Laden Sie das Kernelbild mit U‐Boot, UEFI oder einem JTAG-Flasher auf das Ziel, beobachten Sie frühe Bootmeldungen auf einer seriellen Konsole.

Überprüfen Sie die Kernel-Befehlszeile enthält (oder den richtigen seriellen Port).
Aktivieren Sie und , um die Ausgabe zu sehen, bevor die Konsole vollständig initialisiert ist.
Wenn der Boot hängt, schauen Sie sich die letzte gedruckte Nachricht an - sie weist oft auf einen falsch konfigurierten Gerätetreiber oder ein fehlendes Root-Dateisystem hin.

Verwendung von Dmesg und Strace

Führen Sie nach dem Booten aus, um nach Fehlern und Warnungen zu filtern. Verwenden Sie , um Benutzerraumanwendungen zu debuggen, die mit benutzerdefinierten Kernelmodulen interagieren.

Kernel Debugging mit KGDB

Für tiefe Probleme, richten Sie KGDB über serielle oder Ethernet ein. Konfigurieren Sie den Kernel mit , und Auf dem Ziel starten Sie mit auf der Kernel-Befehlszeile neu.

aarch64-linux-gnu-gdb vmlinux
(gdb) target remote /dev/ttyUSB0
(gdb) continue

Setzen Sie Haltepunkte, untersuchen Sie das Gedächtnis und treten Sie durch Interrupt-Handler.

Bereitstellung des Custom Kernel

Installieren des Kernels und der Module

Kopieren Sie auf dem Zielgerät das Kernel-Image in die Boot-Partition (z. B. ) und installieren Sie Module:

sudo make ARCH=arm64 INSTALL_MOD_PATH=/path/to/rootfs modules_install

Wenn Sie eine Ramdisk (Initramfs) verwenden, bauen Sie sie mit oder um, um alle Module, die für das Root-Dateisystem benötigt werden, aufzunehmen.

Aktualisieren des Bootloaders

Für U-Boot, setzen Sie die , und boot Argumente.

setenv bootargs console=ttyAMA0,115200 root=/dev/mmcblk0p2 rw rootfstype=ext4
setenv kernel_addr_r 0x80000000
setenv fdt_addr_r 0x88000000
load mmc 0:1 ${kernel_addr_r} /Image.gz
unzip ${kernel_addr_r} ${kernel_addr_r} # if gzip compressed
load mmc 0:1 ${fdt_addr_r} /my_board.dtb
booti ${kernel_addr_r} - ${fdt_addr_r}

Verwenden Sie für UEFI-basierte Systeme , um den Kernel als Booteintrag zu registrieren.

Erfolgreiches Boot überprüfen

Nach dem Neustart überprüfen Sie , um die neue Kernelversion zu bestätigen. Überprüfen Sie, ob alle benutzerdefinierten Module mit geladen sind. Führen Sie repräsentative Workload-Tests aus - betonen Sie die Datenpfade der Hardware, messen Sie die Unterbrechungslatenz und bestätigen Sie, dass über einen längeren Einweichzeitraum keine Kernel-Panik oder -Opses in den Protokollen erscheinen.

Performance Tuning und Benchmarking

CPU-Skalierung und Governor-Auswahl

Für Latenz-sensitive Engineering-Anwendungen, stellen Sie den CPU-Governor auf :

echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

Alternativ können Sie Userspace-Planungstools wie verwenden, um kritische Prozesse an dedizierte Kerne anzuheften und sie vom Scheduler des Kernels zu isolieren.

I/O Scheduler und Block Layer

Für Echtzeitbeschränkungen verwenden Sie den oder E/A-Scheduler (NVMe-Geräte verwenden oft ). Deaktivieren Sie Kernelfunktionen wie und , wenn nicht erforderlich, da sie Overhead hinzufügen.

Network Stack Tuning

Engineering-Hardware verwendet häufig Roh-Sockel oder Industrieprotokolle.

Setzen Sie und auf größere Werte.
Verwenden Sie , um Interrupt-induzierten Jitter zu reduzieren.
Aktivieren Sie (Receive Packet Steering), wenn Sie mehrere Kerne haben.

Pflege und Aktualisierung des Custom Kernel

Tracking Upstream Releases

Abonnieren Sie die Linux Kernel Stable Mailing List und folgen Sie den LTS-Releases. Wenn eine neue Stable Release herauskommt, bauen Sie Ihre benutzerdefinierten Patches darauf an. Verwenden Sie Gits Workflow:

git fetch stable
git checkout -b custom-6.7 v6.7
git rebase -i v6.6

Testen Sie jede Rebase gründlich, bevor Sie sie auf die Produktionshardware bereitstellen.

Sicherheits-Patching und Regressions-Tests

Spezialisierte Hardware fehlt oft an Sicherheits-Audits – ein benutzerdefinierter Kernel, der nie aktualisiert wird, kann zu einer Backdoor werden. Richten Sie eine automatisierte Build- und Test-Pipeline ein. Verwenden Sie oder eine lokale Jenkins-Instanz, um Boot-Tests, Latenztests und treiberspezifische Funktionstests durchzuführen, wenn ein neuer Patch angewendet wird.

Dokumentation und Wissensaustausch

Bewahren Sie ein Dokument auf, das alle Konfigurationsoptionen des Kernels, die sich vom Standard unterscheiden, jeden angewendeten Patch und jeden benutzerdefinierten Treiber detailliert aufführt. Fügen Sie eine README mit Anweisungen zum Neuaufbau von Grund auf hinzu. Dies ist von unschätzbarem Wert, wenn Teammitglieder wechseln oder wenn Sie das Setup Jahre später reproduzieren müssen.

Real-World-Beispiel: Custom Kernel für einen High-Energy Physics Detector

Betrachten wir ein wissenschaftliches DAQ-System (Datenerfassung), das 10.000 Kanäle von einem ASIC über eine benutzerdefinierte PCIe-Karte ausliest.

Deterministisches Interrupthandling mit Latenz unter 5 μs.
Kontinuierliche Speicherzuweisung für 2 GB DMA-Puffer.
Keine GUI, kein Netzwerk, minimaler Speicherplatz.

Der Ingenieur würde:

Beginnen Sie mit dem Mainline-ARM64-Kernel und wenden Sie den PREEMPT RT-Patch an.
Deaktivieren Sie alle Netzwerk-, Audio- und GPU-Treiber.
Aktivieren Sie CMA mit auf der Kernel-Befehlszeile.
Schreibe einen Charaktertreiber, der für die Pufferzuweisung verwendet und registriert einen Interrupt-Handler mit mit .
Überprüfen Sie mit einem Stresstest, der 100 Millionen Ereignisse ohne einen einzigen abfallenden Interrupt oder Seitenfehler liest.

Ein solches System würde in einem Labor eingesetzt und niemals mit dem Internet verbunden sein, aber sein Kernel muss immer noch auditiert und aktualisiert werden, wenn kritische Errata auftreten.

Schlussfolgerung

Die Entwicklung eines benutzerdefinierten Linux-Kernels für spezialisierte Engineering-Hardware gibt Ihnen die volle Kontrolle über die Leistung, den Determinismus und die Sicherheit der Plattform. Der Prozess - von der Anforderungsanalyse bis zur Wartung - ist anspruchsvoll, aber gut dokumentiert, sobald Sie die zugrunde liegenden Subsysteme verstehen. Durch die Nutzung von Tools wie Menüconfig, Gerätebaum-Overlays, PREEMPT RT und systematisches Testen mit zyklischem Test und Ftrace können Sie einen Kernel erstellen, der die strengsten Echtzeit- und Durchsatzbeschränkungen erfüllt. Denken Sie daran, Ihren Kernel als lebendes Artefakt zu behandeln: verfolgen Sie jede Änderung, testen Sie gründlich auf Hardware und haben Sie immer einen Wiederherstellungspfad (Backup-Boot-Eintrag oder JTAG-Flash) für den Fall, dass ein neuer Kernel ausfällt. Mit diesen Praktiken wird Ihr benutzerdefinierter Kernel als zuverlässige Grundlage für Ihre Engineering-Lösung dienen für die kommenden Jahre.

Wie man einen benutzerdefinierten Linux-Kernel für spezialisierte Engineering-Hardware entwickelt

Table of Contents