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