diff options
Diffstat (limited to 'include/linux/wait.h')
| -rw-r--r-- | include/linux/wait.h | 185 |
1 files changed, 177 insertions, 8 deletions
diff --git a/include/linux/wait.h b/include/linux/wait.h index 6514693c2..79fae9356 100644 --- a/include/linux/wait.h +++ b/include/linux/wait.h @@ -8,24 +8,193 @@ #ifdef __KERNEL__ +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/stddef.h> + #include <asm/page.h> +#include <asm/spinlock.h> +#include <asm/processor.h> + +/* + * Temporary debugging help until all code is converted to the new + * waitqueue usage. + */ +#define WAITQUEUE_DEBUG 1 + +#if WAITQUEUE_DEBUG +extern int printk(const char *fmt, ...); +#define WQ_BUG() do { \ + printk("wq bug, forcing oops.\n"); \ + *(int*)0 = 0; \ +} while (0) + +#define CHECK_MAGIC(x) if (x != (long)&(x)) \ + { printk("bad magic %lx (should be %lx), ", (long)x, (long)&(x)); WQ_BUG(); } + +#define CHECK_MAGIC_WQHEAD(x) do { \ + if (x->__magic != (long)&(x->__magic)) { \ + printk("bad magic %lx (should be %lx, creator %lx), ", \ + x->__magic, (long)&(x->__magic), x->__creator); \ + WQ_BUG(); \ + } \ +} while (0) +#endif -struct wait_queue { +struct __wait_queue { + unsigned int compiler_warning; struct task_struct * task; - struct wait_queue * next; + struct list_head task_list; +#if WAITQUEUE_DEBUG + long __magic; + long __waker; +#endif +}; +typedef struct __wait_queue wait_queue_t; + +/* + * 'dual' spinlock architecture. Can be switched between spinlock_t and + * rwlock_t locks via changing this define. Since waitqueues are quite + * decoupled in the new architecture, lightweight 'simple' spinlocks give + * us slightly better latencies and smaller waitqueue structure size. + */ +#define USE_RW_WAIT_QUEUE_SPINLOCK 0 + +#if USE_RW_WAIT_QUEUE_SPINLOCK +# define wq_lock_t rwlock_t +# define WAITQUEUE_RW_LOCK_UNLOCKED RW_LOCK_UNLOCKED + +# define wq_read_lock read_lock +# define wq_read_lock_irqsave read_lock_irqsave +# define wq_read_unlock_irqrestore read_unlock_irqrestore +# define wq_read_unlock read_unlock +# define wq_write_lock_irq write_lock_irq +# define wq_write_lock_irqsave write_lock_irqsave +# define wq_write_unlock_irqrestore write_unlock_irqrestore +# define wq_write_unlock write_unlock +#else +# define wq_lock_t spinlock_t +# define WAITQUEUE_RW_LOCK_UNLOCKED SPIN_LOCK_UNLOCKED + +# define wq_read_lock spin_lock +# define wq_read_lock_irqsave spin_lock_irqsave +# define wq_read_unlock spin_unlock +# define wq_read_unlock_irqrestore spin_unlock_irqrestore +# define wq_write_lock_irq spin_lock_irq +# define wq_write_lock_irqsave spin_lock_irqsave +# define wq_write_unlock_irqrestore spin_unlock_irqrestore +# define wq_write_unlock spin_unlock +#endif + +struct __wait_queue_head { + wq_lock_t lock; + struct list_head task_list; +#if WAITQUEUE_DEBUG + long __magic; + long __creator; +#endif }; +typedef struct __wait_queue_head wait_queue_head_t; + +#if WAITQUEUE_DEBUG +# define __WAITQUEUE_DEBUG_INIT(name) \ + , (long)&(name).__magic, 0 +# define __WAITQUEUE_HEAD_DEBUG_INIT(name) \ + , (long)&(name).__magic, (long)&(name).__magic +#else +# define __WAITQUEUE_DEBUG_INIT(name) +# define __WAITQUEUE_HEAD_DEBUG_INIT(name) +#endif + +#define __WAITQUEUE_INITIALIZER(name,task) \ + { 0x1234567, task, { NULL, NULL } __WAITQUEUE_DEBUG_INIT(name)} +#define DECLARE_WAITQUEUE(name,task) \ + wait_queue_t name = __WAITQUEUE_INITIALIZER(name,task) + +#define __WAIT_QUEUE_HEAD_INITIALIZER(name) \ +{ WAITQUEUE_RW_LOCK_UNLOCKED, { &(name).task_list, &(name).task_list } \ + __WAITQUEUE_HEAD_DEBUG_INIT(name)} + +#define DECLARE_WAIT_QUEUE_HEAD(name) \ + wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name) -#define WAIT_QUEUE_HEAD(x) ((struct wait_queue *)((x)-1)) +static inline void init_waitqueue_head(wait_queue_head_t *q) +{ +#if WAITQUEUE_DEBUG + if (!q) + WQ_BUG(); +#endif + q->lock = WAITQUEUE_RW_LOCK_UNLOCKED; + INIT_LIST_HEAD(&q->task_list); +#if WAITQUEUE_DEBUG + q->__magic = (long)&q->__magic; + q->__creator = (long)current_text_addr(); +#endif +} + +static inline void init_waitqueue_entry(wait_queue_t *q, + struct task_struct *p) +{ +#if WAITQUEUE_DEBUG + if (!q || !p) + WQ_BUG(); +#endif + q->task = p; +#if WAITQUEUE_DEBUG + q->__magic = (long)&q->__magic; +#endif +} + +static inline int waitqueue_active(wait_queue_head_t *q) +{ +#if WAITQUEUE_DEBUG + if (!q) + WQ_BUG(); + CHECK_MAGIC_WQHEAD(q); +#endif + + return !list_empty(&q->task_list); +} + +extern inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new) +{ +#if WAITQUEUE_DEBUG + if (!head || !new) + WQ_BUG(); + CHECK_MAGIC_WQHEAD(head); + CHECK_MAGIC(new->__magic); + if (!head->task_list.next || !head->task_list.prev) + WQ_BUG(); +#endif + list_add(&new->task_list, &head->task_list); +} -static inline void init_waitqueue(struct wait_queue **q) +/* + * Used for wake-one threads: + */ +extern inline void __add_wait_queue_tail(wait_queue_head_t *head, + wait_queue_t *new) { - *q = WAIT_QUEUE_HEAD(q); +#if WAITQUEUE_DEBUG + if (!head || !new) + WQ_BUG(); + CHECK_MAGIC_WQHEAD(head); + CHECK_MAGIC(new->__magic); + if (!head->task_list.next || !head->task_list.prev) + WQ_BUG(); +#endif + list_add(&new->task_list, head->task_list.prev); } -static inline int waitqueue_active(struct wait_queue **q) +extern inline void __remove_wait_queue(wait_queue_head_t *head, + wait_queue_t *old) { - struct wait_queue *head = *q; - return head && head != WAIT_QUEUE_HEAD(q); +#if WAITQUEUE_DEBUG + if (!old) + WQ_BUG(); + CHECK_MAGIC(old->__magic); +#endif + list_del(&old->task_list); } #endif /* __KERNEL__ */ |