Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | #ifndef _ASM_GENERIC_BUG_H |
| 3 | #define _ASM_GENERIC_BUG_H |
| 4 | |
| 5 | #include <linux/compiler.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | |
Kees Cook | 2a8358d | 2017-11-17 15:27:21 -0800 | [diff] [blame] | 7 | #define CUT_HERE "------------[ cut here ]------------\n" |
| 8 | |
Paul Mundt | 09682c1 | 2012-06-25 17:15:31 +0900 | [diff] [blame] | 9 | #ifdef CONFIG_GENERIC_BUG |
| 10 | #define BUGFLAG_WARNING (1 << 0) |
Peter Zijlstra | 19d4362 | 2017-02-25 08:56:53 +0100 | [diff] [blame] | 11 | #define BUGFLAG_ONCE (1 << 1) |
| 12 | #define BUGFLAG_DONE (1 << 2) |
Kees Cook | a44f71a | 2019-09-25 16:48:11 -0700 | [diff] [blame] | 13 | #define BUGFLAG_NO_CUT_HERE (1 << 3) /* CUT_HERE already sent */ |
Peter Zijlstra | f26dee1 | 2017-04-10 10:49:39 +0200 | [diff] [blame] | 14 | #define BUGFLAG_TAINT(taint) ((taint) << 8) |
Paul Mundt | 09682c1 | 2012-06-25 17:15:31 +0900 | [diff] [blame] | 15 | #define BUG_GET_TAINT(bug) ((bug)->flags >> 8) |
| 16 | #endif |
| 17 | |
| 18 | #ifndef __ASSEMBLY__ |
| 19 | #include <linux/kernel.h> |
| 20 | |
Ingo Molnar | ffb61c6 | 2018-12-19 11:20:50 +0100 | [diff] [blame] | 21 | #ifdef CONFIG_BUG |
| 22 | |
Nadav Amit | f81f8ad | 2018-10-03 14:30:56 -0700 | [diff] [blame] | 23 | #ifdef CONFIG_GENERIC_BUG |
Ingo Molnar | ffb61c6 | 2018-12-19 11:20:50 +0100 | [diff] [blame] | 24 | struct bug_entry { |
Jan Beulich | b93a531 | 2008-12-16 11:40:27 +0000 | [diff] [blame] | 25 | #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS |
Jeremy Fitzhardinge | 7664c5a | 2006-12-08 02:36:19 -0800 | [diff] [blame] | 26 | unsigned long bug_addr; |
Jan Beulich | b93a531 | 2008-12-16 11:40:27 +0000 | [diff] [blame] | 27 | #else |
| 28 | signed int bug_addr_disp; |
| 29 | #endif |
Jeremy Fitzhardinge | 7664c5a | 2006-12-08 02:36:19 -0800 | [diff] [blame] | 30 | #ifdef CONFIG_DEBUG_BUGVERBOSE |
Jan Beulich | b93a531 | 2008-12-16 11:40:27 +0000 | [diff] [blame] | 31 | #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS |
Jeremy Fitzhardinge | 7664c5a | 2006-12-08 02:36:19 -0800 | [diff] [blame] | 32 | const char *file; |
Jan Beulich | b93a531 | 2008-12-16 11:40:27 +0000 | [diff] [blame] | 33 | #else |
| 34 | signed int file_disp; |
| 35 | #endif |
Jeremy Fitzhardinge | 7664c5a | 2006-12-08 02:36:19 -0800 | [diff] [blame] | 36 | unsigned short line; |
| 37 | #endif |
| 38 | unsigned short flags; |
Nadav Amit | f81f8ad | 2018-10-03 14:30:56 -0700 | [diff] [blame] | 39 | }; |
Ingo Molnar | ffb61c6 | 2018-12-19 11:20:50 +0100 | [diff] [blame] | 40 | #endif /* CONFIG_GENERIC_BUG */ |
Jeremy Fitzhardinge | 7664c5a | 2006-12-08 02:36:19 -0800 | [diff] [blame] | 41 | |
David Brownell | af9379c | 2009-01-06 14:41:01 -0800 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | #ifndef HAVE_ARCH_BUG |
| 54 | #define BUG() do { \ |
Harvey Harrison | d5c003b | 2008-10-15 22:01:24 -0700 | [diff] [blame] | 55 | printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \ |
Arnd Bergmann | 173a3ef | 2018-02-21 14:45:54 -0800 | [diff] [blame] | 56 | barrier_before_unreachable(); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | panic("BUG!"); \ |
| 58 | } while (0) |
| 59 | #endif |
| 60 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | #ifndef HAVE_ARCH_BUG_ON |
Josh Triplett | a3f7607 | 2014-04-07 15:39:11 -0700 | [diff] [blame] | 62 | #define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | #endif |
| 64 | |
David Brownell | af9379c | 2009-01-06 14:41:01 -0800 | [diff] [blame] | 65 | /* |
| 66 | * WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report |
Dmitry Vyukov | 96c6a32 | 2018-08-21 21:55:24 -0700 | [diff] [blame] | 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. |
David Brownell | af9379c | 2009-01-06 14:41:01 -0800 | [diff] [blame] | 80 | */ |
Kees Cook | d4bce14 | 2019-09-25 16:48:04 -0700 | [diff] [blame] | 81 | #ifndef __WARN_FLAGS |
Joe Perches | b9075fa | 2011-10-31 17:11:33 -0700 | [diff] [blame] | 82 | extern __printf(4, 5) |
Kees Cook | ee87113 | 2019-09-25 16:47:52 -0700 | [diff] [blame] | 83 | void warn_slowpath_fmt(const char *file, const int line, unsigned taint, |
| 84 | const char *fmt, ...); |
Kees Cook | f2f84b0 | 2019-09-25 16:47:58 -0700 | [diff] [blame] | 85 | #define __WARN() __WARN_printf(TAINT_WARN, NULL) |
Kees Cook | 89348fc | 2019-09-25 16:47:55 -0700 | [diff] [blame] | 86 | #define __WARN_printf(taint, arg...) \ |
Kees Cook | ee87113 | 2019-09-25 16:47:52 -0700 | [diff] [blame] | 87 | warn_slowpath_fmt(__FILE__, __LINE__, taint, arg) |
Arjan van de Ven | a8f18b9 | 2008-07-25 01:45:53 -0700 | [diff] [blame] | 88 | #else |
Kees Cook | a7bed27a | 2017-11-17 15:27:24 -0800 | [diff] [blame] | 89 | extern __printf(1, 2) void __warn_printk(const char *fmt, ...); |
Kees Cook | a44f71a | 2019-09-25 16:48:11 -0700 | [diff] [blame] | 90 | #define __WARN() __WARN_FLAGS(BUGFLAG_TAINT(TAINT_WARN)) |
Kees Cook | d4bce14 | 2019-09-25 16:48:04 -0700 | [diff] [blame] | 91 | #define __WARN_printf(taint, arg...) do { \ |
| 92 | __warn_printk(arg); \ |
Kees Cook | a44f71a | 2019-09-25 16:48:11 -0700 | [diff] [blame] | 93 | __WARN_FLAGS(BUGFLAG_NO_CUT_HERE | BUGFLAG_TAINT(taint));\ |
Kees Cook | d4bce14 | 2019-09-25 16:48:04 -0700 | [diff] [blame] | 94 | } while (0) |
Kees Cook | 2da1ead | 2019-09-25 16:48:08 -0700 | [diff] [blame] | 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 | }) |
Olof Johansson | 3a6a62f9 | 2008-01-30 13:32:50 +0100 | [diff] [blame] | 102 | #endif |
| 103 | |
Josh Poimboeuf | 2553b67 | 2016-03-17 14:23:04 -0700 | [diff] [blame] | 104 | /* used internally by panic.c */ |
| 105 | struct warn_args; |
Ian Abbott | 0b39692 | 2017-07-10 15:50:55 -0700 | [diff] [blame] | 106 | struct pt_regs; |
Josh Poimboeuf | 2553b67 | 2016-03-17 14:23:04 -0700 | [diff] [blame] | 107 | |
| 108 | void __warn(const char *file, int line, void *caller, unsigned taint, |
| 109 | struct pt_regs *regs, struct warn_args *args); |
| 110 | |
Olof Johansson | 3a6a62f9 | 2008-01-30 13:32:50 +0100 | [diff] [blame] | 111 | #ifndef WARN_ON |
Herbert Xu | 684f978 | 2006-09-29 01:59:06 -0700 | [diff] [blame] | 112 | #define WARN_ON(condition) ({ \ |
Linus Torvalds | 8d4fbcf | 2007-07-31 21:12:07 -0700 | [diff] [blame] | 113 | int __ret_warn_on = !!(condition); \ |
Olof Johansson | 3a6a62f9 | 2008-01-30 13:32:50 +0100 | [diff] [blame] | 114 | if (unlikely(__ret_warn_on)) \ |
| 115 | __WARN(); \ |
Herbert Xu | 684f978 | 2006-09-29 01:59:06 -0700 | [diff] [blame] | 116 | unlikely(__ret_warn_on); \ |
| 117 | }) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | #endif |
| 119 | |
Arjan van de Ven | a8f18b9 | 2008-07-25 01:45:53 -0700 | [diff] [blame] | 120 | #ifndef WARN |
Peter Zijlstra | 19d4362 | 2017-02-25 08:56:53 +0100 | [diff] [blame] | 121 | #define WARN(condition, format...) ({ \ |
Arjan van de Ven | a8f18b9 | 2008-07-25 01:45:53 -0700 | [diff] [blame] | 122 | int __ret_warn_on = !!(condition); \ |
| 123 | if (unlikely(__ret_warn_on)) \ |
Kees Cook | 89348fc | 2019-09-25 16:47:55 -0700 | [diff] [blame] | 124 | __WARN_printf(TAINT_WARN, format); \ |
Arjan van de Ven | a8f18b9 | 2008-07-25 01:45:53 -0700 | [diff] [blame] | 125 | unlikely(__ret_warn_on); \ |
| 126 | }) |
| 127 | #endif |
| 128 | |
Ben Hutchings | b2be052 | 2010-04-03 19:34:56 +0100 | [diff] [blame] | 129 | #define WARN_TAINT(condition, taint, format...) ({ \ |
| 130 | int __ret_warn_on = !!(condition); \ |
| 131 | if (unlikely(__ret_warn_on)) \ |
Kees Cook | 89348fc | 2019-09-25 16:47:55 -0700 | [diff] [blame] | 132 | __WARN_printf(taint, format); \ |
Ben Hutchings | b2be052 | 2010-04-03 19:34:56 +0100 | [diff] [blame] | 133 | unlikely(__ret_warn_on); \ |
| 134 | }) |
| 135 | |
Peter Zijlstra | 19d4362 | 2017-02-25 08:56:53 +0100 | [diff] [blame] | 136 | #ifndef WARN_ON_ONCE |
Andrew Morton | d69a892 | 2006-10-06 00:43:49 -0700 | [diff] [blame] | 137 | #define WARN_ON_ONCE(condition) ({ \ |
Andi Kleen | b1fca27 | 2017-11-17 15:27:03 -0800 | [diff] [blame] | 138 | static bool __section(.data.once) __warned; \ |
Linus Torvalds | 8d4fbcf | 2007-07-31 21:12:07 -0700 | [diff] [blame] | 139 | int __ret_warn_once = !!(condition); \ |
Andrew Morton | d69a892 | 2006-10-06 00:43:49 -0700 | [diff] [blame] | 140 | \ |
Steven Rostedt | dfbf289 | 2016-03-17 14:21:12 -0700 | [diff] [blame] | 141 | if (unlikely(__ret_warn_once && !__warned)) { \ |
| 142 | __warned = true; \ |
| 143 | WARN_ON(1); \ |
| 144 | } \ |
Andrew Morton | d69a892 | 2006-10-06 00:43:49 -0700 | [diff] [blame] | 145 | unlikely(__ret_warn_once); \ |
Ingo Molnar | 74bb6a0 | 2006-06-25 05:48:09 -0700 | [diff] [blame] | 146 | }) |
Peter Zijlstra | 19d4362 | 2017-02-25 08:56:53 +0100 | [diff] [blame] | 147 | #endif |
Ingo Molnar | 74bb6a0 | 2006-06-25 05:48:09 -0700 | [diff] [blame] | 148 | |
Arjan van de Ven | 45e9c0d | 2008-09-15 16:43:18 -0700 | [diff] [blame] | 149 | #define WARN_ONCE(condition, format...) ({ \ |
Andi Kleen | b1fca27 | 2017-11-17 15:27:03 -0800 | [diff] [blame] | 150 | static bool __section(.data.once) __warned; \ |
Arjan van de Ven | 45e9c0d | 2008-09-15 16:43:18 -0700 | [diff] [blame] | 151 | int __ret_warn_once = !!(condition); \ |
| 152 | \ |
Steven Rostedt | dfbf289 | 2016-03-17 14:21:12 -0700 | [diff] [blame] | 153 | if (unlikely(__ret_warn_once && !__warned)) { \ |
| 154 | __warned = true; \ |
| 155 | WARN(1, format); \ |
| 156 | } \ |
Arjan van de Ven | 45e9c0d | 2008-09-15 16:43:18 -0700 | [diff] [blame] | 157 | unlikely(__ret_warn_once); \ |
| 158 | }) |
| 159 | |
Ben Hutchings | b2be052 | 2010-04-03 19:34:56 +0100 | [diff] [blame] | 160 | #define WARN_TAINT_ONCE(condition, taint, format...) ({ \ |
Andi Kleen | b1fca27 | 2017-11-17 15:27:03 -0800 | [diff] [blame] | 161 | static bool __section(.data.once) __warned; \ |
Ben Hutchings | b2be052 | 2010-04-03 19:34:56 +0100 | [diff] [blame] | 162 | int __ret_warn_once = !!(condition); \ |
| 163 | \ |
Steven Rostedt | dfbf289 | 2016-03-17 14:21:12 -0700 | [diff] [blame] | 164 | if (unlikely(__ret_warn_once && !__warned)) { \ |
| 165 | __warned = true; \ |
| 166 | WARN_TAINT(1, taint, format); \ |
| 167 | } \ |
Ben Hutchings | b2be052 | 2010-04-03 19:34:56 +0100 | [diff] [blame] | 168 | unlikely(__ret_warn_once); \ |
| 169 | }) |
| 170 | |
Josh Triplett | b607e70 | 2014-04-07 15:39:10 -0700 | [diff] [blame] | 171 | #else /* !CONFIG_BUG */ |
| 172 | #ifndef HAVE_ARCH_BUG |
Josh Triplett | a4b5d58 | 2014-04-07 15:39:13 -0700 | [diff] [blame] | 173 | #define BUG() do {} while (1) |
Josh Triplett | b607e70 | 2014-04-07 15:39:10 -0700 | [diff] [blame] | 174 | #endif |
| 175 | |
| 176 | #ifndef HAVE_ARCH_BUG_ON |
Denis Efremov | 9b87647 | 2019-08-29 00:09:34 +0300 | [diff] [blame] | 177 | #define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while (0) |
Josh Triplett | b607e70 | 2014-04-07 15:39:10 -0700 | [diff] [blame] | 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); \ |
Josh Triplett | 4e50ebde | 2014-04-07 15:39:12 -0700 | [diff] [blame] | 190 | no_printk(format); \ |
Josh Triplett | b607e70 | 2014-04-07 15:39:10 -0700 | [diff] [blame] | 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 | |
Steven Rostedt | 2092e6b | 2011-03-17 15:21:06 -0400 | [diff] [blame] | 202 | /* |
| 203 | * WARN_ON_SMP() is for cases that the warning is either |
| 204 | * meaningless for !SMP or may even cause failures. |
Steven Rostedt | 2092e6b | 2011-03-17 15:21:06 -0400 | [diff] [blame] | 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 | */ |
Ingo Molnar | 8eb94f8 | 2006-06-27 02:54:50 -0700 | [diff] [blame] | 225 | #ifdef CONFIG_SMP |
| 226 | # define WARN_ON_SMP(x) WARN_ON(x) |
| 227 | #else |
Steven Rostedt | ccd0d44 | 2011-03-25 16:21:06 -0400 | [diff] [blame] | 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 | */ |
Steven Rostedt | 2092e6b | 2011-03-17 15:21:06 -0400 | [diff] [blame] | 235 | # define WARN_ON_SMP(x) ({0;}) |
Ingo Molnar | 8eb94f8 | 2006-06-27 02:54:50 -0700 | [diff] [blame] | 236 | #endif |
| 237 | |
Paul Mundt | 2603efa | 2012-06-18 13:54:17 +0900 | [diff] [blame] | 238 | #endif /* __ASSEMBLY__ */ |
| 239 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | #endif |