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_checking_list, list) { 250 nr_counted++; 251 erasing += c->sector_size; 252 } 253 list_for_each_entry(jeb, &c->erase_complete_list, list) { 254 nr_counted++; 255 erasing += c->sector_size; 256 } 257 list_for_each_entry(jeb, &c->bad_list, list) { 258 nr_counted++; 259 bad += c->sector_size; 260 } 261 262 #define check(sz) \ 263 if (sz != c->sz##_size) { \ 264 printk(KERN_WARNING #sz "_size mismatch counted 0x%x, c->" #sz "_size 0x%x\n", \ 265 sz, c->sz##_size); \ 266 dump = 1; \ 267 } 268 check(free); 269 check(dirty); 270 check(used); 271 check(wasted); 272 check(unchecked); 273 check(bad); 274 check(erasing); 275 #undef check 276 277 if (nr_counted != c->nr_blocks) { 278 printk(KERN_WARNING "%s counted only 0x%x blocks of 0x%x. Where are the others?\n", 279 __func__, nr_counted, c->nr_blocks); 280 dump = 1; 281 } 282 283 if (dump) { 284 __jffs2_dbg_dump_block_lists_nolock(c); 285 BUG(); 286 } 287 } 288 289 /* 290 * Check the space accounting and node_ref list correctness for the JFFS2 erasable block 'jeb'. 291 */ 292 void 293 __jffs2_dbg_acct_paranoia_check(struct jffs2_sb_info *c, 294 struct jffs2_eraseblock *jeb) 295 { 296 spin_lock(&c->erase_completion_lock); 297 __jffs2_dbg_acct_paranoia_check_nolock(c, jeb); 298 spin_unlock(&c->erase_completion_lock); 299 } 300 301 void 302 __jffs2_dbg_acct_paranoia_check_nolock(struct jffs2_sb_info *c, 303 struct jffs2_eraseblock *jeb) 304 { 305 uint32_t my_used_size = 0; 306 uint32_t my_unchecked_size = 0; 307 uint32_t my_dirty_size = 0; 308 struct jffs2_raw_node_ref *ref2 = jeb->first_node; 309 310 while (ref2) { 311 uint32_t totlen = ref_totlen(c, jeb, ref2); 312 313 if (ref_offset(ref2) < jeb->offset || 314 ref_offset(ref2) > jeb->offset + c->sector_size) { 315 JFFS2_ERROR("node_ref %#08x shouldn't be in block at %#08x.\n", 316 ref_offset(ref2), jeb->offset); 317 goto error; 318 319 } 320 if (ref_flags(ref2) == REF_UNCHECKED) 321 my_unchecked_size += totlen; 322 else if (!ref_obsolete(ref2)) 323 my_used_size += totlen; 324 else 325 my_dirty_size += totlen; 326 327 if ((!ref_next(ref2)) != (ref2 == jeb->last_node)) { 328 JFFS2_ERROR("node_ref for node at %#08x (mem %p) has next at %#08x (mem %p), last_node is at %#08x (mem %p).\n", 329 ref_offset(ref2), ref2, ref_offset(ref_next(ref2)), ref_next(ref2), 330 ref_offset(jeb->last_node), jeb->last_node); 331 goto error; 332 } 333 ref2 = ref_next(ref2); 334 } 335 336 if (my_used_size != jeb->used_size) { 337 JFFS2_ERROR("Calculated used size %#08x != stored used size %#08x.\n", 338 my_used_size, jeb->used_size); 339 goto error; 340 } 341 342 if (my_unchecked_size != jeb->unchecked_size) { 343 JFFS2_ERROR("Calculated unchecked size %#08x != stored unchecked size %#08x.\n", 344 my_unchecked_size, jeb->unchecked_size); 345 goto error; 346 } 347 348 #if 0 349 /* This should work when we implement ref->__totlen elemination */ 350 if (my_dirty_size != jeb->dirty_size + jeb->wasted_size) { 351 JFFS2_ERROR("Calculated dirty+wasted size %#08x != stored dirty + wasted size %#08x\n", 352 my_dirty_size, jeb->dirty_size + jeb->wasted_size); 353 goto error; 354 } 355 356 if (jeb->free_size == 0 357 && my_used_size + my_unchecked_size + my_dirty_size != c->sector_size) { 358 JFFS2_ERROR("The sum of all nodes in block (%#x) != size of block (%#x)\n", 359 my_used_size + my_unchecked_size + my_dirty_size, 360 c->sector_size); 361 goto error; 362 } 363 #endif 364 365 if (!(c->flags & (JFFS2_SB_FLAG_BUILDING|JFFS2_SB_FLAG_SCANNING))) 366 __jffs2_dbg_superblock_counts(c); 367 368 return; 369 370 error: 371 __jffs2_dbg_dump_node_refs_nolock(c, jeb); 372 __jffs2_dbg_dump_jeb_nolock(jeb); 373 __jffs2_dbg_dump_block_lists_nolock(c); 374 BUG(); 375 376 } 377 #endif /* JFFS2_DBG_PARANOIA_CHECKS */ 378 379 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS) 380 /* 381 * Dump the node_refs of the 'jeb' JFFS2 eraseblock. 382 */ 383 void 384 __jffs2_dbg_dump_node_refs(struct jffs2_sb_info *c, 385 struct jffs2_eraseblock *jeb) 386 { 387 spin_lock(&c->erase_completion_lock); 388 __jffs2_dbg_dump_node_refs_nolock(c, jeb); 389 spin_unlock(&c->erase_completion_lock); 390 } 391 392 void 393 __jffs2_dbg_dump_node_refs_nolock(struct jffs2_sb_info *c, 394 struct jffs2_eraseblock *jeb) 395 { 396 struct jffs2_raw_node_ref *ref; 397 int i = 0; 398 399 printk(JFFS2_DBG_MSG_PREFIX " Dump node_refs of the eraseblock %#08x\n", jeb->offset); 400 if (!jeb->first_node) { 401 printk(JFFS2_DBG_MSG_PREFIX " no nodes in the eraseblock %#08x\n", jeb->offset); 402 return; 403 } 404 405 printk(JFFS2_DBG); 406 for (ref = jeb->first_node; ; ref = ref_next(ref)) { 407 printk("%#08x", ref_offset(ref)); 408 #ifdef TEST_TOTLEN 409 printk("(%x)", ref->__totlen); 410 #endif 411 if (ref_next(ref)) 412 printk("->"); 413 else 414 break; 415 if (++i == 4) { 416 i = 0; 417 printk("\n" JFFS2_DBG); 418 } 419 } 420 printk("\n"); 421 } 422 423 /* 424 * Dump an eraseblock's space accounting. 425 */ 426 void 427 __jffs2_dbg_dump_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) 428 { 429 spin_lock(&c->erase_completion_lock); 430 __jffs2_dbg_dump_jeb_nolock(jeb); 431 spin_unlock(&c->erase_completion_lock); 432 } 433 434 void 435 __jffs2_dbg_dump_jeb_nolock(struct jffs2_eraseblock *jeb) 436 { 437 if (!jeb) 438 return; 439 440 printk(JFFS2_DBG_MSG_PREFIX " dump space accounting for the eraseblock at %#08x:\n", 441 jeb->offset); 442 443 printk(JFFS2_DBG "used_size: %#08x\n", jeb->used_size); 444 printk(JFFS2_DBG "dirty_size: %#08x\n", jeb->dirty_size); 445 printk(JFFS2_DBG "wasted_size: %#08x\n", jeb->wasted_size); 446 printk(JFFS2_DBG "unchecked_size: %#08x\n", jeb->unchecked_size); 447 printk(JFFS2_DBG "free_size: %#08x\n", jeb->free_size); 448 } 449 450 void 451 __jffs2_dbg_dump_block_lists(struct jffs2_sb_info *c) 452 { 453 spin_lock(&c->erase_completion_lock); 454 __jffs2_dbg_dump_block_lists_nolock(c); 455 spin_unlock(&c->erase_completion_lock); 456 } 457 458 void 459 __jffs2_dbg_dump_block_lists_nolock(struct jffs2_sb_info *c) 460 { 461 printk(JFFS2_DBG_MSG_PREFIX " dump JFFS2 blocks lists:\n"); 462 463 printk(JFFS2_DBG "flash_size: %#08x\n", c->flash_size); 464 printk(JFFS2_DBG "used_size: %#08x\n", c->used_size); 465 printk(JFFS2_DBG "dirty_size: %#08x\n", c->dirty_size); 466 printk(JFFS2_DBG "wasted_size: %#08x\n", c->wasted_size); 467 printk(JFFS2_DBG "unchecked_size: %#08x\n", c->unchecked_size); 468 printk(JFFS2_DBG "free_size: %#08x\n", c->free_size); 469 printk(JFFS2_DBG "erasing_size: %#08x\n", c->erasing_size); 470 printk(JFFS2_DBG "bad_size: %#08x\n", c->bad_size); 471 printk(JFFS2_DBG "sector_size: %#08x\n", c->sector_size); 472 printk(JFFS2_DBG "jffs2_reserved_blocks size: %#08x\n", 473 c->sector_size * c->resv_blocks_write); 474 475 if (c->nextblock) 476 printk(JFFS2_DBG "nextblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 477 c->nextblock->offset, c->nextblock->used_size, 478 c->nextblock->dirty_size, c->nextblock->wasted_size, 479 c->nextblock->unchecked_size, c->nextblock->free_size); 480 else 481 printk(JFFS2_DBG "nextblock: NULL\n"); 482 483 if (c->gcblock) 484 printk(JFFS2_DBG "gcblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 485 c->gcblock->offset, c->gcblock->used_size, c->gcblock->dirty_size, 486 c->gcblock->wasted_size, c->gcblock->unchecked_size, c->gcblock->free_size); 487 else 488 printk(JFFS2_DBG "gcblock: NULL\n"); 489 490 if (list_empty(&c->clean_list)) { 491 printk(JFFS2_DBG "clean_list: empty\n"); 492 } else { 493 struct list_head *this; 494 int numblocks = 0; 495 uint32_t dirty = 0; 496 497 list_for_each(this, &c->clean_list) { 498 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 499 numblocks ++; 500 dirty += jeb->wasted_size; 501 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 502 printk(JFFS2_DBG "clean_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 503 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 504 jeb->unchecked_size, jeb->free_size); 505 } 506 } 507 508 printk (JFFS2_DBG "Contains %d blocks with total wasted size %u, average wasted size: %u\n", 509 numblocks, dirty, dirty / numblocks); 510 } 511 512 if (list_empty(&c->very_dirty_list)) { 513 printk(JFFS2_DBG "very_dirty_list: empty\n"); 514 } else { 515 struct list_head *this; 516 int numblocks = 0; 517 uint32_t dirty = 0; 518 519 list_for_each(this, &c->very_dirty_list) { 520 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 521 522 numblocks ++; 523 dirty += jeb->dirty_size; 524 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 525 printk(JFFS2_DBG "very_dirty_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 526 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 527 jeb->unchecked_size, jeb->free_size); 528 } 529 } 530 531 printk (JFFS2_DBG "Contains %d blocks with total dirty size %u, average dirty size: %u\n", 532 numblocks, dirty, dirty / numblocks); 533 } 534 535 if (list_empty(&c->dirty_list)) { 536 printk(JFFS2_DBG "dirty_list: empty\n"); 537 } else { 538 struct list_head *this; 539 int numblocks = 0; 540 uint32_t dirty = 0; 541 542 list_for_each(this, &c->dirty_list) { 543 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 544 545 numblocks ++; 546 dirty += jeb->dirty_size; 547 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 548 printk(JFFS2_DBG "dirty_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 549 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 550 jeb->unchecked_size, jeb->free_size); 551 } 552 } 553 554 printk (JFFS2_DBG "contains %d blocks with total dirty size %u, average dirty size: %u\n", 555 numblocks, dirty, dirty / numblocks); 556 } 557 558 if (list_empty(&c->erasable_list)) { 559 printk(JFFS2_DBG "erasable_list: empty\n"); 560 } else { 561 struct list_head *this; 562 563 list_for_each(this, &c->erasable_list) { 564 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 565 566 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 567 printk(JFFS2_DBG "erasable_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 568 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 569 jeb->unchecked_size, jeb->free_size); 570 } 571 } 572 } 573 574 if (list_empty(&c->erasing_list)) { 575 printk(JFFS2_DBG "erasing_list: empty\n"); 576 } else { 577 struct list_head *this; 578 579 list_for_each(this, &c->erasing_list) { 580 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 581 582 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 583 printk(JFFS2_DBG "erasing_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 584 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 585 jeb->unchecked_size, jeb->free_size); 586 } 587 } 588 } 589 if (list_empty(&c->erase_checking_list)) { 590 printk(JFFS2_DBG "erase_checking_list: empty\n"); 591 } else { 592 struct list_head *this; 593 594 list_for_each(this, &c->erase_checking_list) { 595 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 596 597 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 598 printk(JFFS2_DBG "erase_checking_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 599 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 600 jeb->unchecked_size, jeb->free_size); 601 } 602 } 603 } 604 605 if (list_empty(&c->erase_pending_list)) { 606 printk(JFFS2_DBG "erase_pending_list: empty\n"); 607 } else { 608 struct list_head *this; 609 610 list_for_each(this, &c->erase_pending_list) { 611 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 612 613 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 614 printk(JFFS2_DBG "erase_pending_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 615 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 616 jeb->unchecked_size, jeb->free_size); 617 } 618 } 619 } 620 621 if (list_empty(&c->erasable_pending_wbuf_list)) { 622 printk(JFFS2_DBG "erasable_pending_wbuf_list: empty\n"); 623 } else { 624 struct list_head *this; 625 626 list_for_each(this, &c->erasable_pending_wbuf_list) { 627 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 628 629 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 630 printk(JFFS2_DBG "erasable_pending_wbuf_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 631 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 632 jeb->unchecked_size, jeb->free_size); 633 } 634 } 635 } 636 637 if (list_empty(&c->free_list)) { 638 printk(JFFS2_DBG "free_list: empty\n"); 639 } else { 640 struct list_head *this; 641 642 list_for_each(this, &c->free_list) { 643 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 644 645 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 646 printk(JFFS2_DBG "free_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 647 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 648 jeb->unchecked_size, jeb->free_size); 649 } 650 } 651 } 652 653 if (list_empty(&c->bad_list)) { 654 printk(JFFS2_DBG "bad_list: empty\n"); 655 } else { 656 struct list_head *this; 657 658 list_for_each(this, &c->bad_list) { 659 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 660 661 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 662 printk(JFFS2_DBG "bad_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 663 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 664 jeb->unchecked_size, jeb->free_size); 665 } 666 } 667 } 668 669 if (list_empty(&c->bad_used_list)) { 670 printk(JFFS2_DBG "bad_used_list: empty\n"); 671 } else { 672 struct list_head *this; 673 674 list_for_each(this, &c->bad_used_list) { 675 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); 676 677 if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) { 678 printk(JFFS2_DBG "bad_used_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n", 679 jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size, 680 jeb->unchecked_size, jeb->free_size); 681 } 682 } 683 } 684 } 685 686 void 687 __jffs2_dbg_dump_fragtree(struct jffs2_inode_info *f) 688 { 689 mutex_lock(&f->sem); 690 jffs2_dbg_dump_fragtree_nolock(f); 691 mutex_unlock(&f->sem); 692 } 693 694 void 695 __jffs2_dbg_dump_fragtree_nolock(struct jffs2_inode_info *f) 696 { 697 struct jffs2_node_frag *this = frag_first(&f->fragtree); 698 uint32_t lastofs = 0; 699 int buggy = 0; 700 701 printk(JFFS2_DBG_MSG_PREFIX " dump fragtree of ino #%u\n", f->inocache->ino); 702 while(this) { 703 if (this->node) 704 printk(JFFS2_DBG "frag %#04x-%#04x: %#08x(%d) on flash (*%p), left (%p), right (%p), parent (%p)\n", 705 this->ofs, this->ofs+this->size, ref_offset(this->node->raw), 706 ref_flags(this->node->raw), this, frag_left(this), frag_right(this), 707 frag_parent(this)); 708 else 709 printk(JFFS2_DBG "frag %#04x-%#04x: hole (*%p). left (%p), right (%p), parent (%p)\n", 710 this->ofs, this->ofs+this->size, this, frag_left(this), 711 frag_right(this), frag_parent(this)); 712 if (this->ofs != lastofs) 713 buggy = 1; 714 lastofs = this->ofs + this->size; 715 this = frag_next(this); 716 } 717 718 if (f->metadata) 719 printk(JFFS2_DBG "metadata at 0x%08x\n", ref_offset(f->metadata->raw)); 720 721 if (buggy) { 722 JFFS2_ERROR("frag tree got a hole in it.\n"); 723 BUG(); 724 } 725 } 726 727 #define JFFS2_BUFDUMP_BYTES_PER_LINE 32 728 void 729 __jffs2_dbg_dump_buffer(unsigned char *buf, int len, uint32_t offs) 730 { 731 int skip; 732 int i; 733 734 printk(JFFS2_DBG_MSG_PREFIX " dump from offset %#08x to offset %#08x (%x bytes).\n", 735 offs, offs + len, len); 736 i = skip = offs % JFFS2_BUFDUMP_BYTES_PER_LINE; 737 offs = offs & ~(JFFS2_BUFDUMP_BYTES_PER_LINE - 1); 738 739 if (skip != 0) 740 printk(JFFS2_DBG "%#08x: ", offs); 741 742 while (skip--) 743 printk(" "); 744 745 while (i < len) { 746 if ((i % JFFS2_BUFDUMP_BYTES_PER_LINE) == 0 && i != len -1) { 747 if (i != 0) 748 printk("\n"); 749 offs += JFFS2_BUFDUMP_BYTES_PER_LINE; 750 printk(JFFS2_DBG "%0#8x: ", offs); 751 } 752 753 printk("%02x ", buf[i]); 754 755 i += 1; 756 } 757 758 printk("\n"); 759 } 760 761 /* 762 * Dump a JFFS2 node. 763 */ 764 void 765 __jffs2_dbg_dump_node(struct jffs2_sb_info *c, uint32_t ofs) 766 { 767 union jffs2_node_union node; 768 int len = sizeof(union jffs2_node_union); 769 size_t retlen; 770 uint32_t crc; 771 int ret; 772 773 printk(JFFS2_DBG_MSG_PREFIX " dump node at offset %#08x.\n", ofs); 774 775 ret = jffs2_flash_read(c, ofs, len, &retlen, (unsigned char *)&node); 776 if (ret || (retlen != len)) { 777 JFFS2_ERROR("read %d bytes failed or short. ret %d, retlen %zd.\n", 778 len, ret, retlen); 779 return; 780 } 781 782 printk(JFFS2_DBG "magic:\t%#04x\n", je16_to_cpu(node.u.magic)); 783 printk(JFFS2_DBG "nodetype:\t%#04x\n", je16_to_cpu(node.u.nodetype)); 784 printk(JFFS2_DBG "totlen:\t%#08x\n", je32_to_cpu(node.u.totlen)); 785 printk(JFFS2_DBG "hdr_crc:\t%#08x\n", je32_to_cpu(node.u.hdr_crc)); 786 787 crc = crc32(0, &node.u, sizeof(node.u) - 4); 788 if (crc != je32_to_cpu(node.u.hdr_crc)) { 789 JFFS2_ERROR("wrong common header CRC.\n"); 790 return; 791 } 792 793 if (je16_to_cpu(node.u.magic) != JFFS2_MAGIC_BITMASK && 794 je16_to_cpu(node.u.magic) != JFFS2_OLD_MAGIC_BITMASK) 795 { 796 JFFS2_ERROR("wrong node magic: %#04x instead of %#04x.\n", 797 je16_to_cpu(node.u.magic), JFFS2_MAGIC_BITMASK); 798 return; 799 } 800 801 switch(je16_to_cpu(node.u.nodetype)) { 802 803 case JFFS2_NODETYPE_INODE: 804 805 printk(JFFS2_DBG "the node is inode node\n"); 806 printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.i.ino)); 807 printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.i.version)); 808 printk(JFFS2_DBG "mode:\t%#08x\n", node.i.mode.m); 809 printk(JFFS2_DBG "uid:\t%#04x\n", je16_to_cpu(node.i.uid)); 810 printk(JFFS2_DBG "gid:\t%#04x\n", je16_to_cpu(node.i.gid)); 811 printk(JFFS2_DBG "isize:\t%#08x\n", je32_to_cpu(node.i.isize)); 812 printk(JFFS2_DBG "atime:\t%#08x\n", je32_to_cpu(node.i.atime)); 813 printk(JFFS2_DBG "mtime:\t%#08x\n", je32_to_cpu(node.i.mtime)); 814 printk(JFFS2_DBG "ctime:\t%#08x\n", je32_to_cpu(node.i.ctime)); 815 printk(JFFS2_DBG "offset:\t%#08x\n", je32_to_cpu(node.i.offset)); 816 printk(JFFS2_DBG "csize:\t%#08x\n", je32_to_cpu(node.i.csize)); 817 printk(JFFS2_DBG "dsize:\t%#08x\n", je32_to_cpu(node.i.dsize)); 818 printk(JFFS2_DBG "compr:\t%#02x\n", node.i.compr); 819 printk(JFFS2_DBG "usercompr:\t%#02x\n", node.i.usercompr); 820 printk(JFFS2_DBG "flags:\t%#04x\n", je16_to_cpu(node.i.flags)); 821 printk(JFFS2_DBG "data_crc:\t%#08x\n", je32_to_cpu(node.i.data_crc)); 822 printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.i.node_crc)); 823 824 crc = crc32(0, &node.i, sizeof(node.i) - 8); 825 if (crc != je32_to_cpu(node.i.node_crc)) { 826 JFFS2_ERROR("wrong node header CRC.\n"); 827 return; 828 } 829 break; 830 831 case JFFS2_NODETYPE_DIRENT: 832 833 printk(JFFS2_DBG "the node is dirent node\n"); 834 printk(JFFS2_DBG "pino:\t%#08x\n", je32_to_cpu(node.d.pino)); 835 printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.d.version)); 836 printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.d.ino)); 837 printk(JFFS2_DBG "mctime:\t%#08x\n", je32_to_cpu(node.d.mctime)); 838 printk(JFFS2_DBG "nsize:\t%#02x\n", node.d.nsize); 839 printk(JFFS2_DBG "type:\t%#02x\n", node.d.type); 840 printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.d.node_crc)); 841 printk(JFFS2_DBG "name_crc:\t%#08x\n", je32_to_cpu(node.d.name_crc)); 842 843 node.d.name[node.d.nsize] = '\0'; 844 printk(JFFS2_DBG "name:\t\"%s\"\n", node.d.name); 845 846 crc = crc32(0, &node.d, sizeof(node.d) - 8); 847 if (crc != je32_to_cpu(node.d.node_crc)) { 848 JFFS2_ERROR("wrong node header CRC.\n"); 849 return; 850 } 851 break; 852 853 default: 854 printk(JFFS2_DBG "node type is unknown\n"); 855 break; 856 } 857 } 858 #endif /* JFFS2_DBG_DUMPS || JFFS2_DBG_PARANOIA_CHECKS */ 859