Release 4.10 kernel/locking/spinlock_debug.c

Directory: kernel/locking
/*
 * Copyright 2005, Red Hat, Inc., Ingo Molnar
 * Released under the General Public License (GPL).
 *
 * This file contains the spinlock/rwlock implementations for
 * DEBUG_SPINLOCK.
 */

#include <linux/spinlock.h>
#include <linux/nmi.h>
#include <linux/interrupt.h>
#include <linux/debug_locks.h>
#include <linux/delay.h>
#include <linux/export.h>



void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name,
			  struct lock_class_key *key)
{
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	/*
         * Make sure we are not reinitializing a held lock:
         */
	debug_check_no_locks_freed((void *)lock, sizeof(*lock));
	lockdep_init_map(&lock->dep_map, name, key, 0);
#endif
	lock->raw_lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
	lock->magic = SPINLOCK_MAGIC;
	lock->owner = SPINLOCK_OWNER_INIT;
	lock->owner_cpu = -1;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 76 92.68% 1 20.00%
thomas gleixner thomas gleixner 4 4.88% 3 60.00%
peter zijlstra peter zijlstra 2 2.44% 1 20.00%
Total 82 100.00% 5 100.00%


EXPORT_SYMBOL(__raw_spin_lock_init);



void __rwlock_init(rwlock_t *lock, const char *name,
		   struct lock_class_key *key)
{
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	/*
         * Make sure we are not reinitializing a held lock:
         */
	debug_check_no_locks_freed((void *)lock, sizeof(*lock));
	lockdep_init_map(&lock->dep_map, name, key, 0);
#endif
	lock->raw_lock = (arch_rwlock_t) __ARCH_RW_LOCK_UNLOCKED;
	lock->magic = RWLOCK_MAGIC;
	lock->owner = SPINLOCK_OWNER_INIT;
	lock->owner_cpu = -1;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 78 95.12% 1 33.33%
peter zijlstra peter zijlstra 2 2.44% 1 33.33%
thomas gleixner thomas gleixner 2 2.44% 1 33.33%
Total 82 100.00% 3 100.00%


EXPORT_SYMBOL(__rwlock_init);



static void spin_dump(raw_spinlock_t *lock, const char *msg)
{
	struct task_struct *owner = NULL;

	if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT)
		owner = lock->owner;
	printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n",
		msg, raw_smp_processor_id(),
		current->comm, task_pid_nr(current));
	printk(KERN_EMERG " lock: %pS, .magic: %08x, .owner: %s/%d, "
			".owner_cpu: %d\n",
		lock, lock->magic,
		owner ? owner->comm : "<none>",
		owner ? task_pid_nr(owner) : -1,
		lock->owner_cpu);
	dump_stack();
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 86 87.76% 2 28.57%
pavel emelianov pavel emelianov 6 6.12% 1 14.29%
dave jones dave jones 3 3.06% 1 14.29%
akinobu mita akinobu mita 1 1.02% 1 14.29%
thomas gleixner thomas gleixner 1 1.02% 1 14.29%
stephen boyd stephen boyd 1 1.02% 1 14.29%
Total 98 100.00% 7 100.00%



static void spin_bug(raw_spinlock_t *lock, const char *msg)
{
	if (!debug_locks_off())
		return;

	spin_dump(lock, msg);
}

Contributors
Person Tokens Prop Commits CommitProp
akinobu mita akinobu mita 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%


#define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg)


static inline void

debug_spin_lock_before(raw_spinlock_t *lock)
{
	SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
	SPIN_BUG_ON(lock->owner == current, lock, "recursion");
	SPIN_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
							lock, "cpu recursion");
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 50 98.04% 1 50.00%
thomas gleixner thomas gleixner 1 1.96% 1 50.00%
Total 51 100.00% 2 100.00%



static inline void debug_spin_lock_after(raw_spinlock_t *lock)
{
	lock->owner_cpu = raw_smp_processor_id();
	lock->owner = current;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 23 95.83% 1 50.00%
thomas gleixner thomas gleixner 1 4.17% 1 50.00%
Total 24 100.00% 2 100.00%



static inline void debug_spin_unlock(raw_spinlock_t *lock)
{
	SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
	SPIN_BUG_ON(!raw_spin_is_locked(lock), lock, "already unlocked");
	SPIN_BUG_ON(lock->owner != current, lock, "wrong owner");
	SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
							lock, "wrong CPU");
	lock->owner = SPINLOCK_OWNER_INIT;
	lock->owner_cpu = -1;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 75 97.40% 1 50.00%
thomas gleixner thomas gleixner 2 2.60% 1 50.00%
Total 77 100.00% 2 100.00%



static void __spin_lock_debug(raw_spinlock_t *lock)
{
	u64 i;
	u64 loops = loops_per_jiffy * HZ;

	for (i = 0; i < loops; i++) {
		if (arch_spin_trylock(&lock->raw_lock))
			return;
		__delay(1);
	}
	/* lockup suspected: */
	spin_dump(lock, "lockup suspected");
#ifdef CONFIG_SMP
	trigger_all_cpu_backtrace();
#endif

	/*
         * The trylock above was causing a livelock.  Give the lower level arch
         * specific lock code a chance to acquire the lock. We have already
         * printed a warning/backtrace at this point. The non-debug arch
         * specific code might actually succeed in acquiring the lock.  If it is
         * not successful, the end-result is the same - there is no forward
         * progress.
         */
	arch_spin_lock(&lock->raw_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 43 56.58% 2 22.22%
chuck ebbert chuck ebbert 11 14.47% 1 11.11%
vikram mulukutla vikram mulukutla 9 11.84% 1 11.11%
andrew morton andrew morton 8 10.53% 1 11.11%
thomas gleixner thomas gleixner 2 2.63% 2 22.22%
akinobu mita akinobu mita 2 2.63% 1 11.11%
christian borntraeger christian borntraeger 1 1.32% 1 11.11%
Total 76 100.00% 9 100.00%



void do_raw_spin_lock(raw_spinlock_t *lock)
{
	debug_spin_lock_before(lock);
	if (unlikely(!arch_spin_trylock(&lock->raw_lock)))
		__spin_lock_debug(lock);
	debug_spin_lock_after(lock);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 35 92.11% 1 25.00%
thomas gleixner thomas gleixner 3 7.89% 3 75.00%
Total 38 100.00% 4 100.00%



int do_raw_spin_trylock(raw_spinlock_t *lock)
{
	int ret = arch_spin_trylock(&lock->raw_lock);

	if (ret)
		debug_spin_lock_after(lock);
#ifndef CONFIG_SMP
	/*
         * Must not happen on UP:
         */
	SPIN_BUG_ON(!ret, lock, "trylock failure on UP");
#endif
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 45 93.75% 1 25.00%
thomas gleixner thomas gleixner 3 6.25% 3 75.00%
Total 48 100.00% 4 100.00%



void do_raw_spin_unlock(raw_spinlock_t *lock)
{
	debug_spin_unlock(lock);
	arch_spin_unlock(&lock->raw_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 19 86.36% 1 25.00%
thomas gleixner thomas gleixner 3 13.64% 3 75.00%
Total 22 100.00% 4 100.00%



static void rwlock_bug(rwlock_t *lock, const char *msg)
{
	if (!debug_locks_off())
		return;

	printk(KERN_EMERG "BUG: rwlock %s on CPU#%d, %s/%d, %p\n",
		msg, raw_smp_processor_id(), current->comm,
		task_pid_nr(current), lock);
	dump_stack();
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 43 91.49% 3 60.00%
pavel emelianov pavel emelianov 3 6.38% 1 20.00%
dave jones dave jones 1 2.13% 1 20.00%
Total 47 100.00% 5 100.00%


#define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg)

#if 0		/* __write_lock_debug() can lock up - maybe this can too? */
static void __read_lock_debug(rwlock_t *lock)
{
        u64 i;
        u64 loops = loops_per_jiffy * HZ;
        int print_once = 1;

        for (;;) {
                for (i = 0; i < loops; i++) {
                        if (arch_read_trylock(&lock->raw_lock))
                                return;
                        __delay(1);
                }
		/* lockup suspected: */
		if (print_once) {
                        print_once = 0;
                        printk(KERN_EMERG "BUG: read-lock lockup on CPU#%d, "
                                        "%s/%d, %p\n",
                                raw_smp_processor_id(), current->comm,
                                current->pid, lock);
                        dump_stack();
                }
        }
}
#endif



void do_raw_read_lock(rwlock_t *lock)
{
	RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
	arch_read_lock(&lock->raw_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 28 93.33% 1 33.33%
thomas gleixner thomas gleixner 2 6.67% 2 66.67%
Total 30 100.00% 3 100.00%



int do_raw_read_trylock(rwlock_t *lock)
{
	int ret = arch_read_trylock(&lock->raw_lock);

#ifndef CONFIG_SMP
	/*
         * Must not happen on UP:
         */
	RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
#endif
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 37 94.87% 1 33.33%
thomas gleixner thomas gleixner 2 5.13% 2 66.67%
Total 39 100.00% 3 100.00%



void do_raw_read_unlock(rwlock_t *lock)
{
	RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
	arch_read_unlock(&lock->raw_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 28 93.33% 1 33.33%
thomas gleixner thomas gleixner 2 6.67% 2 66.67%
Total 30 100.00% 3 100.00%



static inline void debug_write_lock_before(rwlock_t *lock)
{
	RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
	RWLOCK_BUG_ON(lock->owner == current, lock, "recursion");
	RWLOCK_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
							lock, "cpu recursion");
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%



static inline void debug_write_lock_after(rwlock_t *lock)
{
	lock->owner_cpu = raw_smp_processor_id();
	lock->owner = current;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%



static inline void debug_write_unlock(rwlock_t *lock)
{
	RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
	RWLOCK_BUG_ON(lock->owner != current, lock, "wrong owner");
	RWLOCK_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
							lock, "wrong CPU");
	lock->owner = SPINLOCK_OWNER_INIT;
	lock->owner_cpu = -1;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 64 100.00% 1 100.00%
Total 64 100.00% 1 100.00%

#if 0		/* This can cause lockups */
static void __write_lock_debug(rwlock_t *lock)
{
        u64 i;
        u64 loops = loops_per_jiffy * HZ;
        int print_once = 1;

        for (;;) {
                for (i = 0; i < loops; i++) {
                        if (arch_write_trylock(&lock->raw_lock))
                                return;
                        __delay(1);
                }
		/* lockup suspected: */
		if (print_once) {
                        print_once = 0;
                        printk(KERN_EMERG "BUG: write-lock lockup on CPU#%d, "
                                        "%s/%d, %p\n",
                                raw_smp_processor_id(), current->comm,
                                current->pid, lock);
                        dump_stack();
                }
        }
}
#endif



void do_raw_write_lock(rwlock_t *lock)
{
	debug_write_lock_before(lock);
	arch_write_lock(&lock->raw_lock);
	debug_write_lock_after(lock);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 25 92.59% 1 33.33%
thomas gleixner thomas gleixner 2 7.41% 2 66.67%
Total 27 100.00% 3 100.00%



int do_raw_write_trylock(rwlock_t *lock)
{
	int ret = arch_write_trylock(&lock->raw_lock);

	if (ret)
		debug_write_lock_after(lock);
#ifndef CONFIG_SMP
	/*
         * Must not happen on UP:
         */
	RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
#endif
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 46 95.83% 1 33.33%
thomas gleixner thomas gleixner 2 4.17% 2 66.67%
Total 48 100.00% 3 100.00%



void do_raw_write_unlock(rwlock_t *lock)
{
	debug_write_unlock(lock);
	arch_write_unlock(&lock->raw_lock);
}
Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 20 90.91% 1 33.33%
thomas gleixner thomas gleixner 2 9.09% 2 66.67%
Total 22 100.00% 3 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 946 87.76% 5 21.74%
thomas gleixner thomas gleixner 37 3.43% 7 30.43%
akinobu mita akinobu mita 32 2.97% 1 4.35%
andrew morton andrew morton 23 2.13% 2 8.70%
chuck ebbert chuck ebbert 11 1.02% 1 4.35%
vikram mulukutla vikram mulukutla 9 0.83% 1 4.35%
pavel emelianov pavel emelianov 9 0.83% 1 4.35%
dave jones dave jones 4 0.37% 1 4.35%
peter zijlstra peter zijlstra 4 0.37% 1 4.35%
stephen boyd stephen boyd 1 0.09% 1 4.35%
christian borntraeger christian borntraeger 1 0.09% 1 4.35%
paul gortmaker paul gortmaker 1 0.09% 1 4.35%
Total 1078 100.00% 23 100.00%
Directory: kernel/locking

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
ingo molnar	ingo molnar	76	92.68%	1	20.00%
thomas gleixner	thomas gleixner	4	4.88%	3	60.00%
peter zijlstra	peter zijlstra	2	2.44%	1	20.00%
	Total	82	100.00%	5	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 kernel/locking/spinlock_debug.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
