Release 4.11 arch/mips/include/asm/spinlock.h
/*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
* Copyright (C) 1999, 2000, 06 Ralf Baechle (ralf@linux-mips.org)
* Copyright (C) 1999, 2000 Silicon Graphics, Inc.
*/
#ifndef _ASM_SPINLOCK_H
#define _ASM_SPINLOCK_H
#include <linux/compiler.h>
#include <asm/barrier.h>
#include <asm/processor.h>
#include <asm/compiler.h>
#include <asm/war.h>
/*
* Your basic SMP spinlocks, allowing only a single CPU anywhere
*
* Simple spin lock operations. There are two variants, one clears IRQ's
* on the local processor, one does not.
*
* These are fair FIFO ticket locks
*
* (the type definitions are in asm/spinlock_types.h)
*/
/*
* Ticket locks are conceptually two parts, one indicating the current head of
* the queue, and the other indicating the current tail. The lock is acquired
* by atomically noting the tail and incrementing it by one (thus adding
* ourself to the queue and noting our position), then waiting until the head
* becomes equal to the the initial value of the tail.
*/
static inline int arch_spin_is_locked(arch_spinlock_t *lock)
{
u32 counters = ACCESS_ONCE(lock->lock);
return ((counters >> 16) ^ counters) & 0xffff;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 27 | 79.41% | 1 | 16.67% |
| David Daney | 3 | 8.82% | 1 | 16.67% |
| Thomas Gleixner | 2 | 5.88% | 2 | 33.33% |
| Linus Torvalds (pre-git) | 1 | 2.94% | 1 | 16.67% |
| Linus Torvalds | 1 | 2.94% | 1 | 16.67% |
| Total | 34 | 100.00% | 6 | 100.00% |
static inline int arch_spin_value_unlocked(arch_spinlock_t lock)
{
return lock.h.serving_now == lock.h.ticket;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Paul Burton | 23 | 100.00% | 1 | 100.00% |
| Total | 23 | 100.00% | 1 | 100.00% |
#define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock)
static inline void arch_spin_unlock_wait(arch_spinlock_t *lock)
{
u16 owner = READ_ONCE(lock->h.serving_now);
smp_rmb();
for (;;) {
arch_spinlock_t tmp = READ_ONCE(*lock);
if (tmp.h.serving_now == tmp.h.ticket ||
tmp.h.serving_now != owner)
break;
cpu_relax();
}
smp_acquire__after_ctrl_dep();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Peter Zijlstra | 68 | 95.77% | 1 | 33.33% |
| Andrew Morton | 2 | 2.82% | 1 | 33.33% |
| Thomas Gleixner | 1 | 1.41% | 1 | 33.33% |
| Total | 71 | 100.00% | 3 | 100.00% |
static inline int arch_spin_is_contended(arch_spinlock_t *lock)
{
u32 counters = ACCESS_ONCE(lock->lock);
return (((counters >> 16) - counters) & 0xffff) > 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 33 | 86.84% | 1 | 25.00% |
| David Daney | 3 | 7.89% | 1 | 25.00% |
| Thomas Gleixner | 2 | 5.26% | 2 | 50.00% |
| Total | 38 | 100.00% | 4 | 100.00% |
#define arch_spin_is_contended arch_spin_is_contended
static inline void arch_spin_lock(arch_spinlock_t *lock)
{
int my_ticket;
int tmp;
int inc = 0x10000;
if (R10000_LLSC_WAR) {
__asm__ __volatile__ (
" .set push # arch_spin_lock \n"
" .set noreorder \n"
" \n"
"1: ll %[ticket], %[ticket_ptr] \n"
" addu %[my_ticket], %[ticket], %[inc] \n"
" sc %[my_ticket], %[ticket_ptr] \n"
" beqzl %[my_ticket], 1b \n"
" nop \n"
" srl %[my_ticket], %[ticket], 16 \n"
" andi %[ticket], %[ticket], 0xffff \n"
" bne %[ticket], %[my_ticket], 4f \n"
" subu %[ticket], %[my_ticket], %[ticket] \n"
"2: \n"
" .subsection 2 \n"
"4: andi %[ticket], %[ticket], 0xffff \n"
" sll %[ticket], 5 \n"
" \n"
"6: bnez %[ticket], 6b \n"
" subu %[ticket], 1 \n"
" \n"
" lhu %[ticket], %[serving_now_ptr] \n"
" beq %[ticket], %[my_ticket], 2b \n"
" subu %[ticket], %[my_ticket], %[ticket] \n"
" b 4b \n"
" subu %[ticket], %[ticket], 1 \n"
" .previous \n"
" .set pop \n"
: [ticket_ptr] "+" GCC_OFF_SMALL_ASM() (lock->lock),
[serving_now_ptr] "+m" (lock->h.serving_now),
[ticket] "=&r" (tmp),
[my_ticket] "=&r" (my_ticket)
: [inc] "r" (inc));
} else {
__asm__ __volatile__ (
" .set push # arch_spin_lock \n"
" .set noreorder \n"
" \n"
"1: ll %[ticket], %[ticket_ptr] \n"
" addu %[my_ticket], %[ticket], %[inc] \n"
" sc %[my_ticket], %[ticket_ptr] \n"
" beqz %[my_ticket], 1b \n"
" srl %[my_ticket], %[ticket], 16 \n"
" andi %[ticket], %[ticket], 0xffff \n"
" bne %[ticket], %[my_ticket], 4f \n"
" subu %[ticket], %[my_ticket], %[ticket] \n"
"2: .insn \n"
" .subsection 2 \n"
"4: andi %[ticket], %[ticket], 0xffff \n"
" sll %[ticket], 5 \n"
" \n"
"6: bnez %[ticket], 6b \n"
" subu %[ticket], 1 \n"
" \n"
" lhu %[ticket], %[serving_now_ptr] \n"
" beq %[ticket], %[my_ticket], 2b \n"
" subu %[ticket], %[my_ticket], %[ticket] \n"
" b 4b \n"
" subu %[ticket], %[ticket], 1 \n"
" .previous \n"
" .set pop \n"
: [ticket_ptr] "+" GCC_OFF_SMALL_ASM() (lock->lock),
[serving_now_ptr] "+m" (lock->h.serving_now),
[ticket] "=&r" (tmp),
[my_ticket] "=&r" (my_ticket)
: [inc] "r" (inc));
}
smp_llsc_mb();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 17 | 42.50% | 4 | 40.00% |
| Linus Torvalds (pre-git) | 14 | 35.00% | 1 | 10.00% |
| David Daney | 5 | 12.50% | 1 | 10.00% |
| Thomas Gleixner | 2 | 5.00% | 2 | 20.00% |
| Paul Burton | 1 | 2.50% | 1 | 10.00% |
| Markos Chandras | 1 | 2.50% | 1 | 10.00% |
| Total | 40 | 100.00% | 10 | 100.00% |
static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
unsigned int serving_now = lock->h.serving_now + 1;
wmb();
lock->h.serving_now = (u16)serving_now;
nudge_writes();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| David Daney | 25 | 62.50% | 1 | 16.67% |
| Linus Torvalds (pre-git) | 9 | 22.50% | 1 | 16.67% |
| Ralf Bächle | 4 | 10.00% | 2 | 33.33% |
| Thomas Gleixner | 2 | 5.00% | 2 | 33.33% |
| Total | 40 | 100.00% | 6 | 100.00% |
static inline unsigned int arch_spin_trylock(arch_spinlock_t *lock)
{
int tmp, tmp2, tmp3;
int inc = 0x10000;
if (R10000_LLSC_WAR) {
__asm__ __volatile__ (
" .set push # arch_spin_trylock \n"
" .set noreorder \n"
" \n"
"1: ll %[ticket], %[ticket_ptr] \n"
" srl %[my_ticket], %[ticket], 16 \n"
" andi %[now_serving], %[ticket], 0xffff \n"
" bne %[my_ticket], %[now_serving], 3f \n"
" addu %[ticket], %[ticket], %[inc] \n"
" sc %[ticket], %[ticket_ptr] \n"
" beqzl %[ticket], 1b \n"
" li %[ticket], 1 \n"
"2: \n"
" .subsection 2 \n"
"3: b 2b \n"
" li %[ticket], 0 \n"
" .previous \n"
" .set pop \n"
: [ticket_ptr] "+" GCC_OFF_SMALL_ASM() (lock->lock),
[ticket] "=&r" (tmp),
[my_ticket] "=&r" (tmp2),
[now_serving] "=&r" (tmp3)
: [inc] "r" (inc));
} else {
__asm__ __volatile__ (
" .set push # arch_spin_trylock \n"
" .set noreorder \n"
" \n"
"1: ll %[ticket], %[ticket_ptr] \n"
" srl %[my_ticket], %[ticket], 16 \n"
" andi %[now_serving], %[ticket], 0xffff \n"
" bne %[my_ticket], %[now_serving], 3f \n"
" addu %[ticket], %[ticket], %[inc] \n"
" sc %[ticket], %[ticket_ptr] \n"
" beqz %[ticket], 1b \n"
" li %[ticket], 1 \n"
"2: .insn \n"
" .subsection 2 \n"
"3: b 2b \n"
" li %[ticket], 0 \n"
" .previous \n"
" .set pop \n"
: [ticket_ptr] "+" GCC_OFF_SMALL_ASM() (lock->lock),
[ticket] "=&r" (tmp),
[my_ticket] "=&r" (tmp2),
[now_serving] "=&r" (tmp3)
: [inc] "r" (inc));
}
smp_llsc_mb();
return tmp;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 33 | 73.33% | 5 | 45.45% |
| David Daney | 5 | 11.11% | 1 | 9.09% |
| Linus Torvalds (pre-git) | 3 | 6.67% | 1 | 9.09% |
| Thomas Gleixner | 2 | 4.44% | 2 | 18.18% |
| Markos Chandras | 1 | 2.22% | 1 | 9.09% |
| Paul Burton | 1 | 2.22% | 1 | 9.09% |
| Total | 45 | 100.00% | 11 | 100.00% |
/*
* Read-write spinlocks, allowing multiple readers but only one writer.
*
* NOTE! it is quite common to have readers in interrupts but no interrupt
* writers. For those circumstances we can "mix" irq-safe locks - any writer
* needs to get a irq-safe write-lock, but readers can get non-irqsafe
* read-locks.
*/
/*
* read_can_lock - would read_trylock() succeed?
* @lock: the rwlock in question.
*/
#define arch_read_can_lock(rw) ((rw)->lock >= 0)
/*
* write_can_lock - would write_trylock() succeed?
* @lock: the rwlock in question.
*/
#define arch_write_can_lock(rw) (!(rw)->lock)
static inline void arch_read_lock(arch_rwlock_t *rw)
{
unsigned int tmp;
if (R10000_LLSC_WAR) {
__asm__ __volatile__(
" .set noreorder # arch_read_lock \n"
"1: ll %1, %2 \n"
" bltz %1, 1b \n"
" addu %1, 1 \n"
" sc %1, %0 \n"
" beqzl %1, 1b \n"
" nop \n"
" .set reorder \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} else {
do {
__asm__ __volatile__(
"1: ll %1, %2 # arch_read_lock \n"
" bltz %1, 1b \n"
" addu %1, 1 \n"
"2: sc %1, %0 \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} while (unlikely(!tmp));
}
smp_llsc_mb();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 26 | 57.78% | 4 | 50.00% |
| Linus Torvalds (pre-git) | 15 | 33.33% | 1 | 12.50% |
| Thomas Gleixner | 2 | 4.44% | 2 | 25.00% |
| Markos Chandras | 2 | 4.44% | 1 | 12.50% |
| Total | 45 | 100.00% | 8 | 100.00% |
static inline void arch_read_unlock(arch_rwlock_t *rw)
{
unsigned int tmp;
smp_mb__before_llsc();
if (R10000_LLSC_WAR) {
__asm__ __volatile__(
"1: ll %1, %2 # arch_read_unlock \n"
" addiu %1, -1 \n"
" sc %1, %0 \n"
" beqzl %1, 1b \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} else {
do {
__asm__ __volatile__(
"1: ll %1, %2 # arch_read_unlock \n"
" addiu %1, -1 \n"
" sc %1, %0 \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} while (unlikely(!tmp));
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 25 | 55.56% | 3 | 33.33% |
| Linus Torvalds (pre-git) | 15 | 33.33% | 1 | 11.11% |
| Thomas Gleixner | 2 | 4.44% | 2 | 22.22% |
| Markos Chandras | 2 | 4.44% | 2 | 22.22% |
| David Daney | 1 | 2.22% | 1 | 11.11% |
| Total | 45 | 100.00% | 9 | 100.00% |
static inline void arch_write_lock(arch_rwlock_t *rw)
{
unsigned int tmp;
if (R10000_LLSC_WAR) {
__asm__ __volatile__(
" .set noreorder # arch_write_lock \n"
"1: ll %1, %2 \n"
" bnez %1, 1b \n"
" lui %1, 0x8000 \n"
" sc %1, %0 \n"
" beqzl %1, 1b \n"
" nop \n"
" .set reorder \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} else {
do {
__asm__ __volatile__(
"1: ll %1, %2 # arch_write_lock \n"
" bnez %1, 1b \n"
" lui %1, 0x8000 \n"
"2: sc %1, %0 \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} while (unlikely(!tmp));
}
smp_llsc_mb();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 26 | 57.78% | 4 | 50.00% |
| Linus Torvalds (pre-git) | 15 | 33.33% | 1 | 12.50% |
| Thomas Gleixner | 2 | 4.44% | 2 | 25.00% |
| Markos Chandras | 2 | 4.44% | 1 | 12.50% |
| Total | 45 | 100.00% | 8 | 100.00% |
static inline void arch_write_unlock(arch_rwlock_t *rw)
{
smp_mb__before_llsc();
__asm__ __volatile__(
" # arch_write_unlock \n"
" sw $0, %0 \n"
: "=m" (rw->lock)
: "m" (rw->lock)
: "memory");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 11 | 64.71% | 1 | 20.00% |
| Thomas Gleixner | 3 | 17.65% | 2 | 40.00% |
| Ralf Bächle | 2 | 11.76% | 1 | 20.00% |
| Leonid Yegoshin | 1 | 5.88% | 1 | 20.00% |
| Total | 17 | 100.00% | 5 | 100.00% |
static inline int arch_read_trylock(arch_rwlock_t *rw)
{
unsigned int tmp;
int ret;
if (R10000_LLSC_WAR) {
__asm__ __volatile__(
" .set noreorder # arch_read_trylock \n"
" li %2, 0 \n"
"1: ll %1, %3 \n"
" bltz %1, 2f \n"
" addu %1, 1 \n"
" sc %1, %0 \n"
" .set reorder \n"
" beqzl %1, 1b \n"
" nop \n"
__WEAK_LLSC_MB
" li %2, 1 \n"
"2: \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp), "=&r" (ret)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} else {
__asm__ __volatile__(
" .set noreorder # arch_read_trylock \n"
" li %2, 0 \n"
"1: ll %1, %3 \n"
" bltz %1, 2f \n"
" addu %1, 1 \n"
" sc %1, %0 \n"
" beqz %1, 1b \n"
" nop \n"
" .set reorder \n"
__WEAK_LLSC_MB
" li %2, 1 \n"
"2: .insn \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp), "=&r" (ret)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
}
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 30 | 83.33% | 1 | 16.67% |
| Thomas Gleixner | 2 | 5.56% | 2 | 33.33% |
| Ingo Molnar | 2 | 5.56% | 1 | 16.67% |
| Markos Chandras | 1 | 2.78% | 1 | 16.67% |
| Paul Burton | 1 | 2.78% | 1 | 16.67% |
| Total | 36 | 100.00% | 6 | 100.00% |
static inline int arch_write_trylock(arch_rwlock_t *rw)
{
unsigned int tmp;
int ret;
if (R10000_LLSC_WAR) {
__asm__ __volatile__(
" .set noreorder # arch_write_trylock \n"
" li %2, 0 \n"
"1: ll %1, %3 \n"
" bnez %1, 2f \n"
" lui %1, 0x8000 \n"
" sc %1, %0 \n"
" beqzl %1, 1b \n"
" nop \n"
__WEAK_LLSC_MB
" li %2, 1 \n"
" .set reorder \n"
"2: \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp), "=&r" (ret)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} else {
do {
__asm__ __volatile__(
" ll %1, %3 # arch_write_trylock \n"
" li %2, 0 \n"
" bnez %1, 2f \n"
" lui %1, 0x8000 \n"
" sc %1, %0 \n"
" li %2, 1 \n"
"2: .insn \n"
: "=" GCC_OFF_SMALL_ASM() (rw->lock), "=&r" (tmp),
"=&r" (ret)
: GCC_OFF_SMALL_ASM() (rw->lock)
: "memory");
} while (unlikely(!tmp));
smp_llsc_mb();
}
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 26 | 50.98% | 2 | 28.57% |
| Andrew Morton | 21 | 41.18% | 1 | 14.29% |
| Thomas Gleixner | 2 | 3.92% | 2 | 28.57% |
| Markos Chandras | 1 | 1.96% | 1 | 14.29% |
| Paul Burton | 1 | 1.96% | 1 | 14.29% |
| Total | 51 | 100.00% | 7 | 100.00% |
#define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
#define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
#define arch_spin_relax(lock) cpu_relax()
#define arch_read_relax(lock) cpu_relax()
#define arch_write_relax(lock) cpu_relax()
#endif /* _ASM_SPINLOCK_H */
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Ralf Bächle | 275 | 43.93% | 10 | 29.41% |
| Linus Torvalds (pre-git) | 94 | 15.02% | 2 | 5.88% |
| Peter Zijlstra | 71 | 11.34% | 1 | 2.94% |
| David Daney | 42 | 6.71% | 2 | 5.88% |
| Thomas Gleixner | 37 | 5.91% | 4 | 11.76% |
| Paul Burton | 27 | 4.31% | 2 | 5.88% |
| Andrew Morton | 23 | 3.67% | 2 | 5.88% |
| Martin Schwidefsky | 18 | 2.88% | 1 | 2.94% |
| Robin Holt | 14 | 2.24% | 1 | 2.94% |
| Markos Chandras | 10 | 1.60% | 3 | 8.82% |
| Ingo Molnar | 5 | 0.80% | 2 | 5.88% |
| Linus Torvalds | 4 | 0.64% | 1 | 2.94% |
| Maciej W. Rozycki | 3 | 0.48% | 1 | 2.94% |
| Kyle McMartin | 2 | 0.32% | 1 | 2.94% |
| Leonid Yegoshin | 1 | 0.16% | 1 | 2.94% |
| Total | 626 | 100.00% | 34 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.