Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | #ifndef _ASM_GENERIC_BUG_H |
2 | #define _ASM_GENERIC_BUG_H | |
3 | ||
4 | #include <linux/compiler.h> | |
1da177e4 | 5 | |
c8538a7a | 6 | #ifdef CONFIG_BUG |
7664c5a1 JF |
7 | |
8 | #ifdef CONFIG_GENERIC_BUG | |
9 | #ifndef __ASSEMBLY__ | |
10 | struct bug_entry { | |
b93a531e | 11 | #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS |
7664c5a1 | 12 | unsigned long bug_addr; |
b93a531e JB |
13 | #else |
14 | signed int bug_addr_disp; | |
15 | #endif | |
7664c5a1 | 16 | #ifdef CONFIG_DEBUG_BUGVERBOSE |
b93a531e | 17 | #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS |
7664c5a1 | 18 | const char *file; |
b93a531e JB |
19 | #else |
20 | signed int file_disp; | |
21 | #endif | |
7664c5a1 JF |
22 | unsigned short line; |
23 | #endif | |
24 | unsigned short flags; | |
25 | }; | |
26 | #endif /* __ASSEMBLY__ */ | |
27 | ||
b2be0527 BH |
28 | #define BUGFLAG_WARNING (1 << 0) |
29 | #define BUGFLAG_TAINT(taint) (BUGFLAG_WARNING | ((taint) << 8)) | |
30 | #define BUG_GET_TAINT(bug) ((bug)->flags >> 8) | |
31 | ||
7664c5a1 JF |
32 | #endif /* CONFIG_GENERIC_BUG */ |
33 | ||
2603efa3 PM |
34 | #ifndef __ASSEMBLY__ |
35 | #include <linux/kernel.h> | |
36 | ||
af9379c7 DB |
37 | /* |
38 | * Don't use BUG() or BUG_ON() unless there's really no way out; one | |
39 | * example might be detecting data structure corruption in the middle | |
40 | * of an operation that can't be backed out of. If the (sub)system | |
41 | * can somehow continue operating, perhaps with reduced functionality, | |
42 | * it's probably not BUG-worthy. | |
43 | * | |
44 | * If you're tempted to BUG(), think again: is completely giving up | |
45 | * really the *only* solution? There are usually better options, where | |
46 | * users don't need to reboot ASAP and can mostly shut down cleanly. | |
47 | */ | |
1da177e4 LT |
48 | #ifndef HAVE_ARCH_BUG |
49 | #define BUG() do { \ | |
d5c003b4 | 50 | printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \ |
1da177e4 LT |
51 | panic("BUG!"); \ |
52 | } while (0) | |
53 | #endif | |
54 | ||
1da177e4 | 55 | #ifndef HAVE_ARCH_BUG_ON |
2a41de48 | 56 | #define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while(0) |
1da177e4 LT |
57 | #endif |
58 | ||
af9379c7 DB |
59 | /* |
60 | * WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report | |
61 | * significant issues that need prompt attention if they should ever | |
62 | * appear at runtime. Use the versions with printk format strings | |
63 | * to provide better diagnostics. | |
64 | */ | |
b2be0527 | 65 | #ifndef __WARN_TAINT |
b9075fa9 JP |
66 | extern __printf(3, 4) |
67 | void warn_slowpath_fmt(const char *file, const int line, | |
68 | const char *fmt, ...); | |
69 | extern __printf(4, 5) | |
70 | void warn_slowpath_fmt_taint(const char *file, const int line, unsigned taint, | |
71 | const char *fmt, ...); | |
57adc4d2 | 72 | extern void warn_slowpath_null(const char *file, const int line); |
79b4cc5e | 73 | #define WANT_WARN_ON_SLOWPATH |
57adc4d2 AK |
74 | #define __WARN() warn_slowpath_null(__FILE__, __LINE__) |
75 | #define __WARN_printf(arg...) warn_slowpath_fmt(__FILE__, __LINE__, arg) | |
b2be0527 BH |
76 | #define __WARN_printf_taint(taint, arg...) \ |
77 | warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg) | |
a8f18b90 | 78 | #else |
b2be0527 | 79 | #define __WARN() __WARN_TAINT(TAINT_WARN) |
ec5679e5 | 80 | #define __WARN_printf(arg...) do { printk(arg); __WARN(); } while (0) |
b2be0527 BH |
81 | #define __WARN_printf_taint(taint, arg...) \ |
82 | do { printk(arg); __WARN_TAINT(taint); } while (0) | |
3a6a62f9 OJ |
83 | #endif |
84 | ||
85 | #ifndef WARN_ON | |
684f9783 | 86 | #define WARN_ON(condition) ({ \ |
8d4fbcfb | 87 | int __ret_warn_on = !!(condition); \ |
3a6a62f9 OJ |
88 | if (unlikely(__ret_warn_on)) \ |
89 | __WARN(); \ | |
684f9783 HX |
90 | unlikely(__ret_warn_on); \ |
91 | }) | |
1da177e4 LT |
92 | #endif |
93 | ||
a8f18b90 AV |
94 | #ifndef WARN |
95 | #define WARN(condition, format...) ({ \ | |
96 | int __ret_warn_on = !!(condition); \ | |
97 | if (unlikely(__ret_warn_on)) \ | |
98 | __WARN_printf(format); \ | |
99 | unlikely(__ret_warn_on); \ | |
100 | }) | |
101 | #endif | |
102 | ||
b2be0527 BH |
103 | #define WARN_TAINT(condition, taint, format...) ({ \ |
104 | int __ret_warn_on = !!(condition); \ | |
105 | if (unlikely(__ret_warn_on)) \ | |
106 | __WARN_printf_taint(taint, format); \ | |
107 | unlikely(__ret_warn_on); \ | |
108 | }) | |
109 | ||
c8538a7a MM |
110 | #else /* !CONFIG_BUG */ |
111 | #ifndef HAVE_ARCH_BUG | |
da60682c | 112 | #define BUG() do {} while(0) |
c8538a7a MM |
113 | #endif |
114 | ||
c8538a7a MM |
115 | #ifndef HAVE_ARCH_BUG_ON |
116 | #define BUG_ON(condition) do { if (condition) ; } while(0) | |
117 | #endif | |
118 | ||
119 | #ifndef HAVE_ARCH_WARN_ON | |
8c7c7c9b | 120 | #define WARN_ON(condition) ({ \ |
8d4fbcfb | 121 | int __ret_warn_on = !!(condition); \ |
8c7c7c9b RB |
122 | unlikely(__ret_warn_on); \ |
123 | }) | |
c8538a7a | 124 | #endif |
a8f18b90 AV |
125 | |
126 | #ifndef WARN | |
127 | #define WARN(condition, format...) ({ \ | |
128 | int __ret_warn_on = !!(condition); \ | |
129 | unlikely(__ret_warn_on); \ | |
130 | }) | |
131 | #endif | |
132 | ||
b2be0527 BH |
133 | #define WARN_TAINT(condition, taint, format...) WARN_ON(condition) |
134 | ||
c8538a7a MM |
135 | #endif |
136 | ||
d69a8922 | 137 | #define WARN_ON_ONCE(condition) ({ \ |
7ccaba53 | 138 | static bool __section(.data.unlikely) __warned; \ |
8d4fbcfb | 139 | int __ret_warn_once = !!(condition); \ |
d69a8922 AM |
140 | \ |
141 | if (unlikely(__ret_warn_once)) \ | |
142 | if (WARN_ON(!__warned)) \ | |
42f247c8 | 143 | __warned = true; \ |
d69a8922 | 144 | unlikely(__ret_warn_once); \ |
74bb6a09 IM |
145 | }) |
146 | ||
45e9c0de | 147 | #define WARN_ONCE(condition, format...) ({ \ |
7ccaba53 | 148 | static bool __section(.data.unlikely) __warned; \ |
45e9c0de AV |
149 | int __ret_warn_once = !!(condition); \ |
150 | \ | |
151 | if (unlikely(__ret_warn_once)) \ | |
152 | if (WARN(!__warned, format)) \ | |
42f247c8 | 153 | __warned = true; \ |
45e9c0de AV |
154 | unlikely(__ret_warn_once); \ |
155 | }) | |
156 | ||
b2be0527 | 157 | #define WARN_TAINT_ONCE(condition, taint, format...) ({ \ |
7ccaba53 | 158 | static bool __section(.data.unlikely) __warned; \ |
b2be0527 BH |
159 | int __ret_warn_once = !!(condition); \ |
160 | \ | |
161 | if (unlikely(__ret_warn_once)) \ | |
162 | if (WARN_TAINT(!__warned, taint, format)) \ | |
163 | __warned = true; \ | |
164 | unlikely(__ret_warn_once); \ | |
165 | }) | |
166 | ||
2092e6be SR |
167 | /* |
168 | * WARN_ON_SMP() is for cases that the warning is either | |
169 | * meaningless for !SMP or may even cause failures. | |
170 | * This is usually used for cases that we have | |
171 | * WARN_ON(!spin_is_locked(&lock)) checks, as spin_is_locked() | |
172 | * returns 0 for uniprocessor settings. | |
173 | * It can also be used with values that are only defined | |
174 | * on SMP: | |
175 | * | |
176 | * struct foo { | |
177 | * [...] | |
178 | * #ifdef CONFIG_SMP | |
179 | * int bar; | |
180 | * #endif | |
181 | * }; | |
182 | * | |
183 | * void func(struct foo *zoot) | |
184 | * { | |
185 | * WARN_ON_SMP(!zoot->bar); | |
186 | * | |
187 | * For CONFIG_SMP, WARN_ON_SMP() should act the same as WARN_ON(), | |
188 | * and should be a nop and return false for uniprocessor. | |
189 | * | |
190 | * if (WARN_ON_SMP(x)) returns true only when CONFIG_SMP is set | |
191 | * and x is true. | |
192 | */ | |
8eb94f80 IM |
193 | #ifdef CONFIG_SMP |
194 | # define WARN_ON_SMP(x) WARN_ON(x) | |
195 | #else | |
ccd0d44f SR |
196 | /* |
197 | * Use of ({0;}) because WARN_ON_SMP(x) may be used either as | |
198 | * a stand alone line statement or as a condition in an if () | |
199 | * statement. | |
200 | * A simple "0" would cause gcc to give a "statement has no effect" | |
201 | * warning. | |
202 | */ | |
2092e6be | 203 | # define WARN_ON_SMP(x) ({0;}) |
8eb94f80 IM |
204 | #endif |
205 | ||
2603efa3 PM |
206 | #endif /* __ASSEMBLY__ */ |
207 | ||
1da177e4 | 208 | #endif |