include/asm-generic/bug.h

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