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