include/linux/spinlock.h

   1 #ifndef __LINUX_SPINLOCK_H
   2 #define __LINUX_SPINLOCK_H
   3
   4 #include <linux/config.h>
   5
   6 #include <asm/system.h>
   7
   8 /*
   9  * These are the generic versions of the spinlocks and read-write
  10  * locks..
  11  */
  12 #define spin_lock_irqsave(lock, flags)          do { local_irq_save(flags);       spin_lock(lock); } while (0)
  13 #define spin_lock_irq(lock)                     do { local_irq_disable();         spin_lock(lock); } while (0)
  14 #define spin_lock_bh(lock)                      do { local_bh_disable();          spin_lock(lock); } while (0)
  15
  16 #define read_lock_irqsave(lock, flags)          do { local_irq_save(flags);       read_lock(lock); } while (0)
  17 #define read_lock_irq(lock)                     do { local_irq_disable();         read_lock(lock); } while (0)
  18 #define read_lock_bh(lock)                      do { local_bh_disable();          read_lock(lock); } while (0)
  19
  20 #define write_lock_irqsave(lock, flags)         do { local_irq_save(flags);      write_lock(lock); } while (0)
  21 #define write_lock_irq(lock)                    do { local_irq_disable();        write_lock(lock); } while (0)
  22 #define write_lock_bh(lock)                     do { local_bh_disable();         write_lock(lock); } while (0)
  23
  24 #define spin_unlock_irqrestore(lock, flags)     do { spin_unlock(lock);  local_irq_restore(flags); } while (0)
  25 #define spin_unlock_irq(lock)                   do { spin_unlock(lock);  local_irq_enable();       } while (0)
  26 #define spin_unlock_bh(lock)                    do { spin_unlock(lock);  local_bh_enable();        } while (0)
  27
  28 #define read_unlock_irqrestore(lock, flags)     do { read_unlock(lock);  local_irq_restore(flags); } while (0)
  29 #define read_unlock_irq(lock)                   do { read_unlock(lock);  local_irq_enable();       } while (0)
  30 #define read_unlock_bh(lock)                    do { read_unlock(lock);  local_bh_enable();        } while (0)
  31
  32 #define write_unlock_irqrestore(lock, flags)    do { write_unlock(lock); local_irq_restore(flags); } while (0)
  33 #define write_unlock_irq(lock)                  do { write_unlock(lock); local_irq_enable();       } while (0)
  34 #define write_unlock_bh(lock)                   do { write_unlock(lock); local_bh_enable();        } while (0)
  35 #define spin_trylock_bh(lock)                   ({ int __r; local_bh_disable();\
  36                                                 __r = spin_trylock(lock);      \
  37                                                 if (!__r) local_bh_enable();   \
  38                                                 __r; })
  39
  40 /* Must define these before including other files, inline functions need them */
  41
  42 #include <linux/stringify.h>
  43
  44 #define LOCK_SECTION_NAME                       \
  45         ".text.lock." __stringify(KBUILD_BASENAME)
  46
  47 #define LOCK_SECTION_START(extra)               \
  48         ".subsection 1\n\t"                     \
  49         extra                                   \
  50         ".ifndef " LOCK_SECTION_NAME "\n\t"     \
  51         LOCK_SECTION_NAME ":\n\t"               \
  52         ".endif\n\t"
  53
  54 #define LOCK_SECTION_END                        \
  55         ".previous\n\t"
  56
  57 #ifdef CONFIG_SMP
  58 #include <asm/spinlock.h>
  59
  60 #elif !defined(spin_lock_init) /* !SMP and spin_lock_init not previously
  61                                   defined (e.g. by including asm/spinlock.h */
  62
  63 #define DEBUG_SPINLOCKS 0       /* 0 == no debugging, 1 == maintain lock state, 2 == full debug */
  64
  65 #if (DEBUG_SPINLOCKS < 1)
  66
  67 #define atomic_dec_and_lock(atomic,lock) atomic_dec_and_test(atomic)
  68 #define ATOMIC_DEC_AND_LOCK
  69
  70 /*
  71  * Your basic spinlocks, allowing only a single CPU anywhere
  72  *
  73  * Some older gcc versions had a nasty bug with empty initializers.
  74  * (XXX: could someone please confirm whether egcs 1.1 still has this bug?)
  75  */
  76 #if (__GNUC__ > 2 || __GNUC_MINOR__ > 95)
  77   typedef struct { } spinlock_t;
  78   #define SPIN_LOCK_UNLOCKED (spinlock_t) { }
  79 #else
  80   typedef struct { int gcc_is_buggy; } spinlock_t;
  81   #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
  82 #endif
  83
  84 #define spin_lock_init(lock)    do { } while(0)
  85 #define spin_lock(lock)         (void)(lock) /* Not "unused variable". */
  86 #define spin_is_locked(lock)    (0)
  87 #define spin_trylock(lock)      ({1; })
  88 #define spin_unlock_wait(lock)  do { } while(0)
  89 #define spin_unlock(lock)       do { } while(0)
  90
  91 #elif (DEBUG_SPINLOCKS < 2)
  92
  93 typedef struct {
  94         volatile unsigned long lock;
  95 } spinlock_t;
  96 #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
  97
  98 #define spin_lock_init(x)       do { (x)->lock = 0; } while (0)
  99 #define spin_is_locked(lock)    (test_bit(0,(lock)))
 100 #define spin_trylock(lock)      (!test_and_set_bit(0,(lock)))
 101
 102 #define spin_lock(x)            do { (x)->lock = 1; } while (0)
 103 #define spin_unlock_wait(x)     do { } while (0)
 104 #define spin_unlock(x)          do { (x)->lock = 0; } while (0)
 105
 106 #else /* (DEBUG_SPINLOCKS >= 2) */
 107
 108 typedef struct {
 109         volatile unsigned long lock;
 110         volatile unsigned int babble;
 111         const char *module;
 112 } spinlock_t;
 113 #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0, 25, __BASE_FILE__ }
 114
 115 #include <linux/kernel.h>
 116
 117 #define spin_lock_init(x)       do { (x)->lock = 0; } while (0)
 118 #define spin_is_locked(lock)    (test_bit(0,(lock)))
 119 #define spin_trylock(lock)      (!test_and_set_bit(0,(lock)))
 120
 121 #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)
 122 #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)
 123 #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)
 124
 125 #endif  /* DEBUG_SPINLOCKS */
 126
 127 /*
 128  * Read-write spinlocks, allowing multiple readers
 129  * but only one writer.
 130  *
 131  * NOTE! it is quite common to have readers in interrupts
 132  * but no interrupt writers. For those circumstances we
 133  * can "mix" irq-safe locks - any writer needs to get a
 134  * irq-safe write-lock, but readers can get non-irqsafe
 135  * read-locks.
 136  *
 137  * Some older gcc versions had a nasty bug with empty initializers.
 138  * (XXX: could someone please confirm whether egcs 1.1 still has this bug?)
 139  */
 140 #if (__GNUC__ > 2 || __GNUC_MINOR__ > 91)
 141   typedef struct { } rwlock_t;
 142   #define RW_LOCK_UNLOCKED (rwlock_t) { }
 143 #else
 144   typedef struct { int gcc_is_buggy; } rwlock_t;
 145   #define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
 146 #endif
 147
 148 #define rwlock_init(lock)       do { } while(0)
 149 #define read_lock(lock)         (void)(lock) /* Not "unused variable". */
 150 #define read_unlock(lock)       (void)(lock) /* Not "unused variable". */
 151 #define write_lock(lock)        (void)(lock) /* Not "unused variable". */
 152 #define write_unlock(lock)      do { } while(0)
 153
 154 #endif /* !SMP */
 155
 156 /* "lock on reference count zero" */
 157 #ifndef ATOMIC_DEC_AND_LOCK
 158 #include <asm/atomic.h>
 159 extern int atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
 160 #endif
 161
 162 #ifdef CONFIG_SMP
 163 #include <linux/cache.h>
 164
 165 typedef union {
 166     spinlock_t lock;
 167     char fill_up[(SMP_CACHE_BYTES)];
 168 } spinlock_cacheline_t __attribute__ ((aligned(SMP_CACHE_BYTES)));
 169
 170 #else   /* SMP */
 171
 172 typedef struct {
 173     spinlock_t lock;
 174 } spinlock_cacheline_t;
 175
 176
 177 #endif
 178 #endif /* __LINUX_SPINLOCK_H */