Release 4.11 arch/s390/include/asm/spinlock.h
/*
* S390 version
* Copyright IBM Corp. 1999
* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
*
* Derived from "include/asm-i386/spinlock.h"
*/
#ifndef __ASM_SPINLOCK_H
#define __ASM_SPINLOCK_H
#include <linux/smp.h>
#include <asm/barrier.h>
#include <asm/processor.h>
#define SPINLOCK_LOCKVAL (S390_lowcore.spinlock_lockval)
extern int spin_retry;
static inline int
_raw_compare_and_swap(unsigned int *lock, unsigned int old, unsigned int new)
{
return __sync_bool_compare_and_swap(lock, old, new);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 30 | 100.00% | 2 | 100.00% |
| Total | 30 | 100.00% | 2 | 100.00% |
#ifndef CONFIG_SMP
static inline bool arch_vcpu_is_preempted(int cpu) { return false; }
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Christian Bornträger | 13 | 100.00% | 1 | 100.00% |
| Total | 13 | 100.00% | 1 | 100.00% |
#else
bool arch_vcpu_is_preempted(int cpu);
#endif
#define vcpu_is_preempted arch_vcpu_is_preempted
/*
* Simple spin lock operations. There are two variants, one clears IRQ's
* on the local processor, one does not.
*
* We make no fairness assumptions. They have a cost.
*
* (the type definitions are in asm/spinlock_types.h)
*/
void arch_lock_relax(unsigned int cpu);
void arch_spin_lock_wait(arch_spinlock_t *);
int arch_spin_trylock_retry(arch_spinlock_t *);
void arch_spin_lock_wait_flags(arch_spinlock_t *, unsigned long flags);
static inline void arch_spin_relax(arch_spinlock_t *lock)
{
arch_lock_relax(lock->lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 18 | 100.00% | 1 | 100.00% |
| Total | 18 | 100.00% | 1 | 100.00% |
static inline u32 arch_spin_lockval(int cpu)
{
return ~cpu;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Philipp Hachtmann | 14 | 100.00% | 1 | 100.00% |
| Total | 14 | 100.00% | 1 | 100.00% |
static inline int arch_spin_value_unlocked(arch_spinlock_t lock)
{
return lock.lock == 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Heiko Carstens | 16 | 94.12% | 1 | 50.00% |
| Philipp Hachtmann | 1 | 5.88% | 1 | 50.00% |
| Total | 17 | 100.00% | 2 | 100.00% |
static inline int arch_spin_is_locked(arch_spinlock_t *lp)
{
return READ_ONCE(lp->lock) != 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Philipp Hachtmann | 12 | 57.14% | 1 | 20.00% |
| Linus Torvalds (pre-git) | 6 | 28.57% | 1 | 20.00% |
| Thomas Gleixner | 1 | 4.76% | 1 | 20.00% |
| Christian Bornträger | 1 | 4.76% | 1 | 20.00% |
| Martin Schwidefsky | 1 | 4.76% | 1 | 20.00% |
| Total | 21 | 100.00% | 5 | 100.00% |
static inline int arch_spin_trylock_once(arch_spinlock_t *lp)
{
barrier();
return likely(arch_spin_value_unlocked(*lp) &&
_raw_compare_and_swap(&lp->lock, 0, SPINLOCK_LOCKVAL));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 21 | 58.33% | 3 | 60.00% |
| Philipp Hachtmann | 15 | 41.67% | 2 | 40.00% |
| Total | 36 | 100.00% | 5 | 100.00% |
static inline void arch_spin_lock(arch_spinlock_t *lp)
{
if (!arch_spin_trylock_once(lp))
arch_spin_lock_wait(lp);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Philipp Hachtmann | 15 | 62.50% | 1 | 20.00% |
| Martin Schwidefsky | 7 | 29.17% | 2 | 40.00% |
| Thomas Gleixner | 1 | 4.17% | 1 | 20.00% |
| Linus Torvalds (pre-git) | 1 | 4.17% | 1 | 20.00% |
| Total | 24 | 100.00% | 5 | 100.00% |
static inline void arch_spin_lock_flags(arch_spinlock_t *lp,
unsigned long flags)
{
if (!arch_spin_trylock_once(lp))
arch_spin_lock_wait_flags(lp, flags);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Hisashi Hifumi | 22 | 73.33% | 1 | 25.00% |
| Philipp Hachtmann | 5 | 16.67% | 1 | 25.00% |
| Thomas Gleixner | 3 | 10.00% | 2 | 50.00% |
| Total | 30 | 100.00% | 4 | 100.00% |
static inline int arch_spin_trylock(arch_spinlock_t *lp)
{
if (!arch_spin_trylock_once(lp))
return arch_spin_trylock_retry(lp);
return 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Linus Torvalds (pre-git) | 10 | 35.71% | 1 | 16.67% |
| Philipp Hachtmann | 8 | 28.57% | 1 | 16.67% |
| Martin Schwidefsky | 7 | 25.00% | 2 | 33.33% |
| Thomas Gleixner | 3 | 10.71% | 2 | 33.33% |
| Total | 28 | 100.00% | 6 | 100.00% |
static inline void arch_spin_unlock(arch_spinlock_t *lp)
{
typecheck(unsigned int, lp->lock);
asm volatile(
"st %1,%0\n"
: "+Q" (lp->lock)
: "d" (0)
: "cc", "memory");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Heiko Carstens | 7 | 33.33% | 1 | 14.29% |
| Linus Torvalds (pre-git) | 7 | 33.33% | 1 | 14.29% |
| Thomas Gleixner | 2 | 9.52% | 2 | 28.57% |
| Philipp Hachtmann | 2 | 9.52% | 1 | 14.29% |
| Martin Schwidefsky | 2 | 9.52% | 1 | 14.29% |
| Christian Bornträger | 1 | 4.76% | 1 | 14.29% |
| Total | 21 | 100.00% | 7 | 100.00% |
static inline void arch_spin_unlock_wait(arch_spinlock_t *lock)
{
while (arch_spin_is_locked(lock))
arch_spin_relax(lock);
smp_acquire__after_ctrl_dep();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Philipp Hachtmann | 20 | 76.92% | 1 | 25.00% |
| Peter Zijlstra | 3 | 11.54% | 1 | 25.00% |
| Martin Schwidefsky | 2 | 7.69% | 1 | 25.00% |
| Linus Torvalds (pre-git) | 1 | 3.85% | 1 | 25.00% |
| Total | 26 | 100.00% | 4 | 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(x) ((int)(x)->lock >= 0)
/**
* write_can_lock - would write_trylock() succeed?
* @lock: the rwlock in question.
*/
#define arch_write_can_lock(x) ((x)->lock == 0)
extern int _raw_read_trylock_retry(arch_rwlock_t *lp);
extern int _raw_write_trylock_retry(arch_rwlock_t *lp);
#define arch_read_lock_flags(lock, flags) arch_read_lock(lock)
#define arch_write_lock_flags(lock, flags) arch_write_lock(lock)
static inline int arch_read_trylock_once(arch_rwlock_t *rw)
{
unsigned int old = ACCESS_ONCE(rw->lock);
return likely((int) old >= 0 &&
_raw_compare_and_swap(&rw->lock, old, old + 1));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 43 | 91.49% | 2 | 50.00% |
| Linus Torvalds (pre-git) | 3 | 6.38% | 1 | 25.00% |
| Thomas Gleixner | 1 | 2.13% | 1 | 25.00% |
| Total | 47 | 100.00% | 4 | 100.00% |
static inline int arch_write_trylock_once(arch_rwlock_t *rw)
{
unsigned int old = ACCESS_ONCE(rw->lock);
return likely(old == 0 &&
_raw_compare_and_swap(&rw->lock, 0, 0x80000000));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 42 | 100.00% | 1 | 100.00% |
| Total | 42 | 100.00% | 1 | 100.00% |
#ifdef CONFIG_HAVE_MARCH_Z196_FEATURES
#define __RAW_OP_OR "lao"
#define __RAW_OP_AND "lan"
#define __RAW_OP_ADD "laa"
#define __RAW_LOCK(ptr, op_val, op_string) \
({ \
unsigned int old_val; \
\
typecheck(unsigned int *, ptr); \
asm volatile( \
op_string " %0,%2,%1\n" \
"bcr 14,0\n" \
: "=d" (old_val), "+Q" (*ptr) \
: "d" (op_val) \
: "cc", "memory"); \
old_val; \
})
#define __RAW_UNLOCK(ptr, op_val, op_string) \
({ \
unsigned int old_val; \
\
typecheck(unsigned int *, ptr); \
asm volatile( \
op_string " %0,%2,%1\n" \
: "=d" (old_val), "+Q" (*ptr) \
: "d" (op_val) \
: "cc", "memory"); \
old_val; \
})
extern void _raw_read_lock_wait(arch_rwlock_t *lp);
extern void _raw_write_lock_wait(arch_rwlock_t *lp, unsigned int prev);
static inline void arch_read_lock(arch_rwlock_t *rw)
{
unsigned int old;
old = __RAW_LOCK(&rw->lock, 1, __RAW_OP_ADD);
if ((int) old < 0)
_raw_read_lock_wait(rw);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 43 | 100.00% | 1 | 100.00% |
| Total | 43 | 100.00% | 1 | 100.00% |
static inline void arch_read_unlock(arch_rwlock_t *rw)
{
__RAW_UNLOCK(&rw->lock, -1, __RAW_OP_ADD);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 24 | 100.00% | 1 | 100.00% |
| Total | 24 | 100.00% | 1 | 100.00% |
static inline void arch_write_lock(arch_rwlock_t *rw)
{
unsigned int old;
old = __RAW_LOCK(&rw->lock, 0x80000000, __RAW_OP_OR);
if (old != 0)
_raw_write_lock_wait(rw, old);
rw->owner = SPINLOCK_LOCKVAL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 48 | 100.00% | 1 | 100.00% |
| Total | 48 | 100.00% | 1 | 100.00% |
static inline void arch_write_unlock(arch_rwlock_t *rw)
{
rw->owner = 0;
__RAW_UNLOCK(&rw->lock, 0x7fffffff, __RAW_OP_AND);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 29 | 100.00% | 1 | 100.00% |
| Total | 29 | 100.00% | 1 | 100.00% |
#else /* CONFIG_HAVE_MARCH_Z196_FEATURES */
extern void _raw_read_lock_wait(arch_rwlock_t *lp);
extern void _raw_write_lock_wait(arch_rwlock_t *lp);
static inline void arch_read_lock(arch_rwlock_t *rw)
{
if (!arch_read_trylock_once(rw))
_raw_read_lock_wait(rw);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 24 | 100.00% | 2 | 100.00% |
| Total | 24 | 100.00% | 2 | 100.00% |
static inline void arch_read_unlock(arch_rwlock_t *rw)
{
unsigned int old;
do {
old = ACCESS_ONCE(rw->lock);
} while (!_raw_compare_and_swap(&rw->lock, old, old - 1));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 34 | 75.56% | 2 | 40.00% |
| Philipp Hachtmann | 9 | 20.00% | 1 | 20.00% |
| Thomas Gleixner | 2 | 4.44% | 2 | 40.00% |
| Total | 45 | 100.00% | 5 | 100.00% |
static inline void arch_write_lock(arch_rwlock_t *rw)
{
if (!arch_write_trylock_once(rw))
_raw_write_lock_wait(rw);
rw->owner = SPINLOCK_LOCKVAL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 24 | 80.00% | 3 | 42.86% |
| Linus Torvalds (pre-git) | 3 | 10.00% | 1 | 14.29% |
| Thomas Gleixner | 2 | 6.67% | 2 | 28.57% |
| Philipp Hachtmann | 1 | 3.33% | 1 | 14.29% |
| Total | 30 | 100.00% | 7 | 100.00% |
static inline void arch_write_unlock(arch_rwlock_t *rw)
{
typecheck(unsigned int, rw->lock);
rw->owner = 0;
asm volatile(
"st %1,%0\n"
: "+Q" (rw->lock)
: "d" (0)
: "cc", "memory");
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 18 | 66.67% | 3 | 42.86% |
| Heiko Carstens | 6 | 22.22% | 1 | 14.29% |
| Thomas Gleixner | 2 | 7.41% | 2 | 28.57% |
| Christian Bornträger | 1 | 3.70% | 1 | 14.29% |
| Total | 27 | 100.00% | 7 | 100.00% |
#endif /* CONFIG_HAVE_MARCH_Z196_FEATURES */
static inline int arch_read_trylock(arch_rwlock_t *rw)
{
if (!arch_read_trylock_once(rw))
return _raw_read_trylock_retry(rw);
return 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 24 | 85.71% | 2 | 40.00% |
| Ingo Molnar | 2 | 7.14% | 1 | 20.00% |
| Thomas Gleixner | 2 | 7.14% | 2 | 40.00% |
| Total | 28 | 100.00% | 5 | 100.00% |
static inline int arch_write_trylock(arch_rwlock_t *rw)
{
if (!arch_write_trylock_once(rw) && !_raw_write_trylock_retry(rw))
return 0;
rw->owner = SPINLOCK_LOCKVAL;
return 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 35 | 94.59% | 4 | 66.67% |
| Thomas Gleixner | 2 | 5.41% | 2 | 33.33% |
| Total | 37 | 100.00% | 6 | 100.00% |
static inline void arch_read_relax(arch_rwlock_t *rw)
{
arch_lock_relax(rw->owner);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 17 | 94.44% | 2 | 66.67% |
| Thomas Gleixner | 1 | 5.56% | 1 | 33.33% |
| Total | 18 | 100.00% | 3 | 100.00% |
static inline void arch_write_relax(arch_rwlock_t *rw)
{
arch_lock_relax(rw->owner);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 17 | 94.44% | 2 | 66.67% |
| Thomas Gleixner | 1 | 5.56% | 1 | 33.33% |
| Total | 18 | 100.00% | 3 | 100.00% |
#endif /* __ASM_SPINLOCK_H */
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Martin Schwidefsky | 664 | 69.53% | 13 | 41.94% |
| Philipp Hachtmann | 111 | 11.62% | 2 | 6.45% |
| Linus Torvalds (pre-git) | 43 | 4.50% | 1 | 3.23% |
| Christian Bornträger | 35 | 3.66% | 3 | 9.68% |
| Heiko Carstens | 34 | 3.56% | 4 | 12.90% |
| Thomas Gleixner | 30 | 3.14% | 4 | 12.90% |
| Hisashi Hifumi | 26 | 2.72% | 1 | 3.23% |
| Peter Zijlstra | 9 | 0.94% | 1 | 3.23% |
| Ingo Molnar | 3 | 0.31% | 2 | 6.45% |
| Total | 955 | 100.00% | 31 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.