include/asm-parisc/semaphore.h

   1 #ifndef _ASM_PARISC_SEMAPHORE_H
   2 #define _ASM_PARISC_SEMAPHORE_H
   3
   4 #include <linux/linkage.h>
   5
   6 /*
   7  * SMP- and interrupt-safe semaphores.
   8  *
   9  * (C) Copyright 1996 Linus Torvalds
  10  *
  11  * SuperH verison by Niibe Yutaka
  12  *
  13  */
  14
  15 /* if you're going to use out-of-line slowpaths, use .section .lock.text,
  16  * not .text.lock or the -ffunction-sections monster will eat you alive
  17  */
  18
  19 #include <linux/spinlock.h>
  20
  21 #include <asm/system.h>
  22 #include <asm/atomic.h>
  23
  24 struct semaphore {
  25         atomic_t count;
  26         int waking;
  27         wait_queue_head_t wait;
  28 #if WAITQUEUE_DEBUG
  29         long __magic;
  30 #endif
  31 };
  32
  33 #if WAITQUEUE_DEBUG
  34 # define __SEM_DEBUG_INIT(name) \
  35                 , (long)&(name).__magic
  36 #else
  37 # define __SEM_DEBUG_INIT(name)
  38 #endif
  39
  40 #define __SEMAPHORE_INITIALIZER(name,count) \
  41 { ATOMIC_INIT(count), 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
  42         __SEM_DEBUG_INIT(name) }
  43
  44 #define __MUTEX_INITIALIZER(name) \
  45         __SEMAPHORE_INITIALIZER(name,1)
  46
  47 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
  48         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
  49
  50 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
  51 #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
  52
  53 extern inline void sema_init (struct semaphore *sem, int val)
  54 {
  55 /*
  56  *      *sem = (struct semaphore)__SEMAPHORE_INITIALIZER((*sem),val);
  57  *
  58  * i'd rather use the more flexible initialization above, but sadly
  59  * GCC 2.7.2.3 emits a bogus warning. EGCS doesnt. Oh well.
  60  */
  61         atomic_set(&sem->count, val);
  62         sem->waking = 0;
  63         init_waitqueue_head(&sem->wait);
  64 #if WAITQUEUE_DEBUG
  65         sem->__magic = (long)&sem->__magic;
  66 #endif
  67 }
  68
  69 static inline void init_MUTEX (struct semaphore *sem)
  70 {
  71         sema_init(sem, 1);
  72 }
  73
  74 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
  75 {
  76         sema_init(sem, 0);
  77 }
  78
  79 asmlinkage void __down_failed(void /* special register calling convention */);
  80 asmlinkage int  __down_failed_interruptible(void  /* params in registers */);
  81 asmlinkage int  __down_failed_trylock(void  /* params in registers */);
  82 asmlinkage void __up_wakeup(void /* special register calling convention */);
  83
  84 asmlinkage void __down(struct semaphore * sem);
  85 asmlinkage int  __down_interruptible(struct semaphore * sem);
  86 asmlinkage int  __down_trylock(struct semaphore * sem);
  87 asmlinkage void __up(struct semaphore * sem);
  88
  89 extern spinlock_t semaphore_wake_lock;
  90
  91 extern __inline__ void down(struct semaphore * sem)
  92 {
  93 #if WAITQUEUE_DEBUG
  94         CHECK_MAGIC(sem->__magic);
  95 #endif
  96
  97         if (atomic_dec_return(&sem->count) < 0)
  98                 __down(sem);
  99 }
 100
 101 extern __inline__ int down_interruptible(struct semaphore * sem)
 102 {
 103         int ret = 0;
 104 #if WAITQUEUE_DEBUG
 105         CHECK_MAGIC(sem->__magic);
 106 #endif
 107
 108         if (atomic_dec_return(&sem->count) < 0)
 109                 ret = __down_interruptible(sem);
 110         return ret;
 111 }
 112
 113 extern __inline__ int down_trylock(struct semaphore * sem)
 114 {
 115         int ret = 0;
 116 #if WAITQUEUE_DEBUG
 117         CHECK_MAGIC(sem->__magic);
 118 #endif
 119
 120         if (atomic_dec_return(&sem->count) < 0)
 121                 ret = __down_trylock(sem);
 122         return ret;
 123 }
 124
 125 /*
 126  * Note! This is subtle. We jump to wake people up only if
 127  * the semaphore was negative (== somebody was waiting on it).
 128  */
 129 extern __inline__ void up(struct semaphore * sem)
 130 {
 131 #if WAITQUEUE_DEBUG
 132         CHECK_MAGIC(sem->__magic);
 133 #endif
 134         if (atomic_inc_return(&sem->count) <= 0)
 135                 __up(sem);
 136 }
 137
 138 /* rw mutexes (should that be mutices? =) -- throw rw
 139  * spinlocks and semaphores together, and this is what we
 140  * end up with...
 141  *
 142  * The lock is initialized to BIAS.  This way, a writer
 143  * subtracts BIAS ands gets 0 for the case of an uncontended
 144  * lock.  Readers decrement by 1 and see a positive value
 145  * when uncontended, negative if there are writers waiting
 146  * (in which case it goes to sleep).
 147  *
 148  * The value 0x01000000 supports up to 128 processors and
 149  * lots of processes.  BIAS must be chosen such that subl'ing
 150  * BIAS once per CPU will result in the long remaining
 151  * negative.
 152  *
 153  * In terms of fairness, this should result in the lock
 154  * flopping back and forth between readers and writers
 155  * under heavy use.
 156  *
 157  *              -ben
 158  */
 159 struct rw_semaphore {
 160         atomic_t                count;
 161         volatile unsigned char  write_bias_granted;
 162         volatile unsigned char  read_bias_granted;
 163         volatile unsigned char  pad1;
 164         volatile unsigned char  pad2;
 165         wait_queue_head_t       wait;
 166         wait_queue_head_t       write_bias_wait;
 167 #if WAITQUEUE_DEBUG
 168         long                    __magic;
 169         atomic_t                readers;
 170         atomic_t                writers;
 171 #endif
 172 };
 173
 174 #if WAITQUEUE_DEBUG
 175 #define __RWSEM_DEBUG_INIT      , ATOMIC_INIT(0), ATOMIC_INIT(0)
 176 #else
 177 #define __RWSEM_DEBUG_INIT      /* */
 178 #endif
 179
 180 #define RW_LOCK_BIAS 0x01000000
 181
 182 #define __RWSEM_INITIALIZER(name,count) \
 183 { ATOMIC_INIT(count), 0, 0, 0, 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
 184         __WAIT_QUEUE_HEAD_INITIALIZER((name).write_bias_wait) \
 185         __SEM_DEBUG_INIT(name) __RWSEM_DEBUG_INIT }
 186
 187 #define __DECLARE_RWSEM_GENERIC(name,count) \
 188         struct rw_semaphore name = __RWSEM_INITIALIZER(name,count)
 189
 190 #define DECLARE_RWSEM(name) __DECLARE_RWSEM_GENERIC(name,RW_LOCK_BIAS)
 191 #define DECLARE_RWSEM_READ_LOCKED(name) __DECLARE_RWSEM_GENERIC(name,RW_LOCK_BIAS-1)
 192 #define DECLARE_RWSEM_WRITE_LOCKED(name) __DECLARE_RWSEM_GENERIC(name,0)
 193
 194 extern inline void init_rwsem(struct rw_semaphore *sem)
 195 {
 196         atomic_set(&sem->count, RW_LOCK_BIAS);
 197         sem->read_bias_granted = 0;
 198         sem->write_bias_granted = 0;
 199         init_waitqueue_head(&sem->wait);
 200         init_waitqueue_head(&sem->write_bias_wait);
 201 #if WAITQUEUE_DEBUG
 202         sem->__magic = (long)&sem->__magic;
 203         atomic_set(&sem->readers, 0);
 204         atomic_set(&sem->writers, 0);
 205 #endif
 206 }
 207
 208 #ifdef FIXME_WILLY_FIXME_FOR_REAL_THIS_TIME
 209 extern struct rw_semaphore *__build_read_lock(struct rw_semaphore *sem, const char *what);
 210 extern struct rw_semaphore *__build_write_lock(struct rw_semaphore *sem, const char *what);
 211 #endif
 212
 213 /* we use FASTCALL convention for the helpers */
 214 extern struct rw_semaphore *FASTCALL(__down_read_failed(struct rw_semaphore *sem));
 215 extern struct rw_semaphore *FASTCALL(__down_write_failed(struct rw_semaphore *sem));
 216 extern struct rw_semaphore *FASTCALL(__rwsem_wake(struct rw_semaphore *sem));
 217
 218 extern inline void down_read(struct rw_semaphore *sem)
 219 {
 220 #if WAITQUEUE_DEBUG
 221         if (sem->__magic != (long)&sem->__magic)
 222                 BUG();
 223 #endif
 224 #ifdef FIXME_WILLY_FIXME_FOR_REAL_THIS_TIME
 225         __build_read_lock(sem, "__down_read_failed");
 226 #endif
 227 #if WAITQUEUE_DEBUG
 228         if (sem->write_bias_granted)
 229                 BUG();
 230         if (atomic_read(&sem->writers))
 231                 BUG();
 232         atomic_inc(&sem->readers);
 233 #endif
 234 }
 235
 236 extern inline void down_write(struct rw_semaphore *sem)
 237 {
 238 #if WAITQUEUE_DEBUG
 239         if (sem->__magic != (long)&sem->__magic)
 240                 BUG();
 241 #endif
 242 #ifdef FIXME_WILLY_FIXME_FOR_REAL_THIS_TIME
 243         __build_write_lock(sem, "__down_write_failed");
 244 #endif
 245 #if WAITQUEUE_DEBUG
 246         if (atomic_read(&sem->writers))
 247                 BUG();
 248         if (atomic_read(&sem->readers))
 249                 BUG();
 250         if (sem->read_bias_granted)
 251                 BUG();
 252         if (sem->write_bias_granted)
 253                 BUG();
 254         atomic_inc(&sem->writers);
 255 #endif
 256 }
 257
 258 /* When a reader does a release, the only significant
 259  * case is when there was a writer waiting, and we've
 260  * bumped the count to 0: we must wake the writer up.
 261  */
 262 extern inline void __up_read(struct rw_semaphore *sem)
 263 {
 264 }
 265
 266 /* releasing the writer is easy -- just release it and
 267  * wake up any sleepers.
 268  */
 269 extern inline void __up_write(struct rw_semaphore *sem)
 270 {
 271 }
 272
 273 extern inline void up_read(struct rw_semaphore *sem)
 274 {
 275 #if WAITQUEUE_DEBUG
 276         if (sem->write_bias_granted)
 277                 BUG();
 278         if (atomic_read(&sem->writers))
 279                 BUG();
 280         atomic_dec(&sem->readers);
 281 #endif
 282         __up_read(sem);
 283 }
 284
 285 extern inline void up_write(struct rw_semaphore *sem)
 286 {
 287 #if WAITQUEUE_DEBUG
 288         if (sem->read_bias_granted)
 289                 BUG();
 290         if (sem->write_bias_granted)
 291                 BUG();
 292         if (atomic_read(&sem->readers))
 293                 BUG();
 294         if (atomic_read(&sem->writers) != 1)
 295                 BUG();
 296         atomic_dec(&sem->writers);
 297 #endif
 298         __up_write(sem);
 299 }
 300
 301 #endif /* _ASM_PARISC_SEMAPHORE_H */