1 /* 2 * JFFS2 -- Journalling Flash File System, Version 2. 3 * 4 * Copyright © 2001-2007 Red Hat, Inc. 5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 6 * 7 * Created by David Woodhouse <dwmw2@infradead.org> 8 * 9 * For licensing information, see the file 'LICENCE' in this directory. 10 * 11 */ 12 13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14 15 #include <linux/kernel.h> 16 #include <linux/types.h> 17 #include <linux/pagemap.h> 18 #include <linux/crc32.h> 19 #include <linux/jffs2.h> 20 #include <linux/mtd/mtd.h> 21 #include <linux/slab.h> 22 #include "nodelist.h" 23 #include "debug.h" 24 25 #ifdef JFFS2_DBG_SANITY_CHECKS 26 27 void 28 __jffs2_dbg_acct_sanity_check_nolock(struct jffs2_sb_info *c, 29 struct jffs2_eraseblock *jeb) 30 { 31 if (unlikely(jeb && jeb->used_size + jeb->dirty_size + 32 jeb->free_size + jeb->wasted_size + 33 jeb->unchecked_size != c->sector_size)) { 34 JFFS2_ERROR("eeep, space accounting for block at 0x%08x is screwed.\n", jeb->offset); 35 JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n", 36 jeb->free_size, jeb->dirty_size, jeb->used_size, 37 jeb->wasted_size, jeb->unchecked_size, c->sector_size); 38 BUG(); 39 } 40 41 if (unlikely(c->used_size + c->dirty_size + c->free_size + c->erasing_size + c->bad_size 42 + c->wasted_size + c->unchecked_size != c->flash_size)) { 43 JFFS2_ERROR("eeep, space accounting superblock info is screwed.\n"); 44 JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + erasing %#08x + bad %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n", 45 c->free_size, c->dirty_size, c->used_size, c->erasing_size, c->bad_size, 46 c->wasted_size, c->unchecked_size, c->flash_size); 47 BUG(); 48 } 49 } 50 51 void 52 __jffs2_dbg_acct_sanity_check(struct jffs2_sb_info *c, 53 struct jffs2_eraseblock *jeb) 54 { 55 spin_lock(&c->erase_completion_lock); 56 jffs2_dbg_acct_sanity_check_nolock(c, jeb); 57 spin_unlock(&c->erase_completion_lock); 58 } 59 60 #endif /* JFFS2_DBG_SANITY_CHECKS */ 61 62 #ifdef JFFS2_DBG_PARANOIA_CHECKS 63 /* 64 * Check the fragtree. 65 */ 66 void 67 __jffs2_dbg_fragtree_paranoia_check(struct jffs2_inode_info *f) 68 { 69 mutex_lock(&f->sem); 70 __jffs2_dbg_fragtree_paranoia_check_nolock(f); 71 mutex_unlock(&f->sem); 72 } 73 74 void 75 __jffs2_dbg_fragtree_paranoia_check_nolock(struct jffs2_inode_info *f) 76 { 77 struct jffs2_node_frag *frag; 78 int bitched = 0; 79 80 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) { 81 struct jffs2_full_dnode *fn = frag->node; 82 83 if (!fn || !fn->raw) 84 continue; 85 86 if (ref_flags(fn->raw) == REF_PRISTINE) { 87 if (fn->frags > 1) { 88 JFFS2_ERROR("REF_PRISTINE node at 0x%08x had %d frags. Tell dwmw2.\n", 89 ref_offset(fn->raw), fn->frags); 90 bitched = 1; 91 } 92 93 /* A hole node which isn't multi-page should be garbage-collected 94 and merged anyway, so we just check for the frag size here, 95 rather than mucking around with actually reading the node 96 and checking the compression type, which is the real way 97 to tell a hole node. */ 98 if (frag->ofs & (PAGE_SIZE-1) && frag_prev(frag) 99 && frag_prev(frag)->size < PAGE_SIZE && frag_prev(frag)->node) { 100 JFFS2_ERROR("REF_PRISTINE node at 0x%08x had a previous non-hole frag in the same page. Tell dwmw2.\n", 101 ref_offset(fn->raw)); 102 bitched = 1; 103 } 104 105 if ((frag->ofs+frag->size) & (PAGE_SIZE-1) && frag_next(frag) 106 && frag_next(frag)->size < PAGE_SIZE && frag_next(frag)->node) { 107 JFFS2_ERROR("REF_PRISTINE node at 0x%08x (%08x-%08x) had a following non-hole frag in the same page. Tell dwmw2.\n", 108 ref_offset(fn->raw), frag->ofs, frag->ofs+frag->size); 109 bitched = 1; 110 } 111 } 112 } 113 114 if (bitched) { 115 JFFS2_ERROR("fragtree is corrupted.\n"); 116 __jffs2_dbg_dump_fragtree_nolock(f); 117 BUG(); 118 } 119 } 120 121 /* 122 * Check if the flash contains all 0xFF before we start writing. 123 */ 124 void 125 __jffs2_dbg_prewrite_paranoia_check(struct jffs2_sb_info *c, 126 uint32_t ofs, int len) 127 { 128 size_t retlen; 129 int ret, i; 130 unsigned char *buf; 131 132 buf = kmalloc(len, GFP_KERNEL); 133 if (!buf) 134 return; 135 136 ret = jffs2_flash_read(c, ofs, len, &retlen, buf); 137 if (ret || (retlen != len)) { 138 JFFS2_WARNING("read %d bytes failed or short. ret %d, retlen %zd.\n", 139 len, ret, retlen); 140 kfree(buf); 141 return; 142 } 143 144 ret = 0; 145 for (i = 0; i < len; i++) 146 if (buf[i] != 0xff) 147 ret = 1; 148 149 if (ret) { 150 JFFS2_ERROR("argh, about to write node to %#08x on flash, but there are data already there. The first corrupted byte is at %#08x offset.\n", 151 ofs, ofs + i); 152 __jffs2_dbg_dump_buffer(buf, len, ofs); 153 kfree(buf); 154 BUG(); 155 } 156 157 kfree(buf); 158 } 159 160 static void __jffs2_dbg_superblock_counts(struct jffs2_sb_info *c) 161 { 162 struct jffs2_eraseblock *jeb; 163 uint32_t free = 0, dirty = 0, used = 0, wasted = 0, 164 erasing = 0, bad = 0, unchecked = 0; 165 int nr_counted = 0; 166 int dump = 0; 167 168 if (c->gcblock) { 169 nr_counted++; 170 free += c->gcblock->free_size; 171 dirty += c->gcblock->dirty_size; 172 used += c->gcblock->used_size; 173 wasted += c->gcblock->wasted_size; 174 unchecked += c->gcblock->unchecked_size; 175 } 176 if (c->nextblock) { 177 nr_counted++; 178 free += c->nextblock->free_size; 179 dirty += c->nextblock->dirty_size; 180 used += c->nextblock->used_size; 181 wasted += c->nextblock->wasted_size; 182 unchecked += c->nextblock->unchecked_size; 183 } 184 list_for_each_entry(jeb, &c->clean_list, list) { 185 nr_counted++; 186 free += jeb->free_size; 187 dirty += jeb->dirty_size; 188 used += jeb->used_size; 189 wasted += jeb->wasted_size; 190 unchecked += jeb->unchecked_size; 191 } 192 list_for_each_entry(jeb, &c->very_dirty_list, list) { 193 nr_counted++; 194 free += jeb->free_size; 195 dirty += jeb->dirty_size; 196 used += jeb->used_size; 197 wasted += jeb->wasted_size; 198 unchecked += jeb->unchecked_size; 199 } 200 list_for_each_entry(jeb, &c->dirty_list, list) { 201 nr_counted++; 202 free += jeb->free_size; 203 dirty += jeb->dirty_size; 204 used += jeb->used_size; 205 wasted += jeb->wasted_size; 206 unchecked += jeb->unchecked_size; 207 } 208 list_for_each_entry(jeb, &c->erasable_list, list) { 209 nr_counted++; 210 free += jeb->free_size; 211 dirty += jeb->dirty_size; 212 used += jeb->used_size; 213 wasted += jeb->wasted_size; 214 unchecked += jeb->unchecked_size; 215 } 216 list_for_each_entry(jeb, &c->erasable_pending_wbuf_list, list) { 217 nr_counted++; 218 free += jeb->free_size; 219 dirty += jeb->dirty_size; 220 used += jeb->used_size; 221 wasted += jeb->wasted_size; 222 unchecked += jeb->unchecked_size; 223 } 224 list_for_each_entry(jeb, &c->erase_pending_list, list) { 225 nr_counted++; 226 free += jeb->free_size; 227 dirty += jeb->dirty_size; 228 used += jeb->used_size; 229 wasted += jeb->wasted_size; 230 unchecked += jeb->unchecked_size; 231 } 232 list_for_each_entry(jeb, &c->free_list, list) { 233 nr_counted++; 234 free += jeb->free_size; 235 dirty += jeb->dirty_size; 236 used += jeb->used_size; 237 wasted += jeb->wasted_size; 238 unchecked += jeb->unchecked_size; 239 } 240 list_for_each_entry(jeb, &c->bad_used_list, list) { 241 nr_counted++; 242 free += jeb->free_size; 243 dirty += jeb->dirty_size; 244 used += jeb->used_size; 245 wasted += jeb->wasted_size; 246 unchecked += jeb->unchecked_size; 247 } 248 249 list_for_each_entry(jeb, &c->erasing_list, list) { 250 nr_counted++; 251 erasing += c->sector_size; 252 } 253 list_for_each_entry(jeb, &c->erase_checking_list, list) { 254 nr_counted++; 255 erasing += c->sector_size; 256 } 257 list_for_each_entry(jeb, &c->erase_complete_list, list) { 258 nr_counted++; 259 erasing += c->sector_size; 260 } 261 list_for_each_entry(jeb, &c->bad_list, list) { 262 nr_counted++; 263 bad += c->sector_size; 264 } 265 266 #define check(sz) \ 267 do { \ 268 if (sz != c->sz##_size) { \ 269 pr_warn("%s_size mismatch counted 0x%x, c->%s_size 0x%x\n", \ 270 #sz, sz, #sz, c->sz##_size); \ 271 dump = 1; \ 272 } \ 273 } while (0) 274 275 check(free); 276 check(dirty); 277 check(used); 278 check(wasted); 279 check(unchecked); 280 check(bad); 281 check(erasing); 282 283 #undef check 284 285 if (nr_counted != c->nr_blocks) { 286 pr_warn("%s counted only 0x%x blocks of 0x%x. Where are the others?\n", 287 __func__, nr_counted, c->nr_blocks); 288 dump = 1; 289 } 290 291 if (dump) { 292 __jffs2_dbg_dump_block_lists_nolock(c); 293 BUG(); 294 } 295 } 296 297 /* 298 * Check the space accounting and node_ref list correctness for the JFFS2 erasable block 'jeb'. 299 */ 300 void 301 __jffs2_dbg_acct_paranoia_check(struct jffs2_sb_info *c, 302 struct jffs2_eraseblock *jeb) 303 { 304 spin_lock(&c->erase_completion_lock); 305 __jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 306 spin_unlock(&c->erase_completion_lock); 307 } 308 309 void 310 __jffs2_dbg_acct_paranoia_check_nolock(struct jffs2_sb_info *c, 311 struct jffs2_eraseblock *jeb) 312 { 313 uint32_t my_used_size = 0; 314 uint32_t my_unchecked_size = 0; 315 uint32_t my_dirty_size = 0; 316 struct jffs2_raw_node_ref *ref2 = jeb->first_node; 317 318 while (ref2) { 319 uint32_t totlen = ref_totlen(c, jeb, ref2); 320 321 if (ref_offset(ref2) < jeb->offset || 322 ref_offset(ref2) > jeb->offset + c->sector_size) { 323 JFFS2_ERROR("node_ref %#08x shouldn't be in block at %#08x.\n", 324 ref_offset(ref2), jeb->offset); 325 goto error; 326 327 } 328 if (ref_flags(ref2) == REF_UNCHECKED) 329 my_unchecked_size += totlen; 330 else if (!ref_obsolete(ref2)) 331 my_used_size += totlen; 332 else 333 my_dirty_size += totlen; 334 335 if ((!ref_next(ref2)) != (ref2 == jeb->last_node)) { 336 JFFS2_ERROR("node_ref for node at %#08x (mem %p) has next at %#08x (mem %p), last_node is at %#08x (mem %p).\n", 337 ref_offset(ref2), ref2, ref_offset(ref_next(ref2)), ref_next(ref2), 338 ref_offset(jeb->last_node), jeb->last_node); 339 goto error; 340 } 341 ref2 = ref_next(ref2); 342 } 343 344 if (my_used_size != jeb->used_size) { 345 JFFS2_ERROR("Calculated used size %#08x != stored used size %#08x.\n", 346 my_used_size, jeb->used_size); 347 goto error; 348 } 349 350 if (my_unchecked_size != jeb->unchecked_size) { 351 JFFS2_ERROR("Calculated unchecked size %#08x != stored unchecked size %#08x.\n", 352 my_unchecked_size, jeb->unchecked_size); 353 goto error; 354 } 355 356 #if 0 357 /* This should work when we implement ref->__totlen elemination */ 358 if (my_dirty_size != jeb->dirty_size + jeb->wasted_size) { 359 JFFS2_ERROR("Calculated dirty+wasted size %#08x != stored dirty + wasted size %#08x\n", 360 my_dirty_size, jeb->dirty_size + jeb->wasted_size); 361 goto error; 362 } 363 364 if (jeb->free_size == 0 365 && my_used_size + my_unchecked_size + my_dirty_size != c->sector_size) { 366 JFFS2_ERROR("The sum of all nodes in block (%#x) != size of block (%#x)\n", 367 my_used_size + my_unchecked_size + my_dirty_size, 368 c->sector_size); 369 goto error; 370 } 371 #endif 372 373 if (!(c->flags & (JFFS2_SB_FLAG_BUILDING|JFFS2_SB_FLAG_SCANNING))) 374 __jffs2_dbg_superblock_counts(c); 375 376 return; 377 378 error: 379 __jffs2_dbg_dump_node_refs_nolock(c, jeb); 380 __jffs2_dbg_dump_jeb_nolock(jeb); 381 __jffs2_dbg_dump_block_lists_nolock(c); 382 BUG(); 383 384 } 385 #endif /* JFFS2_DBG_PARANOIA_CHECKS */ 386 387 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS) 388 /* 389 * Dump the node_refs of the 'jeb' JFFS2 eraseblock. 390 */ 391 void 392 __jffs2_dbg_dump_node_refs(struct jffs2_sb_info *c, 393 struct jffs2_eraseblock *jeb) 394 { 395 spin_lock(&c->erase_completion_lock); 396 __jffs2_dbg_dump_node_refs_nolock(c, jeb); 397 spin_unlock(&c->erase_completion_lock); 398 } 399 400 void 401 __jffs2_dbg_dump_node_refs_nolock(struct jffs2_sb_info *c, 402 struct jffs2_eraseblock *jeb) 403 { 404 struct jffs2_raw_node_ref *ref; 405 int i = 0; 406 407 printk(JFFS2_DBG_MSG_PREFIX " Dump node_refs of the eraseblock %#08x\n", jeb->offset); 408 if (!jeb->first_node) { 409 printk(JFFS2_DBG_MSG_PREFIX " no nodes in the eraseblock %#08x\n", jeb->offset); 410 return; 411 } 412 413 printk(JFFS2_DBG); 414 for (ref = jeb->first_node; ; ref = ref_next(ref)) { 415 printk("%#08x", ref_offset(ref)); 416 #ifdef TEST_TOTLEN 417 printk("(%x)", ref->__totlen); 418 #endif 419 if (ref_next(ref)) 420 printk("->"); 421 else 422 break; 423 if (++i == 4) { 424 i = 0; 425 printk("\n" JFFS2_DBG); 426 } 427 } 428 printk("\n"); 429 } 430 431 /* 432 * Dump an eraseblock's space accounting. 433 */ 434 void 435 __jffs2_dbg_dump_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 436 { 437 spin_lock(&c->erase_completion_lock); 438 __jffs2_dbg_dump_jeb_nolock(jeb); 439 spin_unlock(&c->erase_completion_lock); 440 } 441 442 void 443 __jffs2_dbg_dump_jeb_nolock(struct jffs2_eraseblock *jeb) 444 { 445 if (!jeb) 446 return; 447 448 printk(JFFS2_DBG_MSG_PREFIX " dump space accounting for the eraseblock at %#08x:\n", 449 jeb->offset); 450 451 printk(JFFS2_DBG "used_size: %#08x\n", jeb->used_size); 452 printk(JFFS2_DBG "dirty_size: %#08x\n", jeb->dirty_size); 453 printk(JFFS2_DBG "wasted_size: %#08x\n", jeb->wasted_size); 454 printk(JFFS2_DBG "unchecked_size: %#08x\n", jeb->unchecked_size); 455 printk(JFFS2_DBG "free_size: %#08x\n", jeb->free_size); 456 } 457 458 void 459 __jffs2_dbg_dump_block_lists(struct jffs2_sb_info *c) 460 { 461 spin_lock(&c->erase_completion_lock); 462 __jffs2_dbg_dump_block_lists_nolock(c); 463 spin_unlock(&c->erase_completion_lock); 464 } 465 466 void 467 __jffs2_dbg_dump_block_lists_nolock(struct jffs2_sb_info *c) 468 { 469 printk(JFFS2_DBG_MSG_PREFIX " dump JFFS2 blocks lists:\n"); 470 471 printk(JFFS2_DBG "flash_size: %#08x\n", c->flash_size); 472 printk(JFFS2_DBG "used_size: %#08x\n", c->used_size); 473 printk(JFFS2_DBG "dirty_size: %#08x\n", c->dirty_size); 474 printk(JFFS2_DBG "wasted_size: %#08x\n", c->wasted_size); 475 printk(JFFS2_DBG "unchecked_size: %#08x\n", c->unchecked_size); 476 printk(JFFS2_DBG "free_size: %#08x\n", c->free_size); 477 printk(JFFS2_DBG "erasing_size: %#08x\n", c->erasing_size); 478 printk(JFFS2_DBG "bad_size: %#08x\n", c->bad_size); 479 printk(JFFS2_DBG "sector_size: %#08x\n", c->sector_size); 480 printk(JFFS2_DBG "jffs2_reserved_blocks size: %#08x\n", 481 c->sector_size * c->resv_blocks_write); 482 483 if (c->nextblock) 484 printk(JFFS2_DBG "nextblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 485 c->nextblock->offset, c->nextblock->used_size, 486 c->nextblock->dirty_size, c->nextblock->wasted_size, 487 c->nextblock->unchecked_size, c->nextblock->free_size); 488 else 489 printk(JFFS2_DBG "nextblock: NULL\n"); 490 491 if (c->gcblock) 492 printk(JFFS2_DBG "gcblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 493 c->gcblock->offset, c->gcblock->used_size, c->gcblock->dirty_size, 494 c->gcblock->wasted_size, c->gcblock->unchecked_size, c->gcblock->free_size); 495 else 496 printk(JFFS2_DBG "gcblock: NULL\n"); 497 498 if (list_empty(&c->clean_list)) { 499 printk(JFFS2_DBG "clean_list: empty\n"); 500 } else { 501 struct list_head *this; 502 int numblocks = 0; 503 uint32_t dirty = 0; 504 505 list_for_each(this, &c->clean_list) { 506 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 507 numblocks ++; 508 dirty += jeb->wasted_size; 509 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 510 printk(JFFS2_DBG "clean_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 511 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 512 jeb->unchecked_size, jeb->free_size); 513 } 514 } 515 516 printk (JFFS2_DBG "Contains %d blocks with total wasted size %u, average wasted size: %u\n", 517 numblocks, dirty, dirty / numblocks); 518 } 519 520 if (list_empty(&c->very_dirty_list)) { 521 printk(JFFS2_DBG "very_dirty_list: empty\n"); 522 } else { 523 struct list_head *this; 524 int numblocks = 0; 525 uint32_t dirty = 0; 526 527 list_for_each(this, &c->very_dirty_list) { 528 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 529 530 numblocks ++; 531 dirty += jeb->dirty_size; 532 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 533 printk(JFFS2_DBG "very_dirty_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 534 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 535 jeb->unchecked_size, jeb->free_size); 536 } 537 } 538 539 printk (JFFS2_DBG "Contains %d blocks with total dirty size %u, average dirty size: %u\n", 540 numblocks, dirty, dirty / numblocks); 541 } 542 543 if (list_empty(&c->dirty_list)) { 544 printk(JFFS2_DBG "dirty_list: empty\n"); 545 } else { 546 struct list_head *this; 547 int numblocks = 0; 548 uint32_t dirty = 0; 549 550 list_for_each(this, &c->dirty_list) { 551 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 552 553 numblocks ++; 554 dirty += jeb->dirty_size; 555 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 556 printk(JFFS2_DBG "dirty_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 557 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 558 jeb->unchecked_size, jeb->free_size); 559 } 560 } 561 562 printk (JFFS2_DBG "contains %d blocks with total dirty size %u, average dirty size: %u\n", 563 numblocks, dirty, dirty / numblocks); 564 } 565 566 if (list_empty(&c->erasable_list)) { 567 printk(JFFS2_DBG "erasable_list: empty\n"); 568 } else { 569 struct list_head *this; 570 571 list_for_each(this, &c->erasable_list) { 572 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 573 574 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 575 printk(JFFS2_DBG "erasable_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 576 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 577 jeb->unchecked_size, jeb->free_size); 578 } 579 } 580 } 581 582 if (list_empty(&c->erasing_list)) { 583 printk(JFFS2_DBG "erasing_list: empty\n"); 584 } else { 585 struct list_head *this; 586 587 list_for_each(this, &c->erasing_list) { 588 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 589 590 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 591 printk(JFFS2_DBG "erasing_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 592 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 593 jeb->unchecked_size, jeb->free_size); 594 } 595 } 596 } 597 if (list_empty(&c->erase_checking_list)) { 598 printk(JFFS2_DBG "erase_checking_list: empty\n"); 599 } else { 600 struct list_head *this; 601 602 list_for_each(this, &c->erase_checking_list) { 603 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 604 605 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 606 printk(JFFS2_DBG "erase_checking_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 607 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 608 jeb->unchecked_size, jeb->free_size); 609 } 610 } 611 } 612 613 if (list_empty(&c->erase_pending_list)) { 614 printk(JFFS2_DBG "erase_pending_list: empty\n"); 615 } else { 616 struct list_head *this; 617 618 list_for_each(this, &c->erase_pending_list) { 619 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 620 621 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 622 printk(JFFS2_DBG "erase_pending_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 623 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 624 jeb->unchecked_size, jeb->free_size); 625 } 626 } 627 } 628 629 if (list_empty(&c->erasable_pending_wbuf_list)) { 630 printk(JFFS2_DBG "erasable_pending_wbuf_list: empty\n"); 631 } else { 632 struct list_head *this; 633 634 list_for_each(this, &c->erasable_pending_wbuf_list) { 635 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 636 637 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 638 printk(JFFS2_DBG "erasable_pending_wbuf_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 639 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 640 jeb->unchecked_size, jeb->free_size); 641 } 642 } 643 } 644 645 if (list_empty(&c->free_list)) { 646 printk(JFFS2_DBG "free_list: empty\n"); 647 } else { 648 struct list_head *this; 649 650 list_for_each(this, &c->free_list) { 651 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 652 653 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 654 printk(JFFS2_DBG "free_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 655 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 656 jeb->unchecked_size, jeb->free_size); 657 } 658 } 659 } 660 661 if (list_empty(&c->bad_list)) { 662 printk(JFFS2_DBG "bad_list: empty\n"); 663 } else { 664 struct list_head *this; 665 666 list_for_each(this, &c->bad_list) { 667 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 668 669 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 670 printk(JFFS2_DBG "bad_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 671 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 672 jeb->unchecked_size, jeb->free_size); 673 } 674 } 675 } 676 677 if (list_empty(&c->bad_used_list)) { 678 printk(JFFS2_DBG "bad_used_list: empty\n"); 679 } else { 680 struct list_head *this; 681 682 list_for_each(this, &c->bad_used_list) { 683 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 684 685 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 686 printk(JFFS2_DBG "bad_used_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 687 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 688 jeb->unchecked_size, jeb->free_size); 689 } 690 } 691 } 692 } 693 694 void 695 __jffs2_dbg_dump_fragtree(struct jffs2_inode_info *f) 696 { 697 mutex_lock(&f->sem); 698 jffs2_dbg_dump_fragtree_nolock(f); 699 mutex_unlock(&f->sem); 700 } 701 702 void 703 __jffs2_dbg_dump_fragtree_nolock(struct jffs2_inode_info *f) 704 { 705 struct jffs2_node_frag *this = frag_first(&f->fragtree); 706 uint32_t lastofs = 0; 707 int buggy = 0; 708 709 printk(JFFS2_DBG_MSG_PREFIX " dump fragtree of ino #%u\n", f->inocache->ino); 710 while(this) { 711 if (this->node) 712 printk(JFFS2_DBG "frag %#04x-%#04x: %#08x(%d) on flash (*%p), left (%p), right (%p), parent (%p)\n", 713 this->ofs, this->ofs+this->size, ref_offset(this->node->raw), 714 ref_flags(this->node->raw), this, frag_left(this), frag_right(this), 715 frag_parent(this)); 716 else 717 printk(JFFS2_DBG "frag %#04x-%#04x: hole (*%p). left (%p), right (%p), parent (%p)\n", 718 this->ofs, this->ofs+this->size, this, frag_left(this), 719 frag_right(this), frag_parent(this)); 720 if (this->ofs != lastofs) 721 buggy = 1; 722 lastofs = this->ofs + this->size; 723 this = frag_next(this); 724 } 725 726 if (f->metadata) 727 printk(JFFS2_DBG "metadata at 0x%08x\n", ref_offset(f->metadata->raw)); 728 729 if (buggy) { 730 JFFS2_ERROR("frag tree got a hole in it.\n"); 731 BUG(); 732 } 733 } 734 735 #define JFFS2_BUFDUMP_BYTES_PER_LINE 32 736 void 737 __jffs2_dbg_dump_buffer(unsigned char *buf, int len, uint32_t offs) 738 { 739 int skip; 740 int i; 741 742 printk(JFFS2_DBG_MSG_PREFIX " dump from offset %#08x to offset %#08x (%x bytes).\n", 743 offs, offs + len, len); 744 i = skip = offs % JFFS2_BUFDUMP_BYTES_PER_LINE; 745 offs = offs & ~(JFFS2_BUFDUMP_BYTES_PER_LINE - 1); 746 747 if (skip != 0) 748 printk(JFFS2_DBG "%#08x: ", offs); 749 750 while (skip--) 751 printk(" "); 752 753 while (i < len) { 754 if ((i % JFFS2_BUFDUMP_BYTES_PER_LINE) == 0 && i != len -1) { 755 if (i != 0) 756 printk("\n"); 757 offs += JFFS2_BUFDUMP_BYTES_PER_LINE; 758 printk(JFFS2_DBG "%0#8x: ", offs); 759 } 760 761 printk("%02x ", buf[i]); 762 763 i += 1; 764 } 765 766 printk("\n"); 767 } 768 769 /* 770 * Dump a JFFS2 node. 771 */ 772 void 773 __jffs2_dbg_dump_node(struct jffs2_sb_info *c, uint32_t ofs) 774 { 775 union jffs2_node_union node; 776 int len = sizeof(union jffs2_node_union); 777 size_t retlen; 778 uint32_t crc; 779 int ret; 780 781 printk(JFFS2_DBG_MSG_PREFIX " dump node at offset %#08x.\n", ofs); 782 783 ret = jffs2_flash_read(c, ofs, len, &retlen, (unsigned char *)&node); 784 if (ret || (retlen != len)) { 785 JFFS2_ERROR("read %d bytes failed or short. ret %d, retlen %zd.\n", 786 len, ret, retlen); 787 return; 788 } 789 790 printk(JFFS2_DBG "magic:\t%#04x\n", je16_to_cpu(node.u.magic)); 791 printk(JFFS2_DBG "nodetype:\t%#04x\n", je16_to_cpu(node.u.nodetype)); 792 printk(JFFS2_DBG "totlen:\t%#08x\n", je32_to_cpu(node.u.totlen)); 793 printk(JFFS2_DBG "hdr_crc:\t%#08x\n", je32_to_cpu(node.u.hdr_crc)); 794 795 crc = crc32(0, &node.u, sizeof(node.u) - 4); 796 if (crc != je32_to_cpu(node.u.hdr_crc)) { 797 JFFS2_ERROR("wrong common header CRC.\n"); 798 return; 799 } 800 801 if (je16_to_cpu(node.u.magic) != JFFS2_MAGIC_BITMASK && 802 je16_to_cpu(node.u.magic) != JFFS2_OLD_MAGIC_BITMASK) 803 { 804 JFFS2_ERROR("wrong node magic: %#04x instead of %#04x.\n", 805 je16_to_cpu(node.u.magic), JFFS2_MAGIC_BITMASK); 806 return; 807 } 808 809 switch(je16_to_cpu(node.u.nodetype)) { 810 811 case JFFS2_NODETYPE_INODE: 812 813 printk(JFFS2_DBG "the node is inode node\n"); 814 printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.i.ino)); 815 printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.i.version)); 816 printk(JFFS2_DBG "mode:\t%#08x\n", node.i.mode.m); 817 printk(JFFS2_DBG "uid:\t%#04x\n", je16_to_cpu(node.i.uid)); 818 printk(JFFS2_DBG "gid:\t%#04x\n", je16_to_cpu(node.i.gid)); 819 printk(JFFS2_DBG "isize:\t%#08x\n", je32_to_cpu(node.i.isize)); 820 printk(JFFS2_DBG "atime:\t%#08x\n", je32_to_cpu(node.i.atime)); 821 printk(JFFS2_DBG "mtime:\t%#08x\n", je32_to_cpu(node.i.mtime)); 822 printk(JFFS2_DBG "ctime:\t%#08x\n", je32_to_cpu(node.i.ctime)); 823 printk(JFFS2_DBG "offset:\t%#08x\n", je32_to_cpu(node.i.offset)); 824 printk(JFFS2_DBG "csize:\t%#08x\n", je32_to_cpu(node.i.csize)); 825 printk(JFFS2_DBG "dsize:\t%#08x\n", je32_to_cpu(node.i.dsize)); 826 printk(JFFS2_DBG "compr:\t%#02x\n", node.i.compr); 827 printk(JFFS2_DBG "usercompr:\t%#02x\n", node.i.usercompr); 828 printk(JFFS2_DBG "flags:\t%#04x\n", je16_to_cpu(node.i.flags)); 829 printk(JFFS2_DBG "data_crc:\t%#08x\n", je32_to_cpu(node.i.data_crc)); 830 printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.i.node_crc)); 831 832 crc = crc32(0, &node.i, sizeof(node.i) - 8); 833 if (crc != je32_to_cpu(node.i.node_crc)) { 834 JFFS2_ERROR("wrong node header CRC.\n"); 835 return; 836 } 837 break; 838 839 case JFFS2_NODETYPE_DIRENT: 840 841 printk(JFFS2_DBG "the node is dirent node\n"); 842 printk(JFFS2_DBG "pino:\t%#08x\n", je32_to_cpu(node.d.pino)); 843 printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.d.version)); 844 printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.d.ino)); 845 printk(JFFS2_DBG "mctime:\t%#08x\n", je32_to_cpu(node.d.mctime)); 846 printk(JFFS2_DBG "nsize:\t%#02x\n", node.d.nsize); 847 printk(JFFS2_DBG "type:\t%#02x\n", node.d.type); 848 printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.d.node_crc)); 849 printk(JFFS2_DBG "name_crc:\t%#08x\n", je32_to_cpu(node.d.name_crc)); 850 851 node.d.name[node.d.nsize] = '\0'; 852 printk(JFFS2_DBG "name:\t\"%s\"\n", node.d.name); 853 854 crc = crc32(0, &node.d, sizeof(node.d) - 8); 855 if (crc != je32_to_cpu(node.d.node_crc)) { 856 JFFS2_ERROR("wrong node header CRC.\n"); 857 return; 858 } 859 break; 860 861 default: 862 printk(JFFS2_DBG "node type is unknown\n"); 863 break; 864 } 865 } 866 #endif /* JFFS2_DBG_DUMPS || JFFS2_DBG_PARANOIA_CHECKS */ 867