These symbols, related to interrupt management, were introduced in this chapter:
#include <linux/sched.h>
,
int request_irq(unsigned int irq, void (*handler)(), unsigned long flags, const char *device, void *dev_id);
,
void free_irq(unsigned int irq, void *dev_id);
These calls are used to register and unregister an interrupt
handler. Kernels older than 2.0 lack the dev_id
argument.
SA_INTERRUPT
,
SA_SHIRQ
,
SA_SAMPLE_RANDOM
Flags for request_irq. SA_INTERRUPT
requests installation of a fast handler (as opposed to a slow
one). SA_SHIRQ
installs a shared handler, and the third
flag asserts that interrupt timestamps can be used to generate
system entropy.
These filesystem nodes are used to report information about hardware interrupts and installed handlers.
unsigned long probe_irq_on(void);
,
int probe_irq_off(unsigned long);
These functions are used by the driver when it has to probe to determine what interrupt line is being used by a device. The result of probe_irq_on must be passed back to probe_irq_off after the interrupt has been generated. The return value of probe_irq_off is the detected interrupt number.
void disable_irq(int irq);
,
void enable_irq(int irq);
A driver can enable and disable interrupt reporting. If the hardware tries to generate an interrupt while interrupts are disabled, the interrupt is lost forever. Calling these functions from a top-half handler has no effect. A driver using a shared handler must not use these functions.
#include <linux/interrupt.h>
,
void mark_bh(int nr);
This function marks a bottom half for execution.
#include <asm/bitops.h>
,
set_bit(nr, void *addr);
,
clear_bit(nr, void *addr);
,
change_bit(nr, void *addr);
,
test_bit(nr, void *addr);
These functions atomically access bit values; they can be used for flags or lock variables. Using these functions prevents any race condition related to concurrent access to the bit.
#include <asm/atomic.h>
,
typedef int atomic_t;
,
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);
These functions atomically access integer variables. To
achieve a clean compile, the atomic_t
variables must
be accessed only through these functions.
#include <linux/sched.h>
,
TASK_RUNNING
,
TASK_INTERRUPTIBLE
,
TASK_UNINTERRUPTIBLE
The most commonly used values for current->state
. They
are used as hints for schedule.
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)
The lowest-level functions that use wait queues. The leading underscores indicate a lower-level functionality, in which case interrupt reporting must already be disabled in the processor.
18.220.184.6