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