Root/
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 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9