Linux-Treiber entwickeln, 4th Edition

Table of contents

1. Cover
2. Titel
3. Impressum
4. Kapitel 1: Einleitung
5. Kapitel 2: Theorie ist notwendig
   1. 2.1 Betriebssystemarchitektur
      1. 2.1.1 Komponenten des Kernels
      2. 2.1.2 Sonstige Betriebssystemkomponenten
   2. 2.2 Abarbeitungskontext und Unterbrechungsmodell
   3. 2.3 Quellensuche
6. Kapitel 3: Kernelcode-Entwicklung in der Praxis
   1. 3.1 Auf der Kommandoebene entwickeln
      1. 3.1.1 Fehler finden
   2. 3.2 Techniken der Kernelprogrammierung
      1. 3.2.1 Coding Style: Kernelcode lesen und Kernelcode schreiben
      2. 3.2.2 Kernelcode kodieren
      3. 3.2.3 Objektbasierte Programmierung und Entwurfsmuster im Kernel
      4. 3.2.4 Hilfsfunktionen
   3. 3.3 Cross-Development
   4. 3.4 Nicht vergessen: Auswahl einer geeigneten Lizenz
      1. 3.4.1 GPL und LGPL
      2. 3.4.2 MPL und BSD
7. Kapitel 4: Treiber aus Sicht der Applikation
   1. 4.1 Die Programmierschnittstelle der Applikation
   2. 4.2 Zugriffsmodi
8. Kapitel 5: Einfache Treiber
   1. 5.1 Bevor es losgeht ...
   2. 5.2 Cross-Kompilierung
   3. 5.3 Den Kernel erweitern
      1. 5.3.1 Kernelmodule
      2. 5.3.2 Vom Modul zum Treiber
      3. 5.3.3 Einfaches Treibertemplate
   4. 5.4 Die Treibereinsprungspunkte
      1. 5.4.1 driver_open: die Zugriffskontrolle
      2. 5.4.2 Aufräumen in driver_close
      3. 5.4.3 Lesezugriffe im Treiber
      4. 5.4.4 Schreibzugriffe im Treiber
      5. 5.4.5 Die Universalschnittstelle IO-Control
      6. 5.4.6 Wenn Applikationen mehrere Ein-/Ausgabekanäle überwachen
   5. 5.5 Daten zwischen Kernel- und Userspace transferieren
   6. 5.6 Hardware anbinden
      1. 5.6.1 Datentypen und Datenablage
      2. 5.6.2 Ressourcenmanagement
      3. 5.6.3 Direkter Hardwarezugriff
      4. 5.6.4 Hardware erkennen
      5. 5.6.5 Device Tree
      6. 5.6.6 PCI
   7. 5.7 Treiberinstanzen
   8. 5.8 Treibertemplate: Basis für Eigenentwicklungen
9. Kapitel 6: Fortgeschrittene Kernelcode-Entwicklung
   1. 6.1 Zunächst die Übersicht
   2. 6.2 Interrupts
      1. 6.2.1 Interruptverarbeitung klassisch
      2. 6.2.2 Threaded Interrupts
      3. 6.2.3 Interrupts, testen mit dem Raspberry Pi
   3. 6.3 Softirqs
      1. 6.3.1 Tasklets
      2. 6.3.2 Timer-Funktionen
      3. 6.3.3 High Resolution Timer
      4. 6.3.4 Tasklet auf Basis des High Resolution Timers
   4. 6.4 Kernel-Threads
      1. 6.4.1 kthread-Daemon
      2. 6.4.2 Workqueues
      3. 6.4.3 Event-Workqueue
   5. 6.5 Kritische Abschnitte sichern
      1. 6.5.1 Atomare Operationen
      2. 6.5.2 Mutex und Semaphor
      3. 6.5.3 Spinlocks
      4. 6.5.4 Sequencelocks
      5. 6.5.5 Interruptsperre und Kernel-Lock
      6. 6.5.6 Synchronisiert warten
      7. 6.5.7 Memory Barriers
      8. 6.5.8 Per-CPU-Variablen
      9. 6.5.9 Fallstricke
   6. 6.6 Vom Umgang mit Zeiten
      1. 6.6.1 Relativ- und Absolutzeiten
      2. 6.6.2 Zeitverzögerungen
   7. 6.7 Dynamischen Speicher effizient verwalten
      1. 6.7.1 Buddy-System
      2. 6.7.2 Objekt-Caching
      3. 6.7.3 Große Speicherbereiche reservieren
      4. 6.7.4 Speicher pro Prozessorkern
10. Kapitel 7: Systemaspekte
    1. 7.1 Proc-Filesystem
       1. 7.1.1 Schreibzugriffe unterstützen
       2. 7.1.2 Sequencefiles
    2. 7.2 Das Gerätemodell
       1. 7.2.1 Implementierungstechnische Grundlagen
       2. 7.2.2 Gerätedateien automatisiert anlegen lassen
       3. 7.2.3 Treiber anmelden
       4. 7.2.4 Geräte anmelden
       5. 7.2.5 Attributdateien erstellen
       6. 7.2.6 Eigene Geräteklassen erstellen
       7. 7.2.7 Neue Bussysteme anlegen
    3. 7.3 Green Computing
    4. 7.4 Firmware-Interface
    5. 7.5 Treiber parametrieren
    6. 7.6 Systemintegration
       1. 7.6.1 Modutils
       2. 7.6.2 Hotplug
       3. 7.6.3 Module beim Booten laden
    7. 7.7 Kernel Build System
       1. 7.7.1 Treiberquellen als integrative Erweiterung der Kernelquellen
       2. 7.7.2 Modultreiber außerhalb der Kernelquellen
    8. 7.8 Module automatisiert generieren (DKMS)
    9. 7.9 Intermodul-Kommunikation
    10. 7.10 Realzeitaspekte
11. Kapitel 8: Sonstige Treibersubsysteme
    1. 8.1 GPIO-Subsystem
    2. 8.2 I2C-Subsystem
    3. 8.3 Serial Peripheral Interface (SPI)
    4. 8.4 USB-Subsystem
       1. 8.4.1 USB programmtechnisch betrachtet
       2. 8.4.2 Den Treiber beim USB-Subsystem registrieren
       3. 8.4.3 Die Geräteinitialisierung und die -deinitialisierung
       4. 8.4.4 Auf das USB-Gerät zugreifen
    5. 8.5 Netzwerk-Subsystem
       1. 8.5.1 Datenaustausch zur Kommunikation
       2. 8.5.2 Netzwerktreiber initialisieren
       3. 8.5.3 Netzwerktreiber deinitialisieren
       4. 8.5.4 Start und Stopp des Treibers
       5. 8.5.5 Senden und Empfangen
    6. 8.6 Blockorientierte Gerätetreiber
       1. 8.6.1 Bevor es richtig losgeht ...
       2. 8.6.2 Daten kerneloptimiert transferieren
       3. 8.6.3 Grundlegendes zu BIO-Blöcken
       4. 8.6.4 Treiberoptimierter Datentransfer
    7. 8.7 Crypto-Subsystem
       1. 8.7.1 Kleines Einmaleins der Kryptografie
       2. 8.7.2 Dienste in der Übersicht
       3. 8.7.3 Eigene Algorithmen einbinden
12. Kapitel 9: Über das Schreiben eines guten, performanten Treibers
    1. 9.1 Konzeption
       1. 9.1.1 Keine halben Sachen ...
       2. 9.1.2 Intuitive Nutzung durch Struktur
       3. 9.1.3 Sicher muss es sein
       4. 9.1.4 Funktional muss es sein
    2. 9.2 Realisierung
       1. 9.2.1 Sicherheitsgerichtetes Programmieren
       2. 9.2.2 Mit Stil programmieren
    3. 9.3 32 Bit und mehr: Portierbarer Code
    4. 9.4 Zeitverhalten
13. Anhang
    1. A Kernel generieren und installieren
       1. A.1 Nativ kompilieren: PC-Plattform
       2. A.2 Nativ kompilieren: Raspberry Pi
       3. A.3 Cross-Kompilieren: PC als Host, Raspberry Pi als Target
    2. B Makros und Funktionen des Kernels kurz gefasst
14. Literaturverzeichnis
15. Index
16. Fußnoten