O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Linux-Treiber entwickeln

Book Description

  • Didaktik (systematische Einführung)+ Nachschlagewerk (Beschreibung von mittlerweile über 600 Kernel-Systemfunktionen+ Einziges Treiberbuch zum aktuellen Kernel 2.6.37

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Vorwort zur dritten Auflage
  5. Inhaltsverzeichnis
  6. 1 Einleitung
    1. Scope
    2. Notwendige Vorkenntnisse
    3. Zusätzliche Informationsquellen
  7. 2 Theorie ist notwendig
    1. 2.1 Betriebssystemarchitektur
      1. 2.1.1 Komponenten des Kernels
        1. Systemcall-Interface
        2. Prozessmanagement
        3. Speichermanagement
        4. IO-Management
        5. Gerätetreiber
      2. 2.1.2 Sonstige Betriebssystemkomponenten
    2. 2.2 Abarbeitungskontext und Unterbrechungsmodell
    3. 2.3 Quellensuche
  8. 3 Treiberentwicklung in der Praxis
    1. 3.1 Auf der Kommandoebene entwickeln
      1. Shell
      2. Editor
      3. Compiler
      4. Make
      5. Versionsverwaltung
      6. Treiber testen
      7. 3.1.1 Fehler finden
        1. Kernel-Debugger
        2. Fehlersuche aktiv betreiben
        3. Kernel-Probes
    2. 3.2 Techniken der Treiberprogrammierung
      1. 3.2.1 Coding Style: Kernelcode lesen und Kernelcode schreiben
      2. 3.2.2 Kernelcode kodieren
      3. 3.2.3 Objektbasierte Programmierung im Kernel
      4. 3.2.4 Hilfsfunktionen
    3. 3.3 Nicht vergessen: Auswahl einer geeigneten Lizenz
      1. 3.3.1 GPL und LGPL
      2. 3.3.2 MPL und BSD
  9. 4 Treiber aus Sicht der Applikation
    1. 4.1 Die Programmierschnittstelle der Applikation
    2. 4.2 Zugriffsmodi
  10. 5 Einfache Treiber
    1. 5.1 Bevor es losgeht ...
    2. 5.2 Den Kernel erweitern
      1. 5.2.1 Kernelmodule
      2. 5.2.2 Vom Modul zum Treiber
      3. 5.2.3 Einfaches Treiber-Template
    3. 5.3 Die Treibereinsprungspunkte
      1. 5.3.1 driver_open: die Zugriffskontrolle
      2. 5.3.2 Aufräumen in driver_close
      3. 5.3.3 Lesezugriffe im Treiber
      4. 5.3.4 Schreibzugriffe im Treiber
      5. 5.3.5 Die Universalschnittstelle IO-Control
      6. 5.3.6 Wenn Applikationen mehrere Ein-/Ausgabekanäle überwachen
    4. 5.4 Daten zwischen Kernel- und Userspace transferieren
    5. 5.5 Hardware anbinden
      1. 5.5.1 Ressourcenmanagement
        1. Ressourcen reservieren
        2. Interruptsharing
        3. Dynamische Speicherverwaltung
        4. Management implizit zugeteilter Ressourcen
      2. 5.5.2 Datentypen und Datenablage
      3. 5.5.3 Direkter Hardwarezugriff
        1. Memory Mapped IO
        2. Port-Zugriff
      4. 5.5.4 Hardware erkennen
      5. 5.5.5 PCI
    6. 5.6 Treiberinstanzen
    7. 5.7 Treiber-Template: Basis für Eigenentwicklungen
  11. 6 Fortgeschrittene Treiberentwicklung
    1. 6.1 Zunächst die Übersicht
    2. 6.2 Interrupt-Betrieb
    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 Kernel-Threads auf die rudimentäre Weise erzeugen
      3. 6.4.3 Workqueues
      4. 6.4.4 Event-Workqueue
    5. 6.5 Kritische Abschnitte sichern
      1. 6.5.1 Atomare Operationen
      2. 6.5.2 Mutex und Semaphor
        1. Mutex
        2. Realtime-Mutex
        3. 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
        1. Immer der Reihe nach
        2. Bis zum »Ende«
      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
        1. Zeitverwaltung auf Basis von dynamischen Timerticks
        2. Zeitverwaltung auf Basis von periodischen Timerticks
      2. 6.6.2 Zeitverzögerungen
        1. Aktives Warten
        2. Passives Warten
    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
  12. 7 Systemaspekte
    1. 7.1 Proc-Filesystem
      1. 7.1.1 Der lesende Zugriff auf die Proc-Datei
        1. Sämtliche Daten passen in die Speicherseite
        2. Die Ausgabe umfangreicher Daten über eine Proc-Datei
      2. 7.1.2 Schreibzugriffe unterstützen
      3. 7.1.3 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
    7. 7.7 Kernel Build System
      1. 7.7.1 Treiberquellen als integrative Erweiterung der Kernel-Quellen
        1. In die Kernel-Konfiguration integrieren
        2. Built-in-Treiber
      2. 7.7.2 Modultreiber außerhalb der Kernel-Quellen
    8. 7.8 Intermodul-Kommunikation
    9. 7.9 Echtzeitaspekte
  13. 8 Sonstige Treibersubsysteme
    1. 8.1 Blockorientierte Gerätetreiber
      1. 8.1.1 Bevor es richtig losgeht ...
      2. 8.1.2 Daten kerneloptimiert transferieren
      3. 8.1.3 Grundlegendes zu BIO-Blöcken
      4. 8.1.4 Treiberoptimierter Datentransfer
    2. 8.2 USB-Subsystem
      1. 8.2.1 USB programmtechnisch betrachtet
      2. 8.2.2 Den Treiber beim USB-Subsystem registrieren
      3. 8.2.3 Die Geräteinitialisierung und die -deinitialisierung
      4. 8.2.4 Auf das USB-Gerät zugreifen
    3. 8.3 Netzwerk-Subsystem
      1. 8.3.1 Datenaustausch zur Kommunikation
      2. 8.3.2 Geräteinitialisierung
        1. Netzwerktreiber als Built-in-Treiber
        2. Netzwerktreiber als Modultreiber mit automatischer Hardwareerkennung
        3. Netzwerktreiber als Modultreiber mit eigener Hardwareerkennung
      3. 8.3.3 Netzwerktreiber deinitialisieren
      4. 8.3.4 Start und Stopp des Treibers
      5. 8.3.5 Senden und Empfangen
        1. Socket-Buffer
        2. Netzwerkstatistik
    4. 8.4 Asynchrone Ein-/Ausgabe
      1. 8.4.1 Applikations-Interface
      2. 8.4.2 Async-IO im Treiber unterstützen
      3. 8.4.3 Kernel-Zugriff auf den Userspace
  14. 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
  15. Anhang
    1. A Kernel generieren und installieren
    2. B Makros und Funktionen des Kernels kurz gefasst
    3. C Literatur- und Quellennachweis
    4. Stichwortverzeichnis
  16. Fußnoten
    1. Kapitel 3
    2. Kapitel 7