include/asm-i386/spinlock.h

   1 #ifndef __ASM_SPINLOCK_H
   2 #define __ASM_SPINLOCK_H
   3
   4 #ifndef __SMP__
   5
   6 #define DEBUG_SPINLOCKS 0       /* 0 == no debugging, 1 == maintain lock state, 2 == full debug */
   7
   8 #if (DEBUG_SPINLOCKS < 1)
   9
  10 /*
  11  * Your basic spinlocks, allowing only a single CPU anywhere
  12  *
  13  * Gcc-2.7.x has a nasty bug with empty initializers.
  14  */
  15 #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
  16   typedef struct { } spinlock_t;
  17   #define SPIN_LOCK_UNLOCKED { }
  18 #else
  19   typedef struct { int gcc_is_buggy; } spinlock_t;
  20   #define SPIN_LOCK_UNLOCKED { 0 }
  21 #endif
  22
  23 #define spin_lock_init(lock)    do { } while(0)
  24 #define spin_lock(lock)         do { } while(0)
  25 #define spin_trylock(lock)      (1)
  26 #define spin_unlock_wait(lock)  do { } while(0)
  27 #define spin_unlock(lock)       do { } while(0)
  28 #define spin_lock_irq(lock)     cli()
  29 #define spin_unlock_irq(lock)   sti()
  30
  31 #define spin_lock_irqsave(lock, flags) \
  32         do { save_flags(flags); cli(); } while (0)
  33 #define spin_unlock_irqrestore(lock, flags) \
  34         restore_flags(flags)
  35
  36 #elif (DEBUG_SPINLOCKS < 2)
  37
  38 typedef struct {
  39         volatile unsigned int lock;
  40 } spinlock_t;
  41 #define SPIN_LOCK_UNLOCKED { 0 }
  42
  43 #define spin_lock_init(x)       do { (x)->lock = 0; } while (0)
  44 #define spin_trylock(lock)      (!test_and_set_bit(0,(lock)))
  45
  46 #define spin_lock(x)            do { (x)->lock = 1; } while (0)
  47 #define spin_unlock_wait(x)     do { } while (0)
  48 #define spin_unlock(x)          do { (x)->lock = 0; } while (0)
  49 #define spin_lock_irq(x)        do { cli(); spin_lock(x); } while (0)
  50 #define spin_unlock_irq(x)      do { spin_unlock(x); sti(); } while (0)
  51
  52 #define spin_lock_irqsave(x, flags) \
  53         do { save_flags(flags); spin_lock_irq(x); } while (0)
  54 #define spin_unlock_irqrestore(x, flags) \
  55         do { spin_unlock(x); restore_flags(flags); } while (0)
  56
  57 #else /* (DEBUG_SPINLOCKS >= 2) */
  58
  59 typedef struct {
  60         volatile unsigned int lock;
  61         volatile unsigned int babble;
  62         const char *module;
  63 } spinlock_t;
  64 #define SPIN_LOCK_UNLOCKED { 0, 25, __BASE_FILE__ }
  65
  66 #include <linux/kernel.h>
  67
  68 #define spin_lock_init(x)       do { (x)->lock = 0; } while (0)
  69 #define spin_trylock(lock)      (!test_and_set_bit(0,(lock)))
  70
  71 #define spin_lock(x)            do {unsigned long __spinflags; save_flags(__spinflags); cli(); if ((x)->lock&&(x)->babble) {printk("%s:%d: spin_lock(%s:%p) already locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 1; restore_flags(__spinflags);} while (0)
  72 #define spin_unlock_wait(x)     do {unsigned long __spinflags; save_flags(__spinflags); cli(); if ((x)->lock&&(x)->babble) {printk("%s:%d: spin_unlock_wait(%s:%p) deadlock\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} restore_flags(__spinflags);} while (0)
  73 #define spin_unlock(x)          do {unsigned long __spinflags; save_flags(__spinflags); cli(); if (!(x)->lock&&(x)->babble) {printk("%s:%d: spin_unlock(%s:%p) not locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 0; restore_flags(__spinflags);} while (0)
  74 #define spin_lock_irq(x)        do {cli(); if ((x)->lock&&(x)->babble) {printk("%s:%d: spin_lock_irq(%s:%p) already locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 1;} while (0)
  75 #define spin_unlock_irq(x)      do {cli(); if (!(x)->lock&&(x)->babble) {printk("%s:%d: spin_lock(%s:%p) not locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 0; sti();} while (0)
  76
  77 #define spin_lock_irqsave(x,flags)      do {save_flags(flags); cli(); if ((x)->lock&&(x)->babble) {printk("%s:%d: spin_lock_irqsave(%s:%p) already locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 1;} while (0)
  78 #define spin_unlock_irqrestore(x,flags) do {cli(); if (!(x)->lock&&(x)->babble) {printk("%s:%d: spin_unlock_irqrestore(%s:%p) not locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 0; restore_flags(flags);} while (0)
  79
  80 #endif  /* DEBUG_SPINLOCKS */
  81
  82 /*
  83  * Read-write spinlocks, allowing multiple readers
  84  * but only one writer.
  85  *
  86  * NOTE! it is quite common to have readers in interrupts
  87  * but no interrupt writers. For those circumstances we
  88  * can "mix" irq-safe locks - any writer needs to get a
  89  * irq-safe write-lock, but readers can get non-irqsafe
  90  * read-locks.
  91  */
  92 typedef struct { } rwlock_t;
  93 #define RW_LOCK_UNLOCKED { }
  94
  95 #define read_lock(lock)         do { } while(0)
  96 #define read_unlock(lock)       do { } while(0)
  97 #define write_lock(lock)        do { } while(0)
  98 #define write_unlock(lock)      do { } while(0)
  99 #define read_lock_irq(lock)     cli()
 100 #define read_unlock_irq(lock)   sti()
 101 #define write_lock_irq(lock)    cli()
 102 #define write_unlock_irq(lock)  sti()
 103
 104 #define read_lock_irqsave(lock, flags)  \
 105         do { save_flags(flags); cli(); } while (0)
 106 #define read_unlock_irqrestore(lock, flags) \
 107         restore_flags(flags)
 108 #define write_lock_irqsave(lock, flags) \
 109         do { save_flags(flags); cli(); } while (0)
 110 #define write_unlock_irqrestore(lock, flags) \
 111         restore_flags(flags)
 112
 113 #else   /* __SMP__ */
 114
 115 /*
 116  * Your basic spinlocks, allowing only a single CPU anywhere
 117  */
 118
 119 typedef struct {
 120         volatile unsigned int lock;
 121 } spinlock_t;
 122
 123 #define SPIN_LOCK_UNLOCKED { 0 }
 124
 125 #define spin_lock_init(x)       do { (x)->lock = 0; } while(0)
 126 /*
 127  * Simple spin lock operations.  There are two variants, one clears IRQ's
 128  * on the local processor, one does not.
 129  *
 130  * We make no fairness assumptions. They have a cost.
 131  */
 132
 133 #define spin_unlock_wait(x)     do { barrier(); } while(((volatile spinlock_t *)(x))->lock)
 134
 135 typedef struct { unsigned long a[100]; } __dummy_lock_t;
 136 #define __dummy_lock(lock) (*(__dummy_lock_t *)(lock))
 137
 138 #define spin_lock_string \
 139         "\n1:\t" \
 140         "lock ; btsl $0,%0\n\t" \
 141         "jc 2f\n" \
 142         ".section .text.lock,\"ax\"\n" \
 143         "2:\t" \
 144         "testb $1,%0\n\t" \
 145         "jne 2b\n\t" \
 146         "jmp 1b\n" \
 147         ".previous"
 148
 149 #define spin_unlock_string \
 150         "lock ; btrl $0,%0"
 151
 152 #define spin_lock(lock) \
 153 __asm__ __volatile__( \
 154         spin_lock_string \
 155 "\n\tcall __getlock" \
 156         :"=m" (__dummy_lock(lock)))
 157
 158 #define spin_unlock(lock) \
 159 __asm__ __volatile__( \
 160 "call __putlock\n\t" \
 161         spin_unlock_string \
 162         :"=m" (__dummy_lock(lock)))
 163
 164 #define spin_trylock(lock) (!test_and_set_bit(0,(lock)))
 165
 166 #define spin_lock_irq(lock) \
 167         do { __cli(); spin_lock(lock); } while (0)
 168
 169 #define spin_unlock_irq(lock) \
 170         do { spin_unlock(lock); __sti(); } while (0)
 171
 172 #define spin_lock_irqsave(lock, flags) \
 173         do { __save_flags(flags); __cli(); spin_lock(lock); } while (0)
 174
 175 #define spin_unlock_irqrestore(lock, flags) \
 176         do { spin_unlock(lock); __restore_flags(flags); } while (0)
 177
 178 /*
 179  * Read-write spinlocks, allowing multiple readers
 180  * but only one writer.
 181  *
 182  * NOTE! it is quite common to have readers in interrupts
 183  * but no interrupt writers. For those circumstances we
 184  * can "mix" irq-safe locks - any writer needs to get a
 185  * irq-safe write-lock, but readers can get non-irqsafe
 186  * read-locks.
 187  */
 188 typedef struct {
 189         volatile unsigned int lock;
 190         unsigned long previous;
 191 } rwlock_t;
 192
 193 #define RW_LOCK_UNLOCKED { 0, 0 }
 194
 195 /*
 196  * On x86, we implement read-write locks as a 32-bit counter
 197  * with the high bit (sign) being the "write" bit.
 198  *
 199  * The inline assembly is non-obvious. Think about it.
 200  */
 201 #define read_lock(rw)   \
 202         asm volatile("\n1:\t" \
 203                      "lock ; incl %0\n\t" \
 204                      "js 2f\n" \
 205 "call __getlock\n" \
 206                      ".section .text.lock,\"ax\"\n" \
 207                      "2:\tlock ; decl %0\n" \
 208                      "3:\tcmpl $0,%0\n\t" \
 209                      "js 3b\n\t" \
 210                      "jmp 1b\n" \
 211                      ".previous" \
 212                      :"=m" (__dummy_lock(&(rw)->lock)))
 213
 214 #define read_unlock(rw) \
 215         asm volatile( \
 216 "call __putlock\n" \
 217                 "lock ; decl %0" \
 218                 :"=m" (__dummy_lock(&(rw)->lock)))
 219
 220 #define write_lock(rw) \
 221         asm volatile("\n1:\t" \
 222                      "lock ; btsl $31,%0\n\t" \
 223                      "jc 4f\n" \
 224                      "2:\ttestl $0x7fffffff,%0\n\t" \
 225                      "jne 3f\n" \
 226 "call __getlock\n" \
 227                      ".section .text.lock,\"ax\"\n" \
 228                      "3:\tlock ; btrl $31,%0\n" \
 229                      "4:\tcmp $0,%0\n\t" \
 230                      "jne 4b\n\t" \
 231                      "jmp 1b\n" \
 232                      ".previous" \
 233                      :"=m" (__dummy_lock(&(rw)->lock)))
 234
 235 #define write_unlock(rw) \
 236         asm volatile( \
 237 "call __putlock\n" \
 238                 "lock ; btrl $31,%0": \
 239                 "=m" (__dummy_lock(&(rw)->lock)))
 240
 241 #define read_lock_irq(lock)     do { __cli(); read_lock(lock); } while (0)
 242 #define read_unlock_irq(lock)   do { read_unlock(lock); __sti(); } while (0)
 243 #define write_lock_irq(lock)    do { __cli(); write_lock(lock); } while (0)
 244 #define write_unlock_irq(lock)  do { write_unlock(lock); __sti(); } while (0)
 245
 246 #define read_lock_irqsave(lock, flags)  \
 247         do { __save_flags(flags); __cli(); read_lock(lock); } while (0)
 248 #define read_unlock_irqrestore(lock, flags) \
 249         do { read_unlock(lock); __restore_flags(flags); } while (0)
 250 #define write_lock_irqsave(lock, flags) \
 251         do { __save_flags(flags); __cli(); write_lock(lock); } while (0)
 252 #define write_unlock_irqrestore(lock, flags) \
 253         do { write_unlock(lock); __restore_flags(flags); } while (0)
 254
 255 #endif /* __SMP__ */
 256 #endif /* __ASM_SPINLOCK_H */