Treiber Fortgeschrittene Konzepte

Transkript

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

2 Übersicht Inhalt: Asynchronität auf Kernel-Ebene Interrupts, Softirqs, Kernel-Threads, Synchronisation und Sperren atomare Operationen, Semaphore, Spinlocks, Interruptsperren, weitere Hilfsmittel. Treiber Fortgeschrittene Konzepte 2/

3 Asynchronität auf Kernel-Ebene Eigenschaften Nebenläufige Funktionen können direkt im Kernel ablaufen, Vorteile: Verringerung der Zeit für Kontextwechsel, Verbesserung der Reaktionszeit, verschiedene Möglichkeiten: Hard-IRQs ( klassische Interrupts), Softirqs, Kernel-Threads. Treiber Fortgeschrittene Konzepte 3/

4 Interrupts Allgemeine Motivation und API-Funktionen: vgl. voriger Foliensatz. Implementierungsaspekte der ISR: während der Abarbeitung sind Interrupts (der lokalen CPU) gesperrt ISR kurz halten, keine Funktionen aufrufen, die Interrupts freigeben, kein Wechsel in Zustand wartend möglich: blockierende API-Funktionen können nicht benutzt werden, nicht im Prozess-Kontext: kein Zugriff auf Treiberinstanzen, zur Verbesserung der Latenz: Auslagern von länger laufenden Funktionen, z.b. in Tasklets (s.u.). Treiber Fortgeschrittene Konzepte 4/

5 Softirqs Ausprägungen Softirq (allgemein), Tasklet, Timer. Treiber Fortgeschrittene Konzepte 5/

6 Softirqs allgemein Eigenschaften Besondere, wichtige Aktionen (in Form von Funktionen), werden unmittelbar nach Rückkehr aus Hard-ISR abgearbeitet, 32 priorisierte Softirq-Routinen, einige spezielle Arten vordefiniert, es sollten möglichst keine neuen Arten eingeführt werden (stattdessen Tasklets verwenden). Treiber Fortgeschrittene Konzepte 6/

7 Softirqs allgemein (2) Vordefinierte Arten HI_SOFTIRQ hochpriore Tasklets, TIMER_SOFTIRQ zeitgesteuerte Aufgaben, NET_TX_SOFTIRQ Netzwerk-Senden, NET_RX_SOFTIRQ Netzwerk-Empfangen, BLOCK_SOFTIRQ Blockgeräteaufgaben, TASKLET_SOFTIRQ normale Tasklets, SCHED_SOFTIRQ Load-Balancing bei SMP, HRTIMER_SOFTIRQ High-Resolution-Timer, RCU_SOFTIRQ Read-Copy-Update-Mechanismus. Treiber Fortgeschrittene Konzepte 7/

8 Softirqs allgemein (3) Wichtig Abarbeitung im Interrupt-Kontext, Interrupts sind aber zugelassen, Abarbeitung in der oben dargestellten Reihenfolge, können bei Multiprozessorsystemen mehrfach gleichzeitig ausgeführt werden. Treiber Fortgeschrittene Konzepte 8/

9 Tasklets Eigenschaften Zur Verbesserung der Interrupt-Latenz: 1 ISR (Interrupts gesperrt): führt kritische Aufgaben durch, schedult Tasklet, 2 Tasklet (Interrupts freigegeben): führt berechnungs-/ IO-intensive Aufgaben durch, werden in Softirq (HI_SOFTIRQ oder TASKLET_SOFTIRQ) eingehängt, ein Tasklet wird nur einmal zu einem Zeitpunkt ausgeführt (auch auf SMP-Systemen), früher: bottom half. Treiber Fortgeschrittene Konzepte 9/

10 API: tasklet_init tasklet_init #i n c l u d e <l i n u x / i n t e r r u p t. h> void t a s k l e t _ i n i t ( s t r u c t t a s k l e t _ s t r u c t t, void ( f u n c ) ( unsigned long ), unsigned long data ) ; Dynamische Variante, initialisiert das Tasklet t, func wird bei Abarbeitung des Tasklets mit Parameter data aufgerufen. Treiber Fortgeschrittene Konzepte 10/

11 API: DECLARE_TASKLET DECLARE_TASKLET #i n c l u d e <l i n u x / i n t e r r u p t. h> DECLARE_TASKLET( s t r u c t t a s k l e t _ s t r u c t name, void ( f u n c ) ( unsigned long ), unsigned long data ) ; Statische Variante, definiert das Tasklet mit Namen name, func wird bei Abarbeitung des Tasklets mit Parameter data aufgerufen. Treiber Fortgeschrittene Konzepte 11/

12 API: tasklet_schedule tasklet_schedule #i n c l u d e <l i n u x / i n t e r r u p t. h> void t a s k l e t _ s c h e d u l e ( s t r u c t t a s k l e t _ s t r u c t t ) ; void t a s k l e t _ h i _ s c h e d u l e ( s t r u c t t a s k l e t _ s t r u c t t ) ; Übergibt das Tasklet t zur Abarbeitung an den Kernel, tasklet_schedule hängt in TASKLET_SOFTIRQ, tasklet_hi_schdule in HI_SOFTIRQ ein, Achtung: zum Schedulen werden die Interrupts gesperrt. Treiber Fortgeschrittene Konzepte 12/

13 API: tasklet_kill tasklet_kill #i n c l u d e <l i n u x / i n t e r r u p t. h> void t a s k l e t _ k i l l ( s t r u c t t a s k l e t _ s t r u c t t ) ; Entfernt das Tasklet t, entfernt werden kann unabhängig davon, ob das Tasklet geschedult ist. Treiber Fortgeschrittene Konzepte 13/

14 Tasklets Probleme Wichtig Tasklets beeinflussen die Task-Latenzzeit, Tasklets laufen im Interrupt-Kontext Schlafenlegen nicht möglich, Race-Gefahr beim Entladen von Modulen, falls zu diesem Zeitpunkt noch Tasklets des Moduls geschedult sind. Treiber Fortgeschrittene Konzepte 14/

15 Timer Eigenschaften Ausführen einer Funktion zu einem Zeitpunkt in der Zukunft, Zeiteinheit ist jiffies (Zahl der Timerinterrupts seit Systemstart), Frequenz ist Plattform- und Kernel-Config-Abhängig (steht in der Konstante HZ aus <asm/param.h>). Treiber Fortgeschrittene Konzepte 15/

16 API: Timer Funktionsübersicht Aus <linux/timer.h>: DEFINE_TIMER, init_timer, add_timer, mod_timer, timer_pending, del_timer, del_timer_sync. Treiber Fortgeschrittene Konzepte 16/

17 Kernel-Threads Wichtige Ausprägungen Kernel-Thread, Workqueue, Event-Workqueue. Treiber Fortgeschrittene Konzepte 17/

18 Kernel-Thread Eigenschaften Vollwertige Task, darf schlafen, wird vom Scheduler i.d.r. nicht unterbrochen, läuft vollständig im Kernel-Space, braucht keine User-Space-Segmente. Treiber Fortgeschrittene Konzepte 18/

19 API: Kernel-Thread Funktionsübersicht Aus <linux/kthread.h>: kthread_create, kthread_run, kthread_stop, kthread_should_stop, aus <linux/sched.h>: wake_up_process, allow_signal, send_sig. Treiber Fortgeschrittene Konzepte 19/

20 Kernel-Thread: Beispiel Thread erzeugen s t a t i c s t r u c t t a s k _ s t r u c t t ; s t a t i c i n t open ( s t r u c t n e t _ d e v i c e dev ) { t = k t h r e a d _ c r e a t e ( th_func, dev, " th_func_%s ", dev >name ) ; i f ( IS_ERR ( t ) ) { r e t u r n PTR_ERR( t ) ; } wake_up_process ( t ) ; } r e t u r n 0 ; Treiber Fortgeschrittene Konzepte 20/

21 Kernel-Thread: Beispiel (2) Threadfunktion s t a t i c i n t th_func ( void data ) { s t r u c t n e t _ d e v i c e dev = ( s t r u c t n e t _ d e v i c e ) data ; w h i l e (! k t h r e a d _ s h o u l d _ s t o p ( ) ) { /... / } } d o _ e x i t ( 0 ) ; Treiber Fortgeschrittene Konzepte 21/

22 Kernel-Thread: Beispiel (3) Thread beenden s t a t i c i n t c l o s e ( s t r u c t n e t _ d e v i c e dev ) { i n t r e t ; r e t = k t h r e a d _ s t o p ( t ) ; } r e t u r n r e t ; Treiber Fortgeschrittene Konzepte 22/

23 Workqueue Eigenschaften Enthält Einträge aus Funktionsadresse und Parameter, jede Funktion wird genau einmal ausgeführt (ähnlich Tasklets), zu jeder Workqueue gehört ein Kernel-Thread, der die Funktionen ausführt Ausführung im Kernel-Space, außerhalb des Interrupt-Kontexts, legt sich eine Funktion schlafen, ist die ganze Queue blockiert, zeitversetztes Einhängen ist möglich. Treiber Fortgeschrittene Konzepte 23/

24 API: Workqueue Funktionsübersicht Aus <linux/workqueue.h>: DECLARE_WORK, INIT_WORK, queue_work, queue_delayed_work, flush_workqueue, destroy_workqueue. Treiber Fortgeschrittene Konzepte 24/

25 Event-Workqueue Eigenschaften Für jede CPU eine, wird beim Start des Systems automatisch angelegt, Funktionen können von allen Treibern beliebig eingehängt werden, Eigenschaften sonst wie bei Workqueue, früher: keventd. Treiber Fortgeschrittene Konzepte 25/

26 API: Event-Workqueue Funktionsübersicht Aus <linux/workqueue.h>: schedule_work, schedule_delayed_work, flush_scheduled_work. Treiber Fortgeschrittene Konzepte 26/

27 Synchronisation und Sperren Motivation Existiert Nebenläufigkeit bzw. Asynchronität (hier: Hard- und Softirqs, Kernel-Threads, SMP), so treten früher oder später Situationen auf, in denen der Zugriff auf gemeinsame Ressourcen synchronisiert werden muss. Treiber Fortgeschrittene Konzepte 27/

28 Synchronisation und Sperren (2) Ausprägungen Atomare Operationen, Semaphore, Spinlocks, Interruptsperren, weitere Hilfsmittel (Completion, Memory Barrier). Treiber Fortgeschrittene Konzepte 28/

29 Atomare Operationen Integer-Operationen Erlauben den garantiert atomaren Zugriff auf Variablen der besonderen Typen atomic_t und atomic64_t, atomic_t stellt 32-Bit-Integers dar, atomic64_t stellt 64-Bit-Integers dar (nur auf X86_64), Operationen: Lesen und Schreiben, Addieren und Subtrahieren, In- und Dekrementieren, Kombinationen aus Verknüpfung und Test. Treiber Fortgeschrittene Konzepte 29/

30 API: Integer-Operationen Funktionsübersicht #i n c l u d e <asm/ atomic. h> i n t atomic_read ( atomic_t v ) ; void atomic_set ( atomic_t v, i n t i ) ; void atomic_add ( i n t i, atomic_t v ) ; void atomic_sub ( i n t i, atomic_t v ) ; void atomic_inc ( atomic_t v ) ; void atomic_dec ( atomic_t v ) ; i n t atomic_sub_and_test ( i n t i, atomic_t v ) ; // v==0 i n t atomic_inc_and_test ( atomic_t v ) ; // v==0 i n t atomic_dec_and_test ( atomic_t v ) ; // v==0 i n t atomic_add_negative ( i n t i, atomic_t v ) ; // v < 0 Treiber Fortgeschrittene Konzepte 30/

31 API: 64-Bit-Integer-Operationen Funktionsübersicht #i n c l u d e <asm/ atomic. h> long atomic64_read ( atomic64_t v ) ; void atomic64_set ( atomic64_t v, long i ) ; void atomic64_add ( long i, atomic64_t v ) ; void atomic64_sub ( long i, atomic64_t v ) ; void atomic64_inc ( atomic64_t v ) ; void atomic64_dec ( atomic64_t v ) ; i n t atomic64_sub_and_test ( long i, atomic64_t v ) ; i n t atomic64_inc_and_test ( atomic64_t v ) ; i n t atomic64_dec_and_test ( atomic64_t v ) ; i n t atomic64_add_negative ( long i, atomic64_t v ) ; Treiber Fortgeschrittene Konzepte 31/

32 Atomare Operationen (2) Bit-Manipulation Erlauben den garantiert atomaren Zugriff auf einzelne Bits von bis zu 32 Bit langen Variablen, Operationen: Setzen und Löschen, Toggeln, Kombinationen aus Test und Änderung. Treiber Fortgeschrittene Konzepte 32/

33 API: Bit-Manipulation Funktionsübersicht #i n c l u d e <asm/ b i t o p s. h> void s e t _ b i t ( i n t nr, unsigned long addr ) ; void c l e a r _ b i t ( i n t nr, unsigned long addr ) ; void change_bit ( i n t nr, unsigned long addr ) ; i n t t e s t _ a n d _ s e t _ b i t ( i n t nr, unsigned long addr ) ; i n t t e s t _ a n d _ c l e a r _ b i t ( i n t nr, unsigned long addr ) ; i n t test_and_change_bit ( i n t nr, unsigned long addr ) ; i n t t e s t _ b i t ( i n t nr, unsigned long addr ) ; Treiber Fortgeschrittene Konzepte 33/

34 Semaphore Eigenschaften Zur Sicherung kritischer Abschnitte, Ausprägungen: Semaphor (i.e.s.), Mutex, Read-/Write-Semaphor, die P-Funktionen versetzen den Prozess ggf. in den Wartezustand nur in Kontexten erlaubt, in denen gewartet werden kann. Treiber Fortgeschrittene Konzepte 34/

35 Semaphore i.e.s. Eigenschaften Mit beliebigem Integer-Wert 0 initialisierbar, Betreten des kritischen Abschnitts: down-funktionen (P-Operation), testen auf > 0, warten ggf., dekrementieren, Verlassen des kritischen Abschnitts: up-funktionen (V-Operation), inkrementieren, wecken ggf. Wartende auf, mehrere Prozesse im kritischen Abschnitt möglich. Treiber Fortgeschrittene Konzepte 35/

36 API: Semaphore i.e.s. Funktionsübersicht #i n c l u d e <l i n u x / semaphore. h> void s e m a _ i n i t ( s t r u c t semaphore s, i n t v a l ) ; void down ( s t r u c t semaphore s ) ; i n t d o w n _ i n t e r r u p t i b l e ( s t r u c t semaphore s ) ; i n t down_trylock ( s t r u c t semaphore s ) ; void up ( s t r u c t semaphore s ) ; Treiber Fortgeschrittene Konzepte 36/

37 Mutex Eigenschaften Einfacher gegenseitiger Ausschluss (Semaphor, der nur 0 oder 1 sein kann). Achtung: Es existieren zwei Arten von Mutex-Implementationen: alt basierend auf Semaphoren, Funktionen zum Belegen und Freigeben wie bei Semaphor, für die Initialisierung gibt es eigene Funktionen/Makros. neu eigenständige Implementation. Treiber Fortgeschrittene Konzepte 37/

38 API: Mutex (alt) Funktionsübersicht #i n c l u d e <l i n u x / semaphore. h> DECLARE_MUTEX( name ) ; DECLARE_MUTEX_LOCKED( name ) ; void init_mutex ( s t r u c t semaphore s ) ; void init_mutex_locked( s t r u c t semaphore s ) ; Vorteil: dürfen (wie Semaphore) auch von anderen Prozessen und aus Interrupt-Kontexten freigegeben werden. Treiber Fortgeschrittene Konzepte 38/

39 API: Mutex (neu) Funktionsübersicht #i n c l u d e <l i n u x /mutex. h> DEFINE_MUTEX( name ) ; m u t e x _ i n i t ( mutex ) ; void mutex_lock ( s t r u c t mutex l o c k ) ; i n t m u t e x _ l o c k _ i n t e r r u p t i b l e ( s t r u c t mutex l o c k ) ; i n t m u t e x _ t r y l o c k ( s t r u c t mutex l o c k ) ; void mutex_unlock ( s t r u c t mutex l o c k ) ; i n t mutex_is_locked ( s t r u c t mutex l o c k ) ; void mutex_lock_nested ( s t r u c t mutex l ock, unsigned i n t s u b c l a s s ) ; i n t m u t e x _ l o c k _ i n t e r r u p t i b l e _ n e s t e d ( s t r u c t mutex l ock, unsigned i n t s u b c l a s s ) ; Vorteil: Bessere Performance und bessere Debug-Möglichkeiten. Treiber Fortgeschrittene Konzepte 39/

40 Read-/Write-Semaphor Eigenschaften Unterscheidung von zwei Modi beim Betreten des kritischen Abschnitts: Lesen und Schreiben, konkurrierendes Lesen ist erlaubt, konkurrierendes Schreiben ist nicht erlaubt. Treiber Fortgeschrittene Konzepte 40/

41 API: Read-/Write-Semaphor Funktionsübersicht #i n c l u d e <l i n u x /rwsem. h> void init_rwsem ( s t r u c t rw_semaphore s ) ; void down_read ( s t r u c t rw_semaphore s ) ; void down_write ( s t r u c t rw_semaphore s ) ; i n t down_read_trylock ( s t r u c t rw_semaphore s ) ; i n t d o w n _ w r i t e _ t r y l o c k ( s t r u c t rw_semaphore s ) ; void up_read ( s t r u c t rw_semaphore s ) ; void up_write ( s t r u c t rw_semaphore s ) ; void downgrade_write ( s t r u c t rw_semaphore s ) ; Treiber Fortgeschrittene Konzepte 41/

42 Spinlocks Motivation Sicherung kritischer Abschnitte zwischen Prozess-Kontext und Interrupt-Kontext: im Interrupt-Kontext ist kein passives Warten (per Prozesszustand) möglich keine Semaphore, bei Monoprozessoren: Interrupt-Sperre würde reichen, bei Multiprozessoren: es können (sinnvollerweise) nur die lokalen Interrupts der eigenen CPU gesperrt werden aktives Warten erforderlich! Treiber Fortgeschrittene Konzepte 42/

43 Spinlocks (2) Konsequenzen Einsatz von Spinlocks (eigentlich) nur auf Multiprozessoren, möglichst kurzer kritischer Abschnitt für kurze Latenzen, im kritischen Abschnitt nicht schlafen legen. Aber... Spinlocks sind auch auf Monoprozessor-Maschinen möglich; die betreffenden Makros/Funktionen verwenden dann automatisch eine einfache Interruptsperre. Treiber Fortgeschrittene Konzepte 43/

44 API: spin_lock_init spin_lock_init #i n c l u d e <asm/ s p i n l o c k. h> void s p i n _ l o c k _ i n i t ( s p i n l o c k _ t sp ) ; Initialisiert das Spinlock sp. Treiber Fortgeschrittene Konzepte 44/

45 API: Lock mit IRQ-Sicherung Funktionen #i n c l u d e <asm/ s p i n l o c k. h> void s p i n _ l o c k _ i r q s a v e ( s p i n l o c k _ t sp, unsigned long f l a g s ) ; void s p i n _ u n l o c k _ i r q r e s t o r e ( s p i n l o c k _ t sp, unsigned long f l a g s ) ; Betreten und Verlassen des durch sp geschützten kritischen Abschnitts, alle lokalen Interrupts werden gesperrt, der alte Interrupt-Zustand wird in flags gespeichert bzw. wieder daraus hergestellt. Treiber Fortgeschrittene Konzepte 45/

46 API: Lock mit IRQ-Deaktivierung Funktionen #i n c l u d e <asm/ s p i n l o c k. h> void s p i n _ l o c k _ i r q ( s p i n l o c k _ t sp ) ; void s p i n _ u n l o c k _ i r q ( s p i n l o c k _ t sp ) ; Betreten und Verlassen des durch sp geschützten kritischen Abschnitts, alle Interrupts werden gesperrt, der alte Interrupt-Zustand wird nicht gesichert. Treiber Fortgeschrittene Konzepte 46/

47 API: Lock mit Softirq-Deaktivierung Funktionen #i n c l u d e <asm/ s p i n l o c k. h> void spin_lock_bh ( s p i n l o c k _ t sp ) ; void spin_unlock_bh ( s p i n l o c k _ t sp ) ; Betreten und Verlassen des durch sp geschützten kritischen Abschnitts, nur Softirqs werden gesperrt, Hardware-Interrupts sind weiterhin möglich. Treiber Fortgeschrittene Konzepte 47/

48 API: Lock ohne IRQ-Deaktivierung Funktionen #i n c l u d e <asm/ s p i n l o c k. h> void s p i n _ l o c k ( s p i n l o c k _ t sp ) ; void s p i n _ u n l o c k ( s p i n l o c k _ t sp ) ; Betreten und Verlassen des durch sp geschützten kritischen Abschnitts, Interrupts werden nicht gesperrt. Treiber Fortgeschrittene Konzepte 48/

49 Spinlocks weitere Varianten Read-/Write-Locks: analog zu Read-/Write-Semaphoren, Sequence-Locks: für sehr kurze kritische Abschnitte, beim lesenden Zugriff auf geschützte Daten umschließt die Spin-Schleife den eigentlichen Zugriff. Treiber Fortgeschrittene Konzepte 49/

50 Interruptsperren Eigenschaften Zum gezielten Aktivieren/Deaktivieren der Interrupts des aktuellen Prozessors, bevorzugte Art unter Linux 2.6 sind Spinlocks! Treiber Fortgeschrittene Konzepte 50/

51 API: Interruptsperren Funktionsübersicht #i n c l u d e <asm/ system. h> void l o c a l _ i r q _ d i s a b l e ( void ) ; void l o c a l _ i r q _ e n a b l e ( void ) ; void l o c a l _ i r q _ s a v e ( unsigned long f l a g s ) ; void l o c a l _ i r q _ r e s t o r e ( unsigned long f l a g s ) ; #i n c l u d e <l i n u x / i n t e r r u p t. h> void l o c a l _ b h _ d i s a b l e ( void ) ; void l o c a l _ b h _ e n a b l e ( void ) ; Treiber Fortgeschrittene Konzepte 51/

52 Weitere Hilfsmittel zur Synchronisation Completion-Objekte Problem wenn ein Modul entladen wird, müssen Kernel-Threads vorher beendet werden, Lösung Einführen spezieller Synchronisationsobjekte, Vorgehen soll ein Modul entladen werden, muss 1 die exit-funktion des Moduls dem Kernel-Threads ein Signal (z.b. SIGTERM) zustellen und 2 auf das Ende des Threads mit wait_for_completion warten, 3 der Thread das Signal entgegennehmen und 4 sich nach Aufruf von complete oder durch Aufruf von complete_and_exit beenden. Treiber Fortgeschrittene Konzepte 52/

53 Weitere Hilfsmittel zur Synchronisation (2) Memory Barriers Problem Race-Conditions, die durch Umsortieren des Codes durch den Compiler entstehen, Lösung Einführen von Speicherzugriffsgrenzen, Vorgehen bei Erreichen der Memory Barrier (im Code markiert durch die Makros mb, rmb oder wmb) ist sichergestellt, das alle vorherigen (Lese- und/oder Schreib-) Speicherzugriffe garantiert durchgeführt wurden. Treiber Fortgeschrittene Konzepte 53/