Loading...
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__ */
1/*
2 * Copyright (c) International Business Machines Corp., 2006
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12 * the GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Author: Artem Bityutskiy (Битюцкий Артём)
19 */
20
21#ifndef __UBI_DEBUG_H__
22#define __UBI_DEBUG_H__
23
24#ifdef CONFIG_MTD_UBI_DEBUG
25#include <linux/random.h>
26
27#define ubi_assert(expr) do { \
28 if (unlikely(!(expr))) { \
29 printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
30 __func__, __LINE__, current->pid); \
31 ubi_dbg_dump_stack(); \
32 } \
33} while (0)
34
35#define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)
36
37#define ubi_dbg_dump_stack() dump_stack()
38
39#define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a) \
40 print_hex_dump(l, ps, pt, r, g, b, len, a)
41
42#define ubi_dbg_msg(type, fmt, ...) \
43 pr_debug("UBI DBG " type ": " fmt "\n", ##__VA_ARGS__)
44
45/* Just a debugging messages not related to any specific UBI subsystem */
46#define dbg_msg(fmt, ...) ubi_dbg_msg("msg", fmt, ##__VA_ARGS__)
47/* General debugging messages */
48#define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__)
49/* Messages from the eraseblock association sub-system */
50#define dbg_eba(fmt, ...) ubi_dbg_msg("eba", fmt, ##__VA_ARGS__)
51/* Messages from the wear-leveling sub-system */
52#define dbg_wl(fmt, ...) ubi_dbg_msg("wl", fmt, ##__VA_ARGS__)
53/* Messages from the input/output sub-system */
54#define dbg_io(fmt, ...) ubi_dbg_msg("io", fmt, ##__VA_ARGS__)
55/* Initialization and build messages */
56#define dbg_bld(fmt, ...) ubi_dbg_msg("bld", fmt, ##__VA_ARGS__)
57
58void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);
59void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr);
60void ubi_dbg_dump_vol_info(const struct ubi_volume *vol);
61void ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx);
62void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv);
63void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type);
64void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);
65void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len);
66int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len);
67int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum,
68 int offset, int len);
69int ubi_debugging_init_dev(struct ubi_device *ubi);
70void ubi_debugging_exit_dev(struct ubi_device *ubi);
71int ubi_debugfs_init(void);
72void ubi_debugfs_exit(void);
73int ubi_debugfs_init_dev(struct ubi_device *ubi);
74void ubi_debugfs_exit_dev(struct ubi_device *ubi);
75
76/*
77 * The UBI debugfs directory name pattern and maximum name length (3 for "ubi"
78 * + 2 for the number plus 1 for the trailing zero byte.
79 */
80#define UBI_DFS_DIR_NAME "ubi%d"
81#define UBI_DFS_DIR_LEN (3 + 2 + 1)
82
83/**
84 * struct ubi_debug_info - debugging information for an UBI device.
85 *
86 * @chk_gen: if UBI general extra checks are enabled
87 * @chk_io: if UBI I/O extra checks are enabled
88 * @disable_bgt: disable the background task for testing purposes
89 * @emulate_bitflips: emulate bit-flips for testing purposes
90 * @emulate_io_failures: emulate write/erase failures for testing purposes
91 * @dfs_dir_name: name of debugfs directory containing files of this UBI device
92 * @dfs_dir: direntry object of the UBI device debugfs directory
93 * @dfs_chk_gen: debugfs knob to enable UBI general extra checks
94 * @dfs_chk_io: debugfs knob to enable UBI I/O extra checks
95 * @dfs_disable_bgt: debugfs knob to disable the background task
96 * @dfs_emulate_bitflips: debugfs knob to emulate bit-flips
97 * @dfs_emulate_io_failures: debugfs knob to emulate write/erase failures
98 */
99struct ubi_debug_info {
100 unsigned int chk_gen:1;
101 unsigned int chk_io:1;
102 unsigned int disable_bgt:1;
103 unsigned int emulate_bitflips:1;
104 unsigned int emulate_io_failures:1;
105 char dfs_dir_name[UBI_DFS_DIR_LEN + 1];
106 struct dentry *dfs_dir;
107 struct dentry *dfs_chk_gen;
108 struct dentry *dfs_chk_io;
109 struct dentry *dfs_disable_bgt;
110 struct dentry *dfs_emulate_bitflips;
111 struct dentry *dfs_emulate_io_failures;
112};
113
114/**
115 * ubi_dbg_is_bgt_disabled - if the background thread is disabled.
116 * @ubi: UBI device description object
117 *
118 * Returns non-zero if the UBI background thread is disabled for testing
119 * purposes.
120 */
121static inline int ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi)
122{
123 return ubi->dbg->disable_bgt;
124}
125
126/**
127 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.
128 * @ubi: UBI device description object
129 *
130 * Returns non-zero if a bit-flip should be emulated, otherwise returns zero.
131 */
132static inline int ubi_dbg_is_bitflip(const struct ubi_device *ubi)
133{
134 if (ubi->dbg->emulate_bitflips)
135 return !(random32() % 200);
136 return 0;
137}
138
139/**
140 * ubi_dbg_is_write_failure - if it is time to emulate a write failure.
141 * @ubi: UBI device description object
142 *
143 * Returns non-zero if a write failure should be emulated, otherwise returns
144 * zero.
145 */
146static inline int ubi_dbg_is_write_failure(const struct ubi_device *ubi)
147{
148 if (ubi->dbg->emulate_io_failures)
149 return !(random32() % 500);
150 return 0;
151}
152
153/**
154 * ubi_dbg_is_erase_failure - if its time to emulate an erase failure.
155 * @ubi: UBI device description object
156 *
157 * Returns non-zero if an erase failure should be emulated, otherwise returns
158 * zero.
159 */
160static inline int ubi_dbg_is_erase_failure(const struct ubi_device *ubi)
161{
162 if (ubi->dbg->emulate_io_failures)
163 return !(random32() % 400);
164 return 0;
165}
166
167#else
168
169/* Use "if (0)" to make compiler check arguments even if debugging is off */
170#define ubi_assert(expr) do { \
171 if (0) { \
172 printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \
173 __func__, __LINE__, current->pid); \
174 } \
175} while (0)
176
177#define dbg_err(fmt, ...) do { \
178 if (0) \
179 ubi_err(fmt, ##__VA_ARGS__); \
180} while (0)
181
182#define ubi_dbg_msg(fmt, ...) do { \
183 if (0) \
184 printk(KERN_DEBUG fmt "\n", ##__VA_ARGS__); \
185} while (0)
186
187#define dbg_msg(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__)
188#define dbg_gen(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__)
189#define dbg_eba(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__)
190#define dbg_wl(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__)
191#define dbg_io(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__)
192#define dbg_bld(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__)
193
194static inline void ubi_dbg_dump_stack(void) { return; }
195static inline void
196ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr) { return; }
197static inline void
198ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr) { return; }
199static inline void
200ubi_dbg_dump_vol_info(const struct ubi_volume *vol) { return; }
201static inline void
202ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx) { return; }
203static inline void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv) { return; }
204static inline void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb,
205 int type) { return; }
206static inline void
207ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req) { return; }
208static inline void ubi_dbg_dump_flash(struct ubi_device *ubi,
209 int pnum, int offset, int len) { return; }
210static inline void
211ubi_dbg_print_hex_dump(const char *l, const char *ps, int pt, int r,
212 int g, const void *b, size_t len, bool a) { return; }
213static inline int ubi_dbg_check_all_ff(struct ubi_device *ubi,
214 int pnum, int offset,
215 int len) { return 0; }
216static inline int ubi_dbg_check_write(struct ubi_device *ubi,
217 const void *buf, int pnum,
218 int offset, int len) { return 0; }
219
220static inline int ubi_debugging_init_dev(struct ubi_device *ubi) { return 0; }
221static inline void ubi_debugging_exit_dev(struct ubi_device *ubi) { return; }
222static inline int ubi_debugfs_init(void) { return 0; }
223static inline void ubi_debugfs_exit(void) { return; }
224static inline int ubi_debugfs_init_dev(struct ubi_device *ubi) { return 0; }
225static inline void ubi_debugfs_exit_dev(struct ubi_device *ubi) { return; }
226
227static inline int
228ubi_dbg_is_bgt_disabled(const struct ubi_device *ubi) { return 0; }
229static inline int ubi_dbg_is_bitflip(const struct ubi_device *ubi) { return 0; }
230static inline int
231ubi_dbg_is_write_failure(const struct ubi_device *ubi) { return 0; }
232static inline int
233ubi_dbg_is_erase_failure(const struct ubi_device *ubi) { return 0; }
234
235#endif /* !CONFIG_MTD_UBI_DEBUG */
236#endif /* !__UBI_DEBUG_H__ */