1 /* 2 * This file is part of UBIFS. 3 * 4 * Copyright (C) 2006-2008 Nokia Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 as published by 8 * the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 * You should have received a copy of the GNU General Public License along with 16 * this program; if not, write to the Free Software Foundation, Inc., 51 17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 * 19 * Authors: Artem Bityutskiy (Битюцкий Артём) 20 * Adrian Hunter 21 */ 22 23 #ifndef __UBIFS_DEBUG_H__ 24 #define __UBIFS_DEBUG_H__ 25 26 #ifdef CONFIG_UBIFS_FS_DEBUG 27 28 #define UBIFS_DBG(op) op 29 30 #define ubifs_assert(expr) do { \ 31 if (unlikely(!(expr))) { \ 32 printk(KERN_CRIT "UBIFS assert failed in %s at %u (pid %d)\n", \ 33 __func__, __LINE__, current->pid); \ 34 dbg_dump_stack(); \ 35 } \ 36 } while (0) 37 38 #define ubifs_assert_cmt_locked(c) do { \ 39 if (unlikely(down_write_trylock(&(c)->commit_sem))) { \ 40 up_write(&(c)->commit_sem); \ 41 printk(KERN_CRIT "commit lock is not locked!\n"); \ 42 ubifs_assert(0); \ 43 } \ 44 } while (0) 45 46 #define dbg_dump_stack() do { \ 47 if (!dbg_failure_mode) \ 48 dump_stack(); \ 49 } while (0) 50 51 /* Generic debugging messages */ 52 #define dbg_msg(fmt, ...) do { \ 53 spin_lock(&dbg_lock); \ 54 printk(KERN_DEBUG "UBIFS DBG (pid %d): %s: " fmt "\n", current->pid, \ 55 __func__, ##__VA_ARGS__); \ 56 spin_unlock(&dbg_lock); \ 57 } while (0) 58 59 #define dbg_do_msg(typ, fmt, ...) do { \ 60 if (ubifs_msg_flags & typ) \ 61 dbg_msg(fmt, ##__VA_ARGS__); \ 62 } while (0) 63 64 #define dbg_err(fmt, ...) do { \ 65 spin_lock(&dbg_lock); \ 66 ubifs_err(fmt, ##__VA_ARGS__); \ 67 spin_unlock(&dbg_lock); \ 68 } while (0) 69 70 const char *dbg_key_str0(const struct ubifs_info *c, 71 const union ubifs_key *key); 72 const char *dbg_key_str1(const struct ubifs_info *c, 73 const union ubifs_key *key); 74 75 /* 76 * DBGKEY macros require dbg_lock to be held, which it is in the dbg message 77 * macros. 78 */ 79 #define DBGKEY(key) dbg_key_str0(c, (key)) 80 #define DBGKEY1(key) dbg_key_str1(c, (key)) 81 82 /* General messages */ 83 #define dbg_gen(fmt, ...) dbg_do_msg(UBIFS_MSG_GEN, fmt, ##__VA_ARGS__) 84 85 /* Additional journal messages */ 86 #define dbg_jnl(fmt, ...) dbg_do_msg(UBIFS_MSG_JNL, fmt, ##__VA_ARGS__) 87 88 /* Additional TNC messages */ 89 #define dbg_tnc(fmt, ...) dbg_do_msg(UBIFS_MSG_TNC, fmt, ##__VA_ARGS__) 90 91 /* Additional lprops messages */ 92 #define dbg_lp(fmt, ...) dbg_do_msg(UBIFS_MSG_LP, fmt, ##__VA_ARGS__) 93 94 /* Additional LEB find messages */ 95 #define dbg_find(fmt, ...) dbg_do_msg(UBIFS_MSG_FIND, fmt, ##__VA_ARGS__) 96 97 /* Additional mount messages */ 98 #define dbg_mnt(fmt, ...) dbg_do_msg(UBIFS_MSG_MNT, fmt, ##__VA_ARGS__) 99 100 /* Additional I/O messages */ 101 #define dbg_io(fmt, ...) dbg_do_msg(UBIFS_MSG_IO, fmt, ##__VA_ARGS__) 102 103 /* Additional commit messages */ 104 #define dbg_cmt(fmt, ...) dbg_do_msg(UBIFS_MSG_CMT, fmt, ##__VA_ARGS__) 105 106 /* Additional budgeting messages */ 107 #define dbg_budg(fmt, ...) dbg_do_msg(UBIFS_MSG_BUDG, fmt, ##__VA_ARGS__) 108 109 /* Additional log messages */ 110 #define dbg_log(fmt, ...) dbg_do_msg(UBIFS_MSG_LOG, fmt, ##__VA_ARGS__) 111 112 /* Additional gc messages */ 113 #define dbg_gc(fmt, ...) dbg_do_msg(UBIFS_MSG_GC, fmt, ##__VA_ARGS__) 114 115 /* Additional scan messages */ 116 #define dbg_scan(fmt, ...) dbg_do_msg(UBIFS_MSG_SCAN, fmt, ##__VA_ARGS__) 117 118 /* Additional recovery messages */ 119 #define dbg_rcvry(fmt, ...) dbg_do_msg(UBIFS_MSG_RCVRY, fmt, ##__VA_ARGS__) 120 121 /* 122 * Debugging message type flags (must match msg_type_names in debug.c). 123 * 124 * UBIFS_MSG_GEN: general messages 125 * UBIFS_MSG_JNL: journal messages 126 * UBIFS_MSG_MNT: mount messages 127 * UBIFS_MSG_CMT: commit messages 128 * UBIFS_MSG_FIND: LEB find messages 129 * UBIFS_MSG_BUDG: budgeting messages 130 * UBIFS_MSG_GC: garbage collection messages 131 * UBIFS_MSG_TNC: TNC messages 132 * UBIFS_MSG_LP: lprops messages 133 * UBIFS_MSG_IO: I/O messages 134 * UBIFS_MSG_LOG: log messages 135 * UBIFS_MSG_SCAN: scan messages 136 * UBIFS_MSG_RCVRY: recovery messages 137 */ 138 enum { 139 UBIFS_MSG_GEN = 0x1, 140 UBIFS_MSG_JNL = 0x2, 141 UBIFS_MSG_MNT = 0x4, 142 UBIFS_MSG_CMT = 0x8, 143 UBIFS_MSG_FIND = 0x10, 144 UBIFS_MSG_BUDG = 0x20, 145 UBIFS_MSG_GC = 0x40, 146 UBIFS_MSG_TNC = 0x80, 147 UBIFS_MSG_LP = 0x100, 148 UBIFS_MSG_IO = 0x200, 149 UBIFS_MSG_LOG = 0x400, 150 UBIFS_MSG_SCAN = 0x800, 151 UBIFS_MSG_RCVRY = 0x1000, 152 }; 153 154 /* Debugging message type flags for each default debug message level */ 155 #define UBIFS_MSG_LVL_0 0 156 #define UBIFS_MSG_LVL_1 0x1 157 #define UBIFS_MSG_LVL_2 0x7f 158 #define UBIFS_MSG_LVL_3 0xffff 159 160 /* 161 * Debugging check flags (must match chk_names in debug.c). 162 * 163 * UBIFS_CHK_GEN: general checks 164 * UBIFS_CHK_TNC: check TNC 165 * UBIFS_CHK_IDX_SZ: check index size 166 * UBIFS_CHK_ORPH: check orphans 167 * UBIFS_CHK_OLD_IDX: check the old index 168 * UBIFS_CHK_LPROPS: check lprops 169 * UBIFS_CHK_FS: check the file-system 170 */ 171 enum { 172 UBIFS_CHK_GEN = 0x1, 173 UBIFS_CHK_TNC = 0x2, 174 UBIFS_CHK_IDX_SZ = 0x4, 175 UBIFS_CHK_ORPH = 0x8, 176 UBIFS_CHK_OLD_IDX = 0x10, 177 UBIFS_CHK_LPROPS = 0x20, 178 UBIFS_CHK_FS = 0x40, 179 }; 180 181 /* 182 * Special testing flags (must match tst_names in debug.c). 183 * 184 * UBIFS_TST_FORCE_IN_THE_GAPS: force the use of in-the-gaps method 185 * UBIFS_TST_RCVRY: failure mode for recovery testing 186 */ 187 enum { 188 UBIFS_TST_FORCE_IN_THE_GAPS = 0x2, 189 UBIFS_TST_RCVRY = 0x4, 190 }; 191 192 #if CONFIG_UBIFS_FS_DEBUG_MSG_LVL == 1 193 #define UBIFS_MSG_FLAGS_DEFAULT UBIFS_MSG_LVL_1 194 #elif CONFIG_UBIFS_FS_DEBUG_MSG_LVL == 2 195 #define UBIFS_MSG_FLAGS_DEFAULT UBIFS_MSG_LVL_2 196 #elif CONFIG_UBIFS_FS_DEBUG_MSG_LVL == 3 197 #define UBIFS_MSG_FLAGS_DEFAULT UBIFS_MSG_LVL_3 198 #else 199 #define UBIFS_MSG_FLAGS_DEFAULT UBIFS_MSG_LVL_0 200 #endif 201 202 #ifdef CONFIG_UBIFS_FS_DEBUG_CHKS 203 #define UBIFS_CHK_FLAGS_DEFAULT 0xffffffff 204 #else 205 #define UBIFS_CHK_FLAGS_DEFAULT 0 206 #endif 207 208 extern spinlock_t dbg_lock; 209 210 extern unsigned int ubifs_msg_flags; 211 extern unsigned int ubifs_chk_flags; 212 extern unsigned int ubifs_tst_flags; 213 214 /* Dump functions */ 215 216 const char *dbg_ntype(int type); 217 const char *dbg_cstate(int cmt_state); 218 const char *dbg_get_key_dump(const struct ubifs_info *c, 219 const union ubifs_key *key); 220 void dbg_dump_inode(const struct ubifs_info *c, const struct inode *inode); 221 void dbg_dump_node(const struct ubifs_info *c, const void *node); 222 void dbg_dump_budget_req(const struct ubifs_budget_req *req); 223 void dbg_dump_lstats(const struct ubifs_lp_stats *lst); 224 void dbg_dump_budg(struct ubifs_info *c); 225 void dbg_dump_lprop(const struct ubifs_info *c, const struct ubifs_lprops *lp); 226 void dbg_dump_lprops(struct ubifs_info *c); 227 void dbg_dump_leb(const struct ubifs_info *c, int lnum); 228 void dbg_dump_znode(const struct ubifs_info *c, 229 const struct ubifs_znode *znode); 230 void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat); 231 void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode, 232 struct ubifs_nnode *parent, int iip); 233 void dbg_dump_tnc(struct ubifs_info *c); 234 void dbg_dump_index(struct ubifs_info *c); 235 236 /* Checking helper functions */ 237 238 typedef int (*dbg_leaf_callback)(struct ubifs_info *c, 239 struct ubifs_zbranch *zbr, void *priv); 240 typedef int (*dbg_znode_callback)(struct ubifs_info *c, 241 struct ubifs_znode *znode, void *priv); 242 243 int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb, 244 dbg_znode_callback znode_cb, void *priv); 245 246 /* Checking functions */ 247 248 int dbg_check_lprops(struct ubifs_info *c); 249 250 int dbg_old_index_check_init(struct ubifs_info *c, struct ubifs_zbranch *zroot); 251 int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot); 252 253 int dbg_check_cats(struct ubifs_info *c); 254 255 int dbg_check_ltab(struct ubifs_info *c); 256 257 int dbg_check_synced_i_size(struct inode *inode); 258 259 int dbg_check_dir_size(struct ubifs_info *c, const struct inode *dir); 260 261 int dbg_check_tnc(struct ubifs_info *c, int extra); 262 263 int dbg_check_idx_size(struct ubifs_info *c, long long idx_size); 264 265 int dbg_check_filesystem(struct ubifs_info *c); 266 267 void dbg_check_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat, 268 int add_pos); 269 270 int dbg_check_lprops(struct ubifs_info *c); 271 int dbg_check_lpt_nodes(struct ubifs_info *c, struct ubifs_cnode *cnode, 272 int row, int col); 273 274 /* Force the use of in-the-gaps method for testing */ 275 276 #define dbg_force_in_the_gaps_enabled \ 277 (ubifs_tst_flags & UBIFS_TST_FORCE_IN_THE_GAPS) 278 279 int dbg_force_in_the_gaps(void); 280 281 /* Failure mode for recovery testing */ 282 283 #define dbg_failure_mode (ubifs_tst_flags & UBIFS_TST_RCVRY) 284 285 void dbg_failure_mode_registration(struct ubifs_info *c); 286 void dbg_failure_mode_deregistration(struct ubifs_info *c); 287 288 #ifndef UBIFS_DBG_PRESERVE_UBI 289 290 #define ubi_leb_read dbg_leb_read 291 #define ubi_leb_write dbg_leb_write 292 #define ubi_leb_change dbg_leb_change 293 #define ubi_leb_erase dbg_leb_erase 294 #define ubi_leb_unmap dbg_leb_unmap 295 #define ubi_is_mapped dbg_is_mapped 296 #define ubi_leb_map dbg_leb_map 297 298 #endif 299 300 int dbg_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset, 301 int len, int check); 302 int dbg_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf, 303 int offset, int len, int dtype); 304 int dbg_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf, 305 int len, int dtype); 306 int dbg_leb_erase(struct ubi_volume_desc *desc, int lnum); 307 int dbg_leb_unmap(struct ubi_volume_desc *desc, int lnum); 308 int dbg_is_mapped(struct ubi_volume_desc *desc, int lnum); 309 int dbg_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype); 310 311 static inline int dbg_read(struct ubi_volume_desc *desc, int lnum, char *buf, 312 int offset, int len) 313 { 314 return dbg_leb_read(desc, lnum, buf, offset, len, 0); 315 } 316 317 static inline int dbg_write(struct ubi_volume_desc *desc, int lnum, 318 const void *buf, int offset, int len) 319 { 320 return dbg_leb_write(desc, lnum, buf, offset, len, UBI_UNKNOWN); 321 } 322 323 static inline int dbg_change(struct ubi_volume_desc *desc, int lnum, 324 const void *buf, int len) 325 { 326 return dbg_leb_change(desc, lnum, buf, len, UBI_UNKNOWN); 327 } 328 329 #else /* !CONFIG_UBIFS_FS_DEBUG */ 330 331 #define UBIFS_DBG(op) 332 #define ubifs_assert(expr) ({}) 333 #define ubifs_assert_cmt_locked(c) 334 #define dbg_dump_stack() 335 #define dbg_err(fmt, ...) ({}) 336 #define dbg_msg(fmt, ...) ({}) 337 #define dbg_key(c, key, fmt, ...) ({}) 338 339 #define dbg_gen(fmt, ...) ({}) 340 #define dbg_jnl(fmt, ...) ({}) 341 #define dbg_tnc(fmt, ...) ({}) 342 #define dbg_lp(fmt, ...) ({}) 343 #define dbg_find(fmt, ...) ({}) 344 #define dbg_mnt(fmt, ...) ({}) 345 #define dbg_io(fmt, ...) ({}) 346 #define dbg_cmt(fmt, ...) ({}) 347 #define dbg_budg(fmt, ...) ({}) 348 #define dbg_log(fmt, ...) ({}) 349 #define dbg_gc(fmt, ...) ({}) 350 #define dbg_scan(fmt, ...) ({}) 351 #define dbg_rcvry(fmt, ...) ({}) 352 353 #define dbg_ntype(type) "" 354 #define dbg_cstate(cmt_state) "" 355 #define dbg_get_key_dump(c, key) ({}) 356 #define dbg_dump_inode(c, inode) ({}) 357 #define dbg_dump_node(c, node) ({}) 358 #define dbg_dump_budget_req(req) ({}) 359 #define dbg_dump_lstats(lst) ({}) 360 #define dbg_dump_budg(c) ({}) 361 #define dbg_dump_lprop(c, lp) ({}) 362 #define dbg_dump_lprops(c) ({}) 363 #define dbg_dump_leb(c, lnum) ({}) 364 #define dbg_dump_znode(c, znode) ({}) 365 #define dbg_dump_heap(c, heap, cat) ({}) 366 #define dbg_dump_pnode(c, pnode, parent, iip) ({}) 367 #define dbg_dump_tnc(c) ({}) 368 #define dbg_dump_index(c) ({}) 369 370 #define dbg_walk_index(c, leaf_cb, znode_cb, priv) 0 371 372 #define dbg_old_index_check_init(c, zroot) 0 373 #define dbg_check_old_index(c, zroot) 0 374 375 #define dbg_check_cats(c) 0 376 377 #define dbg_check_ltab(c) 0 378 379 #define dbg_check_synced_i_size(inode) 0 380 381 #define dbg_check_dir_size(c, dir) 0 382 383 #define dbg_check_tnc(c, x) 0 384 385 #define dbg_check_idx_size(c, idx_size) 0 386 387 #define dbg_check_filesystem(c) 0 388 389 #define dbg_check_heap(c, heap, cat, add_pos) ({}) 390 391 #define dbg_check_lprops(c) 0 392 #define dbg_check_lpt_nodes(c, cnode, row, col) 0 393 394 #define dbg_force_in_the_gaps_enabled 0 395 #define dbg_force_in_the_gaps() 0 396 397 #define dbg_failure_mode 0 398 #define dbg_failure_mode_registration(c) ({}) 399 #define dbg_failure_mode_deregistration(c) ({}) 400 401 #endif /* !CONFIG_UBIFS_FS_DEBUG */ 402 403 #endif /* !__UBIFS_DEBUG_H__ */ 404