[PATCH] lockdep: remove DEBUG_BUG_ON()
[linux-2.6.git] / kernel / mutex-debug.h
1 /*
2  * Mutexes: blocking mutual exclusion locks
3  *
4  * started by Ingo Molnar:
5  *
6  *  Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
7  *
8  * This file contains mutex debugging related internal declarations,
9  * prototypes and inline functions, for the CONFIG_DEBUG_MUTEXES case.
10  * More details are in kernel/mutex-debug.c.
11  */
12
13 extern spinlock_t debug_mutex_lock;
14 extern struct list_head debug_mutex_held_locks;
15 extern int debug_mutex_on;
16
17 /*
18  * In the debug case we carry the caller's instruction pointer into
19  * other functions, but we dont want the function argument overhead
20  * in the nondebug case - hence these macros:
21  */
22 #define __IP_DECL__             , unsigned long ip
23 #define __IP__                  , ip
24 #define __RET_IP__              , (unsigned long)__builtin_return_address(0)
25
26 /*
27  * This must be called with lock->wait_lock held.
28  */
29 extern void debug_mutex_set_owner(struct mutex *lock,
30                                   struct thread_info *new_owner __IP_DECL__);
31
32 static inline void debug_mutex_clear_owner(struct mutex *lock)
33 {
34         lock->owner = NULL;
35 }
36
37 extern void debug_mutex_init_waiter(struct mutex_waiter *waiter);
38 extern void debug_mutex_wake_waiter(struct mutex *lock,
39                                     struct mutex_waiter *waiter);
40 extern void debug_mutex_free_waiter(struct mutex_waiter *waiter);
41 extern void debug_mutex_add_waiter(struct mutex *lock,
42                                    struct mutex_waiter *waiter,
43                                    struct thread_info *ti __IP_DECL__);
44 extern void mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter,
45                                 struct thread_info *ti);
46 extern void debug_mutex_unlock(struct mutex *lock);
47 extern void debug_mutex_init(struct mutex *lock, const char *name);
48
49 #define debug_spin_lock_save(lock, flags)               \
50         do {                                            \
51                 local_irq_save(flags);                  \
52                 if (debug_mutex_on)                     \
53                         spin_lock(lock);                \
54         } while (0)
55
56 #define debug_spin_unlock_restore(lock, flags)          \
57         do {                                            \
58                 if (debug_mutex_on)                     \
59                         spin_unlock(lock);              \
60                 local_irq_restore(flags);               \
61                 preempt_check_resched();                \
62         } while (0)
63
64 #define spin_lock_mutex(lock, flags)                    \
65         do {                                            \
66                 struct mutex *l = container_of(lock, struct mutex, wait_lock); \
67                                                         \
68                 DEBUG_LOCKS_WARN_ON(in_interrupt());    \
69                 debug_spin_lock_save(&debug_mutex_lock, flags); \
70                 spin_lock(lock);                        \
71                 DEBUG_LOCKS_WARN_ON(l->magic != l);     \
72         } while (0)
73
74 #define spin_unlock_mutex(lock, flags)                  \
75         do {                                            \
76                 spin_unlock(lock);                      \
77                 debug_spin_unlock_restore(&debug_mutex_lock, flags);    \
78         } while (0)
79
80 #define DEBUG_OFF()                                     \
81 do {                                                    \
82         if (debug_mutex_on) {                           \
83                 debug_mutex_on = 0;                     \
84                 console_verbose();                      \
85                 if (spin_is_locked(&debug_mutex_lock))  \
86                         spin_unlock(&debug_mutex_lock); \
87         }                                               \
88 } while (0)
89
90 #define DEBUG_BUG()                                     \
91 do {                                                    \
92         if (debug_mutex_on) {                           \
93                 DEBUG_OFF();                            \
94                 BUG();                                  \
95         }                                               \
96 } while (0)
97
98 #define DEBUG_LOCKS_WARN_ON(c)                          \
99 do {                                                    \
100         if (unlikely(c && debug_mutex_on)) {            \
101                 DEBUG_OFF();                            \
102                 WARN_ON(1);                             \
103         }                                               \
104 } while (0)
105
106 #ifdef CONFIG_SMP
107 # define SMP_DEBUG_LOCKS_WARN_ON(c)                     DEBUG_LOCKS_WARN_ON(c)
108 #else
109 # define SMP_DEBUG_LOCKS_WARN_ON(c)                     do { } while (0)
110 #endif
111