/* * Debugging versions of SMP locking primitives. * * Copyright (C) 2004 Thibaut VARENE <varenet@parisc-linux.org> * * Some code stollen from alpha & sparc64 ;) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * We use pdc_printf() throughout the file for all output messages, to avoid * losing messages because of disabled interrupts. Since we're using these * messages for debugging purposes, it makes sense not to send them to the * linux console. */ #include <linux/config.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/spinlock.h>#include <linux/hardirq.h> /* in_interrupt() */#include <asm/system.h>#include <asm/hardirq.h> /* in_interrupt() */#include <asm/pdc.h> #undef INIT_STUCK#define INIT_STUCK 1L << 30 #ifdef CONFIG_DEBUG_SPINLOCK void _dbg_spin_lock(spinlock_t * lock, const char *base_file, int line_no){ volatile unsigned int *a; long stuck = INIT_STUCK; void *inline_pc = __builtin_return_address(0); unsigned long started = jiffies; int printed = 0; int cpu = smp_processor_id(); try_again: /* Do the actual locking */ /* <T-Bone> ggg: we can't get stuck on the outter loop? * <ggg> T-Bone: We can hit the outer loop * alot if multiple CPUs are constantly racing for a lock * and the backplane is NOT fair about which CPU sees * the update first. But it won't hang since every failed * attempt will drop us back into the inner loop and * decrement `stuck'. * <ggg> K-class and some of the others are NOT fair in the HW * implementation so we could see false positives. * But fixing the lock contention is easier than * fixing the HW to be fair. * <tausq> __ldcw() returns 1 if we get the lock; otherwise we * spin until the value of the lock changes, or we time out. */ mb(); a = __ldcw_align(lock); while (stuck && (__ldcw(a) == 0)) while ((*a == 0) && --stuck); mb(); if (unlikely(stuck <= 0)) { pdc_printf( "%s:%d: spin_lock(%s/%p) stuck in %s at %p(%d)" " owned by %s:%d in %s at %p(%d)\n", base_file, line_no, lock->module, lock, current->comm, inline_pc, cpu, lock->bfile, lock->bline, lock->task->comm, lock->previous, lock->oncpu); stuck = INIT_STUCK; printed = 1; goto try_again; } /* Exiting. Got the lock. */ lock->oncpu = cpu; lock->previous = inline_pc; lock->task = current; lock->bfile = (char *)base_file; lock->bline = line_no; if (unlikely(printed)) { pdc_printf( "%s:%d: spin_lock grabbed in %s at %p(%d) %ld ticks\n", base_file, line_no, current->comm, inline_pc, cpu, jiffies - started); }} void _dbg_spin_unlock(spinlock_t * lock, const char *base_file, int line_no){ CHECK_LOCK(lock); volatile unsigned int *a; mb(); a = __ldcw_align(lock); if (unlikely((*a != 0) && lock->babble)) { lock->babble--; pdc_printf( "%s:%d: spin_unlock(%s:%p) not locked\n", base_file, line_no, lock->module, lock); } *a = 1; mb();} int _dbg_spin_trylock(spinlock_t * lock, const char *base_file, int line_no){ int ret; volatile unsigned int *a; mb(); a = __ldcw_align(lock); ret = (__ldcw(a) != 0); mb(); if (ret) { lock->oncpu = smp_processor_id(); lock->previous = __builtin_return_address(0); lock->task = current; } else { lock->bfile = (char *)base_file; lock->bline = line_no; } return ret;} #endif /* CONFIG_DEBUG_SPINLOCK */ #ifdef CONFIG_DEBUG_RWLOCK /* Interrupts trouble detailed explanation, thx Grant: * * o writer (wants to modify data) attempts to acquire the rwlock * o He gets the write lock. * o Interupts are still enabled, we take an interrupt with the * write still holding the lock. * o interrupt handler tries to acquire the rwlock for read. * o deadlock since the writer can't release it at this point. * * In general, any use of spinlocks that competes between "base" * level and interrupt level code will risk deadlock. Interrupts * need to be disabled in the base level routines to avoid it. * Or more precisely, only the IRQ the base level routine * is competing with for the lock. But it's more efficient/faster * to just disable all interrupts on that CPU to guarantee * once it gets the lock it can release it quickly too. */ void _dbg_write_lock(rwlock_t *rw, const char *bfile, int bline){ void *inline_pc = __builtin_return_address(0); unsigned long started = jiffies; long stuck = INIT_STUCK; int printed = 0; int cpu = smp_processor_id(); if(unlikely(in_interrupt())) { /* acquiring write lock in interrupt context, bad idea */ pdc_printf("write_lock caller: %s:%d, IRQs enabled,\n", bfile, bline); BUG(); } /* Note: if interrupts are disabled (which is most likely), the printk will never show on the console. We might need a polling method to flush the dmesg buffer anyhow. */ retry: _raw_spin_lock(&rw->lock); if(rw->counter != 0) { /* this basically never happens */ _raw_spin_unlock(&rw->lock); stuck--; if ((unlikely(stuck <= 0)) && (rw->counter < 0)) { pdc_printf( "%s:%d: write_lock stuck on writer" " in %s at %p(%d) %ld ticks\n", bfile, bline, current->comm, inline_pc, cpu, jiffies - started); stuck = INIT_STUCK; printed = 1; } else if (unlikely(stuck <= 0)) { pdc_printf( "%s:%d: write_lock stuck on reader" " in %s at %p(%d) %ld ticks\n", bfile, bline, current->comm, inline_pc, cpu, jiffies - started); stuck = INIT_STUCK; printed = 1; } while(rw->counter != 0); goto retry; } /* got it. now leave without unlocking */ rw->counter = -1; /* remember we are locked */ if (unlikely(printed)) { pdc_printf( "%s:%d: write_lock grabbed in %s at %p(%d) %ld ticks\n", bfile, bline, current->comm, inline_pc, cpu, jiffies - started); }} int _dbg_write_trylock(rwlock_t *rw, const char *bfile, int bline){#if 0 void *inline_pc = __builtin_return_address(0); int cpu = smp_processor_id();#endif if(unlikely(in_interrupt())) { /* acquiring write lock in interrupt context, bad idea */ pdc_printf("write_lock caller: %s:%d, IRQs enabled,\n", bfile, bline); BUG(); } /* Note: if interrupts are disabled (which is most likely), the printk will never show on the console. We might need a polling method to flush the dmesg buffer anyhow. */ _raw_spin_lock(&rw->lock); if(rw->counter != 0) { /* this basically never happens */ _raw_spin_unlock(&rw->lock); return 0; } /* got it. now leave without unlocking */ rw->counter = -1; /* remember we are locked */#if 0 pdc_printf("%s:%d: try write_lock grabbed in %s at %p(%d)\n", bfile, bline, current->comm, inline_pc, cpu);#endif return 1;} void _dbg_read_lock(rwlock_t * rw, const char *bfile, int bline){#if 0 void *inline_pc = __builtin_return_address(0); unsigned long started = jiffies; int cpu = smp_processor_id();#endif unsigned long flags; local_irq_save(flags); _raw_spin_lock(&rw->lock); rw->counter++;#if 0 pdc_printf( "%s:%d: read_lock grabbed in %s at %p(%d) %ld ticks\n", bfile, bline, current->comm, inline_pc, cpu, jiffies - started);#endif _raw_spin_unlock(&rw->lock); local_irq_restore(flags);} #endif /* CONFIG_DEBUG_RWLOCK */
/*
* Debugging versions of SMP locking primitives.
*
* Copyright (C) 2004 Thibaut VARENE <varenet@parisc-linux.org>
*
* Some code stollen from alpha & sparc64 ;)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* We use pdc_printf() throughout the file for all output messages, to avoid
* losing messages because of disabled interrupts. Since we're using these
* messages for debugging purposes, it makes sense not to send them to the
* linux console.
*/
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/hardirq.h> /* in_interrupt() */
#include <asm/system.h>
#include <asm/hardirq.h> /* in_interrupt() */
#include <asm/pdc.h>
#undef INIT_STUCK
#define INIT_STUCK 1L << 30
#ifdef CONFIG_DEBUG_SPINLOCK
void _dbg_spin_lock(spinlock_t * lock, const char *base_file, int line_no)
{
volatile unsigned int *a;
long stuck = INIT_STUCK;
void *inline_pc = __builtin_return_address(0);
unsigned long started = jiffies;
int printed = 0;
int cpu = smp_processor_id();
try_again:
/* Do the actual locking */
/* <T-Bone> ggg: we can't get stuck on the outter loop?
* <ggg> T-Bone: We can hit the outer loop
* alot if multiple CPUs are constantly racing for a lock
* and the backplane is NOT fair about which CPU sees
* the update first. But it won't hang since every failed
* attempt will drop us back into the inner loop and
* decrement `stuck'.
* <ggg> K-class and some of the others are NOT fair in the HW
* implementation so we could see false positives.
* But fixing the lock contention is easier than
* fixing the HW to be fair.
* <tausq> __ldcw() returns 1 if we get the lock; otherwise we
* spin until the value of the lock changes, or we time out.
*/
mb();
a = __ldcw_align(lock);
while (stuck && (__ldcw(a) == 0))
while ((*a == 0) && --stuck);
mb();
if (unlikely(stuck <= 0)) {
pdc_printf(
"%s:%d: spin_lock(%s/%p) stuck in %s at %p(%d)"
" owned by %s:%d in %s at %p(%d)\n",
base_file, line_no, lock->module, lock,
current->comm, inline_pc, cpu,
lock->bfile, lock->bline, lock->task->comm,
lock->previous, lock->oncpu);
stuck = INIT_STUCK;
printed = 1;
goto try_again;
}
/* Exiting. Got the lock. */
lock->oncpu = cpu;
lock->previous = inline_pc;
lock->task = current;
lock->bfile = (char *)base_file;
lock->bline = line_no;
if (unlikely(printed)) {
pdc_printf(
"%s:%d: spin_lock grabbed in %s at %p(%d) %ld ticks\n",
base_file, line_no, current->comm, inline_pc,
cpu, jiffies - started);
}
}
void _dbg_spin_unlock(spinlock_t * lock, const char *base_file, int line_no)
{
CHECK_LOCK(lock);
volatile unsigned int *a;
mb();
a = __ldcw_align(lock);
if (unlikely((*a != 0) && lock->babble)) {
lock->babble--;
pdc_printf(
"%s:%d: spin_unlock(%s:%p) not locked\n",
base_file, line_no, lock->module, lock);
}
*a = 1;
mb();
}
int _dbg_spin_trylock(spinlock_t * lock, const char *base_file, int line_no)
{
int ret;
volatile unsigned int *a;
mb();
a = __ldcw_align(lock);
ret = (__ldcw(a) != 0);
mb();
if (ret) {
lock->oncpu = smp_processor_id();
lock->previous = __builtin_return_address(0);
lock->task = current;
} else {
lock->bfile = (char *)base_file;
lock->bline = line_no;
}
return ret;
}
#endif /* CONFIG_DEBUG_SPINLOCK */
#ifdef CONFIG_DEBUG_RWLOCK
/* Interrupts trouble detailed explanation, thx Grant:
*
* o writer (wants to modify data) attempts to acquire the rwlock
* o He gets the write lock.
* o Interupts are still enabled, we take an interrupt with the
* write still holding the lock.
* o interrupt handler tries to acquire the rwlock for read.
* o deadlock since the writer can't release it at this point.
*
* In general, any use of spinlocks that competes between "base"
* level and interrupt level code will risk deadlock. Interrupts
* need to be disabled in the base level routines to avoid it.
* Or more precisely, only the IRQ the base level routine
* is competing with for the lock. But it's more efficient/faster
* to just disable all interrupts on that CPU to guarantee
* once it gets the lock it can release it quickly too.
*/
void _dbg_write_lock(rwlock_t *rw, const char *bfile, int bline)
{
void *inline_pc = __builtin_return_address(0);
unsigned long started = jiffies;
long stuck = INIT_STUCK;
int printed = 0;
int cpu = smp_processor_id();
if(unlikely(in_interrupt())) { /* acquiring write lock in interrupt context, bad idea */
pdc_printf("write_lock caller: %s:%d, IRQs enabled,\n", bfile, bline);
BUG();
}
/* Note: if interrupts are disabled (which is most likely), the printk
will never show on the console. We might need a polling method to flush
the dmesg buffer anyhow. */
retry:
_raw_spin_lock(&rw->lock);
if(rw->counter != 0) {
/* this basically never happens */
_raw_spin_unlock(&rw->lock);
stuck--;
if ((unlikely(stuck <= 0)) && (rw->counter < 0)) {
pdc_printf(
"%s:%d: write_lock stuck on writer"
" in %s at %p(%d) %ld ticks\n",
bfile, bline, current->comm, inline_pc,
cpu, jiffies - started);
stuck = INIT_STUCK;
printed = 1;
}
else if (unlikely(stuck <= 0)) {
pdc_printf(
"%s:%d: write_lock stuck on reader"
" in %s at %p(%d) %ld ticks\n",
bfile, bline, current->comm, inline_pc,
cpu, jiffies - started);
stuck = INIT_STUCK;
printed = 1;
}
while(rw->counter != 0);
goto retry;
}
/* got it. now leave without unlocking */
rw->counter = -1; /* remember we are locked */
if (unlikely(printed)) {
pdc_printf(
"%s:%d: write_lock grabbed in %s at %p(%d) %ld ticks\n",
bfile, bline, current->comm, inline_pc,
cpu, jiffies - started);
}
}
int _dbg_write_trylock(rwlock_t *rw, const char *bfile, int bline)
{
#if 0
void *inline_pc = __builtin_return_address(0);
int cpu = smp_processor_id();
#endif
if(unlikely(in_interrupt())) { /* acquiring write lock in interrupt context, bad idea */
pdc_printf("write_lock caller: %s:%d, IRQs enabled,\n", bfile, bline);
BUG();
}
/* Note: if interrupts are disabled (which is most likely), the printk
will never show on the console. We might need a polling method to flush
the dmesg buffer anyhow. */
_raw_spin_lock(&rw->lock);
if(rw->counter != 0) {
/* this basically never happens */
_raw_spin_unlock(&rw->lock);
return 0;
}
/* got it. now leave without unlocking */
rw->counter = -1; /* remember we are locked */
#if 0
pdc_printf("%s:%d: try write_lock grabbed in %s at %p(%d)\n",
bfile, bline, current->comm, inline_pc, cpu);
#endif
return 1;
}
void _dbg_read_lock(rwlock_t * rw, const char *bfile, int bline)
{
#if 0
void *inline_pc = __builtin_return_address(0);
unsigned long started = jiffies;
int cpu = smp_processor_id();
#endif
unsigned long flags;
local_irq_save(flags);
_raw_spin_lock(&rw->lock);
rw->counter++;
#if 0
pdc_printf(
"%s:%d: read_lock grabbed in %s at %p(%d) %ld ticks\n",
bfile, bline, current->comm, inline_pc,
cpu, jiffies - started);
#endif
_raw_spin_unlock(&rw->lock);
local_irq_restore(flags);
}
#endif /* CONFIG_DEBUG_RWLOCK */