Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 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 | |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 9 | #include <linux/spinlock.h> |
Andrew Morton | bb81a09 | 2006-12-07 02:14:01 +0100 | [diff] [blame] | 10 | #include <linux/nmi.h> |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 11 | #include <linux/interrupt.h> |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 12 | #include <linux/debug_locks.h> |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 13 | #include <linux/delay.h> |
Paul Gortmaker | 8bc3bcc | 2011-11-16 21:29:17 -0500 | [diff] [blame] | 14 | #include <linux/export.h> |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 15 | |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 16 | void __raw_spin_lock_init(raw_spinlock_t *lock, const char *name, |
| 17 | struct lock_class_key *key) |
Ingo Molnar | 8a25d5d | 2006-07-03 00:24:54 -0700 | [diff] [blame] | 18 | { |
| 19 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
| 20 | /* |
| 21 | * Make sure we are not reinitializing a held lock: |
| 22 | */ |
| 23 | debug_check_no_locks_freed((void *)lock, sizeof(*lock)); |
Peter Zijlstra | 4dfbb9d | 2006-10-11 01:45:14 -0400 | [diff] [blame] | 24 | lockdep_init_map(&lock->dep_map, name, key, 0); |
Ingo Molnar | 8a25d5d | 2006-07-03 00:24:54 -0700 | [diff] [blame] | 25 | #endif |
Thomas Gleixner | edc35bd | 2009-12-03 12:38:57 +0100 | [diff] [blame] | 26 | lock->raw_lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED; |
Ingo Molnar | 8a25d5d | 2006-07-03 00:24:54 -0700 | [diff] [blame] | 27 | lock->magic = SPINLOCK_MAGIC; |
| 28 | lock->owner = SPINLOCK_OWNER_INIT; |
| 29 | lock->owner_cpu = -1; |
| 30 | } |
| 31 | |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 32 | EXPORT_SYMBOL(__raw_spin_lock_init); |
Ingo Molnar | 8a25d5d | 2006-07-03 00:24:54 -0700 | [diff] [blame] | 33 | |
| 34 | void __rwlock_init(rwlock_t *lock, const char *name, |
| 35 | struct lock_class_key *key) |
| 36 | { |
| 37 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
| 38 | /* |
| 39 | * Make sure we are not reinitializing a held lock: |
| 40 | */ |
| 41 | debug_check_no_locks_freed((void *)lock, sizeof(*lock)); |
Peter Zijlstra | 4dfbb9d | 2006-10-11 01:45:14 -0400 | [diff] [blame] | 42 | lockdep_init_map(&lock->dep_map, name, key, 0); |
Ingo Molnar | 8a25d5d | 2006-07-03 00:24:54 -0700 | [diff] [blame] | 43 | #endif |
Thomas Gleixner | fb3a6bbc | 2009-12-03 20:01:19 +0100 | [diff] [blame] | 44 | lock->raw_lock = (arch_rwlock_t) __ARCH_RW_LOCK_UNLOCKED; |
Ingo Molnar | 8a25d5d | 2006-07-03 00:24:54 -0700 | [diff] [blame] | 45 | lock->magic = RWLOCK_MAGIC; |
| 46 | lock->owner = SPINLOCK_OWNER_INIT; |
| 47 | lock->owner_cpu = -1; |
| 48 | } |
| 49 | |
| 50 | EXPORT_SYMBOL(__rwlock_init); |
| 51 | |
Akinobu Mita | 4e101b0 | 2011-10-31 17:12:29 -0700 | [diff] [blame] | 52 | static void spin_dump(raw_spinlock_t *lock, const char *msg) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 53 | { |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 54 | struct task_struct *owner = NULL; |
| 55 | |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 56 | if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT) |
| 57 | owner = lock->owner; |
| 58 | printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d\n", |
| 59 | msg, raw_smp_processor_id(), |
Pavel Emelyanov | ba25f9d | 2007-10-18 23:40:40 -0700 | [diff] [blame] | 60 | current->comm, task_pid_nr(current)); |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 61 | printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, " |
| 62 | ".owner_cpu: %d\n", |
| 63 | lock, lock->magic, |
| 64 | owner ? owner->comm : "<none>", |
Pavel Emelyanov | ba25f9d | 2007-10-18 23:40:40 -0700 | [diff] [blame] | 65 | owner ? task_pid_nr(owner) : -1, |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 66 | lock->owner_cpu); |
| 67 | dump_stack(); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 68 | } |
| 69 | |
Akinobu Mita | 4e101b0 | 2011-10-31 17:12:29 -0700 | [diff] [blame] | 70 | static void spin_bug(raw_spinlock_t *lock, const char *msg) |
| 71 | { |
| 72 | if (!debug_locks_off()) |
| 73 | return; |
| 74 | |
| 75 | spin_dump(lock, msg); |
| 76 | } |
| 77 | |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 78 | #define SPIN_BUG_ON(cond, lock, msg) if (unlikely(cond)) spin_bug(lock, msg) |
| 79 | |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 80 | static inline void |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 81 | debug_spin_lock_before(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 82 | { |
| 83 | SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic"); |
| 84 | SPIN_BUG_ON(lock->owner == current, lock, "recursion"); |
| 85 | SPIN_BUG_ON(lock->owner_cpu == raw_smp_processor_id(), |
| 86 | lock, "cpu recursion"); |
| 87 | } |
| 88 | |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 89 | static inline void debug_spin_lock_after(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 90 | { |
| 91 | lock->owner_cpu = raw_smp_processor_id(); |
| 92 | lock->owner = current; |
| 93 | } |
| 94 | |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 95 | static inline void debug_spin_unlock(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 96 | { |
| 97 | SPIN_BUG_ON(lock->magic != SPINLOCK_MAGIC, lock, "bad magic"); |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 98 | SPIN_BUG_ON(!raw_spin_is_locked(lock), lock, "already unlocked"); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 99 | SPIN_BUG_ON(lock->owner != current, lock, "wrong owner"); |
| 100 | SPIN_BUG_ON(lock->owner_cpu != raw_smp_processor_id(), |
| 101 | lock, "wrong CPU"); |
| 102 | lock->owner = SPINLOCK_OWNER_INIT; |
| 103 | lock->owner_cpu = -1; |
| 104 | } |
| 105 | |
Thomas Gleixner | c2f21ce | 2009-12-02 20:02:59 +0100 | [diff] [blame] | 106 | static void __spin_lock_debug(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 107 | { |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 108 | u64 i; |
Chuck Ebbert | c22f008b | 2006-09-29 01:59:14 -0700 | [diff] [blame] | 109 | u64 loops = loops_per_jiffy * HZ; |
| 110 | int print_once = 1; |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 111 | |
| 112 | for (;;) { |
Chuck Ebbert | c22f008b | 2006-09-29 01:59:14 -0700 | [diff] [blame] | 113 | for (i = 0; i < loops; i++) { |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 114 | if (arch_spin_trylock(&lock->raw_lock)) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 115 | return; |
Ingo Molnar | e0a6029 | 2006-02-07 12:58:54 -0800 | [diff] [blame] | 116 | __delay(1); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 117 | } |
| 118 | /* lockup suspected: */ |
| 119 | if (print_once) { |
| 120 | print_once = 0; |
Akinobu Mita | 4e101b0 | 2011-10-31 17:12:29 -0700 | [diff] [blame] | 121 | spin_dump(lock, "lockup"); |
Andrew Morton | bb81a09 | 2006-12-07 02:14:01 +0100 | [diff] [blame] | 122 | #ifdef CONFIG_SMP |
| 123 | trigger_all_cpu_backtrace(); |
| 124 | #endif |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 125 | } |
| 126 | } |
| 127 | } |
| 128 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 129 | void do_raw_spin_lock(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 130 | { |
| 131 | debug_spin_lock_before(lock); |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 132 | if (unlikely(!arch_spin_trylock(&lock->raw_lock))) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 133 | __spin_lock_debug(lock); |
| 134 | debug_spin_lock_after(lock); |
| 135 | } |
| 136 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 137 | int do_raw_spin_trylock(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 138 | { |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 139 | int ret = arch_spin_trylock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 140 | |
| 141 | if (ret) |
| 142 | debug_spin_lock_after(lock); |
| 143 | #ifndef CONFIG_SMP |
| 144 | /* |
| 145 | * Must not happen on UP: |
| 146 | */ |
| 147 | SPIN_BUG_ON(!ret, lock, "trylock failure on UP"); |
| 148 | #endif |
| 149 | return ret; |
| 150 | } |
| 151 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 152 | void do_raw_spin_unlock(raw_spinlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 153 | { |
| 154 | debug_spin_unlock(lock); |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 155 | arch_spin_unlock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | static void rwlock_bug(rwlock_t *lock, const char *msg) |
| 159 | { |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 160 | if (!debug_locks_off()) |
| 161 | return; |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 162 | |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 163 | printk(KERN_EMERG "BUG: rwlock %s on CPU#%d, %s/%d, %p\n", |
| 164 | msg, raw_smp_processor_id(), current->comm, |
Pavel Emelyanov | ba25f9d | 2007-10-18 23:40:40 -0700 | [diff] [blame] | 165 | task_pid_nr(current), lock); |
Ingo Molnar | 9a11b49a | 2006-07-03 00:24:33 -0700 | [diff] [blame] | 166 | dump_stack(); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | #define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg) |
| 170 | |
Andrew Morton | 72f0b4e | 2006-08-05 12:13:47 -0700 | [diff] [blame] | 171 | #if 0 /* __write_lock_debug() can lock up - maybe this can too? */ |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 172 | static void __read_lock_debug(rwlock_t *lock) |
| 173 | { |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 174 | u64 i; |
Chuck Ebbert | c22f008b | 2006-09-29 01:59:14 -0700 | [diff] [blame] | 175 | u64 loops = loops_per_jiffy * HZ; |
| 176 | int print_once = 1; |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 177 | |
| 178 | for (;;) { |
Chuck Ebbert | c22f008b | 2006-09-29 01:59:14 -0700 | [diff] [blame] | 179 | for (i = 0; i < loops; i++) { |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 180 | if (arch_read_trylock(&lock->raw_lock)) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 181 | return; |
Ingo Molnar | e0a6029 | 2006-02-07 12:58:54 -0800 | [diff] [blame] | 182 | __delay(1); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 183 | } |
| 184 | /* lockup suspected: */ |
| 185 | if (print_once) { |
| 186 | print_once = 0; |
Dave Jones | 51989b9 | 2006-01-09 20:51:32 -0800 | [diff] [blame] | 187 | printk(KERN_EMERG "BUG: read-lock lockup on CPU#%d, " |
| 188 | "%s/%d, %p\n", |
Ingo Molnar | bb44f11 | 2005-12-20 11:54:17 +0100 | [diff] [blame] | 189 | raw_smp_processor_id(), current->comm, |
| 190 | current->pid, lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 191 | dump_stack(); |
| 192 | } |
| 193 | } |
| 194 | } |
Andrew Morton | 72f0b4e | 2006-08-05 12:13:47 -0700 | [diff] [blame] | 195 | #endif |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 196 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 197 | void do_raw_read_lock(rwlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 198 | { |
| 199 | RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic"); |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 200 | arch_read_lock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 201 | } |
| 202 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 203 | int do_raw_read_trylock(rwlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 204 | { |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 205 | int ret = arch_read_trylock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 206 | |
| 207 | #ifndef CONFIG_SMP |
| 208 | /* |
| 209 | * Must not happen on UP: |
| 210 | */ |
| 211 | RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP"); |
| 212 | #endif |
| 213 | return ret; |
| 214 | } |
| 215 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 216 | void do_raw_read_unlock(rwlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 217 | { |
| 218 | RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic"); |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 219 | arch_read_unlock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 220 | } |
| 221 | |
| 222 | static inline void debug_write_lock_before(rwlock_t *lock) |
| 223 | { |
| 224 | RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic"); |
| 225 | RWLOCK_BUG_ON(lock->owner == current, lock, "recursion"); |
| 226 | RWLOCK_BUG_ON(lock->owner_cpu == raw_smp_processor_id(), |
| 227 | lock, "cpu recursion"); |
| 228 | } |
| 229 | |
| 230 | static inline void debug_write_lock_after(rwlock_t *lock) |
| 231 | { |
| 232 | lock->owner_cpu = raw_smp_processor_id(); |
| 233 | lock->owner = current; |
| 234 | } |
| 235 | |
| 236 | static inline void debug_write_unlock(rwlock_t *lock) |
| 237 | { |
| 238 | RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic"); |
| 239 | RWLOCK_BUG_ON(lock->owner != current, lock, "wrong owner"); |
| 240 | RWLOCK_BUG_ON(lock->owner_cpu != raw_smp_processor_id(), |
| 241 | lock, "wrong CPU"); |
| 242 | lock->owner = SPINLOCK_OWNER_INIT; |
| 243 | lock->owner_cpu = -1; |
| 244 | } |
| 245 | |
Andrew Morton | 72f0b4e | 2006-08-05 12:13:47 -0700 | [diff] [blame] | 246 | #if 0 /* This can cause lockups */ |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 247 | static void __write_lock_debug(rwlock_t *lock) |
| 248 | { |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 249 | u64 i; |
Chuck Ebbert | c22f008b | 2006-09-29 01:59:14 -0700 | [diff] [blame] | 250 | u64 loops = loops_per_jiffy * HZ; |
| 251 | int print_once = 1; |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 252 | |
| 253 | for (;;) { |
Chuck Ebbert | c22f008b | 2006-09-29 01:59:14 -0700 | [diff] [blame] | 254 | for (i = 0; i < loops; i++) { |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 255 | if (arch_write_trylock(&lock->raw_lock)) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 256 | return; |
Ingo Molnar | e0a6029 | 2006-02-07 12:58:54 -0800 | [diff] [blame] | 257 | __delay(1); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 258 | } |
| 259 | /* lockup suspected: */ |
| 260 | if (print_once) { |
| 261 | print_once = 0; |
Dave Jones | 51989b9 | 2006-01-09 20:51:32 -0800 | [diff] [blame] | 262 | printk(KERN_EMERG "BUG: write-lock lockup on CPU#%d, " |
| 263 | "%s/%d, %p\n", |
Ingo Molnar | bb44f11 | 2005-12-20 11:54:17 +0100 | [diff] [blame] | 264 | raw_smp_processor_id(), current->comm, |
| 265 | current->pid, lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 266 | dump_stack(); |
| 267 | } |
| 268 | } |
| 269 | } |
Andrew Morton | 72f0b4e | 2006-08-05 12:13:47 -0700 | [diff] [blame] | 270 | #endif |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 271 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 272 | void do_raw_write_lock(rwlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 273 | { |
| 274 | debug_write_lock_before(lock); |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 275 | arch_write_lock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 276 | debug_write_lock_after(lock); |
| 277 | } |
| 278 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 279 | int do_raw_write_trylock(rwlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 280 | { |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 281 | int ret = arch_write_trylock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 282 | |
| 283 | if (ret) |
| 284 | debug_write_lock_after(lock); |
| 285 | #ifndef CONFIG_SMP |
| 286 | /* |
| 287 | * Must not happen on UP: |
| 288 | */ |
| 289 | RWLOCK_BUG_ON(!ret, lock, "trylock failure on UP"); |
| 290 | #endif |
| 291 | return ret; |
| 292 | } |
| 293 | |
Thomas Gleixner | 9828ea9 | 2009-12-03 20:55:53 +0100 | [diff] [blame] | 294 | void do_raw_write_unlock(rwlock_t *lock) |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 295 | { |
| 296 | debug_write_unlock(lock); |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 297 | arch_write_unlock(&lock->raw_lock); |
Ingo Molnar | fb1c8f9 | 2005-09-10 00:25:56 -0700 | [diff] [blame] | 298 | } |