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