Subversion Repositories or1k

#ifndef _LINUX_WAIT_H

#define _LINUX_WAIT_H

#define WNOHANG         0x00000001

#define WUNTRACED       0x00000002

#define __WNOTHREAD     0x20000000      /* Don't wait on children of other threads in this group */

#define __WALL          0x40000000      /* Wait on all children, regardless of type */

#define __WCLONE        0x80000000      /* Wait only on non-SIGCHLD children */

#ifdef __KERNEL__

#include <linux/kernel.h>

#include <linux/list.h>

#include <linux/stddef.h>

#include <linux/spinlock.h>

#include <linux/config.h>

#include <asm/page.h>

#include <asm/processor.h>

/*

 * Debug control.  Slow but useful.

 */

#if defined(CONFIG_DEBUG_WAITQ)

#define WAITQUEUE_DEBUG 1

#else

#define WAITQUEUE_DEBUG 0

#endif

struct __wait_queue {

        unsigned int flags;

#define WQ_FLAG_EXCLUSIVE       0x01

        struct task_struct * task;

        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;

/*

 * Debugging macros.  We eschew `do { } while (0)' because gcc can generate

 * spurious .aligns.

 */

#if WAITQUEUE_DEBUG

#define WQ_BUG()        BUG()

#define CHECK_MAGIC(x)                                                  \

        do {                                                                    \

                if ((x) != (long)&(x)) {                                        \

                        printk("bad magic %lx (should be %lx), ",               \

                                (long)x, (long)&(x));                           \

                        WQ_BUG();                                               \

                }                                                               \

        } while (0)

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

#define WQ_CHECK_LIST_HEAD(list)                                                \

        do {                                                                    \

                if (!(list)->next || !(list)->prev)                             \

                        WQ_BUG();                                               \

        } while(0)

#define WQ_NOTE_WAKER(tsk)                                                      \

        do {                                                                    \

                (tsk)->__waker = (long)__builtin_return_address(0);              \

        } while (0)

#else

#define WQ_BUG()

#define CHECK_MAGIC(x)

#define CHECK_MAGIC_WQHEAD(x)

#define WQ_CHECK_LIST_HEAD(list)

#define WQ_NOTE_WAKER(tsk)

#endif

/*

 * Macros for declaration and initialization of the datatypes

 */

#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, tsk) {                            \

        task:           tsk,                                            \

        task_list:      { NULL, NULL },                                 \

                         __WAITQUEUE_DEBUG_INIT(name)}

#define DECLARE_WAITQUEUE(name, tsk)                                    \

        wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)

#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                           \

        lock:           WAITQUEUE_RW_LOCK_UNLOCKED,                     \

        task_list:      { &(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)

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->flags = 0;

        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);

}

static 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);

}

/*

 * Used for wake-one threads:

 */

static inline void __add_wait_queue_tail(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_tail(&new->task_list, &head->task_list);

}

static inline void __remove_wait_queue(wait_queue_head_t *head,

                                                        wait_queue_t *old)

{

#if WAITQUEUE_DEBUG

        if (!old)

                WQ_BUG();

        CHECK_MAGIC(old->__magic);

#endif

        list_del(&old->task_list);

}

#endif /* __KERNEL__ */

#endif