Release 4.10 arch/s390/include/asm/spinlock.h

Directory: arch/s390/include/asm
/*
 *  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 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 borntraeger christian borntraeger 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 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 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 heiko carstens 16 94.12% 1 50.00%
philipp hachtmann 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 ACCESS_ONCE(lp->lock) != 0;
}

Contributors
Person Tokens Prop Commits CommitProp
philipp hachtmann philipp hachtmann 13 61.90% 1 25.00%
pre-git pre-git 6 28.57% 1 25.00%
thomas gleixner thomas gleixner 1 4.76% 1 25.00%
martin schwidefsky martin schwidefsky 1 4.76% 1 25.00%
Total 21 100.00% 4 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 martin schwidefsky 21 58.33% 3 60.00%
philipp hachtmann 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 philipp hachtmann 15 62.50% 1 20.00%
martin schwidefsky martin schwidefsky 7 29.17% 2 40.00%
pre-git pre-git 1 4.17% 1 20.00%
thomas gleixner thomas gleixner 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 hisashi hifumi 22 73.33% 1 25.00%
philipp hachtmann philipp hachtmann 5 16.67% 1 25.00%
thomas gleixner 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
pre-git pre-git 10 35.71% 1 16.67%
philipp hachtmann philipp hachtmann 8 28.57% 1 16.67%
martin schwidefsky martin schwidefsky 7 25.00% 2 33.33%
thomas gleixner 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
pre-git pre-git 7 33.33% 1 14.29%
heiko carstens heiko carstens 7 33.33% 1 14.29%
philipp hachtmann philipp hachtmann 2 9.52% 1 14.29%
thomas gleixner thomas gleixner 2 9.52% 2 28.57%
martin schwidefsky martin schwidefsky 2 9.52% 1 14.29%
christian borntraeger christian borntraeger 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 philipp hachtmann 20 76.92% 1 25.00%
peter zijlstra peter zijlstra 3 11.54% 1 25.00%
martin schwidefsky martin schwidefsky 2 7.69% 1 25.00%
pre-git 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 martin schwidefsky 43 91.49% 2 50.00%
pre-git pre-git 3 6.38% 1 25.00%
thomas gleixner 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 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 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 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 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 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 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 martin schwidefsky 34 75.56% 2 40.00%
philipp hachtmann philipp hachtmann 9 20.00% 1 20.00%
thomas gleixner 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 martin schwidefsky 24 80.00% 3 42.86%
pre-git pre-git 3 10.00% 1 14.29%
thomas gleixner thomas gleixner 2 6.67% 2 28.57%
philipp hachtmann 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 martin schwidefsky 18 66.67% 3 42.86%
heiko carstens heiko carstens 6 22.22% 1 14.29%
thomas gleixner thomas gleixner 2 7.41% 2 28.57%
christian borntraeger christian borntraeger 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 martin schwidefsky 24 85.71% 2 40.00%
ingo molnar ingo molnar 2 7.14% 1 20.00%
thomas gleixner 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 martin schwidefsky 35 94.59% 4 66.67%
thomas gleixner 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 martin schwidefsky 17 94.44% 2 66.67%
thomas gleixner 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 martin schwidefsky 17 94.44% 2 66.67%
thomas gleixner 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 martin schwidefsky 664 69.53% 13 43.33%
philipp hachtmann philipp hachtmann 112 11.73% 2 6.67%
pre-git pre-git 43 4.50% 1 3.33%
heiko carstens heiko carstens 34 3.56% 4 13.33%
christian borntraeger christian borntraeger 34 3.56% 2 6.67%
thomas gleixner thomas gleixner 30 3.14% 4 13.33%
hisashi hifumi hisashi hifumi 26 2.72% 1 3.33%
peter zijlstra peter zijlstra 9 0.94% 1 3.33%
ingo molnar ingo molnar 3 0.31% 2 6.67%
Total 955 100.00% 30 100.00%
Directory: arch/s390/include/asm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
martin schwidefsky	martin schwidefsky	30	100.00%	2	100.00%
	Total	30	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 arch/s390/include/asm/spinlock.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
