Subversion Repositories Kolibri OS

Rev

Rev 6936 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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. /* used internally by panic.c */
  85. struct warn_args;
  86.  
  87. void __warn(const char *file, int line, void *caller, unsigned taint,
  88.             struct pt_regs *regs, struct warn_args *args);
  89.  
  90. #ifndef WARN_ON
  91. #define WARN_ON(condition) ({                                           \
  92.         int __ret_warn_on = !!(condition);                              \
  93.         if (unlikely(__ret_warn_on))                                    \
  94.                 __WARN();                                               \
  95.         unlikely(__ret_warn_on);                                        \
  96. })
  97. #endif
  98.  
  99. #ifndef WARN
  100. #define WARN(condition, format...) ({                                           \
  101.         int __ret_warn_on = !!(condition);                              \
  102.         if (unlikely(__ret_warn_on))                                    \
  103.                 __WARN_printf(format);                                  \
  104.         unlikely(__ret_warn_on);                                        \
  105. })
  106. #endif
  107.  
  108. #define WARN_TAINT(condition, taint, format...) ({                      \
  109.         int __ret_warn_on = !!(condition);                              \
  110.         if (unlikely(__ret_warn_on))                                    \
  111.                 __WARN_printf_taint(taint, format);                     \
  112.         unlikely(__ret_warn_on);                                        \
  113. })
  114.  
  115. #define WARN_ON_ONCE(condition) ({                              \
  116.         static bool __section(.data.unlikely) __warned;         \
  117.         int __ret_warn_once = !!(condition);                    \
  118.                                                                 \
  119.         if (unlikely(__ret_warn_once && !__warned)) {           \
  120.                 __warned = true;                                \
  121.                 WARN_ON(1);                                     \
  122.         }                                                       \
  123.         unlikely(__ret_warn_once);                              \
  124. })
  125.  
  126. #define WARN_ONCE(condition, format...) ({                      \
  127.         static bool __section(.data.unlikely) __warned;         \
  128.         int __ret_warn_once = !!(condition);                    \
  129.                                                                 \
  130.         if (unlikely(__ret_warn_once && !__warned)) {           \
  131.                 __warned = true;                                \
  132.                 WARN(1, format);                                \
  133.         }                                                       \
  134.         unlikely(__ret_warn_once);                              \
  135. })
  136.  
  137. #define WARN_TAINT_ONCE(condition, taint, format...)    ({      \
  138.         static bool __section(.data.unlikely) __warned;         \
  139.         int __ret_warn_once = !!(condition);                    \
  140.                                                                 \
  141.         if (unlikely(__ret_warn_once && !__warned)) {           \
  142.                 __warned = true;                                \
  143.                 WARN_TAINT(1, taint, format);                   \
  144.         }                                                       \
  145.         unlikely(__ret_warn_once);                              \
  146. })
  147.  
  148. #else /* !CONFIG_BUG */
  149. #ifndef HAVE_ARCH_BUG
  150. #define BUG() do {} while (1)
  151. #endif
  152.  
  153. #ifndef HAVE_ARCH_BUG_ON
  154. #define BUG_ON(condition) do { if (condition) BUG(); } while (0)
  155. #endif
  156.  
  157. #ifndef HAVE_ARCH_WARN_ON
  158. #define WARN_ON(condition) ({                                           \
  159.         int __ret_warn_on = !!(condition);                              \
  160.         unlikely(__ret_warn_on);                                        \
  161. })
  162. #endif
  163.  
  164. #ifndef WARN
  165. #define WARN(condition, format...) ({                                   \
  166.         int __ret_warn_on = !!(condition);                              \
  167.         no_printk(format);                                              \
  168.         unlikely(__ret_warn_on);                                        \
  169. })
  170. #endif
  171.  
  172. #define WARN_ON_ONCE(condition) WARN_ON(condition)
  173. #define WARN_ONCE(condition, format...) WARN(condition, format)
  174. #define WARN_TAINT(condition, taint, format...) WARN(condition, format)
  175. #define WARN_TAINT_ONCE(condition, taint, format...) WARN(condition, format)
  176.  
  177. #endif
  178.  
  179. /*
  180.  * WARN_ON_SMP() is for cases that the warning is either
  181.  * meaningless for !SMP or may even cause failures.
  182.  * This is usually used for cases that we have
  183.  * WARN_ON(!spin_is_locked(&lock)) checks, as spin_is_locked()
  184.  * returns 0 for uniprocessor settings.
  185.  * It can also be used with values that are only defined
  186.  * on SMP:
  187.  *
  188.  * struct foo {
  189.  *  [...]
  190.  * #ifdef CONFIG_SMP
  191.  *      int bar;
  192.  * #endif
  193.  * };
  194.  *
  195.  * void func(struct foo *zoot)
  196.  * {
  197.  *      WARN_ON_SMP(!zoot->bar);
  198.  *
  199.  * For CONFIG_SMP, WARN_ON_SMP() should act the same as WARN_ON(),
  200.  * and should be a nop and return false for uniprocessor.
  201.  *
  202.  * if (WARN_ON_SMP(x)) returns true only when CONFIG_SMP is set
  203.  * and x is true.
  204.  */
  205. #ifdef CONFIG_SMP
  206. # define WARN_ON_SMP(x)                 WARN_ON(x)
  207. #else
  208. /*
  209.  * Use of ({0;}) because WARN_ON_SMP(x) may be used either as
  210.  * a stand alone line statement or as a condition in an if ()
  211.  * statement.
  212.  * A simple "0" would cause gcc to give a "statement has no effect"
  213.  * warning.
  214.  */
  215. # define WARN_ON_SMP(x)                 ({0;})
  216. #endif
  217.  
  218. #endif /* __ASSEMBLY__ */
  219.  
  220. #endif
  221.