Merge branch 'for-linus' of git://git390.osdl.marist.edu/pub/scm/linux-2.6
[linux-2.6] / 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 (ref2->flash_offset < jeb->offset ||
182                                 ref2->flash_offset > 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 */