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