Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 LT |
2 | #ifndef _ASM_GENERIC_BUG_H |
3 | #define _ASM_GENERIC_BUG_H | |
4 | ||
5 | #include <linux/compiler.h> | |
1da177e4 | 6 | |
2a8358d8 KC |
7 | #define CUT_HERE "------------[ cut here ]------------\n" |
8 | ||
09682c1d PM |
9 | #ifdef CONFIG_GENERIC_BUG |
10 | #define BUGFLAG_WARNING (1 << 0) | |
19d43626 PZ |
11 | #define BUGFLAG_ONCE (1 << 1) |
12 | #define BUGFLAG_DONE (1 << 2) | |
f26dee15 | 13 | #define BUGFLAG_TAINT(taint) ((taint) << 8) |
09682c1d PM |
14 | #define BUG_GET_TAINT(bug) ((bug)->flags >> 8) |
15 | #endif | |
16 | ||
17 | #ifndef __ASSEMBLY__ | |
18 | #include <linux/kernel.h> | |
19 | ||
7664c5a1 | 20 | struct bug_entry { |
f81f8ad5 | 21 | #ifdef CONFIG_GENERIC_BUG |
b93a531e | 22 | #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS |
7664c5a1 | 23 | unsigned long bug_addr; |
b93a531e JB |
24 | #else |
25 | signed int bug_addr_disp; | |
26 | #endif | |
7664c5a1 | 27 | #ifdef CONFIG_DEBUG_BUGVERBOSE |
b93a531e | 28 | #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS |
7664c5a1 | 29 | const char *file; |
b93a531e JB |
30 | #else |
31 | signed int file_disp; | |
32 | #endif | |
7664c5a1 JF |
33 | unsigned short line; |
34 | #endif | |
35 | unsigned short flags; | |
7664c5a1 | 36 | #endif /* CONFIG_GENERIC_BUG */ |
f81f8ad5 NA |
37 | }; |
38 | ||
39 | #ifdef CONFIG_BUG | |
7664c5a1 | 40 | |
af9379c7 DB |
41 | /* |
42 | * Don't use BUG() or BUG_ON() unless there's really no way out; one | |
43 | * example might be detecting data structure corruption in the middle | |
44 | * of an operation that can't be backed out of. If the (sub)system | |
45 | * can somehow continue operating, perhaps with reduced functionality, | |
46 | * it's probably not BUG-worthy. | |
47 | * | |
48 | * If you're tempted to BUG(), think again: is completely giving up | |
49 | * really the *only* solution? There are usually better options, where | |
50 | * users don't need to reboot ASAP and can mostly shut down cleanly. | |
51 | */ | |
1da177e4 LT |
52 | #ifndef HAVE_ARCH_BUG |
53 | #define BUG() do { \ | |
d5c003b4 | 54 | printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \ |
173a3efd | 55 | barrier_before_unreachable(); \ |
1da177e4 LT |
56 | panic("BUG!"); \ |
57 | } while (0) | |
58 | #endif | |
59 | ||
1da177e4 | 60 | #ifndef HAVE_ARCH_BUG_ON |
a3f7607d | 61 | #define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0) |
1da177e4 LT |
62 | #endif |
63 | ||
19d43626 PZ |
64 | #ifdef __WARN_FLAGS |
65 | #define __WARN_TAINT(taint) __WARN_FLAGS(BUGFLAG_TAINT(taint)) | |
66 | #define __WARN_ONCE_TAINT(taint) __WARN_FLAGS(BUGFLAG_ONCE|BUGFLAG_TAINT(taint)) | |
67 | ||
68 | #define WARN_ON_ONCE(condition) ({ \ | |
69 | int __ret_warn_on = !!(condition); \ | |
70 | if (unlikely(__ret_warn_on)) \ | |
71 | __WARN_ONCE_TAINT(TAINT_WARN); \ | |
72 | unlikely(__ret_warn_on); \ | |
73 | }) | |
74 | #endif | |
75 | ||
af9379c7 DB |
76 | /* |
77 | * WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report | |
96c6a32c DV |
78 | * significant kernel issues that need prompt attention if they should ever |
79 | * appear at runtime. | |
80 | * | |
81 | * Do not use these macros when checking for invalid external inputs | |
82 | * (e.g. invalid system call arguments, or invalid data coming from | |
83 | * network/devices), and on transient conditions like ENOMEM or EAGAIN. | |
84 | * These macros should be used for recoverable kernel issues only. | |
85 | * For invalid external inputs, transient conditions, etc use | |
86 | * pr_err[_once/_ratelimited]() followed by dump_stack(), if necessary. | |
87 | * Do not include "BUG"/"WARNING" in format strings manually to make these | |
88 | * conditions distinguishable from kernel issues. | |
89 | * | |
90 | * Use the versions with printk format strings to provide better diagnostics. | |
af9379c7 | 91 | */ |
b2be0527 | 92 | #ifndef __WARN_TAINT |
b9075fa9 JP |
93 | extern __printf(3, 4) |
94 | void warn_slowpath_fmt(const char *file, const int line, | |
95 | const char *fmt, ...); | |
96 | extern __printf(4, 5) | |
97 | void warn_slowpath_fmt_taint(const char *file, const int line, unsigned taint, | |
98 | const char *fmt, ...); | |
57adc4d2 | 99 | extern void warn_slowpath_null(const char *file, const int line); |
79b4cc5e | 100 | #define WANT_WARN_ON_SLOWPATH |
57adc4d2 AK |
101 | #define __WARN() warn_slowpath_null(__FILE__, __LINE__) |
102 | #define __WARN_printf(arg...) warn_slowpath_fmt(__FILE__, __LINE__, arg) | |
b2be0527 BH |
103 | #define __WARN_printf_taint(taint, arg...) \ |
104 | warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg) | |
a8f18b90 | 105 | #else |
a7bed27a | 106 | extern __printf(1, 2) void __warn_printk(const char *fmt, ...); |
b2be0527 | 107 | #define __WARN() __WARN_TAINT(TAINT_WARN) |
a7bed27a | 108 | #define __WARN_printf(arg...) do { __warn_printk(arg); __WARN(); } while (0) |
b2be0527 | 109 | #define __WARN_printf_taint(taint, arg...) \ |
a7bed27a | 110 | do { __warn_printk(arg); __WARN_TAINT(taint); } while (0) |
3a6a62f9 OJ |
111 | #endif |
112 | ||
2553b67a JP |
113 | /* used internally by panic.c */ |
114 | struct warn_args; | |
0b396923 | 115 | struct pt_regs; |
2553b67a JP |
116 | |
117 | void __warn(const char *file, int line, void *caller, unsigned taint, | |
118 | struct pt_regs *regs, struct warn_args *args); | |
119 | ||
3a6a62f9 | 120 | #ifndef WARN_ON |
684f9783 | 121 | #define WARN_ON(condition) ({ \ |
8d4fbcfb | 122 | int __ret_warn_on = !!(condition); \ |
3a6a62f9 OJ |
123 | if (unlikely(__ret_warn_on)) \ |
124 | __WARN(); \ | |
684f9783 HX |
125 | unlikely(__ret_warn_on); \ |
126 | }) | |
1da177e4 LT |
127 | #endif |
128 | ||
a8f18b90 | 129 | #ifndef WARN |
19d43626 | 130 | #define WARN(condition, format...) ({ \ |
a8f18b90 AV |
131 | int __ret_warn_on = !!(condition); \ |
132 | if (unlikely(__ret_warn_on)) \ | |
133 | __WARN_printf(format); \ | |
134 | unlikely(__ret_warn_on); \ | |
135 | }) | |
136 | #endif | |
137 | ||
b2be0527 BH |
138 | #define WARN_TAINT(condition, taint, format...) ({ \ |
139 | int __ret_warn_on = !!(condition); \ | |
140 | if (unlikely(__ret_warn_on)) \ | |
141 | __WARN_printf_taint(taint, format); \ | |
142 | unlikely(__ret_warn_on); \ | |
143 | }) | |
144 | ||
19d43626 | 145 | #ifndef WARN_ON_ONCE |
d69a8922 | 146 | #define WARN_ON_ONCE(condition) ({ \ |
b1fca27d | 147 | static bool __section(.data.once) __warned; \ |
8d4fbcfb | 148 | int __ret_warn_once = !!(condition); \ |
d69a8922 | 149 | \ |
dfbf2897 SR |
150 | if (unlikely(__ret_warn_once && !__warned)) { \ |
151 | __warned = true; \ | |
152 | WARN_ON(1); \ | |
153 | } \ | |
d69a8922 | 154 | unlikely(__ret_warn_once); \ |
74bb6a09 | 155 | }) |
19d43626 | 156 | #endif |
74bb6a09 | 157 | |
45e9c0de | 158 | #define WARN_ONCE(condition, format...) ({ \ |
b1fca27d | 159 | static bool __section(.data.once) __warned; \ |
45e9c0de AV |
160 | int __ret_warn_once = !!(condition); \ |
161 | \ | |
dfbf2897 SR |
162 | if (unlikely(__ret_warn_once && !__warned)) { \ |
163 | __warned = true; \ | |
164 | WARN(1, format); \ | |
165 | } \ | |
45e9c0de AV |
166 | unlikely(__ret_warn_once); \ |
167 | }) | |
168 | ||
b2be0527 | 169 | #define WARN_TAINT_ONCE(condition, taint, format...) ({ \ |
b1fca27d | 170 | static bool __section(.data.once) __warned; \ |
b2be0527 BH |
171 | int __ret_warn_once = !!(condition); \ |
172 | \ | |
dfbf2897 SR |
173 | if (unlikely(__ret_warn_once && !__warned)) { \ |
174 | __warned = true; \ | |
175 | WARN_TAINT(1, taint, format); \ | |
176 | } \ | |
b2be0527 BH |
177 | unlikely(__ret_warn_once); \ |
178 | }) | |
179 | ||
b607e70e JT |
180 | #else /* !CONFIG_BUG */ |
181 | #ifndef HAVE_ARCH_BUG | |
a4b5d580 | 182 | #define BUG() do {} while (1) |
b607e70e JT |
183 | #endif |
184 | ||
185 | #ifndef HAVE_ARCH_BUG_ON | |
3c047057 | 186 | #define BUG_ON(condition) do { if (condition) BUG(); } while (0) |
b607e70e JT |
187 | #endif |
188 | ||
189 | #ifndef HAVE_ARCH_WARN_ON | |
190 | #define WARN_ON(condition) ({ \ | |
191 | int __ret_warn_on = !!(condition); \ | |
192 | unlikely(__ret_warn_on); \ | |
193 | }) | |
194 | #endif | |
195 | ||
196 | #ifndef WARN | |
197 | #define WARN(condition, format...) ({ \ | |
198 | int __ret_warn_on = !!(condition); \ | |
4e50ebde | 199 | no_printk(format); \ |
b607e70e JT |
200 | unlikely(__ret_warn_on); \ |
201 | }) | |
202 | #endif | |
203 | ||
204 | #define WARN_ON_ONCE(condition) WARN_ON(condition) | |
205 | #define WARN_ONCE(condition, format...) WARN(condition, format) | |
206 | #define WARN_TAINT(condition, taint, format...) WARN(condition, format) | |
207 | #define WARN_TAINT_ONCE(condition, taint, format...) WARN(condition, format) | |
208 | ||
209 | #endif | |
210 | ||
2092e6be SR |
211 | /* |
212 | * WARN_ON_SMP() is for cases that the warning is either | |
213 | * meaningless for !SMP or may even cause failures. | |
214 | * This is usually used for cases that we have | |
215 | * WARN_ON(!spin_is_locked(&lock)) checks, as spin_is_locked() | |
216 | * returns 0 for uniprocessor settings. | |
217 | * It can also be used with values that are only defined | |
218 | * on SMP: | |
219 | * | |
220 | * struct foo { | |
221 | * [...] | |
222 | * #ifdef CONFIG_SMP | |
223 | * int bar; | |
224 | * #endif | |
225 | * }; | |
226 | * | |
227 | * void func(struct foo *zoot) | |
228 | * { | |
229 | * WARN_ON_SMP(!zoot->bar); | |
230 | * | |
231 | * For CONFIG_SMP, WARN_ON_SMP() should act the same as WARN_ON(), | |
232 | * and should be a nop and return false for uniprocessor. | |
233 | * | |
234 | * if (WARN_ON_SMP(x)) returns true only when CONFIG_SMP is set | |
235 | * and x is true. | |
236 | */ | |
8eb94f80 IM |
237 | #ifdef CONFIG_SMP |
238 | # define WARN_ON_SMP(x) WARN_ON(x) | |
239 | #else | |
ccd0d44f SR |
240 | /* |
241 | * Use of ({0;}) because WARN_ON_SMP(x) may be used either as | |
242 | * a stand alone line statement or as a condition in an if () | |
243 | * statement. | |
244 | * A simple "0" would cause gcc to give a "statement has no effect" | |
245 | * warning. | |
246 | */ | |
2092e6be | 247 | # define WARN_ON_SMP(x) ({0;}) |
8eb94f80 IM |
248 | #endif |
249 | ||
2603efa3 PM |
250 | #endif /* __ASSEMBLY__ */ |
251 | ||
1da177e4 | 252 | #endif |