Linux-Treiber entwickeln E-Book

Jürgen Quade

• Herausgeber: dpunkt
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Deutsch
• Veröffentlichungsjahr: 2015

Seitenzahl: 781

Beschreibung

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.

Leseprobe

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. Ihre Arbeitsgebiete sind Open Source, Linux und Knowledge Management.

Zu diesem Buch – sowie zu vielen weiteren dpunkt.büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei dpunkt.plus+:

www.dpunkt.de/plus

Linux-Treiber entwickeln

Eine systematische Einführung in die Gerätetreiber- und Kernelprogrammierung – jetzt auch für Raspberry Pi

4., aktualisierte und erweiterte Auflage

Jürgen QuadeEva-Katharina Kunst

Jürgen [email protected] [email protected]

Lektorat: René SchönfeldtCopy-Editing: Annette Schwarz, DitzingenSatz: Da-TeX, LeipzigHerstellung: Nadine ThieleUmschlaggestaltung: Helmut Kraus, www.exclam.deDruck und Bindung: Media-Print Informationstechnologie, Paderborn

Bibliografische Information der Deutschen NationalbibliothekDie Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

ISBNBuch   978-3-86490-288-8PDF   978-3-86491-755-4ePub   978-3-86491-756-1mobi   978-3-86491-757-8

4., aktualisierte und erweiterte Auflage 2016Copyright © 2016 dpunkt.verlag GmbHWieblinger Weg 1769123 Heidelberg

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.

Alle Angaben und Programme in diesem Buch wurden mit größter Sorgfalt kontrolliert. Weder Autor noch Verlag können jedoch für Schäden haftbar gemacht werden, die in Zusammenhang mit der Verwendung dieses Buches stehen.

5 4 3 2 1 0

Vorwort zur vierten Auflage

Professioneller, zugleich komplexer

Linux entwickelt sich unaufhaltsam weiter. Mehr Subsysteme, leichtere Portierbarkeit, besseres Realzeitverhalten und weitere Sicherheitsfunktionen. Die Liste lässt sich beliebig fortführen. In Version 4.x zeigt sich Linux professioneller, stabiler und sicherer, aber eben auch komplexer.

Einfacher per Raspberry Pi

Für den Entwickler wird es dadurch nicht einfacher. Gerade rechtzeitig hat daher Eben Upton 2012 den Raspberry Pi in den Markt gebracht. Das Besondere an diesem Minicomputer: Er ist mit dem Ziel entworfen worden, den Einstieg in die Computertechnik zu erleichtern und die Freude daran anzufachen. Und tatsächlich: Der Raspberry Pi vereinfacht vieles und eignet sich ausgezeichnet als Anschauungs- und Lehrobjekt. Problemlos kann unterschiedlichste Peripherie angeschlossen werden. Der Zugriff ist dabei ohne tiefgreifende Systemkenntnisse über beispielsweise PCI (Peripheral Interconnect) möglich.

Beispiele für PC und Raspberry Pi

Das macht sich die vierte Neuauflage zunutze und zeigt relevante Interfaces wie beispielsweise diejenigen für Interrupts oder für den GPIO-Zugriff anhand von Codebeispielen, die direkt auf dem Raspberry Pi ablauffähig und daher mit sehr wenig Aufwand testbar sind. Die vierte Neuauflage nutzt den Raspberry Pi darüber hinaus, um in die Kernelcodeentwicklung für und auf dem Raspberry Pi einzuführen (crossund native Entwicklung) und neue Konzepte vorzustellen, die wie beispielsweise Device Trees die Portierbarkeit des Kernels erweitern. Damit trägt sie auch dem Umstand Rechnung, dass die Mehrheit aktueller Linux-Systeme milliardenfach (!) auf Prozessoren der Firma ARM (Advanced Risc Machine) ablaufen.

Neue Subsysteme

Neben der Aufnahme der neuen Themenbereiche Kernel- und Treibercodeentwicklung für eingebettete Systeme und Cross-Entwicklung ist die vierte Neuauflage um neue Subsysteme ergänzt. Außerdem sind die bekannten Interfaces auf den aktuellen Stand gebracht worden. Wie gehabt werden wichtige Kernelinterfaces und Softwaremechanismen anhand vieler Codebeispiele anschaulich und zugleich kompakt vorgestellt. In Kombination mit dem vermittelten theoretischen Unterbau hilft damit auch das vorliegende Buch, strukturiert das für die Codeentwicklung notwendige Wissen in kurzer Zeit (anwendbar) aufzubauen. Der aktualisierte und deutlich erweiterte Anhang mit der Beschreibung von über 750 Kernelfunktionen lässt das Buch gleichzeitig ein wertvolles Nachschlagewerk sein.

Open Source hilft.

Doch es gibt auch Grenzen bezüglich Umfang und Aktualität. Ein Blick in den Quellcode zeigt, dass es eine Reihe weiterer Subsysteme und Kernelfunktionen gibt, die hier nicht beschrieben sind. Und da sich der Linux-Kernel unaufhaltsam weiterentwickelt, haben die Entwickler die eine oder andere Kernelfunktion wohl in der Zeit zwischen Drucklegung und Ihrem Lesen geändert. Oft reicht es aus, den Quellcode nur um die Angabe einer Header-Datei zu ergänzen, manchmal tauschen Sie aber auch einen Parameter aus, selten verschwinden ganze Funktionen. Im Fall von Problemen helfen zumeist das Internet und vor allem auch der Linux-Quellcode weiter. Denn das ist eines der größten Assets, die Linux zu bieten hat: den offenen Quellcode.

Danke

Wir möchten die Gelegenheit nutzen und unseren Lesern für die wohlwollende Aufnahme der ersten drei Auflagen, für Korrekturhinweise und Anregungen danken. Möge auch die vierte Auflage Ihnen eine große Hilfe sein. Ein Dankeschön geht wieder an den dpunkt.verlag und hier insbesondere an Herrn Schönfeldt, der dieses Buch als Lektor bei allen Auflagen ausgesprochen freundlich und konstruktiv begleitet hat!

Kempen, im Oktober 2015

Jürgen Quade und Eva-Katharina Kunst

Inhaltsverzeichnis

1       Einleitung

2       Theorie ist notwendig

2.1     Betriebssystemarchitektur

2.1.1     Komponenten des Kernels

2.1.2     Sonstige Betriebssystemkomponenten

2.2     Abarbeitungskontext und Unterbrechungsmodell

2.3     Quellensuche

3       Kernelcode-Entwicklung in der Praxis

3.1     Auf der Kommandoebene entwickeln

3.1.1     Fehler finden

3.2     Techniken der Kernelprogrammierung

3.2.1     Coding Style: Kernelcode lesen und Kernelcode schreiben

3.2.2     Kernelcode kodieren

3.2.3     Objektbasierte Programmierung und Entwurfsmuster im Kernel

3.2.4     Hilfsfunktionen

3.3     Cross-Development

3.4     Nicht vergessen: Auswahl einer geeigneten Lizenz

3.4.1     GPL und LGPL

3.4.2     MPL und BSD

4       Treiber aus Sicht der Applikation

4.1     Die Programmierschnittstelle der Applikation

4.2     Zugriffsmodi

5       Einfache Treiber

5.1     Bevor es losgeht ...

5.2     Cross-Kompilierung

5.3     Den Kernel erweitern

5.3.1     Kernelmodule

5.3.2     Vom Modul zum Treiber

5.3.3     Einfaches Treibertemplate

5.4     Die Treibereinsprungspunkte

5.4.1     driver_open: die Zugriffskontrolle

5.4.2     Aufräumen in driver_close

5.4.3     Lesezugriffe im Treiber

5.4.4     Schreibzugriffe im Treiber

5.4.5     Die Universalschnittstelle IO-Control

5.4.6     Wenn Applikationen mehrere Ein-/Ausgabekanäle überwachen

5.5     Daten zwischen Kernel- und Userspace transferieren

5.6     Hardware anbinden

5.6.1     Datentypen und Datenablage

5.6.2     Ressourcenmanagement

5.6.3     Direkter Hardwarezugriff

5.6.4     Hardware erkennen

5.6.5     Device Tree

5.6.6     PCI

5.7     Treiberinstanzen

5.8     Treibertemplate: Basis für Eigenentwicklungen

6       Fortgeschrittene Kernelcode-Entwicklung

6.1     Zunächst die Übersicht

6.2     Interrupts

6.2.1     Interruptverarbeitung klassisch

6.2.2     Threaded Interrupts

6.2.3     Interrupts, testen mit dem Raspberry Pi

6.3     Softirqs

6.3.1     Tasklets

6.3.2     Timer-Funktionen

6.3.3     High Resolution Timer

6.3.4     Tasklet auf Basis des High Resolution Timers

6.4     Kernel-Threads

6.4.1     kthread-Daemon

6.4.2     Workqueues

6.4.3     Event-Workqueue

6.5     Kritische Abschnitte sichern

6.5.1     Atomare Operationen

6.5.2     Mutex und Semaphor

6.5.3     Spinlocks

6.5.4     Sequencelocks

6.5.5     Interruptsperre und Kernel-Lock

6.5.6     Synchronisiert warten

6.5.7     Memory Barriers

6.5.8     Per-CPU-Variablen

6.5.9     Fallstricke

6.6     Vom Umgang mit Zeiten

6.6.1     Relativ- und Absolutzeiten

6.6.2     Zeitverzögerungen

6.7     Dynamischen Speicher effizient verwalten

6.7.1     Buddy-System

6.7.2     Objekt-Caching

6.7.3     Große Speicherbereiche reservieren

6.7.4     Speicher pro Prozessorkern

7       Systemaspekte

7.1     Proc-Filesystem

7.1.1     Schreibzugriffe unterstützen

7.1.2     Sequencefiles

7.2     Das Gerätemodell

7.2.1     Implementierungstechnische Grundlagen

7.2.2     Gerätedateien automatisiert anlegen lassen

7.2.3     Treiber anmelden

7.2.4     Geräte anmelden

7.2.5     Attributdateien erstellen

7.2.6     Eigene Geräteklassen erstellen

7.2.7     Neue Bussysteme anlegen

7.3     Green Computing

7.4     Firmware-Interface

7.5     Treiber parametrieren

7.6     Systemintegration

7.6.1     Modutils

7.6.2     Hotplug

7.6.3     Module beim Booten laden

7.7     Kernel Build System

7.7.1     Treiberquellen als integrative Erweiterung der Kernelquellen

7.7.2     Modultreiber außerhalb der Kernelquellen

7.8     Module automatisiert generieren (DKMS)

7.9     Intermodul-Kommunikation

7.10   Realzeitaspekte

8       Sonstige Treibersubsysteme

8.1     GPIO-Subsystem

8.2     I2C-Subsystem

8.3     Serial Peripheral Interface (SPI)

8.4     USB-Subsystem

8.4.1     USB programmtechnisch betrachtet

8.4.2     Den Treiber beim USB-Subsystem registrieren

8.4.3     Die Geräteinitialisierung und die -deinitialisierung

8.4.4     Auf das USB-Gerät zugreifen

8.5     Netzwerk-Subsystem

8.5.1     Datenaustausch zur Kommunikation

8.5.2     Netzwerktreiber initialisieren

8.5.3     Netzwerktreiber deinitialisieren

8.5.4     Start und Stopp des Treibers

8.5.5     Senden und Empfangen

8.6     Blockorientierte Gerätetreiber

8.6.1     Bevor es richtig losgeht ...

8.6.2     Daten kerneloptimiert transferieren

8.6.3     Grundlegendes zu BIO-Blöcken

8.6.4     Treiberoptimierter Datentransfer

8.7     Crypto-Subsystem

8.7.1     Kleines Einmaleins der Kryptografie

8.7.2     Dienste in der Übersicht

8.7.3     Eigene Algorithmen einbinden

9       Über das Schreiben eines guten, performanten Treibers

9.1     Konzeption

9.1.1     Keine halben Sachen ...

9.1.2     Intuitive Nutzung durch Struktur

9.1.3     Sicher muss es sein

9.1.4     Funktional muss es sein

9.2     Realisierung

9.2.1     Sicherheitsgerichtetes Programmieren

9.2.2     Mit Stil programmieren

9.3     32 Bit und mehr: Portierbarer Code

9.4     Zeitverhalten

Anhang

A      Kernel generieren und installieren

A.1    Nativ kompilieren: PC-Plattform

A.2    Nativ kompilieren: Raspberry Pi

A.3    Cross-Kompilieren: PC als Host, Raspberry Pi als Target

B      Makros und Funktionen des Kernels kurz gefasst

Literaturverzeichnis

Index

1 Einleitung

Computersysteme bestehen aus einer Anzahl unterschiedlicher Hard- und Softwarekomponenten, deren Zusammenspiel erst die Abarbeitung komplexer Programme ermöglicht. Zu den Hardwarekomponenten gehören beispielsweise die eigentliche Verarbeitungseinheit, der Mikroprozessor mit dem Speicher, aber auch die sogenannte Peripherie, wie Tastatur, Maus, Monitor, LEDs oder Schalter. Diese Peripherie wird über Hardwareschnittstellen an die Verarbeitungseinheit angeschlossen. Hierfür haben sich Schnittstellen wie beispielsweise USB (Universal Serial Bus) oder im Bereich der eingebetteten Systeme auch I2C, SPI oder GPIO-Interfaces etabliert. Im PC-Umfeld ist PCI (Peripheral Component Interconnect) und PCI-Express verbreitet. Die Netzwerk- oder Grafikkarte wird beispielsweise über PCI-Express, Tastatur, Maus oder auch Drucker über USB mit dem Rechner verbunden.

Zentrale Komponente für den HW-Zugriff

Zu den Softwarekomponenten gehören das BIOS, das den Rechner nach dem Anschalten initialisiert, und das Betriebssystem. Das Betriebssystem koordiniert sowohl die Abarbeitung der Applikationen als auch die Zugriffe auf die Peripherie. Vielfach ersetzt man in diesem Kontext den Begriff Peripherie durch Hardware oder einfach durch Gerät, so dass das Betriebssystem den Zugriff auf die Hardware bzw. die Geräte steuert. Dazu muss es die unterschiedlichen Geräte kennen, bzw. es muss wissen, wie auf diese Geräte zugegriffen wird. Derartiges Wissen ist innerhalb des Betriebssystems in den Gerätetreibern hinterlegt. Sie stellen damit als Teil des Betriebssystemkerns die zentrale Komponente für den Hardwarezugriff dar. Ein Gerätetreiber ist eine Softwarekomponente, die aus einer Reihe von Funktionen besteht. Diese Funktionen wiederum steuern den Zugriff auf das Gerät.

Für jedes unterschiedliche Gerät wird ein eigener Treiber benötigt. So gibt es beispielsweise jeweils einen Treiber für den Zugriff auf die Festplatte, das Netzwerk oder die serielle Schnittstelle.

Da das Know-how über das Gerät im Regelfall beim Hersteller des Gerätes und nicht beim Programmierer des Betriebssystems liegt, sind innerhalb des Betriebssystemkerns Schnittstellen offengelegt, über die der vom Hersteller erstellte Treiber für das Gerät integriert werden kann. Kennt der Treiberprogrammierer diese Schnittstellen, kann er seinen Treiber erstellen und den Anwendern Zugriff auf die Hardware ermöglichen.

Der Anwender selbst greift auf die Hardware über ihm bekannte Schnittstellen zu. Bei einem Unix-System ist der Gerätezugriff dabei auf den Dateizugriff abgebildet. Jeder Programmierer, der weiß, wie er auf normale Dateien zugreifen kann, ist imstande, auch Hardware anzusprechen.

Für den Anwender eröffnen sich neben dem einheitlichen Applikationsinterface noch weitere Vorteile. Hält sich ein Gerätetreiber an die festgelegten Konventionen zur Treiberprogrammierung, ist der Betriebssystemkern in der Lage, die Ressourcen zu verwalten. Er stellt damit sicher, dass die Ressourcen – wie Speicher, Portadressen, Interrupts oder DMA-Kanäle – nur einmal verwendet werden. Der Betriebssystemkern kann darüber hinaus ein Gerät in einen definierten, sicheren Zustand überführen, falls eine zugreifende Applikation beispielsweise durch einen Programmierfehler abstürzt.

Reale und virtuelle Geräte

Treiber benötigt man jedoch nicht nur, wenn es um den Zugriff auf reale Geräte geht. Unter Umständen ist auch die Konzeption sogenannter virtueller Geräte sinnvoll. So gibt es in einem Unix-System das Gerät /dev/zero, das beim lesenden Zugriff Nullen zurückgibt. Mit Hilfe dieses Gerätes lassen sich sehr einfach leere Dateien erzeugen. Auf das Gerät /dev/null können beliebige Daten geschrieben werden; sämtliche Daten werden vom zugehörigen Treiber weggeworfen. Dieses Gerät wird beispielsweise verwendet, um Fehlerausgaben von Programmen aus dem Strom sinnvoller Ausgaben zu filtern.

Kernelprogrammierung

Der Linux-Kernel lässt sich aber nicht nur durch Gerätetreiber erweitern. Erweiterungen, die nicht gerätezentriert sind, die vielleicht den Systemzustand überwachen, Daten verschlüsseln oder den zeitkritischen Teil einer Applikation darstellen, sind in vielen Fällen sinnvoll als Kernelcode zu realisieren.

Zur Kernelprogrammierung und zur Erstellung eines Gerätetreibers ist weit mehr als nur das Wissen um Programmierschnittstellen im Kernel notwendig. Man muss sowohl die Möglichkeiten, die das zugrunde liegende Betriebssystem bietet, kennen als auch die prinzipiellen Abläufe innerhalb des Betriebssystemkerns. Eine zusätzliche Erfordernis ist die Vertrautheit mit der Applikationsschnittstelle. Das gesammelte Know-how bildet die Basis für den ersten Schritt vor der eigentlichen Programmierung: die Konzeption.

Ziel dieses Buches ist es damit,

den für die Kernel- und Treiberprogrammierung notwendigen theoretischen Unterbau zu legen,

die durch Linux zur Verfügung gestellten grundlegenden Funktionalitäten vorzustellen,

die für Kernelcode und Gerätetreiber relevanten betriebssysteminternen und applikationsseitigen Schnittstellen zu erläutern,

die Vorgehensweise bei Treiberkonzeption und eigentlicher Treiberentwicklung darzustellen und

Hinweise für ein gutes Design von Kernelcode zu geben.

Scope

Auch wenn viele der vorgestellten Technologien unabhängig vom Betriebssystem bzw. von der Linux-Kernel-Version sind, beziehen sich die Beispiele und Übungen auf den Linux-Kernel 4.x.

Ubuntu und Kernel 4.0.3UP und SMP

Die Beispiele sind auf einem Ubuntu-Linux (Ubuntu 14.04) und dem Kernel 4.0.3 beziehungsweise einem Raspberry Pi 2 unter dem Betriebssystem Raspbian in der Version 2015.03 und dem Kernel in Version 4.0.3 getestet worden. Welche Distribution, ob Debian (pur, in der Ubuntu- oder Raspbian-Variante), Arch Linux, Fedora, SuSE, Red Hat oder ein Selbstbau-Linux (beispielsweise auf Basis von Buildroot), dabei zum Einsatz kommt, spielt im Grunde aber keine Rolle. Kernelcode ist abhängig von der Version des Betriebssystemkerns, nicht aber direkt abhängig von der verwendeten Distribution (Betriebssystemversion). Das Gleiche gilt bezüglich des Einsatzfeldes. Dank seiner hohen Skalierbarkeit ist Linux das erste Betriebssystem, das in eingebetteten Systemen, in Servern, auf Desktop-Rechnern oder sogar auf der Mainframe läuft. Die vorliegende Einführung deckt prinzipiell alle Einsatzfelder ab. Dabei spielt es keine Rolle, ob es sich um eine Einprozessormaschine (Uniprocessor System, UP) oder um eine Mehrprozessormaschine (Symmetric Multiprocessing, SMP) handelt.

Aufbau des Buches

Zu einer systematischen Einführung in die Treiberprogrammierung gehört ein solider theoretischer Unterbau. Dieser soll im folgenden Kapitel gelegt werden. Wer bereits gute Betriebssystemkenntnisse hat und für wen Begriffe wie Prozesskontext und Interrupt-Level keine Fremdwörter sind, kann diesen Abschnitt überspringen. Im Anschluss werden die Werkzeuge und Technologien vorgestellt, die zur Entwicklung von Treibern notwendig sind. In der vierten Auflage wurde dieses Kapitel um einen Abschnitt über die Cross-Entwicklung ergänzt.

Bevor mit der Beschreibung des Treiberinterface im Betriebssystemkern begonnen werden kann, muss das Applikationsinterface zum Treiber hin vorgestellt werden. Denn was nützt es, einen Gerätetreiber zu schreiben, wenn man nicht im Detail weiß, wie die Applikation später auf den Treiber zugreift? Immerhin muss die von der Applikation geforderte Funktionalität im Treiber realisiert werden.

Das folgende Kapitel beschäftigt sich schließlich mit der Treiberentwicklung als solcher. Hier werden insbesondere die Funktionen eines Treibers behandelt, die durch die Applikation aufgerufen werden. In diesem Abschnitt finden Sie auch ein universell einsetzbares Treibertemplate.

Darauf aufbauend werden die Komponenten eines Treibers behandelt, die unabhängig (asynchron) von einer Applikation im Kernel ablaufen. Stichworte hier: Interrupts, Softirqs, Tasklets, Kernel-Threads oder auch Workqueues. Ergänzend finden Sie hier das notwendige Know-how zum Sichern kritischer Abschnitte, zum Umgang mit Zeiten und zur effizienten Speicherverwaltung.

Mit diesen Kenntnissen können bereits komplexere Treiber erstellt werden, Treiber, die sich jetzt noch harmonisch in das gesamte Betriebssystem einfügen sollten. Diese Integration des Treibers ist folglich Thema eines weiteren Kapitels.

Neben den bisher behandelten Treibern für zeichenorientierte Geräte (Character Devices) werden für die Kernelprogrammierung relevante Subsysteme wie GPIO, I2C, USB, Netzwerk und Blockgeräte vorgestellt. Hier zeigen wir Ihnen auch, wie Sie im Kernel existierende und eigene Verschlüsselungsverfahren verwenden.

Einen Treiber zu entwickeln, ist die eine Sache, gutes Treiberdesign eine andere. Dies ist Thema des letzten Kapitels.

Im Anhang schließlich finden sich Hinweise zur Generierung und Installation des Kernels für die PC-Plattform und für den Raspberry Pi. Die Referenzliste der wichtigsten Funktionen, die im Kontext der Kernelprogrammierung eine Rolle spielen, lassen das Buch zu einem Nachschlagewerk werden.

Notwendige Vorkenntnisse

C-Kenntnisse

Das vorliegende Buch ist primär als eine systematische Einführung in das Thema gedacht. Grundkenntnisse im Bereich der Betriebssysteme sind empfehlenswert. Kenntnisse in der Programmiersprache C sind zum Verständnis unabdingbar. Vor allem der Umgang mit Pointern und Funktionsadressen sollte vertraut sein.

Zusätzliche Informationsquellen

Errata und Beispielcode zum Buch

Errata und vor allem auch den Code zu den im Buch vorgestellten Beispieltreibern finden Sie unter https://ezs.kr.hsnr.de/TreiberBuch/.

Die sicherlich wichtigste Informationsquelle zur Erstellung von Gerätetreibern ist der Quellcode des Linux-Kernels selbst. Wer nicht mit Hilfe der Programme find und grep den Quellcode durchsuchen möchte, kann auf die »Linux Cross-Reference« (http://lxr.free-electrons.com/) zurückgreifen. Per Webinterface kann der Quellcode angesehen, aber auch nach Variablen und Funktionen durchsucht werden.

Quellcode online

In den Kernel-Quellen befindet sich eine sehr hilfreiche Dokumentation. Ein Teil der Dokumentation besteht aus Textdateien, die sich mit jedem Editor ansehen lassen. Ein anderer Teil der Dokumentation muss erst erzeugt werden. Dazu wird im Hauptverzeichnis der Kernel-Quellen (/usr/src/linux/) eines der folgenden Kommandos aufgerufen:

(root)# make psdocs   # für Dokumentation in Postscript(root)# make pdfdocs  # für Dokumentation in PDF(root)# make htmldocs # für HTML-Dokumentation

Sind die notwendigen DocBook-Pakete installiert (unter Ubuntu 14.04 unter anderem das Paket docbook-utils), werden eine Reihe unterschiedlicher Dokumente generiert und in das Verzeichnis /usr/src/linux/Documentation/DocBook/ abgelegt. Insbesondere sind hier die folgenden Dokumente zu finden:

Dokumentation als Teil der Kernel-Quellen

device-drivers Dieses Dokument enthält die Beschreibung von Betriebssystemkern-Funktionen, die insbesondere für Entwickler von Gerätetreibern interessant sind.

gadget Eine Einführung in die Erstellung von USB-Slavetreibern

genericirq Eine Einführung in die Interruptverarbeitung, insbesondere auch der Programmierschnittstellen, im Linux-Kernel

kernel-api Dieses Dokument enthält die Beschreibung von Funktionen des Betriebssystemkerns.

kernel-hacking Kernel-Entwickler Rusty Russell führt in einige Grundlagen der Kernel-Entwicklung ein. Leider ist das Dokument nicht mehr aktuell.

kernel-locking Rusty Russell: »Unreliable Guide to kernel-locking«. Hier finden sich einige Aspekte wieder, die die Vermeidung beziehungsweise den Schutz kritischer Abschnitte betreffen.

librs Dieses Dokument enthält die Beschreibung der Reed-Solomon-Bibliothek, die Funktionen zum Kodieren und Dekodieren enthält.

mac80211 Beschreibung des mac80211-Subsystems

parportbook Eine Einführung in die Erstellung von Treibern, die auf die parallele Schnittstelle über das Parport-Subsystem von Linux zugreifen

regulator Eine Beschreibung des Spannungs- und Regulator-Interface (linkstart;regulators driver interface)

uio-howto Howto zu Userspacetreiber (UIO siehe auch [KuQu11/07])

writing_usb_driver Eine Einführung in die Erstellung von USB-Hosttreibern

Neben der Dokumentation, die den Kernel-Quellen beiliegt, gibt es noch diverse Informationsquellen im Internet:

Online-Quellen

http://www.lwn.net Immer donnerstags gibt es hier aktuelle Kernel-News sowie Tipps und Tricks rund um die Kernel- und Treiberprogrammierung. Die ganz aktuelle Ausgabe steht jeweils nur der zahlenden Klientel zur Verfügung. Wer ohne Obolus auskommen will, kann die jeweils vorherige Ausgabe kostenlos lesen.

http://free-electrons.com Sehr wertvolle, praxisorientierte Infos zur Kernel- und Treiberprogrammierung in Form von Tutorials und Foliensätzen. Das Material ist allerdings vorwiegend in Englisch.

http://www.kernel.org Der Server »kernel.org« ist die zentrale Stelle für aktuelle und auch für alte Kernelversionen. Darüber hinaus finden sich hier die Patches einiger Kernelentwickler.

http://www.lkml.org Hier lässt sich die Kernel-Mailing-Liste aktuell mitlesen, ohne selbst eingeschrieben sein zu müssen.

http://www.kernelnewbies.org Hier finden sich viele Einsteigerinformationen und Programmiertricks.

http://www.heise.de/open Unter dem Titel »Kernel-Log« wird hier mit jeder Kernelversion eine detaillierte Zusammenfassung der neuen Features veröffentlicht.

Zu jeweiligen Spezialgebieten der Kernelprogrammierung und Treiberentwicklung gibt es im Internet überdies einige Texte oder Artikel. Hier ist der Leser allerdings selbst gefordert, mit Hilfe einer Suchmaschine Zusatzmaterial zu finden.

Ergänzungen

Zur Abrundung des Themas werden noch die beiden folgenden Bücher empfohlen:

Quade, Mächtel: Moderne Realzeitsysteme kompakt. Eine Einführung mit Embedded Linux. dpunkt.verlag 2012 ([QuMä2012]). Das Buch behandelt verstärkt die Userland-Aspekte, also beispielsweise die Konzeption und Realisierung von realzeitfähigen Applikationen.

Quade: Embedded Linux lernen mit dem Raspberry Pi. Linux-Systeme selber bauen und programmieren. dpunkt.verlag 2014 ([Quade2014]). Das Buch behandelt vor allem die Systemaspekte und zeigt, wie aus den einzelnen Komponenten (Kernel, Treiber, Userland, Applikation) komplette Systeme gebaut werden.

Zu guter Letzt bleibt noch der Verweis auf unsere Artikelserie im Linux-Magazin ab Ausgabe 8/2003, die das Thema Kernelprogrammierung behandelt. In dieser Reihe sind inzwischen weit über 80 Artikel erschienen, die neben der Treiberentwicklung auch praxisorientiert den Linux-Kernel selbst vorstellen. Die Mehrzahl der Artikel kann kostenlos im Internet gelesen werden.

2 Theorie ist notwendig

Natürlich könnte der Entwickler sofort in die Programmierung eines Gerätetreibers einsteigen, und innerhalb kurzer Zeit wären bereits erste Erfolge sichtbar. Doch Treiberprogrammierung ist Kernelprogrammierung, und das heißt auch: Nur wenn Betriebssystemkern und Treiber korrekt interagieren, kann die Stabilität des Systems erhalten bleiben. Andernfalls auftretende Fehler sind subtil und nur äußerst schwer zu finden. Auf jeden Fall sollte sich der Kernelentwickler daher mit der Systemarchitektur, den Kernelkomponenten, den internen Abläufen und dem Unterbrechungsmodell auseinandersetzen.

Diesen grundlegenden, theoretischen Unterbau soll das vorliegende Kapitel legen. Darüber hinaus werden wichtige Begriffe wie Kernelkontext oder Userspace erläutert, und es wird somit für eine einheitliche Begriffswelt gesorgt. Spätestens wenn es in den folgenden Kapiteln um das Schlafenlegen einer Treiberinstanz oder um das Sichern eines kritischen Abschnittes geht, werden Sie die hier vermittelten Kenntnisse benötigen.

2.1 Betriebssystemarchitektur

Definition Betriebssystem

Unter einem Betriebssystem versteht man alle Softwarekomponenten, die

die Ausführung der Applikationen und

die Verteilung der Betriebsmittel (z. B. Interrupts, Speicher, Prozessorzeit)

steuern und überwachen.

Diese Komponenten lassen sich unterteilen in den Kernel (Betriebssystemkern) und in sonstige Betriebssystemkomponenten, auch Userland genannt. Der Betriebssystemkern ist ein Programm, das sämtlichen Applikationen Dienste in Form sogenannter Systemcalls zur Verfügung stellt; dies gilt insbesondere auch für Betriebssystemapplikationen. Mit solchen Diensten lassen sich beispielsweise Daten schreiben und lesen, Daten auf einem Bildschirm oder einem Drucker ausgeben oder Daten von einer Tastatur oder einem Netzwerk-Interface entgegennehmen. Das Userland nutzt die Dienste, um damit Systemkonfigurationen vorzunehmen oder einem Anwender die Möglichkeit zu geben, seine Programme zu starten und ablaufen zu lassen.

2.1.1 Komponenten des Kernels

Abb. 2-1 Betriebssystemarchitektur

In der Abbildung 2-1 ist vereinfacht ein Rechensystem dargestellt. Die grau unterlegten Subsysteme stellen das Betriebssystem dar, wobei sich im unteren Teil der Kernel, im oberen die sonstigen Betriebssystemkomponenten (Services und Bibliotheken) befinden.

Der Betriebssystemkern besteht damit im Wesentlichen aus den folgenden Komponenten, die im Anschluss genauer vorgestellt werden:

Systemcall-Interface

Prozessmanagement

Speichermanagement

IO-Management

Gerätetreiber

Systemcall-Interface

Kerneldienste werden per SW-Interrupt angefordert.

Applikationen können die Dienste, die ein Betriebssystem zur Verfügung stellt, über das Systemcall-Interface in Gebrauch nehmen. Technisch ist diese Schnittstelle über eine Art Software-Interrupt realisiert. Möchte eine Applikation einen Dienst (zum Beispiel das Lesen von Daten aus einer Datei) nutzen, löst sie einen Software-Interrupt aus und übergibt dabei Parameter, die den vom Kernel auszuführenden Dienst hinreichend charakterisieren. Der Kernel selbst führt nach Auslösen des Software-Interrupts die zugehörige Interrupt-Service-Routine (ISR) aus und gibt der aufrufenden Applikation einen Rückgabewert zurück.

Das Auslösen des Software-Interrupts wird im Regelfall durch die Applikationsentwickler nicht selbst programmiert. Vielmehr sind die Aufrufe der Systemcalls in den Standardbibliotheken versteckt, und eine Applikation nutzt eine dem Systemcall entsprechende Funktion in der Bibliothek.

Die Anwendungen fordern die Dienste des IO-Managements über Systemcalls an. Damit wird bei einer Anwendung nicht nur der Code abgearbeitet, der vom Programmierer erstellt wurde, sondern auch der Code, der über die Bibliotheken der eigenen Applikation hinzugebunden wurde, sowie der Kernelcode, der bei der Abarbeitung eines Systemcalls ausgeführt wird.