1
2
3
4
5
6
7
8
9
10
11
12#include <linux/kernel.h>
13#include <linux/sched.h>
14#include <linux/fs.h>
15#include <linux/mtd/mtd.h>
16#include <linux/rbtree.h>
17#include <linux/crc32.h>
18#include <linux/slab.h>
19#include <linux/pagemap.h>
20#include "nodelist.h"
21
22static void jffs2_obsolete_node_frag(struct jffs2_sb_info *c,
23 struct jffs2_node_frag *this);
24
25void jffs2_add_fd_to_list(struct jffs2_sb_info *c, struct jffs2_full_dirent *new, struct jffs2_full_dirent **list)
26{
27 struct jffs2_full_dirent **prev = list;
28
29 dbg_dentlist("add dirent \"%s\", ino #%u\n", new->name, new->ino);
30
31 while ((*prev) && (*prev)->nhash <= new->nhash) {
32 if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) {
33
34 if (new->version < (*prev)->version) {
35 dbg_dentlist("Eep! Marking new dirent node obsolete, old is \"%s\", ino #%u\n",
36 (*prev)->name, (*prev)->ino);
37 jffs2_mark_node_obsolete(c, new->raw);
38 jffs2_free_full_dirent(new);
39 } else {
40 dbg_dentlist("marking old dirent \"%s\", ino #%u obsolete\n",
41 (*prev)->name, (*prev)->ino);
42 new->next = (*prev)->next;
43
44
45 if ((*prev)->raw)
46 jffs2_mark_node_obsolete(c, ((*prev)->raw));
47 jffs2_free_full_dirent(*prev);
48 *prev = new;
49 }
50 return;
51 }
52 prev = &((*prev)->next);
53 }
54 new->next = *prev;
55 *prev = new;
56}
57
58uint32_t jffs2_truncate_fragtree(struct jffs2_sb_info *c, struct rb_root *list, uint32_t size)
59{
60 struct jffs2_node_frag *frag = jffs2_lookup_node_frag(list, size);
61
62 dbg_fragtree("truncating fragtree to 0x%08x bytes\n", size);
63
64
65 if (frag && frag->ofs != size) {
66 if (frag->ofs+frag->size > size) {
67 frag->size = size - frag->ofs;
68 }
69 frag = frag_next(frag);
70 }
71 while (frag && frag->ofs >= size) {
72 struct jffs2_node_frag *next = frag_next(frag);
73
74 frag_erase(frag, list);
75 jffs2_obsolete_node_frag(c, frag);
76 frag = next;
77 }
78
79 if (size == 0)
80 return 0;
81
82 frag = frag_last(list);
83
84
85 if (!frag)
86 return 0;
87 if (frag->ofs + frag->size < size)
88 return frag->ofs + frag->size;
89
90
91
92 if (frag->node && (frag->ofs & (PAGE_CACHE_SIZE - 1)) == 0) {
93 dbg_fragtree2("marking the last fragment 0x%08x-0x%08x REF_PRISTINE.\n",
94 frag->ofs, frag->ofs + frag->size);
95 frag->node->raw->flash_offset = ref_offset(frag->node->raw) | REF_PRISTINE;
96 }
97 return size;
98}
99
100static void jffs2_obsolete_node_frag(struct jffs2_sb_info *c,
101 struct jffs2_node_frag *this)
102{
103 if (this->node) {
104 this->node->frags--;
105 if (!this->node->frags) {
106
107 dbg_fragtree2("marking old node @0x%08x (0x%04x-0x%04x) obsolete\n",
108 ref_offset(this->node->raw), this->node->ofs, this->node->ofs+this->node->size);
109 jffs2_mark_node_obsolete(c, this->node->raw);
110 jffs2_free_full_dnode(this->node);
111 } else {
112 dbg_fragtree2("marking old node @0x%08x (0x%04x-0x%04x) REF_NORMAL. frags is %d\n",
113 ref_offset(this->node->raw), this->node->ofs, this->node->ofs+this->node->size, this->node->frags);
114 mark_ref_normal(this->node->raw);
115 }
116
117 }
118 jffs2_free_node_frag(this);
119}
120
121static void jffs2_fragtree_insert(struct jffs2_node_frag *newfrag, struct jffs2_node_frag *base)
122{
123 struct rb_node *parent = &base->rb;
124 struct rb_node **link = &parent;
125
126 dbg_fragtree2("insert frag (0x%04x-0x%04x)\n", newfrag->ofs, newfrag->ofs + newfrag->size);
127
128 while (*link) {
129 parent = *link;
130 base = rb_entry(parent, struct jffs2_node_frag, rb);
131
132 if (newfrag->ofs > base->ofs)
133 link = &base->rb.rb_right;
134 else if (newfrag->ofs < base->ofs)
135 link = &base->rb.rb_left;
136 else {
137 JFFS2_ERROR("duplicate frag at %08x (%p,%p)\n", newfrag->ofs, newfrag, base);
138 BUG();
139 }
140 }
141
142 rb_link_node(&newfrag->rb, &base->rb, link);
143}
144
145
146
147
148static struct jffs2_node_frag * new_fragment(struct jffs2_full_dnode *fn, uint32_t ofs, uint32_t size)
149{
150 struct jffs2_node_frag *newfrag;
151
152 newfrag = jffs2_alloc_node_frag();
153 if (likely(newfrag)) {
154 newfrag->ofs = ofs;
155 newfrag->size = size;
156 newfrag->node = fn;
157 } else {
158 JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
159 }
160
161 return newfrag;
162}
163
164
165
166
167
168static int no_overlapping_node(struct jffs2_sb_info *c, struct rb_root *root,
169 struct jffs2_node_frag *newfrag,
170 struct jffs2_node_frag *this, uint32_t lastend)
171{
172 if (lastend < newfrag->node->ofs) {
173
174 struct jffs2_node_frag *holefrag;
175
176 holefrag= new_fragment(NULL, lastend, newfrag->node->ofs - lastend);
177 if (unlikely(!holefrag)) {
178 jffs2_free_node_frag(newfrag);
179 return -ENOMEM;
180 }
181
182 if (this) {
183
184
185
186 dbg_fragtree2("add hole frag %#04x-%#04x on the right of the new frag.\n",
187 holefrag->ofs, holefrag->ofs + holefrag->size);
188 rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right);
189 } else {
190 dbg_fragtree2("Add hole frag %#04x-%#04x to the root of the tree.\n",
191 holefrag->ofs, holefrag->ofs + holefrag->size);
192 rb_link_node(&holefrag->rb, NULL, &root->rb_node);
193 }
194 rb_insert_color(&holefrag->rb, root);
195 this = holefrag;
196 }
197
198 if (this) {
199
200
201
202 dbg_fragtree2("add the new node at the right\n");
203 rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
204 } else {
205 dbg_fragtree2("insert the new node at the root of the tree\n");
206 rb_link_node(&newfrag->rb, NULL, &root->rb_node);
207 }
208 rb_insert_color(&newfrag->rb, root);
209
210 return 0;
211}
212
213
214static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info *c, struct rb_root *root, struct jffs2_node_frag *newfrag)
215{
216 struct jffs2_node_frag *this;
217 uint32_t lastend;
218
219
220 this = jffs2_lookup_node_frag(root, newfrag->node->ofs);
221
222 if (this) {
223 dbg_fragtree2("lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
224 this->ofs, this->ofs+this->size, this->node?(ref_offset(this->node->raw)):0xffffffff, this);
225 lastend = this->ofs + this->size;
226 } else {
227 dbg_fragtree2("lookup gave no frag\n");
228 lastend = 0;
229 }
230
231
232 if (lastend <= newfrag->ofs) {
233
234
235
236
237
238
239 if (lastend && (lastend-1) >> PAGE_CACHE_SHIFT == newfrag->ofs >> PAGE_CACHE_SHIFT) {
240 if (this->node)
241 mark_ref_normal(this->node->raw);
242 mark_ref_normal(newfrag->node->raw);
243 }
244
245 return no_overlapping_node(c, root, newfrag, this, lastend);
246 }
247
248 if (this->node)
249 dbg_fragtree2("dealing with frag %u-%u, phys %#08x(%d).\n",
250 this->ofs, this->ofs + this->size,
251 ref_offset(this->node->raw), ref_flags(this->node->raw));
252 else
253 dbg_fragtree2("dealing with hole frag %u-%u.\n",
254 this->ofs, this->ofs + this->size);
255
256
257
258
259 if (newfrag->ofs > this->ofs) {
260
261
262
263
264 mark_ref_normal(newfrag->node->raw);
265 if (this->node)
266 mark_ref_normal(this->node->raw);
267
268 if (this->ofs + this->size > newfrag->ofs + newfrag->size) {
269
270 struct jffs2_node_frag *newfrag2;
271
272 if (this->node)
273 dbg_fragtree2("split old frag 0x%04x-0x%04x, phys 0x%08x\n",
274 this->ofs, this->ofs+this->size, ref_offset(this->node->raw));
275 else
276 dbg_fragtree2("split old hole frag 0x%04x-0x%04x\n",
277 this->ofs, this->ofs+this->size);
278
279
280 newfrag2 = new_fragment(this->node, newfrag->ofs + newfrag->size,
281 this->ofs + this->size - newfrag->ofs - newfrag->size);
282 if (unlikely(!newfrag2))
283 return -ENOMEM;
284 if (this->node)
285 this->node->frags++;
286
287
288 this->size = newfrag->ofs - this->ofs;
289
290
291
292
293
294
295
296 jffs2_fragtree_insert(newfrag, this);
297 rb_insert_color(&newfrag->rb, root);
298
299 jffs2_fragtree_insert(newfrag2, newfrag);
300 rb_insert_color(&newfrag2->rb, root);
301
302 return 0;
303 }
304
305 this->size = newfrag->ofs - this->ofs;
306
307
308 jffs2_fragtree_insert(newfrag, this);
309 rb_insert_color(&newfrag->rb, root);
310 } else {
311
312
313 dbg_fragtree2("inserting newfrag (*%p),%d-%d in before 'this' (*%p),%d-%d\n",
314 newfrag, newfrag->ofs, newfrag->ofs+newfrag->size, this, this->ofs, this->ofs+this->size);
315
316 rb_replace_node(&this->rb, &newfrag->rb, root);
317
318 if (newfrag->ofs + newfrag->size >= this->ofs+this->size) {
319 dbg_fragtree2("obsoleting node frag %p (%x-%x)\n", this, this->ofs, this->ofs+this->size);
320 jffs2_obsolete_node_frag(c, this);
321 } else {
322 this->ofs += newfrag->size;
323 this->size -= newfrag->size;
324
325 jffs2_fragtree_insert(this, newfrag);
326 rb_insert_color(&this->rb, root);
327 return 0;
328 }
329 }
330
331
332
333 while ((this = frag_next(newfrag)) && newfrag->ofs + newfrag->size >= this->ofs + this->size) {
334
335 dbg_fragtree2("obsoleting node frag %p (%x-%x) and removing from tree\n",
336 this, this->ofs, this->ofs+this->size);
337 rb_erase(&this->rb, root);
338 jffs2_obsolete_node_frag(c, this);
339 }
340
341
342
343 if (!this || newfrag->ofs + newfrag->size == this->ofs)
344 return 0;
345
346
347 this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);
348 this->ofs = newfrag->ofs + newfrag->size;
349
350
351 if (this->node)
352 mark_ref_normal(this->node->raw);
353 mark_ref_normal(newfrag->node->raw);
354
355 return 0;
356}
357
358
359
360
361
362int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
363{
364 int ret;
365 struct jffs2_node_frag *newfrag;
366
367 if (unlikely(!fn->size))
368 return 0;
369
370 newfrag = new_fragment(fn, fn->ofs, fn->size);
371 if (unlikely(!newfrag))
372 return -ENOMEM;
373 newfrag->node->frags = 1;
374
375 dbg_fragtree("adding node %#04x-%#04x @0x%08x on flash, newfrag *%p\n",
376 fn->ofs, fn->ofs+fn->size, ref_offset(fn->raw), newfrag);
377
378 ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag);
379 if (unlikely(ret))
380 return ret;
381
382
383
384 if (newfrag->ofs & (PAGE_CACHE_SIZE-1)) {
385 struct jffs2_node_frag *prev = frag_prev(newfrag);
386
387 mark_ref_normal(fn->raw);
388
389 if (prev->node)
390 mark_ref_normal(prev->node->raw);
391 }
392
393 if ((newfrag->ofs+newfrag->size) & (PAGE_CACHE_SIZE-1)) {
394 struct jffs2_node_frag *next = frag_next(newfrag);
395
396 if (next) {
397 mark_ref_normal(fn->raw);
398 if (next->node)
399 mark_ref_normal(next->node->raw);
400 }
401 }
402 jffs2_dbg_fragtree_paranoia_check_nolock(f);
403
404 return 0;
405}
406
407void jffs2_set_inocache_state(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic, int state)
408{
409 spin_lock(&c->inocache_lock);
410 ic->state = state;
411 wake_up(&c->inocache_wq);
412 spin_unlock(&c->inocache_lock);
413}
414
415
416
417
418
419
420struct jffs2_inode_cache *jffs2_get_ino_cache(struct jffs2_sb_info *c, uint32_t ino)
421{
422 struct jffs2_inode_cache *ret;
423
424 ret = c->inocache_list[ino % INOCACHE_HASHSIZE];
425 while (ret && ret->ino < ino) {
426 ret = ret->next;
427 }
428
429 if (ret && ret->ino != ino)
430 ret = NULL;
431
432 return ret;
433}
434
435void jffs2_add_ino_cache (struct jffs2_sb_info *c, struct jffs2_inode_cache *new)
436{
437 struct jffs2_inode_cache **prev;
438
439 spin_lock(&c->inocache_lock);
440 if (!new->ino)
441 new->ino = ++c->highest_ino;
442
443 dbg_inocache("add %p (ino #%u)\n", new, new->ino);
444
445 prev = &c->inocache_list[new->ino % INOCACHE_HASHSIZE];
446
447 while ((*prev) && (*prev)->ino < new->ino) {
448 prev = &(*prev)->next;
449 }
450 new->next = *prev;
451 *prev = new;
452
453 spin_unlock(&c->inocache_lock);
454}
455
456void jffs2_del_ino_cache(struct jffs2_sb_info *c, struct jffs2_inode_cache *old)
457{
458 struct jffs2_inode_cache **prev;
459
460#ifdef CONFIG_JFFS2_FS_XATTR
461 BUG_ON(old->xref);
462#endif
463 dbg_inocache("del %p (ino #%u)\n", old, old->ino);
464 spin_lock(&c->inocache_lock);
465
466 prev = &c->inocache_list[old->ino % INOCACHE_HASHSIZE];
467
468 while ((*prev) && (*prev)->ino < old->ino) {
469 prev = &(*prev)->next;
470 }
471 if ((*prev) == old) {
472 *prev = old->next;
473 }
474
475
476
477
478
479
480 if (old->state != INO_STATE_READING && old->state != INO_STATE_CLEARING)
481 jffs2_free_inode_cache(old);
482
483 spin_unlock(&c->inocache_lock);
484}
485
486void jffs2_free_ino_caches(struct jffs2_sb_info *c)
487{
488 int i;
489 struct jffs2_inode_cache *this, *next;
490
491 for (i=0; i<INOCACHE_HASHSIZE; i++) {
492 this = c->inocache_list[i];
493 while (this) {
494 next = this->next;
495 jffs2_xattr_free_inode(c, this);
496 jffs2_free_inode_cache(this);
497 this = next;
498 }
499 c->inocache_list[i] = NULL;
500 }
501}
502
503void jffs2_free_raw_node_refs(struct jffs2_sb_info *c)
504{
505 int i;
506 struct jffs2_raw_node_ref *this, *next;
507
508 for (i=0; i<c->nr_blocks; i++) {
509 this = c->blocks[i].first_node;
510 while (this) {
511 if (this[REFS_PER_BLOCK].flash_offset == REF_LINK_NODE)
512 next = this[REFS_PER_BLOCK].next_in_ino;
513 else
514 next = NULL;
515
516 jffs2_free_refblock(this);
517 this = next;
518 }
519 c->blocks[i].first_node = c->blocks[i].last_node = NULL;
520 }
521}
522
523struct jffs2_node_frag *jffs2_lookup_node_frag(struct rb_root *fragtree, uint32_t offset)
524{
525
526
527 struct rb_node *next;
528 struct jffs2_node_frag *prev = NULL;
529 struct jffs2_node_frag *frag = NULL;
530
531 dbg_fragtree2("root %p, offset %d\n", fragtree, offset);
532
533 next = fragtree->rb_node;
534
535 while(next) {
536 frag = rb_entry(next, struct jffs2_node_frag, rb);
537
538 if (frag->ofs + frag->size <= offset) {
539
540 if (!prev || frag->ofs > prev->ofs)
541 prev = frag;
542 next = frag->rb.rb_right;
543 } else if (frag->ofs > offset) {
544 next = frag->rb.rb_left;
545 } else {
546 return frag;
547 }
548 }
549
550
551
552
553 if (prev)
554 dbg_fragtree2("no match. Returning frag %#04x-%#04x, closest previous\n",
555 prev->ofs, prev->ofs+prev->size);
556 else
557 dbg_fragtree2("returning NULL, empty fragtree\n");
558
559 return prev;
560}
561
562
563
564void jffs2_kill_fragtree(struct rb_root *root, struct jffs2_sb_info *c)
565{
566 struct jffs2_node_frag *frag;
567 struct jffs2_node_frag *parent;
568
569 if (!root->rb_node)
570 return;
571
572 dbg_fragtree("killing\n");
573
574 frag = (rb_entry(root->rb_node, struct jffs2_node_frag, rb));
575 while(frag) {
576 if (frag->rb.rb_left) {
577 frag = frag_left(frag);
578 continue;
579 }
580 if (frag->rb.rb_right) {
581 frag = frag_right(frag);
582 continue;
583 }
584
585 if (frag->node && !(--frag->node->frags)) {
586
587
588 if (c)
589 jffs2_mark_node_obsolete(c, frag->node->raw);
590
591 jffs2_free_full_dnode(frag->node);
592 }
593 parent = frag_parent(frag);
594 if (parent) {
595 if (frag_left(parent) == frag)
596 parent->rb.rb_left = NULL;
597 else
598 parent->rb.rb_right = NULL;
599 }
600
601 jffs2_free_node_frag(frag);
602 frag = parent;
603
604 cond_resched();
605 }
606}
607
608struct jffs2_raw_node_ref *jffs2_link_node_ref(struct jffs2_sb_info *c,
609 struct jffs2_eraseblock *jeb,
610 uint32_t ofs, uint32_t len,
611 struct jffs2_inode_cache *ic)
612{
613 struct jffs2_raw_node_ref *ref;
614
615 BUG_ON(!jeb->allocated_refs);
616 jeb->allocated_refs--;
617
618 ref = jeb->last_node;
619
620 dbg_noderef("Last node at %p is (%08x,%p)\n", ref, ref->flash_offset,
621 ref->next_in_ino);
622
623 while (ref->flash_offset != REF_EMPTY_NODE) {
624 if (ref->flash_offset == REF_LINK_NODE)
625 ref = ref->next_in_ino;
626 else
627 ref++;
628 }
629
630 dbg_noderef("New ref is %p (%08x becomes %08x,%p) len 0x%x\n", ref,
631 ref->flash_offset, ofs, ref->next_in_ino, len);
632
633 ref->flash_offset = ofs;
634
635 if (!jeb->first_node) {
636 jeb->first_node = ref;
637 BUG_ON(ref_offset(ref) != jeb->offset);
638 } else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
639 uint32_t last_len = ref_totlen(c, jeb, jeb->last_node);
640
641 JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
642 ref, ref_offset(ref), ref_offset(ref)+len,
643 ref_offset(jeb->last_node),
644 ref_offset(jeb->last_node)+last_len);
645 BUG();
646 }
647 jeb->last_node = ref;
648
649 if (ic) {
650 ref->next_in_ino = ic->nodes;
651 ic->nodes = ref;
652 } else {
653 ref->next_in_ino = NULL;
654 }
655
656 switch(ref_flags(ref)) {
657 case REF_UNCHECKED:
658 c->unchecked_size += len;
659 jeb->unchecked_size += len;
660 break;
661
662 case REF_NORMAL:
663 case REF_PRISTINE:
664 c->used_size += len;
665 jeb->used_size += len;
666 break;
667
668 case REF_OBSOLETE:
669 c->dirty_size += len;
670 jeb->dirty_size += len;
671 break;
672 }
673 c->free_size -= len;
674 jeb->free_size -= len;
675
676#ifdef TEST_TOTLEN
677
678 ref->__totlen = len;
679 ref_totlen(c, jeb, ref);
680#endif
681 return ref;
682}
683
684
685int jffs2_scan_dirty_space(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
686 uint32_t size)
687{
688 if (!size)
689 return 0;
690 if (unlikely(size > jeb->free_size)) {
691 printk(KERN_CRIT "Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
692 size, jeb->free_size, jeb->wasted_size);
693 BUG();
694 }
695
696 if (jeb->last_node && ref_obsolete(jeb->last_node)) {
697#ifdef TEST_TOTLEN
698 jeb->last_node->__totlen += size;
699#endif
700 c->dirty_size += size;
701 c->free_size -= size;
702 jeb->dirty_size += size;
703 jeb->free_size -= size;
704 } else {
705 uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
706 ofs |= REF_OBSOLETE;
707
708 jffs2_link_node_ref(c, jeb, ofs, size, NULL);
709 }
710
711 return 0;
712}
713
714
715static inline uint32_t __ref_totlen(struct jffs2_sb_info *c,
716 struct jffs2_eraseblock *jeb,
717 struct jffs2_raw_node_ref *ref)
718{
719 uint32_t ref_end;
720 struct jffs2_raw_node_ref *next_ref = ref_next(ref);
721
722 if (next_ref)
723 ref_end = ref_offset(next_ref);
724 else {
725 if (!jeb)
726 jeb = &c->blocks[ref->flash_offset / c->sector_size];
727
728
729 if (unlikely(ref != jeb->last_node)) {
730 printk(KERN_CRIT "ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
731 ref, ref_offset(ref), jeb->last_node, jeb->last_node?ref_offset(jeb->last_node):0);
732 BUG();
733 }
734 ref_end = jeb->offset + c->sector_size - jeb->free_size;
735 }
736 return ref_end - ref_offset(ref);
737}
738
739uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
740 struct jffs2_raw_node_ref *ref)
741{
742 uint32_t ret;
743
744 ret = __ref_totlen(c, jeb, ref);
745
746#ifdef TEST_TOTLEN
747 if (unlikely(ret != ref->__totlen)) {
748 if (!jeb)
749 jeb = &c->blocks[ref->flash_offset / c->sector_size];
750
751 printk(KERN_CRIT "Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n",
752 ref, ref_offset(ref), ref_offset(ref)+ref->__totlen,
753 ret, ref->__totlen);
754 if (ref_next(ref)) {
755 printk(KERN_CRIT "next %p (0x%08x-0x%08x)\n", ref_next(ref), ref_offset(ref_next(ref)),
756 ref_offset(ref_next(ref))+ref->__totlen);
757 } else
758 printk(KERN_CRIT "No next ref. jeb->last_node is %p\n", jeb->last_node);
759
760 printk(KERN_CRIT "jeb->wasted_size %x, dirty_size %x, used_size %x, free_size %x\n", jeb->wasted_size, jeb->dirty_size, jeb->used_size, jeb->free_size);
761
762#if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
763 __jffs2_dbg_dump_node_refs_nolock(c, jeb);
764#endif
765
766 WARN_ON(1);
767
768 ret = ref->__totlen;
769 }
770#endif
771 return ret;
772}
773