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 */ 179