Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258#ifndef __LINUX_SPINLOCK_API_SMP_H#define __LINUX_SPINLOCK_API_SMP_H
#ifndef __LINUX_INSIDE_SPINLOCK_H# error "Please do not include this file directly."#endif
/* * include/linux/spinlock_api_smp.h * * spinlock API declarations on SMP (and debug) * (implemented in kernel/spinlock.c) * * portions Copyright 2005, Red Hat, Inc., Ingo Molnar * Released under the General Public License (GPL). */
int in_lock_functions(unsigned long addr);
#define assert_raw_spin_locked(x) BUG_ON(!raw_spin_is_locked(x))
void __lockfunc _raw_spin_lock(raw_spinlock_t *lock) __acquires(lock);void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass) __acquires(lock);void __lockfunc_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map) __acquires(lock);void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock) __acquires(lock);void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock) __acquires(lock);void __lockfunc _raw_spin_lock_irq_disable(raw_spinlock_t *lock) __acquires(lock);
unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock) __acquires(lock);unsigned long __lockfunc_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass) __acquires(lock);int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock) __cond_acquires(true, lock);int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock) __cond_acquires(true, lock);void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock) __releases(lock);void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock);void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock);void __lockfunc _raw_spin_unlock_irq_enable(raw_spinlock_t *lock) __releases(lock);void __lockfunc_raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags) __releases(lock);
#ifdef CONFIG_INLINE_SPIN_LOCK#define _raw_spin_lock(lock) __raw_spin_lock(lock)#endif
#ifdef CONFIG_INLINE_SPIN_LOCK_BH#define _raw_spin_lock_bh(lock) __raw_spin_lock_bh(lock)#endif
#ifdef CONFIG_INLINE_SPIN_LOCK_IRQ#define _raw_spin_lock_irq(lock) __raw_spin_lock_irq(lock)#endif
/* Use the same config as spin_lock_irq() temporarily. */#ifdef CONFIG_INLINE_SPIN_LOCK_IRQ#define _raw_spin_lock_irq_disable(lock) __raw_spin_lock_irq_disable(lock)#endif
#ifdef CONFIG_INLINE_SPIN_LOCK_IRQSAVE#define _raw_spin_lock_irqsave(lock) __raw_spin_lock_irqsave(lock)#endif
#ifdef CONFIG_INLINE_SPIN_TRYLOCK#define _raw_spin_trylock(lock) __raw_spin_trylock(lock)#endif
#ifdef CONFIG_INLINE_SPIN_TRYLOCK_BH#define _raw_spin_trylock_bh(lock) __raw_spin_trylock_bh(lock)#endif
#ifndef CONFIG_UNINLINE_SPIN_UNLOCK#define _raw_spin_unlock(lock) __raw_spin_unlock(lock)#endif
#ifdef CONFIG_INLINE_SPIN_UNLOCK_BH#define _raw_spin_unlock_bh(lock) __raw_spin_unlock_bh(lock)#endif
#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQ#define _raw_spin_unlock_irq(lock) __raw_spin_unlock_irq(lock)#endif
/* Use the same config as spin_unlock_irq() temporarily. */#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQ#define _raw_spin_unlock_irq_enable(lock) __raw_spin_unlock_irq_enable(lock)#endif
#ifdef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE#define _raw_spin_unlock_irqrestore(lock, flags) __raw_spin_unlock_irqrestore(lock, flags)#endif
static inline int __raw_spin_trylock(raw_spinlock_t *lock) __cond_acquires(true, lock){ preempt_disable(); if (do_raw_spin_trylock(lock)) { spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); return 1; } preempt_enable(); return 0;}
static __always_inline bool _raw_spin_trylock_irq(raw_spinlock_t *lock) __cond_acquires(true, lock){ local_irq_disable(); if (_raw_spin_trylock(lock)) return true; local_irq_enable(); return false;}
static __always_inline bool _raw_spin_trylock_irq_disable(raw_spinlock_t *lock) __cond_acquires(true, lock){ local_interrupt_disable(); if (_raw_spin_trylock(lock)) return true; local_interrupt_enable(); return false;}
static __always_inline bool _raw_spin_trylock_irqsave(raw_spinlock_t *lock, unsigned long *flags) __cond_acquires(true, lock){ local_irq_save(*flags); if (_raw_spin_trylock(lock)) return true; local_irq_restore(*flags); return false;}
/* * If lockdep is enabled then we use the non-preemption spin-ops * even on CONFIG_PREEMPTION, because lockdep assumes that interrupts are * not re-enabled during lock-acquire (which the preempt-spin-ops do): */#if !defined(CONFIG_GENERIC_LOCKBREAK) || defined(CONFIG_DEBUG_LOCK_ALLOC)
static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock) __acquires(lock) __no_context_analysis{ unsigned long flags;
local_irq_save(flags); preempt_disable(); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock); return flags;}
static inline void __raw_spin_lock_irq(raw_spinlock_t *lock) __acquires(lock) __no_context_analysis{ local_irq_disable(); preempt_disable(); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);}
static inline void __raw_spin_lock_irq_disable(raw_spinlock_t *lock) __acquires(lock) __no_context_analysis{ local_interrupt_disable(); preempt_disable(); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);}
static inline void __raw_spin_lock_bh(raw_spinlock_t *lock) __acquires(lock) __no_context_analysis{ __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);}
static inline void __raw_spin_lock(raw_spinlock_t *lock) __acquires(lock) __no_context_analysis{ preempt_disable(); spin_acquire(&lock->dep_map, 0, 0, _RET_IP_); LOCK_CONTENDED(lock, do_raw_spin_trylock, do_raw_spin_lock);}
#endif /* !CONFIG_GENERIC_LOCKBREAK || CONFIG_DEBUG_LOCK_ALLOC */
static inline void __raw_spin_unlock(raw_spinlock_t *lock) __releases(lock){ spin_release(&lock->dep_map, _RET_IP_); do_raw_spin_unlock(lock); preempt_enable();}
static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags) __releases(lock){ spin_release(&lock->dep_map, _RET_IP_); do_raw_spin_unlock(lock); local_irq_restore(flags); preempt_enable();}
static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock) __releases(lock){ spin_release(&lock->dep_map, _RET_IP_); do_raw_spin_unlock(lock); local_irq_enable(); preempt_enable();}
static inline void __raw_spin_unlock_irq_enable(raw_spinlock_t *lock) __releases(lock){ spin_release(&lock->dep_map, _RET_IP_); do_raw_spin_unlock(lock); local_interrupt_enable(); preempt_enable();}
static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock) __releases(lock){ spin_release(&lock->dep_map, _RET_IP_); do_raw_spin_unlock(lock); __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);}
static inline int __raw_spin_trylock_bh(raw_spinlock_t *lock) __cond_acquires(true, lock){ __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); if (do_raw_spin_trylock(lock)) { spin_acquire(&lock->dep_map, 0, 1, _RET_IP_); return 1; } __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET); return 0;}
/* PREEMPT_RT has its own rwlock implementation */#ifndef CONFIG_PREEMPT_RT#include <linux/rwlock_api_smp.h>#endif
#endif /* __LINUX_SPINLOCK_API_SMP_H */