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