xref: /linux/drivers/mtd/ubi/debug.h (revision 06d07429858317ded2db7986113a9e0129cd599b)
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 
ubi_dbg_bitflip(const struct ubi_device * ubi)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(200);
66 	return 0;
67 }
68 
ubi_dbg_write_failure(const struct ubi_device * ubi)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(500);
73 	return 0;
74 }
75 
ubi_dbg_erase_failure(const struct ubi_device * ubi)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(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 
ubi_dbg_fail_bitflip(const struct ubi_device * ubi)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 
ubi_dbg_fail_write(const struct ubi_device * ubi)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 
ubi_dbg_fail_erase(const struct ubi_device * ubi)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 
ubi_dbg_fail_power_cut(const struct ubi_device * ubi,unsigned int caller)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 
ubi_dbg_fail_read(const struct ubi_device * ubi,unsigned int caller)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 
ubi_dbg_fail_eccerr(const struct ubi_device * ubi)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 
ubi_dbg_fail_ff(const struct ubi_device * ubi,unsigned int caller)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 
ubi_dbg_fail_ff_bitflips(const struct ubi_device * ubi,unsigned int caller)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 
ubi_dbg_fail_bad_hdr(const struct ubi_device * ubi,unsigned int caller)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 
ubi_dbg_fail_bad_hdr_ebadmsg(const struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_power_cut(struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_bitflip(const struct ubi_device * ubi)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  */
ubi_dbg_is_write_failure(const struct ubi_device * ubi)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  */
ubi_dbg_is_erase_failure(const struct ubi_device * ubi)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  */
ubi_dbg_is_eccerr(const struct ubi_device * ubi)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  */
ubi_dbg_is_read_failure(const struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_ff(const struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_ff_bitflips(const struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_bad_hdr(const struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_bad_hdr_ebadmsg(const struct ubi_device * ubi,unsigned int caller)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  */
ubi_dbg_is_bgt_disabled(const struct ubi_device * ubi)362 static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi)
363 {
364 	return ubi->dbg.disable_bgt;
365 }
366 
ubi_dbg_chk_io(const struct ubi_device * ubi)367 static inline int ubi_dbg_chk_io(const struct ubi_device *ubi)
368 {
369 	return ubi->dbg.chk_io;
370 }
371 
ubi_dbg_chk_gen(const struct ubi_device * ubi)372 static inline int ubi_dbg_chk_gen(const struct ubi_device *ubi)
373 {
374 	return ubi->dbg.chk_gen;
375 }
376 
ubi_dbg_chk_fastmap(const struct ubi_device * ubi)377 static inline int ubi_dbg_chk_fastmap(const struct ubi_device *ubi)
378 {
379 	return ubi->dbg.chk_fastmap;
380 }
381 
ubi_enable_dbg_chk_fastmap(struct ubi_device * ubi)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