fs/jffs2/debug.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 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  * $Id: debug.c,v 1.12 2005/11/07 11:14:39 gleixner Exp $
  11  *
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/types.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/crc32.h>
  17 #include <linux/jffs2.h>
  18 #include <linux/mtd/mtd.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         down(&f->sem);
  67         __jffs2_dbg_fragtree_paranoia_check_nolock(f);
  68         up(&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 /*
 158  * Check the space accounting and node_ref list correctness for the JFFS2 erasable block 'jeb'.
 159  */
 160 void
 161 __jffs2_dbg_acct_paranoia_check(struct jffs2_sb_info *c,
 162                                 struct jffs2_eraseblock *jeb)
 163 {
 164         spin_lock(&c->erase_completion_lock);
 165         __jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 166         spin_unlock(&c->erase_completion_lock);
 167 }
 168
 169 void
 170 __jffs2_dbg_acct_paranoia_check_nolock(struct jffs2_sb_info *c,
 171                                        struct jffs2_eraseblock *jeb)
 172 {
 173         uint32_t my_used_size = 0;
 174         uint32_t my_unchecked_size = 0;
 175         uint32_t my_dirty_size = 0;
 176         struct jffs2_raw_node_ref *ref2 = jeb->first_node;
 177
 178         while (ref2) {
 179                 uint32_t totlen = ref_totlen(c, jeb, ref2);
 180
 181                 if (ref_offset(ref2) < jeb->offset ||
 182                                 ref_offset(ref2) > jeb->offset + c->sector_size) {
 183                         JFFS2_ERROR("node_ref %#08x shouldn't be in block at %#08x.\n",
 184                                 ref_offset(ref2), jeb->offset);
 185                         goto error;
 186
 187                 }
 188                 if (ref_flags(ref2) == REF_UNCHECKED)
 189                         my_unchecked_size += totlen;
 190                 else if (!ref_obsolete(ref2))
 191                         my_used_size += totlen;
 192                 else
 193                         my_dirty_size += totlen;
 194
 195                 if ((!ref_next(ref2)) != (ref2 == jeb->last_node)) {
 196                         JFFS2_ERROR("node_ref for node at %#08x (mem %p) has next at %#08x (mem %p), last_node is at %#08x (mem %p).\n",
 197                                     ref_offset(ref2), ref2, ref_offset(ref_next(ref2)), ref_next(ref2),
 198                                     ref_offset(jeb->last_node), jeb->last_node);
 199                         goto error;
 200                 }
 201                 ref2 = ref_next(ref2);
 202         }
 203
 204         if (my_used_size != jeb->used_size) {
 205                 JFFS2_ERROR("Calculated used size %#08x != stored used size %#08x.\n",
 206                         my_used_size, jeb->used_size);
 207                 goto error;
 208         }
 209
 210         if (my_unchecked_size != jeb->unchecked_size) {
 211                 JFFS2_ERROR("Calculated unchecked size %#08x != stored unchecked size %#08x.\n",
 212                         my_unchecked_size, jeb->unchecked_size);
 213                 goto error;
 214         }
 215
 216 #if 0
 217         /* This should work when we implement ref->__totlen elemination */
 218         if (my_dirty_size != jeb->dirty_size + jeb->wasted_size) {
 219                 JFFS2_ERROR("Calculated dirty+wasted size %#08x != stored dirty + wasted size %#08x\n",
 220                         my_dirty_size, jeb->dirty_size + jeb->wasted_size);
 221                 goto error;
 222         }
 223
 224         if (jeb->free_size == 0
 225                 && my_used_size + my_unchecked_size + my_dirty_size != c->sector_size) {
 226                 JFFS2_ERROR("The sum of all nodes in block (%#x) != size of block (%#x)\n",
 227                         my_used_size + my_unchecked_size + my_dirty_size,
 228                         c->sector_size);
 229                 goto error;
 230         }
 231 #endif
 232
 233         return;
 234
 235 error:
 236         __jffs2_dbg_dump_node_refs_nolock(c, jeb);
 237         __jffs2_dbg_dump_jeb_nolock(jeb);
 238         __jffs2_dbg_dump_block_lists_nolock(c);
 239         BUG();
 240
 241 }
 242 #endif /* JFFS2_DBG_PARANOIA_CHECKS */
 243
 244 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
 245 /*
 246  * Dump the node_refs of the 'jeb' JFFS2 eraseblock.
 247  */
 248 void
 249 __jffs2_dbg_dump_node_refs(struct jffs2_sb_info *c,
 250                            struct jffs2_eraseblock *jeb)
 251 {
 252         spin_lock(&c->erase_completion_lock);
 253         __jffs2_dbg_dump_node_refs_nolock(c, jeb);
 254         spin_unlock(&c->erase_completion_lock);
 255 }
 256
 257 void
 258 __jffs2_dbg_dump_node_refs_nolock(struct jffs2_sb_info *c,
 259                                   struct jffs2_eraseblock *jeb)
 260 {
 261         struct jffs2_raw_node_ref *ref;
 262         int i = 0;
 263
 264         printk(JFFS2_DBG_MSG_PREFIX " Dump node_refs of the eraseblock %#08x\n", jeb->offset);
 265         if (!jeb->first_node) {
 266                 printk(JFFS2_DBG_MSG_PREFIX " no nodes in the eraseblock %#08x\n", jeb->offset);
 267                 return;
 268         }
 269
 270         printk(JFFS2_DBG);
 271         for (ref = jeb->first_node; ; ref = ref_next(ref)) {
 272                 printk("%#08x(%#x)", ref_offset(ref), ref->__totlen);
 273                 if (ref_next(ref))
 274                         printk("->");
 275                 else
 276                         break;
 277                 if (++i == 4) {
 278                         i = 0;
 279                         printk("\n" JFFS2_DBG);
 280                 }
 281         }
 282         printk("\n");
 283 }
 284
 285 /*
 286  * Dump an eraseblock's space accounting.
 287  */
 288 void
 289 __jffs2_dbg_dump_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 290 {
 291         spin_lock(&c->erase_completion_lock);
 292         __jffs2_dbg_dump_jeb_nolock(jeb);
 293         spin_unlock(&c->erase_completion_lock);
 294 }
 295
 296 void
 297 __jffs2_dbg_dump_jeb_nolock(struct jffs2_eraseblock *jeb)
 298 {
 299         if (!jeb)
 300                 return;
 301
 302         printk(JFFS2_DBG_MSG_PREFIX " dump space accounting for the eraseblock at %#08x:\n",
 303                         jeb->offset);
 304
 305         printk(JFFS2_DBG "used_size: %#08x\n",          jeb->used_size);
 306         printk(JFFS2_DBG "dirty_size: %#08x\n",         jeb->dirty_size);
 307         printk(JFFS2_DBG "wasted_size: %#08x\n",        jeb->wasted_size);
 308         printk(JFFS2_DBG "unchecked_size: %#08x\n",     jeb->unchecked_size);
 309         printk(JFFS2_DBG "free_size: %#08x\n",          jeb->free_size);
 310 }
 311
 312 void
 313 __jffs2_dbg_dump_block_lists(struct jffs2_sb_info *c)
 314 {
 315         spin_lock(&c->erase_completion_lock);
 316         __jffs2_dbg_dump_block_lists_nolock(c);
 317         spin_unlock(&c->erase_completion_lock);
 318 }
 319
 320 void
 321 __jffs2_dbg_dump_block_lists_nolock(struct jffs2_sb_info *c)
 322 {
 323         printk(JFFS2_DBG_MSG_PREFIX " dump JFFS2 blocks lists:\n");
 324
 325         printk(JFFS2_DBG "flash_size: %#08x\n",         c->flash_size);
 326         printk(JFFS2_DBG "used_size: %#08x\n",          c->used_size);
 327         printk(JFFS2_DBG "dirty_size: %#08x\n",         c->dirty_size);
 328         printk(JFFS2_DBG "wasted_size: %#08x\n",        c->wasted_size);
 329         printk(JFFS2_DBG "unchecked_size: %#08x\n",     c->unchecked_size);
 330         printk(JFFS2_DBG "free_size: %#08x\n",          c->free_size);
 331         printk(JFFS2_DBG "erasing_size: %#08x\n",       c->erasing_size);
 332         printk(JFFS2_DBG "bad_size: %#08x\n",           c->bad_size);
 333         printk(JFFS2_DBG "sector_size: %#08x\n",        c->sector_size);
 334         printk(JFFS2_DBG "jffs2_reserved_blocks size: %#08x\n",
 335                                 c->sector_size * c->resv_blocks_write);
 336
 337         if (c->nextblock)
 338                 printk(JFFS2_DBG "nextblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 339                         c->nextblock->offset, c->nextblock->used_size,
 340                         c->nextblock->dirty_size, c->nextblock->wasted_size,
 341                         c->nextblock->unchecked_size, c->nextblock->free_size);
 342         else
 343                 printk(JFFS2_DBG "nextblock: NULL\n");
 344
 345         if (c->gcblock)
 346                 printk(JFFS2_DBG "gcblock: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 347                         c->gcblock->offset, c->gcblock->used_size, c->gcblock->dirty_size,
 348                         c->gcblock->wasted_size, c->gcblock->unchecked_size, c->gcblock->free_size);
 349         else
 350                 printk(JFFS2_DBG "gcblock: NULL\n");
 351
 352         if (list_empty(&c->clean_list)) {
 353                 printk(JFFS2_DBG "clean_list: empty\n");
 354         } else {
 355                 struct list_head *this;
 356                 int numblocks = 0;
 357                 uint32_t dirty = 0;
 358
 359                 list_for_each(this, &c->clean_list) {
 360                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 361                         numblocks ++;
 362                         dirty += jeb->wasted_size;
 363                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 364                                 printk(JFFS2_DBG "clean_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 365                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 366                                         jeb->unchecked_size, jeb->free_size);
 367                         }
 368                 }
 369
 370                 printk (JFFS2_DBG "Contains %d blocks with total wasted size %u, average wasted size: %u\n",
 371                         numblocks, dirty, dirty / numblocks);
 372         }
 373
 374         if (list_empty(&c->very_dirty_list)) {
 375                 printk(JFFS2_DBG "very_dirty_list: empty\n");
 376         } else {
 377                 struct list_head *this;
 378                 int numblocks = 0;
 379                 uint32_t dirty = 0;
 380
 381                 list_for_each(this, &c->very_dirty_list) {
 382                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 383
 384                         numblocks ++;
 385                         dirty += jeb->dirty_size;
 386                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 387                                 printk(JFFS2_DBG "very_dirty_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 388                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 389                                         jeb->unchecked_size, jeb->free_size);
 390                         }
 391                 }
 392
 393                 printk (JFFS2_DBG "Contains %d blocks with total dirty size %u, average dirty size: %u\n",
 394                         numblocks, dirty, dirty / numblocks);
 395         }
 396
 397         if (list_empty(&c->dirty_list)) {
 398                 printk(JFFS2_DBG "dirty_list: empty\n");
 399         } else {
 400                 struct list_head *this;
 401                 int numblocks = 0;
 402                 uint32_t dirty = 0;
 403
 404                 list_for_each(this, &c->dirty_list) {
 405                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 406
 407                         numblocks ++;
 408                         dirty += jeb->dirty_size;
 409                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 410                                 printk(JFFS2_DBG "dirty_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 411                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 412                                         jeb->unchecked_size, jeb->free_size);
 413                         }
 414                 }
 415
 416                 printk (JFFS2_DBG "contains %d blocks with total dirty size %u, average dirty size: %u\n",
 417                         numblocks, dirty, dirty / numblocks);
 418         }
 419
 420         if (list_empty(&c->erasable_list)) {
 421                 printk(JFFS2_DBG "erasable_list: empty\n");
 422         } else {
 423                 struct list_head *this;
 424
 425                 list_for_each(this, &c->erasable_list) {
 426                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 427
 428                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 429                                 printk(JFFS2_DBG "erasable_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 430                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 431                                         jeb->unchecked_size, jeb->free_size);
 432                         }
 433                 }
 434         }
 435
 436         if (list_empty(&c->erasing_list)) {
 437                 printk(JFFS2_DBG "erasing_list: empty\n");
 438         } else {
 439                 struct list_head *this;
 440
 441                 list_for_each(this, &c->erasing_list) {
 442                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 443
 444                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 445                                 printk(JFFS2_DBG "erasing_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 446                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 447                                         jeb->unchecked_size, jeb->free_size);
 448                         }
 449                 }
 450         }
 451
 452         if (list_empty(&c->erase_pending_list)) {
 453                 printk(JFFS2_DBG "erase_pending_list: empty\n");
 454         } else {
 455                 struct list_head *this;
 456
 457                 list_for_each(this, &c->erase_pending_list) {
 458                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 459
 460                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 461                                 printk(JFFS2_DBG "erase_pending_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 462                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 463                                         jeb->unchecked_size, jeb->free_size);
 464                         }
 465                 }
 466         }
 467
 468         if (list_empty(&c->erasable_pending_wbuf_list)) {
 469                 printk(JFFS2_DBG "erasable_pending_wbuf_list: empty\n");
 470         } else {
 471                 struct list_head *this;
 472
 473                 list_for_each(this, &c->erasable_pending_wbuf_list) {
 474                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 475
 476                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 477                                 printk(JFFS2_DBG "erasable_pending_wbuf_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 478                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 479                                         jeb->unchecked_size, jeb->free_size);
 480                         }
 481                 }
 482         }
 483
 484         if (list_empty(&c->free_list)) {
 485                 printk(JFFS2_DBG "free_list: empty\n");
 486         } else {
 487                 struct list_head *this;
 488
 489                 list_for_each(this, &c->free_list) {
 490                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 491
 492                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 493                                 printk(JFFS2_DBG "free_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 494                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 495                                         jeb->unchecked_size, jeb->free_size);
 496                         }
 497                 }
 498         }
 499
 500         if (list_empty(&c->bad_list)) {
 501                 printk(JFFS2_DBG "bad_list: empty\n");
 502         } else {
 503                 struct list_head *this;
 504
 505                 list_for_each(this, &c->bad_list) {
 506                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 507
 508                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 509                                 printk(JFFS2_DBG "bad_list: %#08x (used %#08x, dirty %#08x, wasted %#08x, unchecked %#08x, free %#08x)\n",
 510                                         jeb->offset, jeb->used_size, jeb->dirty_size, jeb->wasted_size,
 511                                         jeb->unchecked_size, jeb->free_size);
 512                         }
 513                 }
 514         }
 515
 516         if (list_empty(&c->bad_used_list)) {
 517                 printk(JFFS2_DBG "bad_used_list: empty\n");
 518         } else {
 519                 struct list_head *this;
 520
 521                 list_for_each(this, &c->bad_used_list) {
 522                         struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
 523
 524                         if (!(jeb->used_size == 0 && jeb->dirty_size == 0 && jeb->wasted_size == 0)) {
 525                                 printk(JFFS2_DBG "bad_used_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 }
 532
 533 void
 534 __jffs2_dbg_dump_fragtree(struct jffs2_inode_info *f)
 535 {
 536         down(&f->sem);
 537         jffs2_dbg_dump_fragtree_nolock(f);
 538         up(&f->sem);
 539 }
 540
 541 void
 542 __jffs2_dbg_dump_fragtree_nolock(struct jffs2_inode_info *f)
 543 {
 544         struct jffs2_node_frag *this = frag_first(&f->fragtree);
 545         uint32_t lastofs = 0;
 546         int buggy = 0;
 547
 548         printk(JFFS2_DBG_MSG_PREFIX " dump fragtree of ino #%u\n", f->inocache->ino);
 549         while(this) {
 550                 if (this->node)
 551                         printk(JFFS2_DBG "frag %#04x-%#04x: %#08x(%d) on flash (*%p), left (%p), right (%p), parent (%p)\n",
 552                                 this->ofs, this->ofs+this->size, ref_offset(this->node->raw),
 553                                 ref_flags(this->node->raw), this, frag_left(this), frag_right(this),
 554                                 frag_parent(this));
 555                 else
 556                         printk(JFFS2_DBG "frag %#04x-%#04x: hole (*%p). left (%p), right (%p), parent (%p)\n",
 557                                 this->ofs, this->ofs+this->size, this, frag_left(this),
 558                                 frag_right(this), frag_parent(this));
 559                 if (this->ofs != lastofs)
 560                         buggy = 1;
 561                 lastofs = this->ofs + this->size;
 562                 this = frag_next(this);
 563         }
 564
 565         if (f->metadata)
 566                 printk(JFFS2_DBG "metadata at 0x%08x\n", ref_offset(f->metadata->raw));
 567
 568         if (buggy) {
 569                 JFFS2_ERROR("frag tree got a hole in it.\n");
 570                 BUG();
 571         }
 572 }
 573
 574 #define JFFS2_BUFDUMP_BYTES_PER_LINE    32
 575 void
 576 __jffs2_dbg_dump_buffer(unsigned char *buf, int len, uint32_t offs)
 577 {
 578         int skip;
 579         int i;
 580
 581         printk(JFFS2_DBG_MSG_PREFIX " dump from offset %#08x to offset %#08x (%x bytes).\n",
 582                 offs, offs + len, len);
 583         i = skip = offs % JFFS2_BUFDUMP_BYTES_PER_LINE;
 584         offs = offs & ~(JFFS2_BUFDUMP_BYTES_PER_LINE - 1);
 585
 586         if (skip != 0)
 587                 printk(JFFS2_DBG "%#08x: ", offs);
 588
 589         while (skip--)
 590                 printk("   ");
 591
 592         while (i < len) {
 593                 if ((i % JFFS2_BUFDUMP_BYTES_PER_LINE) == 0 && i != len -1) {
 594                         if (i != 0)
 595                                 printk("\n");
 596                         offs += JFFS2_BUFDUMP_BYTES_PER_LINE;
 597                         printk(JFFS2_DBG "%0#8x: ", offs);
 598                 }
 599
 600                 printk("%02x ", buf[i]);
 601
 602                 i += 1;
 603         }
 604
 605         printk("\n");
 606 }
 607
 608 /*
 609  * Dump a JFFS2 node.
 610  */
 611 void
 612 __jffs2_dbg_dump_node(struct jffs2_sb_info *c, uint32_t ofs)
 613 {
 614         union jffs2_node_union node;
 615         int len = sizeof(union jffs2_node_union);
 616         size_t retlen;
 617         uint32_t crc;
 618         int ret;
 619
 620         printk(JFFS2_DBG_MSG_PREFIX " dump node at offset %#08x.\n", ofs);
 621
 622         ret = jffs2_flash_read(c, ofs, len, &retlen, (unsigned char *)&node);
 623         if (ret || (retlen != len)) {
 624                 JFFS2_ERROR("read %d bytes failed or short. ret %d, retlen %zd.\n",
 625                         len, ret, retlen);
 626                 return;
 627         }
 628
 629         printk(JFFS2_DBG "magic:\t%#04x\n", je16_to_cpu(node.u.magic));
 630         printk(JFFS2_DBG "nodetype:\t%#04x\n", je16_to_cpu(node.u.nodetype));
 631         printk(JFFS2_DBG "totlen:\t%#08x\n", je32_to_cpu(node.u.totlen));
 632         printk(JFFS2_DBG "hdr_crc:\t%#08x\n", je32_to_cpu(node.u.hdr_crc));
 633
 634         crc = crc32(0, &node.u, sizeof(node.u) - 4);
 635         if (crc != je32_to_cpu(node.u.hdr_crc)) {
 636                 JFFS2_ERROR("wrong common header CRC.\n");
 637                 return;
 638         }
 639
 640         if (je16_to_cpu(node.u.magic) != JFFS2_MAGIC_BITMASK &&
 641                 je16_to_cpu(node.u.magic) != JFFS2_OLD_MAGIC_BITMASK)
 642         {
 643                 JFFS2_ERROR("wrong node magic: %#04x instead of %#04x.\n",
 644                         je16_to_cpu(node.u.magic), JFFS2_MAGIC_BITMASK);
 645                 return;
 646         }
 647
 648         switch(je16_to_cpu(node.u.nodetype)) {
 649
 650         case JFFS2_NODETYPE_INODE:
 651
 652                 printk(JFFS2_DBG "the node is inode node\n");
 653                 printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.i.ino));
 654                 printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.i.version));
 655                 printk(JFFS2_DBG "mode:\t%#08x\n", node.i.mode.m);
 656                 printk(JFFS2_DBG "uid:\t%#04x\n", je16_to_cpu(node.i.uid));
 657                 printk(JFFS2_DBG "gid:\t%#04x\n", je16_to_cpu(node.i.gid));
 658                 printk(JFFS2_DBG "isize:\t%#08x\n", je32_to_cpu(node.i.isize));
 659                 printk(JFFS2_DBG "atime:\t%#08x\n", je32_to_cpu(node.i.atime));
 660                 printk(JFFS2_DBG "mtime:\t%#08x\n", je32_to_cpu(node.i.mtime));
 661                 printk(JFFS2_DBG "ctime:\t%#08x\n", je32_to_cpu(node.i.ctime));
 662                 printk(JFFS2_DBG "offset:\t%#08x\n", je32_to_cpu(node.i.offset));
 663                 printk(JFFS2_DBG "csize:\t%#08x\n", je32_to_cpu(node.i.csize));
 664                 printk(JFFS2_DBG "dsize:\t%#08x\n", je32_to_cpu(node.i.dsize));
 665                 printk(JFFS2_DBG "compr:\t%#02x\n", node.i.compr);
 666                 printk(JFFS2_DBG "usercompr:\t%#02x\n", node.i.usercompr);
 667                 printk(JFFS2_DBG "flags:\t%#04x\n", je16_to_cpu(node.i.flags));
 668                 printk(JFFS2_DBG "data_crc:\t%#08x\n", je32_to_cpu(node.i.data_crc));
 669                 printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.i.node_crc));
 670
 671                 crc = crc32(0, &node.i, sizeof(node.i) - 8);
 672                 if (crc != je32_to_cpu(node.i.node_crc)) {
 673                         JFFS2_ERROR("wrong node header CRC.\n");
 674                         return;
 675                 }
 676                 break;
 677
 678         case JFFS2_NODETYPE_DIRENT:
 679
 680                 printk(JFFS2_DBG "the node is dirent node\n");
 681                 printk(JFFS2_DBG "pino:\t%#08x\n", je32_to_cpu(node.d.pino));
 682                 printk(JFFS2_DBG "version:\t%#08x\n", je32_to_cpu(node.d.version));
 683                 printk(JFFS2_DBG "ino:\t%#08x\n", je32_to_cpu(node.d.ino));
 684                 printk(JFFS2_DBG "mctime:\t%#08x\n", je32_to_cpu(node.d.mctime));
 685                 printk(JFFS2_DBG "nsize:\t%#02x\n", node.d.nsize);
 686                 printk(JFFS2_DBG "type:\t%#02x\n", node.d.type);
 687                 printk(JFFS2_DBG "node_crc:\t%#08x\n", je32_to_cpu(node.d.node_crc));
 688                 printk(JFFS2_DBG "name_crc:\t%#08x\n", je32_to_cpu(node.d.name_crc));
 689
 690                 node.d.name[node.d.nsize] = '\0';
 691                 printk(JFFS2_DBG "name:\t\"%s\"\n", node.d.name);
 692
 693                 crc = crc32(0, &node.d, sizeof(node.d) - 8);
 694                 if (crc != je32_to_cpu(node.d.node_crc)) {
 695                         JFFS2_ERROR("wrong node header CRC.\n");
 696                         return;
 697                 }
 698                 break;
 699
 700         default:
 701                 printk(JFFS2_DBG "node type is unknown\n");
 702                 break;
 703         }
 704 }
 705 #endif /* JFFS2_DBG_DUMPS || JFFS2_DBG_PARANOIA_CHECKS */