Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
1: #ifndef __LINUX_SPINLOCK_API_SMP_H 2: #define __LINUX_SPINLOCK_API_SMP_H 3: 4: #ifndef __LINUX_SPINLOCK_H 5: # error "please don't include this file directly" 6: #endif 7: 8: /* 9: * include/linux/spinlock_api_smp.h 10: * 11: * spinlock API declarations on SMP (and debug) 12: * (implemented in kernel/spinlock.c) 13: * 14: * portions Copyright 2005, Red Hat, Inc., Ingo Molnar 15: * Released under the General Public License (GPL). 16: */ 17: 18: int in_lock_functions(unsigned long addr); 19: 20: #define assert_raw_spin_locked(x) BUG_ON(!raw_spin_is_locked(x)) 21: 22: void __lockfunc _raw_spin_lock(raw_spinlock_t *lock) __acquires(lock); 23: void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass) 24: __acquires(lock); 25: void __lockfunc 26: _raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map) 27: __acquires(lock); 28: void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock) __acquires(lock); 29: void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock) 30: __acquires(lock); 31: 32: unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock) 33: __acquires(lock); 34: unsigned long __lockfunc 35: _raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass) 36: __acquires(lock); 37: int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock); 38: int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock); 39: void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock) __releases(lock); 40: void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock); 41: void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock); 42: void __lockfunc 43: _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags) 44: __releases(lock); 45: 46: #ifdef CONFIG_INLINE_SPIN_LOCK 47: #define _raw_spin_lock(lock) __raw_spin_lock(lock) 48: #endif 49: 50: #ifdef CONFIG_INLINE_SPIN_LOCK_BH 51: #define _raw_spin_lock_bh(lock) __raw_spin_lock_bh(lock) 52: #endif 53: 54: #ifdef CONFIG_INLINE_SPIN_LOCK_IRQ 55: #define _raw_spin_lock_irq(lock) __raw_spin_lock_irq(lock) 56: #endif 57: 58: #ifdef CONFIG_INLINE_SPIN_LOCK_IRQSAVE 59: #define _raw_spin_lock_irqsave(lock) __raw_spin_lock_irqsave(lock) 60: #endif 61: 62: #ifdef CONFIG_INLINE_SPIN_TRYLOCK 63: #define _raw_spin_trylock(lock) __raw_spin_trylock(lock) 64: #endif 65: 66: #ifdef CONFIG_INLINE_SPIN_TRYLOCK_BH 67: #define _raw_spin_trylock_bh(lock) __raw_spin_trylock_bh(lock) 68: #endif 69: 70: #ifndef CONFIG_UNINLINE_SPIN_UNLOCK 71: #define _raw_spin_unlock(lock) __raw_spin_unlock(lock) 72: #endif 73: 74: #ifdef CONFIG_INLINE_SPIN_UNLOCK_BH 75: #define _raw_spin_unlock_bh(lock) __raw_spin_unlock_bh(lock) 76: #endif 77: 78: #ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQ 79: #define _raw_spin_unlock_irq(lock) __raw_spin_unlock_irq(lock) 80: #endif 81: 82: #ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE 83: #define _raw_spin_unlock_irqrestore(lock, flags) __raw_spin_unlock_irqrestore(lock, flags) 84: #endif 85: 86: static inline int __raw_spin_trylock(raw_spinlock_t *lock) 87: { 88: preempt_disable(); 89: if (do_raw_spin_trylock(lock)) { 90: spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); 91: return 1; 92: } 93: preempt_enable(); 94: return 0; 95: } 96: 97: /* 98: * If lockdep is enabled then we use the non-preemption spin-ops 99: * even on CONFIG_PREEMPT, because lockdep assumes that interrupts are 100: * not re-enabled during lock-acquire (which the preempt-spin-ops do): 101: */ 102: #if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC) 103: 104: static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock) 105: { 106: unsigned long flags; 107: 108: local_irq_save(flags); 109: preempt_disable(); 110: spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 111: /* 112: * On lockdep we dont want the hand-coded irq-enable of 113: * do_raw_spin_lock_flags() code, because lockdep assumes 114: * that interrupts are not re-enabled during lock-acquire: 115: */ 116: #ifdef CONFIG_LOCKDEP 117: LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 118: #else 119: do_raw_spin_lock_flags(lock, &flags); 120: #endif 121: return flags; 122: } 123: 124: static inline void __raw_spin_lock_irq(raw_spinlock_t *lock) 125: { 126: local_irq_disable(); 127: preempt_disable(); 128: spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 129: LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 130: } 131: 132: static inline void __raw_spin_lock_bh(raw_spinlock_t *lock) 133: { 134: local_bh_disable(); 135: preempt_disable(); 136: spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 137: LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 138: } 139: 140: static inline void __raw_spin_lock(raw_spinlock_t *lock) 141: { 142: preempt_disable(); 143: spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 144: LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 145: } 146: 147: #endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */ 148: 149: static inline void __raw_spin_unlock(raw_spinlock_t *lock) 150: { 151: spin_release(&lock->dep_map, 1, _RET_IP_); 152: do_raw_spin_unlock(lock); 153: preempt_enable(); 154: } 155: 156: static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock, 157: unsigned long flags) 158: { 159: spin_release(&lock->dep_map, 1, _RET_IP_); 160: do_raw_spin_unlock(lock); 161: local_irq_restore(flags); 162: preempt_enable(); 163: } 164: 165: static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock) 166: { 167: spin_release(&lock->dep_map, 1, _RET_IP_); 168: do_raw_spin_unlock(lock); 169: local_irq_enable(); 170: preempt_enable(); 171: } 172: 173: static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock) 174: { 175: spin_release(&lock->dep_map, 1, _RET_IP_); 176: do_raw_spin_unlock(lock); 177: preempt_enable_no_resched(); 178: local_bh_enable_ip((unsigned long)__builtin_return_address(0)); 179: } 180: 181: static inline int __raw_spin_trylock_bh(raw_spinlock_t *lock) 182: { 183: local_bh_disable(); 184: preempt_disable(); 185: if (do_raw_spin_trylock(lock)) { 186: spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); 187: return 1; 188: } 189: preempt_enable_no_resched(); 190: local_bh_enable_ip((unsigned long)__builtin_return_address(0)); 191: return 0; 192: } 193: 194: #include <linux/rwlock_api_smp.h> 195: 196: #endif /* __LINUX_SPINLOCK_API_SMP_H */ 197: