URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-ppc64/] [semaphore.h] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


#ifndef _PPC64_SEMAPHORE_H
#define _PPC64_SEMAPHORE_H
 
/*
 * Remove spinlock-based RW semaphores; RW semaphore definitions are
 * now in rwsem.h and we use the generic lib/rwsem.c implementation.
 * Rework semaphores to use atomic_dec_if_positive.
 * -- Paul Mackerras (paulus@samba.org)
 */
 
#ifdef __KERNEL__
 
#include <asm/atomic.h>
#include <asm/system.h>
#include <linux/wait.h>
#include <linux/rwsem.h>
 
struct semaphore {
        /*
         * Note that any negative value of count is equivalent to 0,
         * but additionally indicates that some process(es) might be
         * sleeping on `wait'.
         */
        atomic_t count;
        wait_queue_head_t wait;
#if WAITQUEUE_DEBUG
        long __magic;
#endif
};
 
#if WAITQUEUE_DEBUG
# define __SEM_DEBUG_INIT(name) \
                , (long)&(name).__magic
#else
# define __SEM_DEBUG_INIT(name)
#endif
 
#define __SEMAPHORE_INITIALIZER(name, count) \
        { ATOMIC_INIT(count), \
          __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
          __SEM_DEBUG_INIT(name) }
 
#define __MUTEX_INITIALIZER(name) \
        __SEMAPHORE_INITIALIZER(name, 1)
 
#define __DECLARE_SEMAPHORE_GENERIC(name, count) \
        struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
 
#define DECLARE_MUTEX(name)             __DECLARE_SEMAPHORE_GENERIC(name, 1)
#define DECLARE_MUTEX_LOCKED(name)      __DECLARE_SEMAPHORE_GENERIC(name, 0)
 
static inline void sema_init (struct semaphore *sem, int val)
{
        atomic_set(&sem->count, val);
        init_waitqueue_head(&sem->wait);
#if WAITQUEUE_DEBUG
        sem->__magic = (long)&sem->__magic;
#endif
}
 
static inline void init_MUTEX (struct semaphore *sem)
{
        sema_init(sem, 1);
}
 
static inline void init_MUTEX_LOCKED (struct semaphore *sem)
{
        sema_init(sem, 0);
}
 
extern void __down(struct semaphore * sem);
extern int  __down_interruptible(struct semaphore * sem);
extern void __up(struct semaphore * sem);
 
static inline void down(struct semaphore * sem)
{
#if WAITQUEUE_DEBUG
        CHECK_MAGIC(sem->__magic);
#endif
 
        /*
         * Try to get the semaphore, take the slow path if we fail.
         */
        if (atomic_dec_return(&sem->count) < 0)
                __down(sem);
        smp_wmb();
}
 
static inline int down_interruptible(struct semaphore * sem)
{
        int ret = 0;
 
#if WAITQUEUE_DEBUG
        CHECK_MAGIC(sem->__magic);
#endif
 
        if (atomic_dec_return(&sem->count) < 0)
                ret = __down_interruptible(sem);
        smp_wmb();
        return ret;
}
 
static inline int down_trylock(struct semaphore * sem)
{
        int ret;
 
#if WAITQUEUE_DEBUG
        CHECK_MAGIC(sem->__magic);
#endif
 
        ret = atomic_dec_if_positive(&sem->count) < 0;
        smp_wmb();
        return ret;
}
 
static inline void up(struct semaphore * sem)
{
#if WAITQUEUE_DEBUG
        CHECK_MAGIC(sem->__magic);
#endif
 
        smp_wmb();
        if (atomic_inc_return(&sem->count) <= 0)
                __up(sem);
}
 
static inline int sem_getcount(struct semaphore *sem)
{
        return atomic_read(&sem->count);
}
 
#endif /* __KERNEL__ */
 
#endif /* !(_PPC64_SEMAPHORE_H) */

Line No.	Rev	Author	Line
1	1275	phoenix	`#ifndef _PPC64_SEMAPHORE_H`
2			`#define _PPC64_SEMAPHORE_H`
3
4			`/*`
5			`* Remove spinlock-based RW semaphores; RW semaphore definitions are`
6			`* now in rwsem.h and we use the generic lib/rwsem.c implementation.`
7			`* Rework semaphores to use atomic_dec_if_positive.`
8			`* -- Paul Mackerras (paulus@samba.org)`
9			`*/`
10
11			`#ifdef __KERNEL__`
12
13			`#include <asm/atomic.h>`
14			`#include <asm/system.h>`
15			`#include <linux/wait.h>`
16			`#include <linux/rwsem.h>`
17
18			`struct semaphore {`
19			`/*`
20			`* Note that any negative value of count is equivalent to 0,`
21			`* but additionally indicates that some process(es) might be`
22			* sleeping on `wait'.
23			`*/`
24			`atomic_t count;`
25			`wait_queue_head_t wait;`
26			`#if WAITQUEUE_DEBUG`
27			`long __magic;`
28			`#endif`
29			`};`
30
31			`#if WAITQUEUE_DEBUG`
32			`# define __SEM_DEBUG_INIT(name) \`
33			`, (long)&(name).__magic`
34			`#else`
35			`# define __SEM_DEBUG_INIT(name)`
36			`#endif`
37
38			`#define __SEMAPHORE_INITIALIZER(name, count) \`
39			`{ ATOMIC_INIT(count), \`
40			`__WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \`
41			`__SEM_DEBUG_INIT(name) }`
42
43			`#define __MUTEX_INITIALIZER(name) \`
44			`__SEMAPHORE_INITIALIZER(name, 1)`
45
46			`#define __DECLARE_SEMAPHORE_GENERIC(name, count) \`
47			`struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)`
48
49			`#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name, 1)`
50			`#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name, 0)`
51
52			`static inline void sema_init (struct semaphore *sem, int val)`
53			`{`
54			`atomic_set(&sem->count, val);`
55			`init_waitqueue_head(&sem->wait);`
56			`#if WAITQUEUE_DEBUG`
57			`sem->__magic = (long)&sem->__magic;`
58			`#endif`
59			`}`
60
61			`static inline void init_MUTEX (struct semaphore *sem)`
62			`{`
63			`sema_init(sem, 1);`
64			`}`
65
66			`static inline void init_MUTEX_LOCKED (struct semaphore *sem)`
67			`{`
68			`sema_init(sem, 0);`
69			`}`
70
71			`extern void __down(struct semaphore * sem);`
72			`extern int __down_interruptible(struct semaphore * sem);`
73			`extern void __up(struct semaphore * sem);`
74
75			`static inline void down(struct semaphore * sem)`
76			`{`
77			`#if WAITQUEUE_DEBUG`
78			`CHECK_MAGIC(sem->__magic);`
79			`#endif`
80
81			`/*`
82			`* Try to get the semaphore, take the slow path if we fail.`
83			`*/`
84			`if (atomic_dec_return(&sem->count) < 0)`
85			`__down(sem);`
86			`smp_wmb();`
87			`}`
88
89			`static inline int down_interruptible(struct semaphore * sem)`
90			`{`
91			`int ret = 0;`
92
93			`#if WAITQUEUE_DEBUG`
94			`CHECK_MAGIC(sem->__magic);`
95			`#endif`
96
97			`if (atomic_dec_return(&sem->count) < 0)`
98			`ret = __down_interruptible(sem);`
99			`smp_wmb();`
100			`return ret;`
101			`}`
102
103			`static inline int down_trylock(struct semaphore * sem)`
104			`{`
105			`int ret;`
106
107			`#if WAITQUEUE_DEBUG`
108			`CHECK_MAGIC(sem->__magic);`
109			`#endif`
110
111			`ret = atomic_dec_if_positive(&sem->count) < 0;`
112			`smp_wmb();`
113			`return ret;`
114			`}`
115
116			`static inline void up(struct semaphore * sem)`
117			`{`
118			`#if WAITQUEUE_DEBUG`
119			`CHECK_MAGIC(sem->__magic);`
120			`#endif`
121
122			`smp_wmb();`
123			`if (atomic_inc_return(&sem->count) <= 0)`
124			`__up(sem);`
125			`}`
126
127			`static inline int sem_getcount(struct semaphore *sem)`
128			`{`
129			`return atomic_read(&sem->count);`
130			`}`
131
132			`#endif /* __KERNEL__ */`
133
134			`#endif /* !(_PPC64_SEMAPHORE_H) */`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-ppc64/] [semaphore.h] - Blame information for rev 1774