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