LFD420 Linux Kernel Interna und Entwicklung

Dieser Kurs vermittelt erfahrenen Programmierern ein tiefgehendes Verständnis des Linux-Kernels. Neben ausführlichen Informationen zur Theorie und Philosophie hinter dem Linux-Kernel erlernen Sie in umfangreichen praktischen Übungen und Demonstrationen die notwendigen Fähigkeiten zum Entwickeln und Debuggen des Linux-Kernel-Codes. Sie lernen folgendes kennen:

  • Linux-Architektur
  • Funktionsweise der Kernel-Algorithmen
  • Hardware- und Speicherverwaltung
  • Modularisierungsmethoden und Debugging
  • Arbeitsweise der Kernel-Enwickler-Community und effizientes Arbeiten mit Linux
  • Und vieles mehr

Die im Kurs vermittelten Inhalte lassen sich auf alle großen Linux-Distributionen anwenden.

Voraussetzungen

Dieser Kurs richtet sich an alle, die das Schreiben und/oder Debuggen von Linux-Kernel-Code erlernen wollen. Die Teilnehmer sollten mit den wesentlichen Linux-Dienstprogrammen und Text-Editoren vertraut sein und die Programmiersprache C beherrschen.

Inhalt

Einführung

  • Ziele
  • Vorstellung
  • Die Linux Foundation
  • Schulungen der Linux Foundation
  • Registrierung

Übersicht

  • Verfahren
  • Veränderungen in Linux
  • Linux-Distributionen
  • Kernel-Versionen
  • Kernel-Quellen und Verwendung von git
  • Plattformen
  • Dokumentation und Links

Kernel-Architektur I

  • UNIX und Linux **
  • Monolithische und Micro-Kernels
  • Objektorientiere Methoden
  • Die wichtigsten Kernel-Tasks
  • User-Space und Kernel-Space
  • Kernel-Mode Linux **

Kernel-Programmierung - Vorschau

  • Fehlerzahlen und Kernel-Output
  • Task-Strukturen
  • Speicherzuweisung
  • Datenübertragung zwischen User- und Kernel-Space
  • Linked-Listen
  • Konvertierung von String in Zahl
  • Jiffies
  • Übungen

Module

  • Was sind Module?
  • Einfaches Beispiel
  • Compilieren von Modulen
  • Modul oder Built-in
  • Modul-Dienstprogramme
  • Automatisches Load/Unload von Modulen
  • Module Usage Count
  • Modul struct
  • Modul-Lizenzierung
  • Exportieren von Symbolen
  • Auflösen von Symbolen **
  • Übungen

Kernel-Architektur II

  • Prozesse, Threads und Tasks
  • Prozess-Kontext
  • Kernel-Preemption
  • Echtzeit-Preemption-Patch
  • Dynamisches Kernel-Patching
  • Laufzeit-Alternativen **
  • Portierung auf eine neue Plattform **

Kernel-Initialisierung

  • System-Initialisierung - Überblick
  • System-Boot
  • U-Boot für Embedded-Systeme **

Kernel-Konfiguration und -Compilierung

  • Installation und Layout der Kernel-Quelle
  • Kernel-Browser
  • Kernel-Konfigurationsdateien
  • Kernel-Erstellung und Makefiles
  • initrd und initramfs
  • Übungen

Systemaufrufe

  • Was sind Systemaufrufe?
  • Verfügbare Systemaufrufe
  • Implementieren von Systemaufrufen
  • Hinzufügen eines neuen Systemaufrufs
  • Ersetzen von Systemaufrufen von Modulen
  • Übungen

Kernel-Style und allgemeine Betrachtungen

  • Codier-Style
  • kernel-doc **
  • Verwendung von generischen Kernel-Routinen und Methoden
  • Erzeugen eines Kernel-Patch
  • sparse
  • Verwendung von likely() und unlikely()
  • Schreiben von portierbarem Code, CPU, 32/64-Bit, Endianness
  • Schreiben für SMP
  • Schreiben für High-Memory-Systeme
  • Power-Management
  • Sicherheitsaspekte
  • Kombinieren von User- und Kernel-Space-Header **
  • Übungen

Race Conditions und Synchronisationsmethoden

  • Nebenläufigkeit und Synchronisationsmethoden
  • Atomare Operationen
  • Bit-Operationen
  • Spinlocks
  • Seqlocks
  • Deaktivieren von Preemption
  • Mutexe
  • Semaphore
  • Completion-Funktionen
  • Read-Copy-Update (RCU)
  • Referenzzählungen
  • Übungen

SMP und Threads

  • SMP-Kernel und Module
  • Prozessor-Affinität
  • CPUSETS
  • SMP-Algorithmen - Scheduling, Locking, etc.
  • Per-CPU Variable **
  • Übungen

Prozesse

  • Was sind Prozesse?
  • task_struct
  • Erzeugen von User-Prozessen und Threads
  • Erzeugen von Kernel-Threads
  • Zerstören von Prozessen und Threads
  • Ausführung von User-Space-Prozessen aus dem Kernel heraus
  • Übungen

Einschränkungen und Möglichkeiten von Prozessen **

  • Einschränkungen
  • Möglichkeiten
  • Übungen

Überwachen und Debuggen

  • Debuginfo-Pakete
  • Tracen und Profilen
  • sysctl
  • SysRq Key
  • oops Nachrichten
  • Kernel-Debugger
  • debugfs
  • Übungen

Scheduling-Grundlagen

  • Die wichtigsten Scheduling-Tasks
  • SMP
  • Scheduling-Prioritäten
  • Scheduling-Systemaufrufe
  • Die 2.4 schedule() Funktion
  • O(1) Scheduler
  • Timeslices und Prioritäten
  • Lastverteilung
  • Prioritätsinversion und Prioritätsvererbung **
  • Übungen

Completely Fair Scheduler (CFS)

  • Der CFS-Scheduler
  • Kalkulation von Prioritäten und fairen Zeiten
  • Scheduling-Klassen
  • CFS Scheduler - Einzelheiten
  • Übungen

Speicher-Adressierung

  • Virtuelle Speicherverwaltung
  • Systeme ohne MMU
  • Speicher-Adressen
  • High und Low Memory
  • Speicher-Zonen
  • Spezielle Device-Nodes
  • NUMA
  • Paging
  • Page-Tabellen
  • page structure
  • Kernel Samepage Merging (KSM) **
  • Übungen

Huge Pages

  • Unterstützung von Huge Page
  • libhugetlbfs
  • Transparente Huge Pages
  • Übungen

Speicherzuweisung

  • Anforderung und Freigabe von Pages
  • Buddy-Verfahren
  • Zuweisung von Slabs und Cache
  • Speicher-Pools
  • kmalloc()
  • vmalloc()
  • Frühe Zuweisung und bootmem()
  • Speicher-Defragmentierung
  • Übungen

Prozess-Adressraum

  • Zuweisen von User-Speicher und Adressraum
  • Verriegeln von Pages
  • Speicher-Deskriptoren und -bereiche
  • Zugriffsrechte
  • Zuweisen und Freigeben von Speicherbereichen
  • Page-Fehler
  • Übungen

Laufwerk-Cache und Swapping

  • Cache
  • Page Cache - Grundlagen
  • Was ist Swapping?
  • Swap-Bereiche
  • Aus- und Einlagern von Pages
  • Überwachen der Swappiness
  • Der Swap-Cache
  • Reverse-Mapping **
  • OOM Killer
  • Übungen

Gerätetreiber **

  • Geräte-Arten
  • Device-Nodes
  • Zeichen-Treiber
  • Beispiel
  • Übungen

Signale

  • Was sind Signale?
  • Verfügbare Signale
  • Systemaufrufe für Signale
  • Sigaction
  • Signale und Threads
  • Installation von Signal-Handlern durch den Kernel
  • Senden von Signalen durch den Kernel
  • Aktivieren von Signal-Handlern durch den Kernel
  • Echtzeit-Signale
  • Übungen

** Diese Abschnitte können wahlweise zum Teil oder in vollem Umfang abgehandelt werden. Sie beinhalten z.B. Hintergrundinformationen, spezielle Themen oder fortgeschrittene Themen. Je nach Erfahrungsstand der Teilnehmergruppe oder zeitlichen Gegebenheiten entscheidet der Kursleiter, ob und welchem Umfang diese Abschnitte behandelt werden.