Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
24struct 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
82extern __printf(4, 5)
83void 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
89extern __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 */
105struct warn_args;
106struct pt_regs;
107
108void __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