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