include/asm-arm/semaphore.h

Name: Public Git Hosting - davej-history.git/blob - include/asm-arm/semaphore.h
Rating: 4.8 (359 reviews)
 1 /*
 2  * linux/include/asm-arm/semaphore.h
 3  */
 4 #ifndef __ASM_ARM_SEMAPHORE_H
 5 #define __ASM_ARM_SEMAPHORE_H
 6
 7 #include <linux/linkage.h>
 8 #include <linux/spinlock.h>
 9 #include <linux/wait.h>
 10
 11 #include <asm/atomic.h>
 12 #include <asm/proc/locks.h>
 13
 14 struct semaphore {
 15  atomic_t count;
 16 int sleepers;
 17  wait_queue_head_t wait;
 18 #if WAITQUEUE_DEBUG
 19 long __magic;
 20 #endif
 21 };
 22
 23 #if WAITQUEUE_DEBUG
 24 # define __SEM_DEBUG_INIT(name) \
 25  , (long)&(name).__magic
 26 #else
 27 # define __SEM_DEBUG_INIT(name)
 28 #endif
 29
 30 #define __SEMAPHORE_INIT(name,count) \
 31  { ATOMIC_INIT(count), 0, \
 32  __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
 33  __SEM_DEBUG_INIT(name) }
 34
 35 #define __MUTEX_INITIALIZER(name) \
 36  __SEMAPHORE_INIT(name,1)
 37
 38 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
 39  struct semaphore name = __SEMAPHORE_INIT(name,count)
 40
 41 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
 42 #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
 43
 44 extern inlinevoidsema_init(struct semaphore *sem,int val)
 45 {
 46 atomic_set(&sem->count, val);
 47  sem->sleepers =0;
 48 init_waitqueue_head(&sem->wait);
 49 #if WAITQUEUE_DEBUG
 50  sem->__magic = (long)&sem->__magic;
 51 #endif
 52 }
 53
 54 staticinlinevoidinit_MUTEX(struct semaphore *sem)
 55 {
 56 sema_init(sem,1);
 57 }
 58
 59 staticinlinevoidinit_MUTEX_LOCKED(struct semaphore *sem)
 60 {
 61 sema_init(sem,0);
 62 }
 63
 64 /*
 65  * special register calling convention
 66  */
 67 asmlinkage void__down_failed(void);
 68 asmlinkage int__down_interruptible_failed(void);
 69 asmlinkage int__down_trylock_failed(void);
 70 asmlinkage void__up_wakeup(void);
 71
 72 externvoid__down(struct semaphore * sem);
 73 externint__down_interruptible(struct semaphore * sem);
 74 externint__down_trylock(struct semaphore * sem);
 75 externvoid__up(struct semaphore * sem);
 76
 77 /*
 78  * This is ugly, but we want the default case to fall through.
 79  * "__down" is the actual routine that waits...
 80  */
 81 extern inlinevoiddown(struct semaphore * sem)
 82 {
 83 #if WAITQUEUE_DEBUG
 84 CHECK_MAGIC(sem->__magic);
 85 #endif
 86
 87 __down_op(sem, __down_failed);
 88 }
 89
 90 /*
 91  * This is ugly, but we want the default case to fall through.
 92  * "__down_interruptible" is the actual routine that waits...
 93  */
 94 extern inlineintdown_interruptible(struct semaphore * sem)
 95 {
 96 #if WAITQUEUE_DEBUG
 97 CHECK_MAGIC(sem->__magic);
 98 #endif
 99
 100 return__down_op_ret(sem, __down_interruptible_failed);
 101 }
 102
 103 extern inlineintdown_trylock(struct semaphore *sem)
 104 {
 105 #if WAITQUEUE_DEBUG
 106 CHECK_MAGIC(sem->__magic);
 107 #endif
 108
 109 return__down_op_ret(sem, __down_trylock_failed);
 110 }
 111
 112 /*
 113  * Note! This is subtle. We jump to wake people up only if
 114  * the semaphore was negative (== somebody was waiting on it).
 115  * The default case (no contention) will result in NO
 116  * jumps for both down() and up().
 117  */
 118 extern inlinevoidup(struct semaphore * sem)
 119 {
 120 #if WAITQUEUE_DEBUG
 121 CHECK_MAGIC(sem->__magic);
 122 #endif
 123
 124 __up_op(sem, __up_wakeup);
 125 }
 126
 127 /* rw mutexes (should that be mutices? =) -- throw rw
 128  * spinlocks and semaphores together, and this is what we
 129  * end up with...
 130  *
 131  * The lock is initialized to BIAS. This way, a writer
 132  * subtracts BIAS ands gets 0 for the case of an uncontended
 133  * lock. Readers decrement by 1 and see a positive value
 134  * when uncontended, negative if there are writers waiting
 135  * (in which case it goes to sleep).
 136  *
 137  * In terms of fairness, this should result in the lock
 138  * flopping back and forth between readers and writers
 139  * under heavy use.
 140  *
 141  * -ben
 142  */
 143 struct rw_semaphore {
 144  atomic_t count;
 145 volatileunsigned char write_bias_granted;
 146 volatileunsigned char read_bias_granted;
 147 volatileunsigned char pad1;
 148 volatileunsigned char pad2;
 149  wait_queue_head_t wait;
 150  wait_queue_head_t write_bias_wait;
 151 #if WAITQUEUE_DEBUG
 152 long __magic;
 153  atomic_t readers;
 154  atomic_t writers;
 155 #endif
 156 };
 157
 158 #if WAITQUEUE_DEBUG
 159 #define __RWSEM_DEBUG_INIT , ATOMIC_INIT(0), ATOMIC_INIT(0)
 160 #else
 161 #define __RWSEM_DEBUG_INIT/* */
 162 #endif
 163
 164 #define __RWSEM_INITIALIZER(name,count) \
 165 { ATOMIC_INIT(count), 0, 0, 0, 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
 166  __WAIT_QUEUE_HEAD_INITIALIZER((name).write_bias_wait) \
 167  __SEM_DEBUG_INIT(name) __RWSEM_DEBUG_INIT }
 168
 169 #define __DECLARE_RWSEM_GENERIC(name,count) \
 170  struct rw_semaphore name = __RWSEM_INITIALIZER(name,count)
 171
 172 #define DECLARE_RWSEM(name) __DECLARE_RWSEM_GENERIC(name,RW_LOCK_BIAS)
 173 #define DECLARE_RWSEM_READ_LOCKED(name) __DECLARE_RWSEM_GENERIC(name,RW_LOCK_BIAS-1)
 174 #define DECLARE_RWSEM_WRITE_LOCKED(name) __DECLARE_RWSEM_GENERIC(name,0)
 175
 176 extern inlinevoidinit_rwsem(struct rw_semaphore *sem)
 177 {
 178 atomic_set(&sem->count, RW_LOCK_BIAS);
 179  sem->read_bias_granted =0;
 180  sem->write_bias_granted =0;
 181 init_waitqueue_head(&sem->wait);
 182 init_waitqueue_head(&sem->write_bias_wait);
 183 #if WAITQUEUE_DEBUG
 184  sem->__magic = (long)&sem->__magic;
 185 atomic_set(&sem->readers,0);
 186 atomic_set(&sem->writers,0);
 187 #endif
 188 }
 189
 190 externstruct rw_semaphore *__down_read_failed(struct rw_semaphore *sem);
 191 externstruct rw_semaphore *__down_write_failed(struct rw_semaphore *sem);
 192 externstruct rw_semaphore *__rwsem_wake(struct rw_semaphore *sem);
 193
 194 extern inlinevoiddown_read(struct rw_semaphore *sem)
 195 {
 196 #if WAITQUEUE_DEBUG
 197 CHECK_MAGIC(sem->__magic);
 198 #endif
 199 __down_op_read(sem, __down_read_failed);
 200 #if WAITQUEUE_DEBUG
 201 if(sem->write_bias_granted)
 202 BUG();
 203 if(atomic_read(&sem->writers))
 204 BUG();
 205 atomic_inc(&sem->readers);
 206 #endif
 207 }
 208
 209 extern inlinevoiddown_write(struct rw_semaphore *sem)
 210 {
 211 #if WAITQUEUE_DEBUG
 212 CHECK_MAGIC(sem->__magic);
 213 #endif
 214 __down_op_write(sem, __down_write_failed);
 215 #if WAITQUEUE_DEBUG
 216 if(atomic_read(&sem->writers))
 217 BUG();
 218 if(atomic_read(&sem->readers))
 219 BUG();
 220 if(sem->read_bias_granted)
 221 BUG();
 222 if(sem->write_bias_granted)
 223 BUG();
 224 atomic_inc(&sem->writers);
 225 #endif
 226 }
 227
 228 extern inlinevoidup_read(struct rw_semaphore *sem)
 229 {
 230 #if WAITQUEUE_DEBUG
 231 if(sem->write_bias_granted)
 232 BUG();
 233 if(atomic_read(&sem->writers))
 234 BUG();
 235 atomic_dec(&sem->readers);
 236 #endif
 237 __up_op_read(sem, __rwsem_wake);
 238 }
 239
 240 extern inlinevoidup_write(struct rw_semaphore *sem)
 241 {
 242 #if WAITQUEUE_DEBUG
 243 if(sem->read_bias_granted)
 244 BUG();
 245 if(sem->write_bias_granted)
 246 BUG();
 247 if(atomic_read(&sem->readers))
 248 BUG();
 249 if(atomic_read(&sem->writers) !=1)
 250 BUG();
 251 atomic_dec(&sem->writers);
 252 #endif
 253 __up_op_write(sem, __rwsem_wake);
 254 }
 255
 256 #endif