Quick Reference

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.

/proc/interrupts, /proc/stat

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.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.220.184.6