spinlock_api_smp.h (5346B)
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 18int in_lock_functions(unsigned long addr); 19 20#define assert_raw_spin_locked(x) BUG_ON(!raw_spin_is_locked(x)) 21 22void __lockfunc _raw_spin_lock(raw_spinlock_t *lock) __acquires(lock); 23void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass) 24 __acquires(lock); 25void __lockfunc 26_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map) 27 __acquires(lock); 28void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock) __acquires(lock); 29void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock) 30 __acquires(lock); 31 32unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock) 33 __acquires(lock); 34unsigned long __lockfunc 35_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass) 36 __acquires(lock); 37int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock); 38int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock); 39void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock) __releases(lock); 40void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock); 41void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock); 42void __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 86static 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_PREEMPTION, 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 104static 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 LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 112 return flags; 113} 114 115static inline void __raw_spin_lock_irq(raw_spinlock_t *lock) 116{ 117 local_irq_disable(); 118 preempt_disable(); 119 spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 120 LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 121} 122 123static inline void __raw_spin_lock_bh(raw_spinlock_t *lock) 124{ 125 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 126 spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 127 LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 128} 129 130static inline void __raw_spin_lock(raw_spinlock_t *lock) 131{ 132 preempt_disable(); 133 spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); 134 LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); 135} 136 137#endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */ 138 139static inline void __raw_spin_unlock(raw_spinlock_t *lock) 140{ 141 spin_release(&lock->dep_map, _RET_IP_); 142 do_raw_spin_unlock(lock); 143 preempt_enable(); 144} 145 146static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock, 147 unsigned long flags) 148{ 149 spin_release(&lock->dep_map, _RET_IP_); 150 do_raw_spin_unlock(lock); 151 local_irq_restore(flags); 152 preempt_enable(); 153} 154 155static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock) 156{ 157 spin_release(&lock->dep_map, _RET_IP_); 158 do_raw_spin_unlock(lock); 159 local_irq_enable(); 160 preempt_enable(); 161} 162 163static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock) 164{ 165 spin_release(&lock->dep_map, _RET_IP_); 166 do_raw_spin_unlock(lock); 167 __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 168} 169 170static inline int __raw_spin_trylock_bh(raw_spinlock_t *lock) 171{ 172 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 173 if (do_raw_spin_trylock(lock)) { 174 spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); 175 return 1; 176 } 177 __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); 178 return 0; 179} 180 181/* PREEMPT_RT has its own rwlock implementation */ 182#ifndef CONFIG_PREEMPT_RT 183#include <linux/rwlock_api_smp.h> 184#endif 185 186#endif /* __LINUX_SPINLOCK_API_SMP_H */