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_BUG
   7
   8#ifdef CONFIG_GENERIC_BUG
   9#ifndef __ASSEMBLY__
  10struct bug_entry {
  11#ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
  12        unsigned long   bug_addr;
  13#else
  14        signed int      bug_addr_disp;
  15#endif
  16#ifdef CONFIG_DEBUG_BUGVERBOSE
  17#ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
  18        const char      *file;
  19#else
  20        signed int      file_disp;
  21#endif
  22        unsigned short  line;
  23#endif
  24        unsigned short  flags;
  25};
  26#endif          /* __ASSEMBLY__ */
  27
  28#define BUGFLAG_WARNING (1<<0)
  29#endif  /* CONFIG_GENERIC_BUG */
  30
  31/*
  32 * Don't use BUG() or BUG_ON() unless there's really no way out; one
  33 * example might be detecting data structure corruption in the middle
  34 * of an operation that can't be backed out of.  If the (sub)system
  35 * can somehow continue operating, perhaps with reduced functionality,
  36 * it's probably not BUG-worthy.
  37 *
  38 * If you're tempted to BUG(), think again:  is completely giving up
  39 * really the *only* solution?  There are usually better options, where
  40 * users don't need to reboot ASAP and can mostly shut down cleanly.
  41 */
  42#ifndef HAVE_ARCH_BUG
  43#define BUG() do { \
  44        printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
  45        panic("BUG!"); \
  46} while (0)
  47#endif
  48
  49#ifndef HAVE_ARCH_BUG_ON
  50#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while(0)
  51#endif
  52
  53/*
  54 * WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report
  55 * significant issues that need prompt attention if they should ever
  56 * appear at runtime.  Use the versions with printk format strings
  57 * to provide better diagnostics.
  58 */
  59#ifndef __WARN
  60#ifndef __ASSEMBLY__
  61extern void warn_slowpath_fmt(const char *file, const int line,
  62                const char *fmt, ...) __attribute__((format(printf, 3, 4)));
  63extern void warn_slowpath_null(const char *file, const int line);
  64#define WANT_WARN_ON_SLOWPATH
  65#endif
  66#define __WARN()                warn_slowpath_null(__FILE__, __LINE__)
  67#define __WARN_printf(arg...)   warn_slowpath_fmt(__FILE__, __LINE__, arg)
  68#else
  69#define __WARN_printf(arg...)   do { printk(arg); __WARN(); } while (0)
  70#endif
  71
  72#ifndef WARN_ON
  73#define WARN_ON(condition) ({                                           \
  74        int __ret_warn_on = !!(condition);                              \
  75        if (unlikely(__ret_warn_on))                                    \
  76                __WARN();                                               \
  77        unlikely(__ret_warn_on);                                        \
  78})
  79#endif
  80
  81#ifndef WARN
  82#define WARN(condition, format...) ({                                           \
  83        int __ret_warn_on = !!(condition);                              \
  84        if (unlikely(__ret_warn_on))                                    \
  85                __WARN_printf(format);                                  \
  86        unlikely(__ret_warn_on);                                        \
  87})
  88#endif
  89
  90#else /* !CONFIG_BUG */
  91#ifndef HAVE_ARCH_BUG
  92#define BUG() do {} while(0)
  93#endif
  94
  95#ifndef HAVE_ARCH_BUG_ON
  96#define BUG_ON(condition) do { if (condition) ; } while(0)
  97#endif
  98
  99#ifndef HAVE_ARCH_WARN_ON
 100#define WARN_ON(condition) ({                                           \
 101        int __ret_warn_on = !!(condition);                              \
 102        unlikely(__ret_warn_on);                                        \
 103})
 104#endif
 105
 106#ifndef WARN
 107#define WARN(condition, format...) ({                                   \
 108        int __ret_warn_on = !!(condition);                              \
 109        unlikely(__ret_warn_on);                                        \
 110})
 111#endif
 112
 113#endif
 114
 115#define WARN_ON_ONCE(condition) ({                              \
 116        static int __warned;                                    \
 117        int __ret_warn_once = !!(condition);                    \
 118                                                                \
 119        if (unlikely(__ret_warn_once))                          \
 120                if (WARN_ON(!__warned))                         \
 121                        __warned = 1;                           \
 122        unlikely(__ret_warn_once);                              \
 123})
 124
 125#define WARN_ONCE(condition, format...) ({                      \
 126        static int __warned;                                    \
 127        int __ret_warn_once = !!(condition);                    \
 128                                                                \
 129        if (unlikely(__ret_warn_once))                          \
 130                if (WARN(!__warned, format))                    \
 131                        __warned = 1;                           \
 132        unlikely(__ret_warn_once);                              \
 133})
 134
 135#define WARN_ON_RATELIMIT(condition, state)                     \
 136                WARN_ON((condition) && __ratelimit(state))
 137
 138#ifdef CONFIG_SMP
 139# define WARN_ON_SMP(x)                 WARN_ON(x)
 140#else
 141# define WARN_ON_SMP(x)                 do { } while (0)
 142#endif
 143
 144#endif
 145