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 struct ubi_ec_hdr; 25 struct ubi_vid_hdr; 26 struct ubi_volume; 27 struct ubi_vtbl_record; 28 struct ubi_scan_volume; 29 struct ubi_scan_leb; 30 struct ubi_mkvol_req; 31 32 #ifdef CONFIG_MTD_UBI_DEBUG 33 #include <linux/random.h> 34 35 #define ubi_assert(expr) do { \ 36 if (unlikely(!(expr))) { \ 37 printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \ 38 __func__, __LINE__, current->pid); \ 39 ubi_dbg_dump_stack(); \ 40 } \ 41 } while (0) 42 43 #define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__) 44 45 #define ubi_dbg_dump_stack() dump_stack() 46 47 #define ubi_dbg_print_hex_dump(l, ps, pt, r, g, b, len, a) \ 48 print_hex_dump(l, ps, pt, r, g, b, len, a) 49 50 #define ubi_dbg_msg(type, fmt, ...) \ 51 pr_debug("UBI DBG " type ": " fmt "\n", ##__VA_ARGS__) 52 53 /* Just a debugging messages not related to any specific UBI subsystem */ 54 #define dbg_msg(fmt, ...) ubi_dbg_msg("msg", fmt, ##__VA_ARGS__) 55 /* General debugging messages */ 56 #define dbg_gen(fmt, ...) ubi_dbg_msg("gen", fmt, ##__VA_ARGS__) 57 /* Messages from the eraseblock association sub-system */ 58 #define dbg_eba(fmt, ...) ubi_dbg_msg("eba", fmt, ##__VA_ARGS__) 59 /* Messages from the wear-leveling sub-system */ 60 #define dbg_wl(fmt, ...) ubi_dbg_msg("wl", fmt, ##__VA_ARGS__) 61 /* Messages from the input/output sub-system */ 62 #define dbg_io(fmt, ...) ubi_dbg_msg("io", fmt, ##__VA_ARGS__) 63 /* Initialization and build messages */ 64 #define dbg_bld(fmt, ...) ubi_dbg_msg("bld", fmt, ##__VA_ARGS__) 65 66 void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr); 67 void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr); 68 void ubi_dbg_dump_vol_info(const struct ubi_volume *vol); 69 void ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx); 70 void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv); 71 void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type); 72 void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req); 73 void ubi_dbg_dump_flash(struct ubi_device *ubi, int pnum, int offset, int len); 74 75 extern unsigned int ubi_chk_flags; 76 77 /* 78 * Debugging check flags. 79 * 80 * UBI_CHK_GEN: general checks 81 * UBI_CHK_IO: check writes and erases 82 */ 83 enum { 84 UBI_CHK_GEN = 0x1, 85 UBI_CHK_IO = 0x2, 86 }; 87 88 int ubi_dbg_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len); 89 int ubi_dbg_check_write(struct ubi_device *ubi, const void *buf, int pnum, 90 int offset, int len); 91 92 extern unsigned int ubi_tst_flags; 93 94 /* 95 * Special testing flags. 96 * 97 * UBIFS_TST_DISABLE_BGT: disable the background thread 98 * UBI_TST_EMULATE_BITFLIPS: emulate bit-flips 99 * UBI_TST_EMULATE_WRITE_FAILURES: emulate write failures 100 * UBI_TST_EMULATE_ERASE_FAILURES: emulate erase failures 101 */ 102 enum { 103 UBI_TST_DISABLE_BGT = 0x1, 104 UBI_TST_EMULATE_BITFLIPS = 0x2, 105 UBI_TST_EMULATE_WRITE_FAILURES = 0x4, 106 UBI_TST_EMULATE_ERASE_FAILURES = 0x8, 107 }; 108 109 /** 110 * ubi_dbg_is_bgt_disabled - if the background thread is disabled. 111 * 112 * Returns non-zero if the UBI background thread is disabled for testing 113 * purposes. 114 */ 115 static inline int ubi_dbg_is_bgt_disabled(void) 116 { 117 return ubi_tst_flags & UBI_TST_DISABLE_BGT; 118 } 119 120 /** 121 * ubi_dbg_is_bitflip - if it is time to emulate a bit-flip. 122 * 123 * Returns non-zero if a bit-flip should be emulated, otherwise returns zero. 124 */ 125 static inline int ubi_dbg_is_bitflip(void) 126 { 127 if (ubi_tst_flags & UBI_TST_EMULATE_BITFLIPS) 128 return !(random32() % 200); 129 return 0; 130 } 131 132 /** 133 * ubi_dbg_is_write_failure - if it is time to emulate a write failure. 134 * 135 * Returns non-zero if a write failure should be emulated, otherwise returns 136 * zero. 137 */ 138 static inline int ubi_dbg_is_write_failure(void) 139 { 140 if (ubi_tst_flags & UBI_TST_EMULATE_WRITE_FAILURES) 141 return !(random32() % 500); 142 return 0; 143 } 144 145 /** 146 * ubi_dbg_is_erase_failure - if its time to emulate an erase failure. 147 * 148 * Returns non-zero if an erase failure should be emulated, otherwise returns 149 * zero. 150 */ 151 static inline int ubi_dbg_is_erase_failure(void) 152 { 153 if (ubi_tst_flags & UBI_TST_EMULATE_ERASE_FAILURES) 154 return !(random32() % 400); 155 return 0; 156 } 157 158 #else 159 160 /* Use "if (0)" to make compiler check arguments even if debugging is off */ 161 #define ubi_assert(expr) do { \ 162 if (0) { \ 163 printk(KERN_CRIT "UBI assert failed in %s at %u (pid %d)\n", \ 164 __func__, __LINE__, current->pid); \ 165 } \ 166 } while (0) 167 168 #define dbg_err(fmt, ...) do { \ 169 if (0) \ 170 ubi_err(fmt, ##__VA_ARGS__); \ 171 } while (0) 172 173 #define ubi_dbg_msg(fmt, ...) do { \ 174 if (0) \ 175 pr_debug(fmt "\n", ##__VA_ARGS__); \ 176 } while (0) 177 178 #define dbg_msg(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__) 179 #define dbg_gen(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__) 180 #define dbg_eba(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__) 181 #define dbg_wl(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__) 182 #define dbg_io(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__) 183 #define dbg_bld(fmt, ...) ubi_dbg_msg(fmt, ##__VA_ARGS__) 184 185 static inline void ubi_dbg_dump_stack(void) { return; } 186 static inline void 187 ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr) { return; } 188 static inline void 189 ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr) { return; } 190 static inline void 191 ubi_dbg_dump_vol_info(const struct ubi_volume *vol) { return; } 192 static inline void 193 ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx) { return; } 194 static inline void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv) { return; } 195 static inline void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, 196 int type) { return; } 197 static inline void 198 ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req) { return; } 199 static inline void ubi_dbg_dump_flash(struct ubi_device *ubi, 200 int pnum, int offset, int len) { return; } 201 static inline void 202 ubi_dbg_print_hex_dump(const char *l, const char *ps, int pt, int r, 203 int g, const void *b, size_t len, bool a) { return; } 204 205 static inline int ubi_dbg_is_bgt_disabled(void) { return 0; } 206 static inline int ubi_dbg_is_bitflip(void) { return 0; } 207 static inline int ubi_dbg_is_write_failure(void) { return 0; } 208 static inline int ubi_dbg_is_erase_failure(void) { return 0; } 209 static inline int ubi_dbg_check_all_ff(struct ubi_device *ubi, 210 int pnum, int offset, 211 int len) { return 0; } 212 static inline int ubi_dbg_check_write(struct ubi_device *ubi, 213 const void *buf, int pnum, 214 int offset, int len) { return 0; } 215 216 #endif /* !CONFIG_MTD_UBI_DEBUG */ 217 #endif /* !__UBI_DEBUG_H__ */ 218