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(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(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(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