File: /Users/paulross/dev/linux/linux-3.13/include/asm-generic/bug.h

Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.

       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:     panic("BUG!"); \
      51: } while (0)
      52: #endif
      53: 
      54: #ifndef HAVE_ARCH_BUG_ON
      55: #define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while(0)
      56: #endif
      57: 
      58: /*
      59:  * WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report
      60:  * significant issues that need prompt attention if they should ever
      61:  * appear at runtime.  Use the versions with printk format strings
      62:  * to provide better diagnostics.
      63:  */
      64: #ifndef __WARN_TAINT
      65: extern __printf(3, 4)
      66: void warn_slowpath_fmt(const char *file, const int line,
      67:                const char *fmt, ...);
      68: extern __printf(4, 5)
      69: void warn_slowpath_fmt_taint(const char *file, const int line, unsigned taint,
      70:                  const char *fmt, ...);
      71: extern void warn_slowpath_null(const char *file, const int line);
      72: #define WANT_WARN_ON_SLOWPATH
      73: #define __WARN()        warn_slowpath_null(__FILE__, __LINE__)
      74: #define __WARN_printf(arg...)    warn_slowpath_fmt(__FILE__, __LINE__, arg)
      75: #define __WARN_printf_taint(taint, arg...)                \
      76:     warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg)
      77: #else
      78: #define __WARN()        __WARN_TAINT(TAINT_WARN)
      79: #define __WARN_printf(arg...)    do { printk(arg); __WARN(); } while (0)
      80: #define __WARN_printf_taint(taint, arg...)                \
      81:     do { printk(arg); __WARN_TAINT(taint); } while (0)
      82: #endif
      83: 
      84: #ifndef WARN_ON
      85: #define WARN_ON(condition) ({                        \
      86:     int __ret_warn_on = !!(condition);                \
      87:     if (unlikely(__ret_warn_on))                    \
      88:         __WARN();                        \
      89:     unlikely(__ret_warn_on);                    \
      90: })
      91: #endif
      92: 
      93: #ifndef WARN
      94: #define WARN(condition, format...) ({                        \
      95:     int __ret_warn_on = !!(condition);                \
      96:     if (unlikely(__ret_warn_on))                    \
      97:         __WARN_printf(format);                    \
      98:     unlikely(__ret_warn_on);                    \
      99: })
     100: #endif
     101: 
     102: #define WARN_TAINT(condition, taint, format...) ({            \
     103:     int __ret_warn_on = !!(condition);                \
     104:     if (unlikely(__ret_warn_on))                    \
     105:         __WARN_printf_taint(taint, format);            \
     106:     unlikely(__ret_warn_on);                    \
     107: })
     108: 
     109: #else /* !CONFIG_BUG */
     110: #ifndef HAVE_ARCH_BUG
     111: #define BUG() do {} while(0)
     112: #endif
     113: 
     114: #ifndef HAVE_ARCH_BUG_ON
     115: #define BUG_ON(condition) do { if (condition) ; } while(0)
     116: #endif
     117: 
     118: #ifndef HAVE_ARCH_WARN_ON
     119: #define WARN_ON(condition) ({                        \
     120:     int __ret_warn_on = !!(condition);                \
     121:     unlikely(__ret_warn_on);                    \
     122: })
     123: #endif
     124: 
     125: #ifndef WARN
     126: #define WARN(condition, format...) ({                    \
     127:     int __ret_warn_on = !!(condition);                \
     128:     unlikely(__ret_warn_on);                    \
     129: })
     130: #endif
     131: 
     132: #define WARN_TAINT(condition, taint, format...) WARN_ON(condition)
     133: 
     134: #endif
     135: 
     136: #define WARN_ON_ONCE(condition)    ({                \
     137:     static bool __section(.data.unlikely) __warned;        \
     138:     int __ret_warn_once = !!(condition);            \
     139:                                 \
     140:     if (unlikely(__ret_warn_once))                \
     141:         if (WARN_ON(!__warned))             \
     142:             __warned = true;            \
     143:     unlikely(__ret_warn_once);                \
     144: })
     145: 
     146: #define WARN_ONCE(condition, format...)    ({            \
     147:     static bool __section(.data.unlikely) __warned;        \
     148:     int __ret_warn_once = !!(condition);            \
     149:                                 \
     150:     if (unlikely(__ret_warn_once))                \
     151:         if (WARN(!__warned, format))             \
     152:             __warned = true;            \
     153:     unlikely(__ret_warn_once);                \
     154: })
     155: 
     156: #define WARN_TAINT_ONCE(condition, taint, format...)    ({    \
     157:     static bool __section(.data.unlikely) __warned;        \
     158:     int __ret_warn_once = !!(condition);            \
     159:                                 \
     160:     if (unlikely(__ret_warn_once))                \
     161:         if (WARN_TAINT(!__warned, taint, format))    \
     162:             __warned = true;            \
     163:     unlikely(__ret_warn_once);                \
     164: })
     165: 
     166: /*
     167:  * WARN_ON_SMP() is for cases that the warning is either
     168:  * meaningless for !SMP or may even cause failures.
     169:  * This is usually used for cases that we have
     170:  * WARN_ON(!spin_is_locked(&lock)) checks, as spin_is_locked()
     171:  * returns 0 for uniprocessor settings.
     172:  * It can also be used with values that are only defined
     173:  * on SMP:
     174:  *
     175:  * struct foo {
     176:  *  [...]
     177:  * #ifdef CONFIG_SMP
     178:  *    int bar;
     179:  * #endif
     180:  * };
     181:  *
     182:  * void func(struct foo *zoot)
     183:  * {
     184:  *    WARN_ON_SMP(!zoot->bar);
     185:  *
     186:  * For CONFIG_SMP, WARN_ON_SMP() should act the same as WARN_ON(),
     187:  * and should be a nop and return false for uniprocessor.
     188:  *
     189:  * if (WARN_ON_SMP(x)) returns true only when CONFIG_SMP is set
     190:  * and x is true.
     191:  */
     192: #ifdef CONFIG_SMP
     193: # define WARN_ON_SMP(x)            WARN_ON(x)
     194: #else
     195: /*
     196:  * Use of ({0;}) because WARN_ON_SMP(x) may be used either as
     197:  * a stand alone line statement or as a condition in an if ()
     198:  * statement.
     199:  * A simple "0" would cause gcc to give a "statement has no effect"
     200:  * warning.
     201:  */
     202: # define WARN_ON_SMP(x)            ({0;})
     203: #endif
     204: 
     205: #endif /* __ASSEMBLY__ */
     206: 
     207: #endif
     208: