lib/spinlock_debug.c

   1 /*
   2  * Copyright 2005, Red Hat, Inc., Ingo Molnar
   3  * Released under the General Public License (GPL).
   4  *
   5  * This file contains the spinlock/rwlock implementations for
   6  * DEBUG_SPINLOCK.
   7  */
   8
   9 #include <linux/spinlock.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/delay.h>
  12
  13 static void spin_bug(spinlock_t *lock, const char *msg)
  14 {
  15         static long print_once = 1;
  16         struct task_struct *owner = NULL;
  17
  18         if (xchg(&print_once, 0)) {
  19                 if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT)
  20                         owner = lock->owner;
  21                 printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n",
  22                         msg, raw_smp_processor_id(),
  23                         current->comm, current->pid);
  24                 printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, "
  25                                 ".owner_cpu: %d\n",
  26                         lock, lock->magic,
  27                         owner ? owner->comm : "<none>",
  28                         owner ? owner->pid : -1,
  29                         lock->owner_cpu);
  30                 dump_stack();
  31 #ifdef CONFIG_SMP
  32                 /*
  33                  * We cannot continue on SMP:
  34                  */
  35 //              panic("bad locking");
  36 #endif
  37         }
  38 }
  39
  40 #define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg)
  41
  42 static inline void debug_spin_lock_before(spinlock_t *lock)
  43 {
  44         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
  45         SPIN_BUG_ON(lock->owner == current, lock, "recursion");
  46         SPIN_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
  47                                                         lock, "cpu recursion");
  48 }
  49
  50 static inline void debug_spin_lock_after(spinlock_t *lock)
  51 {
  52         lock->owner_cpu = raw_smp_processor_id();
  53         lock->owner = current;
  54 }
  55
  56 static inline void debug_spin_unlock(spinlock_t *lock)
  57 {
  58         SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic");
  59         SPIN_BUG_ON(!spin_is_locked(lock), lock, "already unlocked");
  60         SPIN_BUG_ON(lock->owner != current, lock, "wrong owner");
  61         SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
  62                                                         lock, "wrong CPU");
  63         lock->owner = SPINLOCK_OWNER_INIT;
  64         lock->owner_cpu = -1;
  65 }
  66
  67 static void __spin_lock_debug(spinlock_t *lock)
  68 {
  69         int print_once = 1;
  70         u64 i;
  71
  72         for (;;) {
  73                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
  74                         if (__raw_spin_trylock(&lock->raw_lock))
  75                                 return;
  76                         __delay(1);
  77                 }
  78                 /* lockup suspected: */
  79                 if (print_once) {
  80                         print_once = 0;
  81                         printk(KERN_EMERG "BUG: spinlock lockup on CPU#%d, "
  82                                         "%s/%d, %p\n",
  83                                 raw_smp_processor_id(), current->comm,
  84                                 current->pid, lock);
  85                         dump_stack();
  86                 }
  87         }
  88 }
  89
  90 void _raw_spin_lock(spinlock_t *lock)
  91 {
  92         debug_spin_lock_before(lock);
  93         if (unlikely(!__raw_spin_trylock(&lock->raw_lock)))
  94                 __spin_lock_debug(lock);
  95         debug_spin_lock_after(lock);
  96 }
  97
  98 int _raw_spin_trylock(spinlock_t *lock)
  99 {
 100         int ret = __raw_spin_trylock(&lock->raw_lock);
 101
 102         if (ret)
 103                 debug_spin_lock_after(lock);
 104 #ifndef CONFIG_SMP
 105         /*
 106          * Must not happen on UP:
 107          */
 108         SPIN_BUG_ON(!ret, lock, "trylock failure on UP");
 109 #endif
 110         return ret;
 111 }
 112
 113 void _raw_spin_unlock(spinlock_t *lock)
 114 {
 115         debug_spin_unlock(lock);
 116         __raw_spin_unlock(&lock->raw_lock);
 117 }
 118
 119 static void rwlock_bug(rwlock_t *lock, const char *msg)
 120 {
 121         static long print_once = 1;
 122
 123         if (xchg(&print_once, 0)) {
 124                 printk(KERN_EMERG "BUG: rwlock %s on CPU#%d, %s/%d, %p\n",
 125                         msg, raw_smp_processor_id(), current->comm,
 126                         current->pid, lock);
 127                 dump_stack();
 128 #ifdef CONFIG_SMP
 129                 /*
 130                  * We cannot continue on SMP:
 131                  */
 132                 panic("bad locking");
 133 #endif
 134         }
 135 }
 136
 137 #define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg)
 138
 139 static void __read_lock_debug(rwlock_t *lock)
 140 {
 141         int print_once = 1;
 142         u64 i;
 143
 144         for (;;) {
 145                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
 146                         if (__raw_read_trylock(&lock->raw_lock))
 147                                 return;
 148                         __delay(1);
 149                 }
 150                 /* lockup suspected: */
 151                 if (print_once) {
 152                         print_once = 0;
 153                         printk(KERN_EMERG "BUG: read-lock lockup on CPU#%d, "
 154                                         "%s/%d, %p\n",
 155                                 raw_smp_processor_id(), current->comm,
 156                                 current->pid, lock);
 157                         dump_stack();
 158                 }
 159         }
 160 }
 161
 162 void _raw_read_lock(rwlock_t *lock)
 163 {
 164         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
 165         if (unlikely(!__raw_read_trylock(&lock->raw_lock)))
 166                 __read_lock_debug(lock);
 167 }
 168
 169 int _raw_read_trylock(rwlock_t *lock)
 170 {
 171         int ret = __raw_read_trylock(&lock->raw_lock);
 172
 173 #ifndef CONFIG_SMP
 174         /*
 175          * Must not happen on UP:
 176          */
 177         RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
 178 #endif
 179         return ret;
 180 }
 181
 182 void _raw_read_unlock(rwlock_t *lock)
 183 {
 184         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
 185         __raw_read_unlock(&lock->raw_lock);
 186 }
 187
 188 static inline void debug_write_lock_before(rwlock_t *lock)
 189 {
 190         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
 191         RWLOCK_BUG_ON(lock->owner == current, lock, "recursion");
 192         RWLOCK_BUG_ON(lock->owner_cpu == raw_smp_processor_id(),
 193                                                         lock, "cpu recursion");
 194 }
 195
 196 static inline void debug_write_lock_after(rwlock_t *lock)
 197 {
 198         lock->owner_cpu = raw_smp_processor_id();
 199         lock->owner = current;
 200 }
 201
 202 static inline void debug_write_unlock(rwlock_t *lock)
 203 {
 204         RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
 205         RWLOCK_BUG_ON(lock->owner != current, lock, "wrong owner");
 206         RWLOCK_BUG_ON(lock->owner_cpu != raw_smp_processor_id(),
 207                                                         lock, "wrong CPU");
 208         lock->owner = SPINLOCK_OWNER_INIT;
 209         lock->owner_cpu = -1;
 210 }
 211
 212 static void __write_lock_debug(rwlock_t *lock)
 213 {
 214         int print_once = 1;
 215         u64 i;
 216
 217         for (;;) {
 218                 for (i = 0; i < loops_per_jiffy * HZ; i++) {
 219                         if (__raw_write_trylock(&lock->raw_lock))
 220                                 return;
 221                         __delay(1);
 222                 }
 223                 /* lockup suspected: */
 224                 if (print_once) {
 225                         print_once = 0;
 226                         printk(KERN_EMERG "BUG: write-lock lockup on CPU#%d, "
 227                                         "%s/%d, %p\n",
 228                                 raw_smp_processor_id(), current->comm,
 229                                 current->pid, lock);
 230                         dump_stack();
 231                 }
 232         }
 233 }
 234
 235 void _raw_write_lock(rwlock_t *lock)
 236 {
 237         debug_write_lock_before(lock);
 238         if (unlikely(!__raw_write_trylock(&lock->raw_lock)))
 239                 __write_lock_debug(lock);
 240         debug_write_lock_after(lock);
 241 }
 242
 243 int _raw_write_trylock(rwlock_t *lock)
 244 {
 245         int ret = __raw_write_trylock(&lock->raw_lock);
 246
 247         if (ret)
 248                 debug_write_lock_after(lock);
 249 #ifndef CONFIG_SMP
 250         /*
 251          * Must not happen on UP:
 252          */
 253         RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP");
 254 #endif
 255         return ret;
 256 }
 257
 258 void _raw_write_unlock(rwlock_t *lock)
 259 {
 260         debug_write_unlock(lock);
 261         __raw_write_unlock(&lock->raw_lock);
 262 }