~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/asm-generic/bug.h

Version: ~ [ linux-6.11-rc3 ] ~ [ linux-6.10.4 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.45 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.104 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.164 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.223 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.281 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.319 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /include/asm-generic/bug.h (Version linux-6.11-rc3) and /include/asm-m68k/bug.h (Version linux-2.6.0)


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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php