Release 4.7 include/linux/bit_spinlock.h
#ifndef __LINUX_BIT_SPINLOCK_H
#define __LINUX_BIT_SPINLOCK_H
#include <linux/kernel.h>
#include <linux/preempt.h>
#include <linux/atomic.h>
#include <linux/bug.h>
/*
* bit-based spin_lock()
*
* Don't use this unless you really need to: spin_lock() and spin_unlock()
* are significantly faster.
*/
static inline void bit_spin_lock(int bitnum, unsigned long *addr)
{
/*
* Assuming the lock is uncontended, this never enters
* the body of the outer loop. If it is contended, then
* within the inner loop a non-atomic test is used to
* busywait with less bus contention for a good time to
* attempt to acquire the lock bit.
*/
preempt_disable();
#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
while (unlikely(test_and_set_bit_lock(bitnum, addr))) {
preempt_enable();
do {
cpu_relax();
} while (test_bit(bitnum, addr));
preempt_disable();
}
#endif
__acquire(bitlock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| ingo molnar | ingo molnar | 58 | 79.45% | 1 | 33.33% |
| linus torvalds | linus torvalds | 11 | 15.07% | 1 | 33.33% |
| nick piggin | nick piggin | 4 | 5.48% | 1 | 33.33% |
| Total | 73 | 100.00% | 3 | 100.00% |
/*
* Return true if it was acquired
*/
static inline int bit_spin_trylock(int bitnum, unsigned long *addr)
{
preempt_disable();
#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
if (unlikely(test_and_set_bit_lock(bitnum, addr))) {
preempt_enable();
return 0;
}
#endif
__acquire(bitlock);
return 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| ingo molnar | ingo molnar | 55 | 93.22% | 1 | 50.00% |
| nick piggin | nick piggin | 4 | 6.78% | 1 | 50.00% |
| Total | 59 | 100.00% | 2 | 100.00% |
/*
* bit-based spin_unlock()
*/
static inline void bit_spin_unlock(int bitnum, unsigned long *addr)
{
#ifdef CONFIG_DEBUG_SPINLOCK
BUG_ON(!test_bit(bitnum, addr));
#endif
#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
clear_bit_unlock(bitnum, addr);
#endif
preempt_enable();
__release(bitlock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| nick piggin | nick piggin | 34 | 57.63% | 1 | 50.00% |
| ingo molnar | ingo molnar | 25 | 42.37% | 1 | 50.00% |
| Total | 59 | 100.00% | 2 | 100.00% |
/*
* bit-based spin_unlock()
* non-atomic version, which can be used eg. if the bit lock itself is
* protecting the rest of the flags in the word.
*/
static inline void __bit_spin_unlock(int bitnum, unsigned long *addr)
{
#ifdef CONFIG_DEBUG_SPINLOCK
BUG_ON(!test_bit(bitnum, addr));
#endif
#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
__clear_bit_unlock(bitnum, addr);
#endif
preempt_enable();
__release(bitlock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| nick piggin | nick piggin | 31 | 52.54% | 1 | 50.00% |
| ingo molnar | ingo molnar | 28 | 47.46% | 1 | 50.00% |
| Total | 59 | 100.00% | 2 | 100.00% |
/*
* Return true if the lock is held.
*/
static inline int bit_spin_is_locked(int bitnum, unsigned long *addr)
{
#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
return test_bit(bitnum, addr);
#elif defined CONFIG_PREEMPT_COUNT
return preempt_count();
#else
return 1;
#endif
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| ingo molnar | ingo molnar | 48 | 97.96% | 1 | 50.00% |
| frederic weisbecker | frederic weisbecker | 1 | 2.04% | 1 | 50.00% |
| Total | 49 | 100.00% | 2 | 100.00% |
#endif /* __LINUX_BIT_SPINLOCK_H */
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| ingo molnar | ingo molnar | 227 | 69.85% | 1 | 14.29% |
| nick piggin | nick piggin | 82 | 25.23% | 2 | 28.57% |
| linus torvalds | linus torvalds | 11 | 3.38% | 1 | 14.29% |
| paul gortmaker | paul gortmaker | 3 | 0.92% | 1 | 14.29% |
| arun sharma | arun sharma | 1 | 0.31% | 1 | 14.29% |
| frederic weisbecker | frederic weisbecker | 1 | 0.31% | 1 | 14.29% |
| Total | 325 | 100.00% | 7 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.