[net-next-2.6.git] / include / asm-generic / bug.h

#ifndef _ASM_GENERIC_BUG_H
#define _ASM_GENERIC_BUG_H

#include <linux/compiler.h>

#ifdef CONFIG_BUG

#ifdef CONFIG_GENERIC_BUG
#ifndef __ASSEMBLY__
struct bug_entry {
#ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
	unsigned long	bug_addr;
#else
	signed int	bug_addr_disp;
#endif
#ifdef CONFIG_DEBUG_BUGVERBOSE
#ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
	const char	*file;
#else
	signed int	file_disp;
#endif
	unsigned short	line;
#endif
	unsigned short	flags;
};
#endif		/* __ASSEMBLY__ */

#define BUGFLAG_WARNING		(1 << 0)
#define BUGFLAG_TAINT(taint)	(BUGFLAG_WARNING | ((taint) << 8))
#define BUG_GET_TAINT(bug)	((bug)->flags >> 8)

#endif	/* CONFIG_GENERIC_BUG */

/*
 * Don't use BUG() or BUG_ON() unless there's really no way out; one
 * example might be detecting data structure corruption in the middle
 * of an operation that can't be backed out of.  If the (sub)system
 * can somehow continue operating, perhaps with reduced functionality,
 * it's probably not BUG-worthy.
 *
 * If you're tempted to BUG(), think again:  is completely giving up
 * really the *only* solution?  There are usually better options, where
 * users don't need to reboot ASAP and can mostly shut down cleanly.
 */
#ifndef HAVE_ARCH_BUG
#define BUG() do { \
	printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
	panic("BUG!"); \
} while (0)
#endif

#ifndef HAVE_ARCH_BUG_ON
#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while(0)
#endif

/*
 * WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report
 * significant issues that need prompt attention if they should ever
 * appear at runtime.  Use the versions with printk format strings
 * to provide better diagnostics.
 */
#ifndef __WARN_TAINT
#ifndef __ASSEMBLY__
extern void warn_slowpath_fmt(const char *file, const int line,
		const char *fmt, ...) __attribute__((format(printf, 3, 4)));
extern void warn_slowpath_fmt_taint(const char *file, const int line,
				    unsigned taint, const char *fmt, ...)
	__attribute__((format(printf, 4, 5)));
extern void warn_slowpath_null(const char *file, const int line);
#define WANT_WARN_ON_SLOWPATH
#endif
#define __WARN()		warn_slowpath_null(__FILE__, __LINE__)
#define __WARN_printf(arg...)	warn_slowpath_fmt(__FILE__, __LINE__, arg)
#define __WARN_printf_taint(taint, arg...)				\
	warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg)
#else
#define __WARN()		__WARN_TAINT(TAINT_WARN)
#define __WARN_printf(arg...)	do { printk(arg); __WARN(); } while (0)
#define __WARN_printf_taint(taint, arg...)				\
	do { printk(arg); __WARN_TAINT(taint); } while (0)
#endif

#ifndef WARN_ON
#define WARN_ON(condition) ({						\
	int __ret_warn_on = !!(condition);				\
	if (unlikely(__ret_warn_on))					\
		__WARN();						\
	unlikely(__ret_warn_on);					\
})
#endif

#ifndef WARN
#define WARN(condition, format...) ({						\
	int __ret_warn_on = !!(condition);				\
	if (unlikely(__ret_warn_on))					\
		__WARN_printf(format);					\
	unlikely(__ret_warn_on);					\
})
#endif

#define WARN_TAINT(condition, taint, format...) ({			\
	int __ret_warn_on = !!(condition);				\
	if (unlikely(__ret_warn_on))					\
		__WARN_printf_taint(taint, format);			\
	unlikely(__ret_warn_on);					\
})

#else /* !CONFIG_BUG */
#ifndef HAVE_ARCH_BUG
#define BUG() do {} while(0)
#endif

#ifndef HAVE_ARCH_BUG_ON
#define BUG_ON(condition) do { if (condition) ; } while(0)
#endif

#ifndef HAVE_ARCH_WARN_ON
#define WARN_ON(condition) ({						\
	int __ret_warn_on = !!(condition);				\
	unlikely(__ret_warn_on);					\
})
#endif

#ifndef WARN
#define WARN(condition, format...) ({					\
	int __ret_warn_on = !!(condition);				\
	unlikely(__ret_warn_on);					\
})
#endif

#define WARN_TAINT(condition, taint, format...) WARN_ON(condition)

#endif

#define WARN_ON_ONCE(condition)	({				\
	static bool __warned;					\
	int __ret_warn_once = !!(condition);			\
								\
	if (unlikely(__ret_warn_once))				\
		if (WARN_ON(!__warned)) 			\
			__warned = true;			\
	unlikely(__ret_warn_once);				\
})

#define WARN_ONCE(condition, format...)	({			\
	static bool __warned;					\
	int __ret_warn_once = !!(condition);			\
								\
	if (unlikely(__ret_warn_once))				\
		if (WARN(!__warned, format)) 			\
			__warned = true;			\
	unlikely(__ret_warn_once);				\
})

#define WARN_TAINT_ONCE(condition, taint, format...)	({	\
	static bool __warned;					\
	int __ret_warn_once = !!(condition);			\
								\
	if (unlikely(__ret_warn_once))				\
		if (WARN_TAINT(!__warned, taint, format))	\
			__warned = true;			\
	unlikely(__ret_warn_once);				\
})

#define WARN_ON_RATELIMIT(condition, state)			\
		WARN_ON((condition) && __ratelimit(state))

#ifdef CONFIG_SMP
# define WARN_ON_SMP(x)			WARN_ON(x)
#else
# define WARN_ON_SMP(x)			do { } while (0)
#endif

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _ASM_GENERIC_BUG_H
	2	#define _ASM_GENERIC_BUG_H
	3
	4	#include <linux/compiler.h>
1da177e4	5
c8538a7a	6	#ifdef CONFIG_BUG
7664c5a1 JF	7
	8	#ifdef CONFIG_GENERIC_BUG
	9	#ifndef __ASSEMBLY__
	10	struct bug_entry {
b93a531e	11	#ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
7664c5a1	12	unsigned long bug_addr;
b93a531e JB	13	#else
	14	signed int bug_addr_disp;
	15	#endif
7664c5a1	16	#ifdef CONFIG_DEBUG_BUGVERBOSE
b93a531e	17	#ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
7664c5a1	18	const char *file;
b93a531e JB	19	#else
	20	signed int file_disp;
	21	#endif
7664c5a1 JF	22	unsigned short line;
	23	#endif
	24	unsigned short flags;
	25	};
	26	#endif /* __ASSEMBLY__ */
	27
b2be0527 BH	28	#define BUGFLAG_WARNING (1 << 0)
	29	#define BUGFLAG_TAINT(taint) (BUGFLAG_WARNING \| ((taint) << 8))
	30	#define BUG_GET_TAINT(bug) ((bug)->flags >> 8)
	31
7664c5a1 JF	32	#endif /* CONFIG_GENERIC_BUG */
7664c5a1 JF	33
af9379c7 DB	34	/*
	35	* Don't use BUG() or BUG_ON() unless there's really no way out; one
	36	* example might be detecting data structure corruption in the middle
	37	* of an operation that can't be backed out of. If the (sub)system
	38	* can somehow continue operating, perhaps with reduced functionality,
	39	* it's probably not BUG-worthy.
	40	*
	41	* If you're tempted to BUG(), think again: is completely giving up
	42	* really the only solution? There are usually better options, where
	43	* users don't need to reboot ASAP and can mostly shut down cleanly.
	44	*/
1da177e4 LT	45	#ifndef HAVE_ARCH_BUG
1da177e4 LT	46	#define BUG() do { \
d5c003b4	47	printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
1da177e4 LT	48	panic("BUG!"); \
	49	} while (0)
	50	#endif
	51
1da177e4	52	#ifndef HAVE_ARCH_BUG_ON
2a41de48	53	#define BUG_ON(condition) do { if (unlikely(condition)) BUG(); } while(0)
1da177e4 LT	54	#endif
1da177e4 LT	55
af9379c7 DB	56	/*
	57	* WARN(), WARN_ON(), WARN_ON_ONCE, and so on can be used to report
	58	* significant issues that need prompt attention if they should ever
	59	* appear at runtime. Use the versions with printk format strings
	60	* to provide better diagnostics.
	61	*/
b2be0527	62	#ifndef __WARN_TAINT
79b4cc5e	63	#ifndef __ASSEMBLY__
57adc4d2	64	extern void warn_slowpath_fmt(const char *file, const int line,
a8f18b90	65	const char *fmt, ...) __attribute__((format(printf, 3, 4)));
b2be0527 BH	66	extern void warn_slowpath_fmt_taint(const char *file, const int line,
	67	unsigned taint, const char *fmt, ...)
	68	__attribute__((format(printf, 4, 5)));
57adc4d2	69	extern void warn_slowpath_null(const char *file, const int line);
79b4cc5e AV	70	#define WANT_WARN_ON_SLOWPATH
79b4cc5e AV	71	#endif
57adc4d2 AK	72	#define __WARN() warn_slowpath_null(__FILE__, __LINE__)
57adc4d2 AK	73	#define __WARN_printf(arg...) warn_slowpath_fmt(__FILE__, __LINE__, arg)
b2be0527 BH	74	#define __WARN_printf_taint(taint, arg...) \
b2be0527 BH	75	warn_slowpath_fmt_taint(__FILE__, __LINE__, taint, arg)
a8f18b90	76	#else
b2be0527	77	#define __WARN() __WARN_TAINT(TAINT_WARN)
ec5679e5	78	#define __WARN_printf(arg...) do { printk(arg); __WARN(); } while (0)
b2be0527 BH	79	#define __WARN_printf_taint(taint, arg...) \
b2be0527 BH	80	do { printk(arg); __WARN_TAINT(taint); } while (0)
3a6a62f9 OJ	81	#endif
	82
	83	#ifndef WARN_ON
684f9783	84	#define WARN_ON(condition) ({ \
8d4fbcfb	85	int __ret_warn_on = !!(condition); \
3a6a62f9 OJ	86	if (unlikely(__ret_warn_on)) \
3a6a62f9 OJ	87	__WARN(); \
684f9783 HX	88	unlikely(__ret_warn_on); \
684f9783 HX	89	})
1da177e4 LT	90	#endif
1da177e4 LT	91
a8f18b90 AV	92	#ifndef WARN
	93	#define WARN(condition, format...) ({ \
	94	int __ret_warn_on = !!(condition); \
	95	if (unlikely(__ret_warn_on)) \
	96	__WARN_printf(format); \
	97	unlikely(__ret_warn_on); \
	98	})
	99	#endif
	100
b2be0527 BH	101	#define WARN_TAINT(condition, taint, format...) ({ \
	102	int __ret_warn_on = !!(condition); \
	103	if (unlikely(__ret_warn_on)) \
	104	__WARN_printf_taint(taint, format); \
	105	unlikely(__ret_warn_on); \
	106	})
	107
c8538a7a MM	108	#else /* !CONFIG_BUG */
c8538a7a MM	109	#ifndef HAVE_ARCH_BUG
da60682c	110	#define BUG() do {} while(0)
c8538a7a MM	111	#endif
c8538a7a MM	112
c8538a7a MM	113	#ifndef HAVE_ARCH_BUG_ON
	114	#define BUG_ON(condition) do { if (condition) ; } while(0)
	115	#endif
	116
	117	#ifndef HAVE_ARCH_WARN_ON
8c7c7c9b	118	#define WARN_ON(condition) ({ \
8d4fbcfb	119	int __ret_warn_on = !!(condition); \
8c7c7c9b RB	120	unlikely(__ret_warn_on); \
8c7c7c9b RB	121	})
c8538a7a	122	#endif
a8f18b90 AV	123
	124	#ifndef WARN
	125	#define WARN(condition, format...) ({ \
	126	int __ret_warn_on = !!(condition); \
	127	unlikely(__ret_warn_on); \
	128	})
	129	#endif
	130
b2be0527 BH	131	#define WARN_TAINT(condition, taint, format...) WARN_ON(condition)
b2be0527 BH	132
c8538a7a MM	133	#endif
c8538a7a MM	134
d69a8922	135	#define WARN_ON_ONCE(condition) ({ \
42f247c8	136	static bool __warned; \
8d4fbcfb	137	int __ret_warn_once = !!(condition); \
d69a8922 AM	138	\
	139	if (unlikely(__ret_warn_once)) \
	140	if (WARN_ON(!__warned)) \
42f247c8	141	__warned = true; \
d69a8922	142	unlikely(__ret_warn_once); \
74bb6a09 IM	143	})
74bb6a09 IM	144
45e9c0de	145	#define WARN_ONCE(condition, format...) ({ \
42f247c8	146	static bool __warned; \
45e9c0de AV	147	int __ret_warn_once = !!(condition); \
	148	\
	149	if (unlikely(__ret_warn_once)) \
	150	if (WARN(!__warned, format)) \
42f247c8	151	__warned = true; \
45e9c0de AV	152	unlikely(__ret_warn_once); \
	153	})
	154
b2be0527 BH	155	#define WARN_TAINT_ONCE(condition, taint, format...) ({ \
	156	static bool __warned; \
	157	int __ret_warn_once = !!(condition); \
	158	\
	159	if (unlikely(__ret_warn_once)) \
	160	if (WARN_TAINT(!__warned, taint, format)) \
	161	__warned = true; \
	162	unlikely(__ret_warn_once); \
	163	})
	164
717115e1 DY	165	#define WARN_ON_RATELIMIT(condition, state) \
	166	WARN_ON((condition) && __ratelimit(state))
	167
8eb94f80 IM	168	#ifdef CONFIG_SMP
	169	# define WARN_ON_SMP(x) WARN_ON(x)
	170	#else
	171	# define WARN_ON_SMP(x) do { } while (0)
	172	#endif
	173
1da177e4	174	#endif