projects/linux·blob master · refs

387 lines · 11.2 KiB

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
11void ubi_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);
12void ubi_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);
13void 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
43void ubi_dump_vol_info(const struct ubi_volume *vol);
44void ubi_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx);
45void ubi_dump_av(const struct ubi_ainf_volume *av);
46void ubi_dump_aeb(const struct ubi_ainf_peb *aeb, int type);
47void ubi_dump_mkvol_req(const struct ubi_mkvol_req *req);
48int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset,
49 int len);
50int ubi_debugfs_init(void);
51void ubi_debugfs_exit(void);
52int ubi_debugfs_init_dev(struct ubi_device *ubi);
53void 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 */
60int ubi_dbg_power_cut(struct ubi_device *ubi, int caller);
61
62static 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
69static 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
76static 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
119extern bool should_fail_eccerr(void);
120extern bool should_fail_bitflips(void);
121extern bool should_fail_read_failure(void);
122extern bool should_fail_write_failure(void);
123extern bool should_fail_erase_failure(void);
124extern bool should_fail_power_cut(void);
125extern bool should_fail_io_ff(void);
126extern bool should_fail_io_ff_bitflips(void);
127extern bool should_fail_bad_hdr(void);
128extern bool should_fail_bad_hdr_ebadmsg(void);
129
130static 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
137static 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
144static 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
151static 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
159static 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
167static 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
174static 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
182static 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
190static 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
198static 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 */
226static 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 */
240static 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 */
254static 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 */
268static 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 */
281static 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 */
293static 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 */
306static 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 */
321static 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 */
334static 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 */
349static 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 */
362static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi)
363{
364 return ubi->dbg.disable_bgt;
365}
366
367static inline int ubi_dbg_chk_io(const struct ubi_device *ubi)
368{
369 return ubi->dbg.chk_io;
370}
371
372static inline int ubi_dbg_chk_gen(const struct ubi_device *ubi)
373{
374 return ubi->dbg.chk_gen;
375}
376
377static inline int ubi_dbg_chk_fastmap(const struct ubi_device *ubi)
378{
379 return ubi->dbg.chk_fastmap;
380}
381
382static 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__ */