- #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.