Subversion Repositories Kolibri OS

#ifndef _ASM_GENERIC_BUG_H

#define _ASM_GENERIC_BUG_H

#include 

#ifdef CONFIG_GENERIC_BUG

#define BUGFLAG_WARNING		(1 << 0)

#define BUGFLAG_TAINT(taint)	(BUGFLAG_WARNING | ((taint) << 8))

#define BUG_GET_TAINT(bug)	((bug)->flags >> 8)

#endif

#ifndef __ASSEMBLY__

#include 

#ifdef CONFIG_BUG

#ifdef CONFIG_GENERIC_BUG

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	/* 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

extern __printf(3, 4)

void warn_slowpath_fmt(const char *file, const int line,

		       const char *fmt, ...);

extern __printf(4, 5)

void warn_slowpath_fmt_taint(const char *file, const int line, unsigned taint,

			     const char *fmt, ...);

extern void warn_slowpath_null(const char *file, const int line);

#define WANT_WARN_ON_SLOWPATH

#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

/* used internally by panic.c */

struct warn_args;

void __warn(const char *file, int line, void *caller, unsigned taint,

	    struct pt_regs *regs, struct warn_args *args);

#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);					\

})

#define WARN_ON_ONCE(condition)	({				\

	static bool __section(.data.unlikely) __warned;		\

	int __ret_warn_once = !!(condition);			\

								\

	if (unlikely(__ret_warn_once && !__warned)) {		\

		__warned = true;				\

		WARN_ON(1);					\

	}							\

	unlikely(__ret_warn_once);				\

})

#define WARN_ONCE(condition, format...)	({			\

	static bool __section(.data.unlikely) __warned;		\

	int __ret_warn_once = !!(condition);			\

								\

	if (unlikely(__ret_warn_once && !__warned)) {		\

		__warned = true;				\

		WARN(1, format);				\

	}							\

	unlikely(__ret_warn_once);				\

})

#define WARN_TAINT_ONCE(condition, taint, format...)	({	\

	static bool __section(.data.unlikely) __warned;		\

	int __ret_warn_once = !!(condition);			\

								\

	if (unlikely(__ret_warn_once && !__warned)) {		\

		__warned = true;				\

		WARN_TAINT(1, taint, format);			\

	}							\

	unlikely(__ret_warn_once);				\

})

#else /* !CONFIG_BUG */

#ifndef HAVE_ARCH_BUG

#define BUG() do {} while (1)

#endif

#ifndef HAVE_ARCH_BUG_ON

#define BUG_ON(condition) do { if (condition) BUG(); } 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);				\

	no_printk(format);						\

	unlikely(__ret_warn_on);					\

})

#endif

#define WARN_ON_ONCE(condition) WARN_ON(condition)

#define WARN_ONCE(condition, format...) WARN(condition, format)

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

#define WARN_TAINT_ONCE(condition, taint, format...) WARN(condition, format)

#endif

/*

 * WARN_ON_SMP() is for cases that the warning is either

 * meaningless for !SMP or may even cause failures.

 * This is usually used for cases that we have

 * WARN_ON(!spin_is_locked(&lock)) checks, as spin_is_locked()

 * returns 0 for uniprocessor settings.

 * It can also be used with values that are only defined

 * on SMP:

 *

 * struct foo {

 *  [...]

 * #ifdef CONFIG_SMP

 *	int bar;

 * #endif

 * };

 *

 * void func(struct foo *zoot)

 * {

 *	WARN_ON_SMP(!zoot->bar);

 *

 * For CONFIG_SMP, WARN_ON_SMP() should act the same as WARN_ON(),

 * and should be a nop and return false for uniprocessor.

 *

 * if (WARN_ON_SMP(x)) returns true only when CONFIG_SMP is set

 * and x is true.

 */

#ifdef CONFIG_SMP

# define WARN_ON_SMP(x)			WARN_ON(x)

#else

/*

 * Use of ({0;}) because WARN_ON_SMP(x) may be used either as

 * a stand alone line statement or as a condition in an if ()

 * statement.

 * A simple "0" would cause gcc to give a "statement has no effect"

 * warning.

 */

# define WARN_ON_SMP(x)			({0;})

#endif

#endif /* __ASSEMBLY__ */

#endif