Linux-Treiber entwickeln

Eine systematische Einführung in die Gerätetreiber- und Kernelprogrammierung - jetzt auch für Raspberry Pi
 
 
dpunkt (Verlag)
  • 4. Auflage
  • |
  • erschienen am 11. November 2015
  • |
  • 688 Seiten
 
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-86491-755-4 (ISBN)
 
Dieses Buch bietet eine systematische Einführung in die Kernelprogrammierung und in die Entwicklung von Gerätetreibern unter Linux - angefangen bei den Grundlagen bis hin zu speziellen Treibern
und Techniken.

Die innerhalb des Kernels nutzbaren Technologien werden umfassend vermittelt und mit vielen wiederverwertbaren Codebeispielen illustriert.
Behandelt werden unter anderem:

die Architektur des Linux-Betriebssystems
die Programmierung von Tasklets, Kernel-Threads, Workqueues und hochauflösenden Timern
die Sicherung kritischer Abschnitte
effiziente Speicherverwaltung (Objekt-Caching)
die Systemintegration des Treibers (Proc-, Sysund Device-Filesystem)
das Kernel Build System
professionelle Hardwareanbindung für den Raspberry Pi
Green-Computing (Stromsparmodi)
Realzeitaspekte
spezielle Treiber (u.a. GPIO, I2C, PCI, USB, Blockgeräte)

Hilfreich für die praktische Arbeit sind außerdem Programmiertricks erfahrener Kernelhacker, Code Templates als Ausgangspunkt für eigene Entwicklungen, ein eigenes Kapitel zum Entwurf guter und
performanter Treiber sowie ein Anhang mit detaillierten Beschreibungen von mehr als 700 internen Kernelfunktionen.

Das Buch richtet sich an Entwickler, Kernelhacker und Linux-Interessierte mit guten Programmierkenntnissen in der Sprache C. Einsteiger in Kernelprogrammierung, in Treiberentwicklung (und in Linux) erhalten eine praxisorientierte Einführung in das Thema. Profis, wie Entwickler eingebetteter Systeme, werden es auch als wertvolles Nachschlagewerk für die tägliche Arbeit einsetzen.

Die 4. Auflage ist durchgehend auf den Stand des Kernels 4 aktualisiert worden. Ergänzt wurden Themen wie Cross-Entwicklung, Device Tree, GPIO, I2C und SPI sowie die Kernelcode-Entwicklung für eingebettete Systeme, insbesondere für den Raspberry Pi.
aktualisierte und erweiterte Auflage
  • Deutsch
  • Heidelberg
  • |
  • Deutschland
  • 6,46 MB
978-3-86491-755-4 (9783864917554)
weitere Ausgaben werden ermittelt
Jürgen Quade studierte Elektrotechnik an der TU München. Danach arbeitete er dort als Assistent am Lehrstuhl für Prozessrechner (heute Lehrstuhl für Realzeit-Computersysteme), promovierte und wechselte später in die Industrie, wo er im Bereich Prozessautomatisierung bei der Softing AG tätig war. Heute ist Jürgen Quade Professor an der Hochschule Niederrhein, wo er u.a. das Labor für Echtzeitsysteme betreut. Seine Schwerpunkte sind Echtzeitsysteme, Embedded Linux, Rechner- und Netzwerksicherheit sowie Open Source.

Eva-Katharina Kunst studierte Kommunikationswissenschaft an der LMU München sowie Wirtschaftsinformatik an der Fachhochschule München. Sie ist freiberuflich tätig als Journalistin. IhreArbeitsgebiete sind Open Source, Linux und Knowledge Management.
1 - Einleitung [Seite 11]
2 - Theorie ist notwendig [Seite 19]
2.1 - Betriebssystemarchitektur [Seite 19]
2.1.1 - Komponenten des Kernels [Seite 20]
2.1.2 - Sonstige Betriebssystemkomponenten [Seite 33]
2.2 - Abarbeitungskontext und Unterbrechungsmodell [Seite 34]
2.3 - Quellensuche [Seite 37]
3 - Kernelcode-Entwicklung in der Praxis [Seite 41]
3.1 - Auf der Kommandoebene entwickeln [Seite 42]
3.1.1 - Fehler finden [Seite 52]
3.2 - Techniken der Kernelprogrammierung [Seite 62]
3.2.1 - Coding Style: Kernelcode lesen und Kernelcodeschreiben [Seite 62]
3.2.2 - Kernelcode kodieren [Seite 64]
3.2.3 - Objektbasierte Programmierung und Entwurfsmuster im Kernel [Seite 66]
3.2.4 - Hilfsfunktionen [Seite 70]
3.3 - Cross-Development [Seite 72]
3.4 - Nicht vergessen: Auswahl einer geeigneten Lizenz [Seite 74]
3.4.1 - GPL und LGPL [Seite 75]
3.4.2 - MPL und BSD [Seite 76]
4 - Treiber aus Sicht der Applikation [Seite 79]
4.1 - Die Programmierschnittstelle der Applikation [Seite 79]
4.2 - Zugriffsmodi [Seite 84]
5 - Einfache Treiber [Seite 89]
5.1 - Bevor es losgeht . [Seite 90]
5.2 - Cross-Kompilierung [Seite 92]
5.3 - Den Kernel erweitern [Seite 93]
5.3.1 - Kernelmodule [Seite 93]
5.3.2 - Vom Modul zum Treiber [Seite 98]
5.3.3 - Einfaches Treibertemplate [Seite 101]
5.4 - Die Treibereinsprungspunkte [Seite 105]
5.4.1 - driver_open: die Zugriffskontrolle [Seite 108]
5.4.2 - Aufräumen in driver_close [Seite 111]
5.4.3 - Lesezugriffe im Treiber [Seite 111]
5.4.4 - Schreibzugriffe im Treiber [Seite 121]
5.4.5 - Die Universalschnittstelle IO-Control [Seite 123]
5.4.6 - Wenn Applikationen mehrere Ein-/Ausgabekanäleüberwachen [Seite 127]
5.5 - Daten zwischen Kernel- und Userspace transferieren [Seite 130]
5.6 - Hardware anbinden [Seite 134]
5.6.1 - Datentypen und Datenablage [Seite 135]
5.6.2 - Ressourcenmanagement [Seite 136]
5.6.3 - Direkter Hardwarezugriff [Seite 145]
5.6.4 - Hardware erkennen [Seite 150]
5.6.5 - Device Tree [Seite 154]
5.6.6 - PCI [Seite 160]
5.7 - Treiberinstanzen [Seite 173]
5.8 - Treibertemplate: Basis für Eigenentwicklungen [Seite 175]
6 - Fortgeschrittene Kernelcode-Entwicklung [Seite 181]
6.1 - Zunächst die Übersicht [Seite 182]
6.2 - Interrupts [Seite 183]
6.2.1 - Interruptverarbeitung klassisch [Seite 183]
6.2.2 - Threaded Interrupts [Seite 187]
6.2.3 - Interrupts, testen mit dem Raspberry Pi [Seite 191]
6.3 - Softirqs [Seite 199]
6.3.1 - Tasklets [Seite 200]
6.3.2 - Timer-Funktionen [Seite 203]
6.3.3 - High Resolution Timer [Seite 207]
6.3.4 - Tasklet auf Basis des High Resolution Timers [Seite 210]
6.4 - Kernel-Threads [Seite 211]
6.4.1 - kthread-Daemon [Seite 213]
6.4.2 - Workqueues [Seite 216]
6.4.3 - Event-Workqueue [Seite 221]
6.5 - Kritische Abschnitte sichern [Seite 222]
6.5.1 - Atomare Operationen [Seite 223]
6.5.2 - Mutex und Semaphor [Seite 229]
6.5.3 - Spinlocks [Seite 240]
6.5.4 - Sequencelocks [Seite 247]
6.5.5 - Interruptsperre und Kernel-Lock [Seite 250]
6.5.6 - Synchronisiert warten [Seite 251]
6.5.7 - Memory Barriers [Seite 254]
6.5.8 - Per-CPU-Variablen [Seite 256]
6.5.9 - Fallstricke [Seite 256]
6.6 - Vom Umgang mit Zeiten [Seite 258]
6.6.1 - Relativ- und Absolutzeiten [Seite 258]
6.6.2 - Zeitverzögerungen [Seite 264]
6.7 - Dynamischen Speicher effizient verwalten [Seite 267]
6.7.1 - Buddy-System [Seite 268]
6.7.2 - Objekt-Caching [Seite 270]
6.7.3 - Große Speicherbereiche reservieren [Seite 275]
6.7.4 - Speicher pro Prozessorkern [Seite 276]
7 - Systemaspekte [Seite 281]
7.1 - Proc-Filesystem [Seite 282]
7.1.1 - Schreibzugriffe unterstützen [Seite 287]
7.1.2 - Sequencefiles [Seite 290]
7.2 - Das Gerätemodell [Seite 295]
7.2.1 - Implementierungstechnische Grundlagen [Seite 299]
7.2.2 - Gerätedateien automatisiert anlegen lassen [Seite 300]
7.2.3 - Treiber anmelden [Seite 302]
7.2.4 - Geräte anmelden [Seite 304]
7.2.5 - Attributdateien erstellen [Seite 310]
7.2.6 - Eigene Geräteklassen erstellen [Seite 314]
7.2.7 - Neue Bussysteme anlegen [Seite 315]
7.3 - Green Computing [Seite 316]
7.4 - Firmware-Interface [Seite 328]
7.5 - Treiber parametrieren [Seite 334]
7.6 - Systemintegration [Seite 339]
7.6.1 - Modutils [Seite 341]
7.6.2 - Hotplug [Seite 344]
7.6.3 - Module beim Booten laden [Seite 345]
7.7 - Kernel Build System [Seite 345]
7.7.1 - Treiberquellen als integrative Erweiterung der Kernelquellen [Seite 346]
7.7.2 - Modultreiber außerhalb der Kernelquellen [Seite 350]
7.8 - Module automatisiert generieren (DKMS) [Seite 352]
7.9 - Intermodul-Kommunikation [Seite 357]
7.10 - Realzeitaspekte [Seite 362]
8 - Sonstige Treibersubsysteme [Seite 367]
8.1 - GPIO-Subsystem [Seite 367]
8.2 - I2C-Subsystem [Seite 372]
8.3 - Serial Peripheral Interface (SPI) [Seite 380]
8.4 - USB-Subsystem [Seite 388]
8.4.1 - USB programmtechnisch betrachtet [Seite 389]
8.4.2 - Den Treiber beim USB-Subsystem registrieren [Seite 393]
8.4.3 - Die Geräteinitialisierung und die -deinitialisierung [Seite 395]
8.4.4 - Auf das USB-Gerät zugreifen [Seite 397]
8.5 - Netzwerk-Subsystem [Seite 403]
8.5.1 - Datenaustausch zur Kommunikation [Seite 404]
8.5.2 - Netzwerktreiber initialisieren [Seite 406]
8.5.3 - Netzwerktreiber deinitialisieren [Seite 407]
8.5.4 - Start und Stopp des Treibers [Seite 407]
8.5.5 - Senden und Empfangen [Seite 408]
8.6 - Blockorientierte Gerätetreiber [Seite 413]
8.6.1 - Bevor es richtig losgeht . [Seite 416]
8.6.2 - Daten kerneloptimiert transferieren [Seite 418]
8.6.3 - Grundlegendes zu BIO-Blöcken [Seite 424]
8.6.4 - Treiberoptimierter Datentransfer [Seite 428]
8.7 - Crypto-Subsystem [Seite 430]
8.7.1 - Kleines Einmaleins der Kryptografie [Seite 430]
8.7.2 - Dienste in der Übersicht [Seite 433]
8.7.3 - Eigene Algorithmen einbinden [Seite 444]
9 - Über das Schreiben eines guten, performanten Treibers [Seite 451]
9.1 - Konzeption [Seite 451]
9.1.1 - Keine halben Sachen . [Seite 452]
9.1.2 - Intuitive Nutzung durch Struktur [Seite 453]
9.1.3 - Sicher muss es sein [Seite 454]
9.1.4 - Funktional muss es sein [Seite 455]
9.2 - Realisierung [Seite 455]
9.2.1 - Sicherheitsgerichtetes Programmieren [Seite 455]
9.2.2 - Mit Stil programmieren [Seite 456]
9.3 - 32 Bit und mehr: Portierbarer Code [Seite 461]
9.4 - Zeitverhalten [Seite 466]
10 - Anhang [Seite 471]
10.1 - Kernel generieren und installieren [Seite 473]
10.1.1 - Nativ kompilieren: PC-Plattform [Seite 475]
10.1.2 - Nativ kompilieren: Raspberry Pi [Seite 479]
10.1.3 - Cross-Kompilieren: PC als Host, Raspberry Pi als Target [Seite 480]
10.2 - Makros und Funktionen des Kernels kurz gefasst [Seite 485]
10.3 - Literaturverzeichnis [Seite 669]
10.4 - Index [Seite 671]
11 - www.dpunkt.de [Seite 0]

Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

39,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
E-Book bestellen