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__ */ 388