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...) do { \ 87 instrumentation_begin(); \ 88 warn_slowpath_fmt(__FILE__, __LINE__, taint, arg); \ 89 instrumentation_end(); \ 90 } while (0) 91 #else 92 extern __printf(1, 2) void __warn_printk(const char *fmt, ...); 93 #define __WARN() __WARN_FLAGS(BUGFLAG_TAINT(TAINT_WARN)) 94 #define __WARN_printf(taint, arg...) do { \ 95 instrumentation_begin(); \ 96 __warn_printk(arg); \ 97 __WARN_FLAGS(BUGFLAG_NO_CUT_HERE | BUGFLAG_TAINT(taint));\ 98 instrumentation_end(); \ 99 } while (0) 100 #define WARN_ON_ONCE(condition) ({ \ 101 int __ret_warn_on = !!(condition); \ 102 if (unlikely(__ret_warn_on)) \ 103 __WARN_FLAGS(BUGFLAG_ONCE | \ 104 BUGFLAG_TAINT(TAINT_WARN)); \ 105 unlikely(__ret_warn_on); \ 106 }) 107 #endif 108 109 /* used internally by panic.c */ 110 struct warn_args; 111 struct pt_regs; 112 113 void __warn(const char *file, int line, void *caller, unsigned taint, 114 struct pt_regs *regs, struct warn_args *args); 115 116 #ifndef WARN_ON 117 #define WARN_ON(condition) ({ \ 118 int __ret_warn_on = !!(condition); \ 119 if (unlikely(__ret_warn_on)) \ 120 __WARN(); \ 121 unlikely(__ret_warn_on); \ 122 }) 123 #endif 124 125 #ifndef WARN 126 #define WARN(condition, format...) ({ \ 127 int __ret_warn_on = !!(condition); \ 128 if (unlikely(__ret_warn_on)) \ 129 __WARN_printf(TAINT_WARN, format); \ 130 unlikely(__ret_warn_on); \ 131 }) 132 #endif 133 134 #define WARN_TAINT(condition, taint, format...) ({ \ 135 int __ret_warn_on = !!(condition); \ 136 if (unlikely(__ret_warn_on)) \ 137 __WARN_printf(taint, format); \ 138 unlikely(__ret_warn_on); \ 139 }) 140 141 #ifndef WARN_ON_ONCE 142 #define WARN_ON_ONCE(condition) ({ \ 143 static bool __section(.data.once) __warned; \ 144 int __ret_warn_once = !!(condition); \ 145 \ 146 if (unlikely(__ret_warn_once && !__warned)) { \ 147 __warned = true; \ 148 WARN_ON(1); \ 149 } \ 150 unlikely(__ret_warn_once); \ 151 }) 152 #endif 153 154 #define WARN_ONCE(condition, format...) ({ \ 155 static bool __section(.data.once) __warned; \ 156 int __ret_warn_once = !!(condition); \ 157 \ 158 if (unlikely(__ret_warn_once && !__warned)) { \ 159 __warned = true; \ 160 WARN(1, format); \ 161 } \ 162 unlikely(__ret_warn_once); \ 163 }) 164 165 #define WARN_TAINT_ONCE(condition, taint, format...) ({ \ 166 static bool __section(.data.once) __warned; \ 167 int __ret_warn_once = !!(condition); \ 168 \ 169 if (unlikely(__ret_warn_once && !__warned)) { \ 170 __warned = true; \ 171 WARN_TAINT(1, taint, format); \ 172 } \ 173 unlikely(__ret_warn_once); \ 174 }) 175 176 #else /* !CONFIG_BUG */ 177 #ifndef HAVE_ARCH_BUG 178 #define BUG() do {} while (1) 179 #endif 180 181 #ifndef HAVE_ARCH_BUG_ON 182 #define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0) 183 #endif 184 185 #ifndef HAVE_ARCH_WARN_ON 186 #define WARN_ON(condition) ({ \ 187 int __ret_warn_on = !!(condition); \ 188 unlikely(__ret_warn_on); \ 189 }) 190 #endif 191 192 #ifndef WARN 193 #define WARN(condition, format...) ({ \ 194 int __ret_warn_on = !!(condition); \ 195 no_printk(format); \ 196 unlikely(__ret_warn_on); \ 197 }) 198 #endif 199 200 #define WARN_ON_ONCE(condition) WARN_ON(condition) 201 #define WARN_ONCE(condition, format...) WARN(condition, format) 202 #define WARN_TAINT(condition, taint, format...) WARN(condition, format) 203 #define WARN_TAINT_ONCE(condition, taint, format...) WARN(condition, format) 204 205 #endif 206 207 /* 208 * WARN_ON_SMP() is for cases that the warning is either 209 * meaningless for !SMP or may even cause failures. 210 * It can also be used with values that are only defined 211 * on SMP: 212 * 213 * struct foo { 214 * [...] 215 * #ifdef CONFIG_SMP 216 * int bar; 217 * #endif 218 * }; 219 * 220 * void func(struct foo *zoot) 221 * { 222 * WARN_ON_SMP(!zoot->bar); 223 * 224 * For CONFIG_SMP, WARN_ON_SMP() should act the same as WARN_ON(), 225 * and should be a nop and return false for uniprocessor. 226 * 227 * if (WARN_ON_SMP(x)) returns true only when CONFIG_SMP is set 228 * and x is true. 229 */ 230 #ifdef CONFIG_SMP 231 # define WARN_ON_SMP(x) WARN_ON(x) 232 #else 233 /* 234 * Use of ({0;}) because WARN_ON_SMP(x) may be used either as 235 * a stand alone line statement or as a condition in an if () 236 * statement. 237 * A simple "0" would cause gcc to give a "statement has no effect" 238 * warning. 239 */ 240 # define WARN_ON_SMP(x) ({0;}) 241 #endif 242 243 #endif /* __ASSEMBLY__ */ 244 245 #endif 246