Treiber Einfache Gerätetreiber

Transkript

1 Treiber Einfache Gerätetreiber Dr.-Ing. Matthias Sand Lehrstuhl für Informatik 3 (Rechnerarchitektur) Friedrich-Alexander-Universität Erlangen-Nürnberg WS 2010/2011 Treiber Einfache Gerätetreiber 1/

2 Übersicht Inhalt: Das Geräteprinzip, Registrieren und Entfernen, wichtige Treiberfunktionen: open, release (AKA close), read, write, ioctl, poll. Treiber Einfache Gerätetreiber 2/

3 Das Geräteprinzip Geräte werden durch spezielle Dateien im Dateisystem repräsentiert (Device-Nodes), zwei Arten: Block-Devices und Character-Devices, aus Sicht der Anwendungsprogramme kein (wesentlicher) Unterschied zu Dateien, die von Dateisystem-Interaktionen her bekannten Systemaufrufe können benutzt werden (open(2), read(2) etc.). N.B. Netzwerkgeräte werden nicht auf diese Weise ins Dateisystem integriert! (Kommt später...) Treiber Einfache Gerätetreiber 3/

4 Geräte-Knoten Eigenschaften Jeder Geräte-Knoten trägt Informationen über: den Typ des Geräts (Character oder Block), die Major-Nummer des Geräts, die Minor-Nummer des (Unter-)Geräts, (außerdem die üblichen Inode-Informationen wie Eigentümer, Zugriffsrechte etc.). Siehe auch stat(2). Über die Major-Nummer wird beim Zugriff der zuständige Treiber ausgewählt, die Minor-Nummern kann der Treiber nach eigenen Erfordernissen verwalten (auch ignorieren). Treiber Einfache Gerätetreiber 4/

5 Geräte-Knoten anlegen Anlegen Als root mit mknod(1), z.b.: $ mknod / dev /dhwk c $ l s l / dev /dhwk crw r r 1 r o o t r o o t 240, :55 / dev /dhwk $ Treiber Einfache Gerätetreiber 5/

6 Exkurs: Geräteknoten-Verwaltung Problem Wer legt wann und mit welchen Meta-Daten die für meine Hardware nötigen Geräteknoten an? Lösungsmöglichkeiten statisch alle möglichen Geräteknoten werden einmal angelegt und bleiben erhalten, dynamisch Geräteknoten werden genau dann angelegt, wenn eine HW-Komponente erkannt wird. Treiber Einfache Gerätetreiber 6/

7 Exkurs: Geräteknoten-Verwaltung (2) Statische Geräteknoten Vorteil auf einfache Weise volle Kontrolle über Zuordnung Gerätenummer Knoten und Metadaten, Nachteile unflexibel bei neuartigen Geräten, unpraktisch bei Hot-Plugging, (zu) große Zahl möglicher Geräte. Treiber Einfache Gerätetreiber 7/

8 Exkurs: Geräteknoten-Verwaltung (3) Dynamische Geräteknoten Erkenntnis: Kernel weiß bereits, welche Geräte es gibt. Kernel kann das Anlegen von Geräteknoten veranlassen. Früher: devfs: spezielles Dateisystem Erzeugung findet nur im Kernelspace statt. Nachteile: Zuordnung Gerätenummer Knoten willkürlich, Benennung/Pfad kann vom Benutzer nicht ohne weiteres geändert werden, Zugriffsberechtigungen oft nicht passend. heute: udev(7). Treiber Einfache Gerätetreiber 8/

9 Exkurs: Geräteknoten-Verwaltung (4) udev udevd(8) läuft im Userspace, registriert sich beim Kernel, erhält Hot-Plug-Events, sobald der Kernel erkennt, dass Hardware zum System hinzugefügt wurde, aus dem System entfernt wurde, sich in ihren Eigenschaften geändert hat, benutzt sysfs (gemountet unter /sys) für weitere Informationen über das Gerät, durch Konfigurationsdateien unter /etc/udev/rules.d frei konfigurierbar. Treiber Einfache Gerätetreiber 9/

10 Exkurs: Geräteknoten-Verwaltung (5) Beispiel: udev-regeln KERNEL=="mouse[0-9]*", NAME="input/%k" KERNEL=="sr[0-9]*", ACTION=="add change", \ IMPORT{program}="cdrom_id --export $tempnode" SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", \ ATTR{address}=="00:19:99:2c:de:f2", \ ATTR{type}=="1", KERNEL=="eth*", \ NAME="eth0" Treiber Einfache Gerätetreiber 10/

11 Exkurs: Geräteknoten-Verwaltung (6) sysfs Bietet Informationen über: geladene Module, Geräteklassen, Bussysteme/Subsysteme, Geräte, orientiert sich an der Struktur der Kernel-Subsysteme (und somit an der Busstruktur). Treiber Einfache Gerätetreiber 11/

12 Gerät registieren register_chrdev #include <l i n u x / f s. h> i n t r e g i s t e r _ c h r d e v ( unsigned i n t major, const char name, s t r u c t f i l e _ o p e r a t i o n s f o p s ) ; Treiberseitige Anmeldung von Geräten beim IO-Subsystem, typischerweise im Zuge der Modul-Initialisierung, bekanntgeben von Major-Nummer, Gerätenamen und Funktions-Callbacks, Rückgabewert: 0 im Erfolgsfall, negativ im Fehlerfall. Treiber Einfache Gerätetreiber 12/

13 Gerät registieren (2) Wahl der Gerätenummer Effektiv nur unsigned char, Zuordnung durch Kernel-Verantwortliche, frei verfügbare Bereiche: automatische Zuweisung: benutze Nummer 0 bei register_chrdev, Rückgabewert ist dann die vergebene Nummer im Erfolgsfall und 0 im Fehlerfall. Nach erfolgreicher Registrierung steht in /proc/devices Gerätenummer und -name. Treiber Einfache Gerätetreiber 13/

14 Gerät registieren (3) Beispiel s t a t i c s t r u c t f i l e _ o p e r a t i o n s f o p s ; s t a t i c i n t i n i t dhwk_init ( void ) { i f ( r e g i s t e r _ c h r d e v (240, "DHWK",& f o p s ) == 0) { r e t u r n 0 ; } r e t u r n EIO ; } m o d u l e _ i n i t ( dhwk_init ) ; Treiber Einfache Gerätetreiber 14/

15 Gerät entfernen unregister_chrdev #include <l i n u x / f s. h> i n t u n r e g i s t e r _ c h r d e v ( unsigned i n t major, const char name ) ; Treiberseitige Abmeldung von Geräten beim IO-Subsystem, typischerweise im Zuge der Modul-Deinitialisierung, Rückgabewert: 0 im Erfolgsfall, negativ im Fehlerfall (meist -EFAULT, nämlich wenn Name oder Nummer ungültig sind). Treiber Einfache Gerätetreiber 15/

16 Gerät entfernen (2) Beispiel s t a t i c void exit dhwk_exit ( void ) { u n r e g i s t e r _ c h r d e v (240, "DHWK" ) ; } module_exit ( dhwk_exit ) ; Treiber Einfache Gerätetreiber 16/

17 Treiberfunktionen Aus <linux/fs.h>... s t r u c t f i l e _ o p e r a t i o n s {... s t r u c t module owner ; s s i z e _ t ( r e a d ) ( s t r u c t f i l e, char user, s i z e _ t, l o f f _ t ) ; s s i z e _ t ( w r i t e ) ( s t r u c t f i l e, const char user, s i z e _ t, l o f f _ t ) ; unsigned i n t ( p o l l ) ( s t r u c t f i l e, s t r u c t p o l l _ t a b l e _ s t r u c t ) ; i n t ( i o c t l ) ( s t r u c t i n o d e, s t r u c t f i l e, unsigned i n t, unsigned long ) ; i n t ( open ) ( s t r u c t i n o d e, s t r u c t f i l e ) ; i n t ( r e l e a s e ) ( s t r u c t i n o d e, s t r u c t f i l e ) ;... } ; Treiber Einfache Gerätetreiber 17/

18 Treiberfunktionen (2) Eine Instanz von struct file_operations wird bei der Registrierung des Geräts übergeben, sie muss mit Funktionszeigern auf die Implementationen der Datei-IO-Funktionen des Treibers gefüllt sein, nicht-zugewiesene Funktionen führen i.d.r. dazu, dass der Systemcall eine geeignete Fehlermeldung liefert (-EINVAL), owner sollte ein Zeiger auf die Modulstruktur des Moduls zugewiesen werden; dieser ist über das Makro THIS_MODULE verfügbar. Treiber Einfache Gerätetreiber 18/

19 Treiberfunktionen (3) Instanzen Beim Öffnen eines Geräts durch ein Anwendungsprogramm wird vom Kernel eine Instanz von struct file angelegt. Diese dient dem Treiber dann zur Unterscheidung der Zugriffe. Aus <linux/fs.h>... s t r u c t f i l e {... const s t r u c t f i l e _ o p e r a t i o n s f_op ;... unsigned i n t f _ f l a g s ; mode_t f_mode ; void p r i v a t e _ d a t a ;... } ; Treiber Einfache Gerätetreiber 19/

20 Treiberfunktionen open open i n t d r i v e r _ o p e n ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e ) ; Bekommt Device-Node- und Datei-Struktur übergeben, Zugriffsrechte wurden bereits vom Kern geprüft, muss prüfen, ob aus der Sicht des Treibers ein Zugriff zulässig ist, muss ggf. treiberspezifische Initialisierungen durchführen, Rückgabewert: 0 bei Erfolg, negativer Fehlercode bei Fehler. Treiber Einfache Gerätetreiber 20/

21 Treiberfunktionen open (2) Zugriffsprüfung und Initialiserung Aspekte können, je nach Gerät, u.a. sein: begrenzte Zahl gleichzeitig lesender/schreibender Instanzen, unterschiedliche Behandlung verschiedener Minor-Nummern (Zugriff über das Makro iminor(node)), blockierender vs. nicht blockierender Zugriff,... Treiber Einfache Gerätetreiber 21/

22 Treiberfunktionen open (3) Beispiel s t a t i c i n t dhwk_open ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e ) { i f ( ( i n s t a n c e >f _ f l a g s & O_ACCMODE) == O_RDWR ( i n s t a n c e >f _ f l a g s & O_ACCMODE) == O_WRONLY) { i f ( w r i t e _ c o u n t > 0) { r e t u r n EBUSY ; } w r i t e _ c o u n t++; } r e t u r n 0 ; } Treiber Einfache Gerätetreiber 22/

23 Treiberfunktionen release release i n t d r i v e r _ c l o s e ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e ) ; Gegenstück zu open, ist dem close(2)-systemcall zugeordnet, muss ggf. die durch das Öffnen belegten Ressourcen wieder freigeben, Rückgabewert: 0 bei Erfolg, negativer Fehlercode sonst. Treiber Einfache Gerätetreiber 23/

24 Treiberfunktionen release (2) Beispiel s t a t i c i n t dhwk_close ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e ) { i f ( ( i n s t a n c e >f _ f l a g s & O_ACCMODE) == O_RDWR ( i n s t a n c e >f _ f l a g s & O_ACCMODE) == O_WRONLY) { write_count ; } r e t u r n 0 ; } s t a t i c s t r u c t f i l e _ o p e r a t i o n s f o p s = {. owner = THIS_MODULE,. open = dhwk_open,. r e l e a s e = dhwk_close, } ; Treiber Einfache Gerätetreiber 24/

25 API: kmalloc kmalloc #include <l i n u x / s l a b. h> void k m a l l o c ( s i z e _ t s i z e, i n t f l a g s ) ; Allokiert Speicher der Länge size zur Verwendung im Kernel, Flags (vgl. <linux/mm.h>): GFP_KERNEL Kernelthread darf bei zu wenig Speicher schlafen gelegt werden, GFP_USER dito für Treiberinstanz, GFP_ATOMIC blockiert nie, Rückgabewert: Zeiger auf den Speicher im Erfolgsfall, NULL im Fehlerfall. Gegenstück: void kfree(const void *); Treiber Einfache Gerätetreiber 25/

26 API: kmalloc (2) Beispiel s t a t i c i n t dhwk_open ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e ) { i n s t a n c e >p r i v a t e _ d a t a = k m a l l o c ( s i z e o f ( s t r u c t my_data ),GFP_USER ) ; i f ( i n s t a n c e >p r i v a t e _ d a t a == NULL) { r e t u r n ENOMEM; } r e t u r n 0 ; } s t a t i c i n t dhwk_close ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e ) { k f r e e ( i n s t a n c e >p r i v a t e _ d a t a ) ; r e t u r n 0 ; } Treiber Einfache Gerätetreiber 26/

27 Treiberfunktionen read read s s i z e _ t d r i v e r _ r e a d ( s t r u c t f i l e i n s t a n c e, char user b u f f e r, s i z e _ t count, l o f f _ t o f f s e t ) ; Es sollen ab der Position *offset bis zu count Bytes vom Gerät gelesen und nach buffer im Userspace geschrieben werden. Rückgabewert: Anzahl der tatsächlich gelesenen Bytes oder 0, um EOF zu signalisieren oder negativer Fehlercode. Treiber Einfache Gerätetreiber 27/

28 Treiberfunktionen read (2) Beispiel s t a t i c char o u t _ s t r i n g [ ] = " World O H e l l \n " ; s t a t i c s s i z e _ t dhwk_read ( s t r u c t f i l e i n s t a n c e, char user b u f f e r, s i z e _ t count, l o f f _ t o f f s e t ) { } i n t not_copied, to_copy ; to_copy = s t r l e n ( o u t _ s t r i n g )+1; i f ( to_copy > count ) to_copy = count ; not_copied = copy_to_user ( b u f f e r, o u t _ s t r i n g, to_copy ) ; r e t u r n to_copy not_copied ; Treiber Einfache Gerätetreiber 28/

29 API: copy_to_user copy_to_user #include <asm/ u a c c e s s. h> unsigned long copy_to_user ( void to, const void from, unsigned long count ) ; Kopiert count Bytes ab der Speicherstelle from im Kernelspace an die Speicherstelle to im Userspace, prüft Adressbereiche, Rückgabewert: Anzahl der Bytes, die nicht kopiert werden konnten. Treiber Einfache Gerätetreiber 29/

30 (Nicht-)Blockierender Zugriff Blockierend vs. Nicht-Blockierend Wurde die Datei mit dem Flag O_NONBLOCK geöffnet, so muss die read-funktion sofort wieder mit dem Fehlercode -EAGAIN zurückkehren, wenn keine Daten zum Lesen vorhanden sind und das Ende der Datei noch nicht erreicht ist, im blockierenden Modus muss die read-funktion dagegen den aufrufenden Prozess schlafen legen! Treiber Einfache Gerätetreiber 30/

31 Scheduling Treiber Einfache Gerätetreiber 31/

32 API: Scheduling Scheduler-Funktionen #i n c l u d e <l i n u x / sched. h> void s e t _ c u r r e n t _ s t a t e ( i n t s t a t e _ v a l u e ) ; void s c h e d u l e ( void ) ; long s c h e d u l e _ t i m e o u t ( long t i m e o u t ) ; set_current_state setzt den Prozesszustand auf state_value (vgl. vorige Folie), schedule ruft den Scheduler auf, schedule_timeout ruft den Scheduler auf und veranlasst, dass der Prozess nach timout Jiffies wieder in den Zustand TASK_RUNNING versetzt wird; gibt bei Unterbrechung die übrige Wartezeit zurück. Treiber Einfache Gerätetreiber 32/

33 API: Wait-Queues Die Wait-Queue-Funktionen und -Makros vereinfachen den Umgang mit Prozesszuständen für Treiberprogrammierer erheblich. Wait-Queues sind das bevorzugte Mittel, um Prozesse schlafen zu legen und wieder aufzuwecken. init_waitqueue_head #i n c l u d e <l i n u x / w a i t. h> void i n i t _ w a i t q u e u e _ h e a d ( waitqueue_head_t q ) ; Initialisiert das Kopf-Element einer Wait-Queue, muss vor der ersten Verwendung der Wait-Queue aufgerufen werden. Treiber Einfache Gerätetreiber 33/

34 API: Wait-Queues (2) wait_event #i n c l u d e <l i n u x / w a i t. h> void w a i t _ e vent ( wait_queue_head_t q, c o n d i t i o n ) ; i n t w a i t _ e v e n t _ i n t e r r u p t i b l e ( wait_queue_head_t q, c o n d i t i o n ) ; i n t w a i t _ e v e n t _ k i l l a b l e ( wait_queue_head_t q, c o n d i t i o n ) ; Ist condition nicht erfüllt, wartet der Prozess, bis er aufgeweckt wird und condition erfüllt ist, bei der interruptible-variante kann das Warten durch Signale (signal(7)) unterbrochen werden, Rückgabewert (so vorhanden): 0 bei erfüllter Bedingung, ungleich 0 bei Abbruch (typischerweise: -ERESTARTSYS). Treiber Einfache Gerätetreiber 34/

35 API: Wait-Queues (3) wait_event (2) #i n c l u d e <l i n u x / w a i t. h> void wait_event_timeout ( wait_queue_head_t q, c o n d i t i o n, long t i m e o u t ) ; i n t w a i t _ e v e n t _ i n t e r r u p t i b l e _ t i m e o u t ( wait_queue_head_t q, c o n d i t i o n, long t i m e o u t ) ; Wartet bis condition erfüllt oder timeout abgelaufen ist, Rückgabewert: 0 bei abgelaufenem Timer, verbleibende Restwartezeit bei erfüllter Bedingung, ggf. negativen Wert bei Abbruch/Fehler (typischerweise: -ERESTARTSYS). Treiber Einfache Gerätetreiber 35/

36 API: Wait-Queues (4) wake_up #i n c l u d e <l i n u x / w a i t. h> void wake_up ( wait_queue_head_t q ) ; void w a k e _ u p _ i n t e r r u p t i b l e ( wait_queue_head_t q ) ; Weckt an der Wait-Queue q schlafende Prozesse auf, wake_up weckt alle Prozesse auf, wake_up_interruptible nur Prozesse, die mit wait_event_interruptible warten, Wake-Up-Ereignisse werden nicht gespeichert. Treiber Einfache Gerätetreiber 36/

37 API: Wait-Queues (5) Beispiel s t a t i c i n t d a t a _ a v a i l ; s t a t i c wait_queue_head_t read_queue ;... d a t a _ a v a i l = 0 ; i n i t _ w a i t q u e u e _ h e a d (&read_queue ) ;... i f (! ( i n s t a n c e >f _ f l a g s & O_NONBLOCK) ) { r e t = w a i t _ e v e n t _ i n t e r r u p t i b l e ( read_queue, d a t a _ a v a i l ) ;... i n t ISR (... ) {... d a t a _ a v a i l = 1 ; w a k e _ u p _ i n t e r r u p t i b l e (&read_queue ) ;... Treiber Einfache Gerätetreiber 37/

38 Treiberfunktionen und Signale Unterbrechung durch Signal Situation Systemcall (read(2), write(2), ioctl(2),... ; siehe signal(7)) wartet unterbrechbar. Problem Was passiert, wenn der Systemcall von einem Signal unterbrochen wird? Vorgehen wait-funktion kehrt mit -ERESTARTSYS zurück, kann der Systemcall identisch wiederholt werden, bzw. ein Zustand hergestellt werden, in dem das möglich ist, kehrt die Treiberfunktion mit -ERESTARTSYS zurück, wurden (bei Lese-/Schreib-Aufrufen) bereits Daten transferiert, kehrt die Treiberfunktion mit der Zahl der übertragenen Bytes zurück, Betriebssystem sorgt dann dafür, dass die Funktion ggf. erneut aufgerufen wird. Treiber Einfache Gerätetreiber 38/

39 Treiberfunktionen write write s s i z e _ t d r i v e r _ w r i t e ( s t r u c t f i l e i n s t a n c e, const char user b u f f e r, s i z e _ t count, l o f f _ t o f f s e t ) ; Es sollen ab der Position *offset bis zu count Bytes aus buffer auf dem Gerät ausgegeben werden. Rückgabewert: Anzahl der tatsächlich geschriebenen Bytes oder negativer Fehlercode. Treiber Einfache Gerätetreiber 39/

40 Treiberfunktionen write (2) Beispiel s t a t i c s s i z e _ t dhwk_write ( s t r u c t f i l e i n s t a n c e, const char user b u f f e r, s i z e _ t count, l o f f _ t o f f s e t ) { } r e t u r n count ; Treiber Einfache Gerätetreiber 40/

41 API: copy_from_user copy_from_user #include <asm/ u a c c e s s. h> unsigned long copy_from_user ( void to, const void from, unsigned long count ) ; Kopiert count Bytes ab der Speicherstelle from im Userspace an die Speicherstelle to im Kernelspace, prüft Adressbereiche, Rückgabewert: Anzahl der Bytes, die nicht kopiert werden konnten. Treiber Einfache Gerätetreiber 41/

42 API: Stringfunktionen Stringfunktionen #include <l i n u x / s t r i n g. h> char s t r c a t ( char dest, const char s r c ) ; s i z e _ t s t r l c p y ( char dest, char s r c, s i z e _ t count ) ; s i z e _ t s t r l e n ( const char s ) ; char s t r n c a t ( char dest, const char s r c, s i z e _ t maxlen ) ; i n t strncmp ( const char cs, const char ct, s i z e _ t count ) ; char s t r n c p y ( char dest, char s r c, s i z e _ t count ) ; char s t r s t r ( const char s1, const char s2 ) ; Die Funktionen folgen im Wesentlichen ihren gleichnamigen Pendants der C-Bibliothek. Treiber Einfache Gerätetreiber 42/

43 Treiberfunktionen ioctl ioctl i n t d r i v e r _ i o c t l ( s t r u c t i n o d e node, s t r u c t f i l e i n s t a n c e, unsigned i n t command, unsigned long argument ) ; Universelle IO-Kontroll-Funktion, dem Systemaufruf ioctl(2) zugeordnet, command: Befehlsnummer; kann vom implementierenden Treiber prinzipiell beliebig definiert werden (vgl. aber z.b. ioctl_list(2)), argument: Befehlsparameter; typischerweise Zeiger auf eine zum Befehl gehörende Datenstruktur (Casting!), Rückgabwert: 0 bei Erfolg, negativer Fehlercode sonst (häufig: -EINVAL bei ungültigem Befehl). Treiber Einfache Gerätetreiber 43/

44 API: Datentransfer User Kernel Datentransfer Bereits vorgestellt: copy_to_user und copy_from_user. Außerdem existieren noch: #i n c l u d e <asm/ u a c c e s s. h> i n t put_user ( datum, d e s t i n a t i o n ) ; i n t g e t _ u s e r ( v a r i a b l e, s o u r c e ) ; Kopieren ein, zwei oder vier Bytes zwischen Kernel- und Userspace, Länge des Datenworts wird aus dem Typ von datum bzw. variable abgeleitet, Adressen werden geprüft, Rückgabewert: 0 bei Erfolg, negativer Fehlercode (-EFAULT) sonst. Treiber Einfache Gerätetreiber 44/

45 API: Datentransfer User Kernel (2) access_ok #i n c l u d e <asm/ u a c c e s s. h> i n t access_ok ( type, addr, s i z e ) ; Prüft, ob der Zugriff type (VERIFY_READ oder VERIFY_WRITE) auf den Speicherbereich der Größe size beginnend bei addr zulässig ist, Rückgabewert: 0, falls der Zugriff nicht möglich ist. Aber: Bei read(2) und write(2) prüft der Kernel schon selbst, ob die Ziel- bzw. Quellbuffer zulässig sind. Treiber Einfache Gerätetreiber 45/

46 API: Datentransfer User Kernel (3) Ungeprüfter Transfer Von den bisher vorgestellten Funktionen/Makros gibt es auch Varianten, die die Gültigkeit der Speicherbereiche nicht prüfen: copy_to_user, copy_from_user, put_user, get_user. Treiber Einfache Gerätetreiber 46/

47 Treiberfunktionen poll poll unsigned i n t d r i v e r _ p o l l ( s t r u c t f i l e i n s t a n c e, p o l l _ t a b l e w a i t ) ; Dient der Überwachung des IO-Kanals, wird von den Systemaufrufen poll(2) und select(2) verwendet, teilt dem Kernel ggf. relevante Wait-Queues mit (vgl. unten), Rückgabewert: veroderte Flags (siehe nächste Folie). Treiber Einfache Gerätetreiber 47/

48 Treiberfunktionen poll (2) Flags Die Flags sagen aus, welche IO-Operationen möglich sind, ohne dass ein auf das poll folgender Aufruf von read oder write blockieren würde. Name POLLIN POLLOUT POLLERR POLLRDNORM POLLWRNORM Bedeutung Daten können ohne zu blockieren gelesen werden, Daten können ohne zu blockieren geschrieben werden, Fehler aufgetreten, Äquivalent zu POLLIN (Kompatibilität!), dito für POLLOUT. Treiber Einfache Gerätetreiber 48/

49 Treiberfunktionen poll (3) Achtung! Greifen mehrere Instanzen auf einen Treiber zu, muss sichergestellt werden, dass genau die Instanz, der durch den Aufruf von poll signalisiert wurde, dass die IO-Operation ohne blockieren möglich ist, bei einem folgenden read/write auch tatsächlich nicht blockiert, auch wenn zwischen dem poll und dem Lese/Schreib-Aufruf eine andere Instanz lesen/schreiben will! Treiber Einfache Gerätetreiber 49/

50 API: poll_wait poll_wait #i n c l u d e <l i n u x / p o l l. h> void p o l l _ w a i t ( s t r u c t f i l e i n s t a n c e, wait_queue_head_t wait_q, p o l l _ t a b l e t a b l e ) ; Gibt dem Kernel innerhalb der Implementation der poll-funktion die Wait-Queue (wait_q) bekannt, auf die sich der Treiber schlafen legt, die übrigen Parameter werden einfach weitergereicht. Treiber Einfache Gerätetreiber 50/