Schnellreferenz

Die folgenden Symbole aus dem Bereich der Interrupt-Verwaltung wurden in diesem Kapitel eingeführt:

#include <linux/sched.h>, int request_irq(unsigned int irq, void (*handler)(), unsigned long flags, const char *dev_name, void *dev_id);, void free_irq(unsigned int irq, void *dev_id);

Diese Aufrufe werden verwendet, um einen Interrupt-Handler zu registrieren und abzumelden.

SA_INTERRUPT, SA_SHIRQ, SA_SAMPLE_RANDOM

Flags für request_irq. SA_INTERRUPT fordert die Installation eines schnellen Handlers (im Gegensatz zu einem langsamen). SA_SHIRQ installiert einen gemeinsam genutzten Handler, und das dritte Flag zeigt an, daß Interrupt-Zeitstempel zur Erzeugung der System-Entropie verwendet werden können.

/proc/interrupts, /proc/stat

Diese Dateisystem-Einträge werden verwendet, um Informationen über Hardware-Interrupts und installierte Handler zu melden.

unsigned long probe_irq_on(void);, int probe_irq_off(unsigned long);

Diese Funktion gibt eine Bitmaske nicht zugewiesener Interrupts zurück. Der Treiber muß sich diese Bitmaske merken und später an probe_irq_off weitergeben. Nach diesem Aufruf sollte der Treiber veranlassen, daß sein Gerät mindestens einen Interrupt erzeugt. Der Rückgabewert von probe_irq_off ist der gefundene Interrupt-Wert.

void disable_irq(int irq);, void disable_irq_nosync(int irq);, void enable_irq(int irq);

Ein Treiber kann das Melden von Interrupts ein- und ausschalten. Wenn die Hardware versucht, einen Interrupt auszulösen, während die Interrupts abgeschaltet sind, dann ist der Interrupt für immer verloren. Ein Treiber, der einen gemeinsam genutzten Handler verwendet, darf diese Funktionen nicht benutzen.

DECLARE_TASKLET(name, function, arg);, tasklet_schedule(struct tasklet_struct *);

Hilfsfunktionen für die Arbeit mit Tasklets. DECLARE_TASKLETS deklariert ein Tasklet mit dem Namen name; bei der Ausführung wird die angegebene function mit arg aufgerufen. Mit tasklet_schedule wird ein Tasklet zur Ausführung vorgemerkt.

#include <linux/interrupt.h>, void mark_bh(int nr);

Diese Funktion merkt eine untere Hälfte zur Ausführung vor.

#include <linux/spinlock.h>, spinlock_t my_lock = SPINLOCK_UNLOCKED;, spin_lock_init(spinlock_t *lock);, spin_lock(spinlock_t *lock);, spin_lock_irqsave(spinlock_t *lock, unsigned long flags);, spin_lock_irq(spinlock_t *lock);, spin_lock_bh(spinlock_t *lock);, spin_unlock(spinlock_t *lock);, spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);, spin_unlock_irq(spinlock_t *lock);, spin_unlock_bh(spinlock_t *lock);, spin_is_locked(spinlock_t *lock);, spin_trylock(spinlock_t *lock), spin_unlock_wait(spinlock_t *lock);

Diverse Funktionen und Symbole für die Arbeit mit Spinlocks.

rwlock_t my_lock = RW_LOCK_UNLOCKED;, read_lock(rwlock_t *lock);, read_lock_irqsave(rwlock_t *lock, unsigned long flags);, read_lock_irq(rwlock_t *lock);, read_lock_bh(rwlock_t *lock);, read_unlock(rwlock_t *lock);, read_unlock_irqrestore(rwlock_t *lock, unsigned long flags);, read_unlock_irq(rwlock_t *lock);, read_unlock_bh(rwlock_t *lock);, write_lock(rwlock_t *lock);, write_lock_irqsave(rwlock_t *lock, unsigned long flags);, write_lock_irq(rwlock_t *lock);, write_lock_bh(rwlock_t *lock);, write_unlock(rwlock_t *lock);, write_unlock_irqrestore(rwlock_t *lock, unsigned long flags);, write_unlock_irq(rwlock_t *lock);, write_unlock_bh(rwlock_t *lock);

Verschiedene Möglichkeiten zum Sperren und Entsperren bei Leser-Schreiber-Spinlocks.

#include <asm/bitops.h>, void set_bit(nr, void *addr);, void clear_bit(nr, void *addr);, void change_bit(nr, void *addr);, test_bit(nr, void *addr);, int test_and_set_bit(nr, void *addr);, int test_and_clear_bit(nr, void *addr);, int test_and_change_bit(nr, void *addr);

Diese Funktionen greifen atomar auf Bit-Werte zu; sie können für Flags oder Sperr-Variablen verwendet werden. Die Verwendung dieser Funktionen verhindert Race Conditions im nebenläufigen Zugriff auf das Bit.

#include <asm/atomic.h>, void atomic_add(atomic_t i, atomic_t *v);, void atomic_sub(atomic_t i, atomic_t *v);, void atomic_inc(atomic_t *v);, void atomic_dec(atomic_t *v);, int atomic_dec_and_test(atomic_t *v);

Diese Funktionen greifen atomar auf Integer-Variablen zu. Damit sauber kompiliert werden kann, darf nur über diese Funktionen auf atomic_t-Variablen zugegriffen werden.

#include <linux/sched.h>, TASK_RUNNING, TASK_INTERRUPTIBLE, TASK_UNINTERRUPTIBLE

Die am häufigsten verwendeten Werte für den Zustand des aktuellen Tasks. Diese werden als Hinweise für schedule verwendet.

set_current_state(int state);

Setzt den Zustand des aktuellen Tasks auf den angegebenen Wert.

void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait), void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait), void _ _add_wait_queue(struct wait_queue ** p, struct wait_queue * wait), void _ _remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait)

Die Funktionen niederster Ebene, die Warteschlangen verwenden. Die führenden Unterstriche weisen auf eine Funktionalität niederer Ebene hin. In diesem Fall muß die Meldung von Interrupts bereits im Prozessor abgeschaltet sein.

wait_event(wait_queue_head_t queue, condition);, wait_event_interruptible(wait_queue_head_t queue, condition);

Diese Makros warten in der angegebenen Warteschlange, bis die angegebene Bedingung wahr ist.