1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2 | /* |
3 | * Copyright (c) International Business Machines Corp., 2006 |
4 | * |
5 | * Author: Artem Bityutskiy (Битюцкий Артём) |
6 | */ |
7 | |
8 | #ifndef __UBI_DEBUG_H__ |
9 | #define __UBI_DEBUG_H__ |
10 | |
11 | void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len); |
12 | void ubi_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr); |
13 | void ubi_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr); |
14 | |
15 | #include <linux/random.h> |
16 | |
17 | #define ubi_assert(expr) do { \ |
18 | if (unlikely(!(expr))) { \ |
19 | pr_crit("UBI assert failed in %s at %u (pid %d)\n", \ |
20 | __func__, __LINE__, current->pid); \ |
21 | dump_stack(); \ |
22 | } \ |
23 | } while (0) |
24 | |
25 | #define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a) \ |
26 | print_hex_dump(l, ps, pt, r, g, b, len, a) |
27 | |
28 | #define ubi_dbg_msg(type, fmt, ...) \ |
29 | pr_debug("UBI DBG " type " (pid %d): " fmt "\n", current->pid, \ |
30 | ##__VA_ARGS__) |
31 | |
32 | /* General debugging messages */ |
33 | #define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__) |
34 | /* Messages from the eraseblock association sub-system */ |
35 | #define dbg_eba(fmt, ...) ubi_dbg_msg("eba", fmt, ##__VA_ARGS__) |
36 | /* Messages from the wear-leveling sub-system */ |
37 | #define dbg_wl(fmt, ...) ubi_dbg_msg("wl", fmt, ##__VA_ARGS__) |
38 | /* Messages from the input/output sub-system */ |
39 | #define dbg_io(fmt, ...) ubi_dbg_msg("io", fmt, ##__VA_ARGS__) |
40 | /* Initialization and build messages */ |
41 | #define dbg_bld(fmt, ...) ubi_dbg_msg("bld", fmt, ##__VA_ARGS__) |
42 | |
43 | void ubi_dump_vol_info(const struct ubi_volume *vol); |
44 | void ubi_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx); |
45 | void ubi_dump_av(const struct ubi_ainf_volume *av); |
46 | void ubi_dump_aeb(const struct ubi_ainf_peb *aeb, int type); |
47 | void ubi_dump_mkvol_req(const struct ubi_mkvol_req *req); |
48 | int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, |
49 | int len); |
50 | int ubi_debugfs_init(void); |
51 | void ubi_debugfs_exit(void); |
52 | int ubi_debugfs_init_dev(struct ubi_device *ubi); |
53 | void ubi_debugfs_exit_dev(struct ubi_device *ubi); |
54 | |
55 | /** |
56 | * The following function is a legacy implementation of UBI fault-injection |
57 | * hook. When using more powerful fault injection capabilities, the legacy |
58 | * fault injection interface should be retained. |
59 | */ |
60 | int ubi_dbg_power_cut(struct ubi_device *ubi, int caller); |
61 | |
62 | static inline int ubi_dbg_bitflip(const struct ubi_device *ubi) |
63 | { |
64 | if (ubi->dbg.emulate_bitflips) |
65 | return !get_random_u32_below(ceil: 200); |
66 | return 0; |
67 | } |
68 | |
69 | static inline int ubi_dbg_write_failure(const struct ubi_device *ubi) |
70 | { |
71 | if (ubi->dbg.emulate_io_failures) |
72 | return !get_random_u32_below(ceil: 500); |
73 | return 0; |
74 | } |
75 | |
76 | static inline int ubi_dbg_erase_failure(const struct ubi_device *ubi) |
77 | { |
78 | if (ubi->dbg.emulate_io_failures) |
79 | return !get_random_u32_below(ceil: 400); |
80 | return 0; |
81 | } |
82 | |
83 | /** |
84 | * MASK_XXX: Mask for emulate_failures in ubi_debug_info.The mask is used to |
85 | * precisely control the type and process of fault injection. |
86 | */ |
87 | /* Emulate a power cut when writing EC/VID header */ |
88 | #define MASK_POWER_CUT_EC (1 << 0) |
89 | #define MASK_POWER_CUT_VID (1 << 1) |
90 | /* Emulate a power cut when writing data*/ |
91 | #define MASK_POWER_CUT_DATA (1 << 2) |
92 | /* Emulate bit-flips */ |
93 | #define MASK_BITFLIPS (1 << 3) |
94 | /* Emulate ecc error */ |
95 | #define MASK_ECCERR (1 << 4) |
96 | /* Emulates -EIO during data read */ |
97 | #define MASK_READ_FAILURE (1 << 5) |
98 | #define MASK_READ_FAILURE_EC (1 << 6) |
99 | #define MASK_READ_FAILURE_VID (1 << 7) |
100 | /* Emulates -EIO during data write */ |
101 | #define MASK_WRITE_FAILURE (1 << 8) |
102 | /* Emulates -EIO during erase a PEB*/ |
103 | #define MASK_ERASE_FAILURE (1 << 9) |
104 | /* Return UBI_IO_FF when reading EC/VID header */ |
105 | #define MASK_IO_FF_EC (1 << 10) |
106 | #define MASK_IO_FF_VID (1 << 11) |
107 | /* Return UBI_IO_FF_BITFLIPS when reading EC/VID header */ |
108 | #define MASK_IO_FF_BITFLIPS_EC (1 << 12) |
109 | #define MASK_IO_FF_BITFLIPS_VID (1 << 13) |
110 | /* Return UBI_IO_BAD_HDR when reading EC/VID header */ |
111 | #define MASK_BAD_HDR_EC (1 << 14) |
112 | #define MASK_BAD_HDR_VID (1 << 15) |
113 | /* Return UBI_IO_BAD_HDR_EBADMSG when reading EC/VID header */ |
114 | #define MASK_BAD_HDR_EBADMSG_EC (1 << 16) |
115 | #define MASK_BAD_HDR_EBADMSG_VID (1 << 17) |
116 | |
117 | #ifdef CONFIG_MTD_UBI_FAULT_INJECTION |
118 | |
119 | extern bool should_fail_eccerr(void); |
120 | extern bool should_fail_bitflips(void); |
121 | extern bool should_fail_read_failure(void); |
122 | extern bool should_fail_write_failure(void); |
123 | extern bool should_fail_erase_failure(void); |
124 | extern bool should_fail_power_cut(void); |
125 | extern bool should_fail_io_ff(void); |
126 | extern bool should_fail_io_ff_bitflips(void); |
127 | extern bool should_fail_bad_hdr(void); |
128 | extern bool should_fail_bad_hdr_ebadmsg(void); |
129 | |
130 | static inline bool ubi_dbg_fail_bitflip(const struct ubi_device *ubi) |
131 | { |
132 | if (ubi->dbg.emulate_failures & MASK_BITFLIPS) |
133 | return should_fail_bitflips(); |
134 | return false; |
135 | } |
136 | |
137 | static inline bool ubi_dbg_fail_write(const struct ubi_device *ubi) |
138 | { |
139 | if (ubi->dbg.emulate_failures & MASK_WRITE_FAILURE) |
140 | return should_fail_write_failure(); |
141 | return false; |
142 | } |
143 | |
144 | static inline bool ubi_dbg_fail_erase(const struct ubi_device *ubi) |
145 | { |
146 | if (ubi->dbg.emulate_failures & MASK_ERASE_FAILURE) |
147 | return should_fail_erase_failure(); |
148 | return false; |
149 | } |
150 | |
151 | static inline bool ubi_dbg_fail_power_cut(const struct ubi_device *ubi, |
152 | unsigned int caller) |
153 | { |
154 | if (ubi->dbg.emulate_failures & caller) |
155 | return should_fail_power_cut(); |
156 | return false; |
157 | } |
158 | |
159 | static inline bool ubi_dbg_fail_read(const struct ubi_device *ubi, |
160 | unsigned int caller) |
161 | { |
162 | if (ubi->dbg.emulate_failures & caller) |
163 | return should_fail_read_failure(); |
164 | return false; |
165 | } |
166 | |
167 | static inline bool ubi_dbg_fail_eccerr(const struct ubi_device *ubi) |
168 | { |
169 | if (ubi->dbg.emulate_failures & MASK_ECCERR) |
170 | return should_fail_eccerr(); |
171 | return false; |
172 | } |
173 | |
174 | static inline bool ubi_dbg_fail_ff(const struct ubi_device *ubi, |
175 | unsigned int caller) |
176 | { |
177 | if (ubi->dbg.emulate_failures & caller) |
178 | return should_fail_io_ff(); |
179 | return false; |
180 | } |
181 | |
182 | static inline bool ubi_dbg_fail_ff_bitflips(const struct ubi_device *ubi, |
183 | unsigned int caller) |
184 | { |
185 | if (ubi->dbg.emulate_failures & caller) |
186 | return should_fail_io_ff_bitflips(); |
187 | return false; |
188 | } |
189 | |
190 | static inline bool ubi_dbg_fail_bad_hdr(const struct ubi_device *ubi, |
191 | unsigned int caller) |
192 | { |
193 | if (ubi->dbg.emulate_failures & caller) |
194 | return should_fail_bad_hdr(); |
195 | return false; |
196 | } |
197 | |
198 | static inline bool ubi_dbg_fail_bad_hdr_ebadmsg(const struct ubi_device *ubi, |
199 | unsigned int caller) |
200 | { |
201 | if (ubi->dbg.emulate_failures & caller) |
202 | return should_fail_bad_hdr_ebadmsg(); |
203 | return false; |
204 | } |
205 | #else /* CONFIG_MTD_UBI_FAULT_INJECTION */ |
206 | |
207 | #define ubi_dbg_fail_bitflip(u) false |
208 | #define ubi_dbg_fail_write(u) false |
209 | #define ubi_dbg_fail_erase(u) false |
210 | #define ubi_dbg_fail_power_cut(u, c) false |
211 | #define ubi_dbg_fail_read(u, c) false |
212 | #define ubi_dbg_fail_eccerr(u) false |
213 | #define ubi_dbg_fail_ff(u, c) false |
214 | #define ubi_dbg_fail_ff_bitflips(u, v) false |
215 | #define ubi_dbg_fail_bad_hdr(u, c) false |
216 | #define ubi_dbg_fail_bad_hdr_ebadmsg(u, c) false |
217 | |
218 | #endif |
219 | |
220 | /** |
221 | * ubi_dbg_is_power_cut - if it is time to emulate power cut. |
222 | * @ubi: UBI device description object |
223 | * |
224 | * Returns true if power cut should be emulated, otherwise returns false. |
225 | */ |
226 | static inline bool ubi_dbg_is_power_cut(struct ubi_device *ubi, |
227 | unsigned int caller) |
228 | { |
229 | if (ubi_dbg_power_cut(ubi, caller)) |
230 | return true; |
231 | return ubi_dbg_fail_power_cut(ubi, caller); |
232 | } |
233 | |
234 | /** |
235 | * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip. |
236 | * @ubi: UBI device description object |
237 | * |
238 | * Returns true if a bit-flip should be emulated, otherwise returns false. |
239 | */ |
240 | static inline bool ubi_dbg_is_bitflip(const struct ubi_device *ubi) |
241 | { |
242 | if (ubi_dbg_bitflip(ubi)) |
243 | return true; |
244 | return ubi_dbg_fail_bitflip(ubi); |
245 | } |
246 | |
247 | /** |
248 | * ubi_dbg_is_write_failure - if it is time to emulate a write failure. |
249 | * @ubi: UBI device description object |
250 | * |
251 | * Returns true if a write failure should be emulated, otherwise returns |
252 | * false. |
253 | */ |
254 | static inline bool ubi_dbg_is_write_failure(const struct ubi_device *ubi) |
255 | { |
256 | if (ubi_dbg_write_failure(ubi)) |
257 | return true; |
258 | return ubi_dbg_fail_write(ubi); |
259 | } |
260 | |
261 | /** |
262 | * ubi_dbg_is_erase_failure - if its time to emulate an erase failure. |
263 | * @ubi: UBI device description object |
264 | * |
265 | * Returns true if an erase failure should be emulated, otherwise returns |
266 | * false. |
267 | */ |
268 | static inline bool ubi_dbg_is_erase_failure(const struct ubi_device *ubi) |
269 | { |
270 | if (ubi_dbg_erase_failure(ubi)) |
271 | return true; |
272 | return ubi_dbg_fail_erase(ubi); |
273 | } |
274 | |
275 | /** |
276 | * ubi_dbg_is_eccerr - if it is time to emulate ECC error. |
277 | * @ubi: UBI device description object |
278 | * |
279 | * Returns true if a ECC error should be emulated, otherwise returns false. |
280 | */ |
281 | static inline bool ubi_dbg_is_eccerr(const struct ubi_device *ubi) |
282 | { |
283 | return ubi_dbg_fail_eccerr(ubi); |
284 | } |
285 | |
286 | /** |
287 | * ubi_dbg_is_read_failure - if it is time to emulate a read failure. |
288 | * @ubi: UBI device description object |
289 | * |
290 | * Returns true if a read failure should be emulated, otherwise returns |
291 | * false. |
292 | */ |
293 | static inline bool ubi_dbg_is_read_failure(const struct ubi_device *ubi, |
294 | unsigned int caller) |
295 | { |
296 | return ubi_dbg_fail_read(ubi, caller); |
297 | } |
298 | |
299 | /** |
300 | * ubi_dbg_is_ff - if it is time to emulate that read region is only 0xFF. |
301 | * @ubi: UBI device description object |
302 | * |
303 | * Returns true if read region should be emulated 0xFF, otherwise |
304 | * returns false. |
305 | */ |
306 | static inline bool ubi_dbg_is_ff(const struct ubi_device *ubi, |
307 | unsigned int caller) |
308 | { |
309 | return ubi_dbg_fail_ff(ubi, caller); |
310 | } |
311 | |
312 | /** |
313 | * ubi_dbg_is_ff_bitflips - if it is time to emulate that read region is only 0xFF |
314 | * with error reported by the MTD driver |
315 | * |
316 | * @ubi: UBI device description object |
317 | * |
318 | * Returns true if read region should be emulated 0xFF and error |
319 | * reported by the MTD driver, otherwise returns false. |
320 | */ |
321 | static inline bool ubi_dbg_is_ff_bitflips(const struct ubi_device *ubi, |
322 | unsigned int caller) |
323 | { |
324 | return ubi_dbg_fail_ff_bitflips(ubi, caller); |
325 | } |
326 | |
327 | /** |
328 | * ubi_dbg_is_bad_hdr - if it is time to emulate a bad header |
329 | * @ubi: UBI device description object |
330 | * |
331 | * Returns true if a bad header error should be emulated, otherwise |
332 | * returns false. |
333 | */ |
334 | static inline bool ubi_dbg_is_bad_hdr(const struct ubi_device *ubi, |
335 | unsigned int caller) |
336 | { |
337 | return ubi_dbg_fail_bad_hdr(ubi, caller); |
338 | } |
339 | |
340 | /** |
341 | * ubi_dbg_is_bad_hdr_ebadmsg - if it is time to emulate a bad header with |
342 | * ECC error. |
343 | * |
344 | * @ubi: UBI device description object |
345 | * |
346 | * Returns true if a bad header with ECC error should be emulated, otherwise |
347 | * returns false. |
348 | */ |
349 | static inline bool ubi_dbg_is_bad_hdr_ebadmsg(const struct ubi_device *ubi, |
350 | unsigned int caller) |
351 | { |
352 | return ubi_dbg_fail_bad_hdr_ebadmsg(ubi, caller); |
353 | } |
354 | |
355 | /** |
356 | * ubi_dbg_is_bgt_disabled - if the background thread is disabled. |
357 | * @ubi: UBI device description object |
358 | * |
359 | * Returns non-zero if the UBI background thread is disabled for testing |
360 | * purposes. |
361 | */ |
362 | static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi) |
363 | { |
364 | return ubi->dbg.disable_bgt; |
365 | } |
366 | |
367 | static inline int ubi_dbg_chk_io(const struct ubi_device *ubi) |
368 | { |
369 | return ubi->dbg.chk_io; |
370 | } |
371 | |
372 | static inline int ubi_dbg_chk_gen(const struct ubi_device *ubi) |
373 | { |
374 | return ubi->dbg.chk_gen; |
375 | } |
376 | |
377 | static inline int ubi_dbg_chk_fastmap(const struct ubi_device *ubi) |
378 | { |
379 | return ubi->dbg.chk_fastmap; |
380 | } |
381 | |
382 | static inline void ubi_enable_dbg_chk_fastmap(struct ubi_device *ubi) |
383 | { |
384 | ubi->dbg.chk_fastmap = 1; |
385 | } |
386 | |
387 | #endif /* !__UBI_DEBUG_H__ */ |
388 | |