fs/jffs2/debug.c

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