2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
10 * $Id: nodelist.c,v 1.115 2005/11/07 11:14:40 gleixner Exp $
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
17 #include <linux/mtd/mtd.h>
18 #include <linux/rbtree.h>
19 #include <linux/crc32.h>
20 #include <linux/slab.h>
21 #include <linux/pagemap.h>
24 static void jffs2_obsolete_node_frag(struct jffs2_sb_info
*c
,
25 struct jffs2_node_frag
*this);
27 void jffs2_add_fd_to_list(struct jffs2_sb_info
*c
, struct jffs2_full_dirent
*new, struct jffs2_full_dirent
**list
)
29 struct jffs2_full_dirent
**prev
= list
;
31 dbg_dentlist("add dirent \"%s\", ino #%u\n", new->name
, new->ino
);
33 while ((*prev
) && (*prev
)->nhash
<= new->nhash
) {
34 if ((*prev
)->nhash
== new->nhash
&& !strcmp((*prev
)->name
, new->name
)) {
35 /* Duplicate. Free one */
36 if (new->version
< (*prev
)->version
) {
37 dbg_dentlist("Eep! Marking new dirent node is obsolete, old is \"%s\", ino #%u\n",
38 (*prev
)->name
, (*prev
)->ino
);
39 jffs2_mark_node_obsolete(c
, new->raw
);
40 jffs2_free_full_dirent(new);
42 dbg_dentlist("marking old dirent \"%s\", ino #%u bsolete\n",
43 (*prev
)->name
, (*prev
)->ino
);
44 new->next
= (*prev
)->next
;
45 jffs2_mark_node_obsolete(c
, ((*prev
)->raw
));
46 jffs2_free_full_dirent(*prev
);
51 prev
= &((*prev
)->next
);
57 void jffs2_truncate_fragtree(struct jffs2_sb_info
*c
, struct rb_root
*list
, uint32_t size
)
59 struct jffs2_node_frag
*frag
= jffs2_lookup_node_frag(list
, size
);
61 dbg_fragtree("truncating fragtree to 0x%08x bytes\n", size
);
63 /* We know frag->ofs <= size. That's what lookup does for us */
64 if (frag
&& frag
->ofs
!= size
) {
65 if (frag
->ofs
+frag
->size
> size
) {
66 frag
->size
= size
- frag
->ofs
;
68 frag
= frag_next(frag
);
70 while (frag
&& frag
->ofs
>= size
) {
71 struct jffs2_node_frag
*next
= frag_next(frag
);
73 frag_erase(frag
, list
);
74 jffs2_obsolete_node_frag(c
, frag
);
82 * If the last fragment starts at the RAM page boundary, it is
83 * REF_PRISTINE irrespective of its size.
85 frag
= frag_last(list
);
86 if (frag
->node
&& (frag
->ofs
& (PAGE_CACHE_SIZE
- 1)) == 0) {
87 dbg_fragtree2("marking the last fragment 0x%08x-0x%08x REF_PRISTINE.\n",
88 frag
->ofs
, frag
->ofs
+ frag
->size
);
89 frag
->node
->raw
->flash_offset
= ref_offset(frag
->node
->raw
) | REF_PRISTINE
;
93 static void jffs2_obsolete_node_frag(struct jffs2_sb_info
*c
,
94 struct jffs2_node_frag
*this)
98 if (!this->node
->frags
) {
99 /* The node has no valid frags left. It's totally obsoleted */
100 dbg_fragtree2("marking old node @0x%08x (0x%04x-0x%04x) obsolete\n",
101 ref_offset(this->node
->raw
), this->node
->ofs
, this->node
->ofs
+this->node
->size
);
102 jffs2_mark_node_obsolete(c
, this->node
->raw
);
103 jffs2_free_full_dnode(this->node
);
105 dbg_fragtree2("marking old node @0x%08x (0x%04x-0x%04x) REF_NORMAL. frags is %d\n",
106 ref_offset(this->node
->raw
), this->node
->ofs
, this->node
->ofs
+this->node
->size
, this->node
->frags
);
107 mark_ref_normal(this->node
->raw
);
111 jffs2_free_node_frag(this);
114 static void jffs2_fragtree_insert(struct jffs2_node_frag
*newfrag
, struct jffs2_node_frag
*base
)
116 struct rb_node
*parent
= &base
->rb
;
117 struct rb_node
**link
= &parent
;
119 dbg_fragtree2("insert frag (0x%04x-0x%04x)\n", newfrag
->ofs
, newfrag
->ofs
+ newfrag
->size
);
123 base
= rb_entry(parent
, struct jffs2_node_frag
, rb
);
125 if (newfrag
->ofs
> base
->ofs
)
126 link
= &base
->rb
.rb_right
;
127 else if (newfrag
->ofs
< base
->ofs
)
128 link
= &base
->rb
.rb_left
;
130 JFFS2_ERROR("duplicate frag at %08x (%p,%p)\n", newfrag
->ofs
, newfrag
, base
);
135 rb_link_node(&newfrag
->rb
, &base
->rb
, link
);
139 * Allocate and initializes a new fragment.
141 static struct jffs2_node_frag
* new_fragment(struct jffs2_full_dnode
*fn
, uint32_t ofs
, uint32_t size
)
143 struct jffs2_node_frag
*newfrag
;
145 newfrag
= jffs2_alloc_node_frag();
146 if (likely(newfrag
)) {
148 newfrag
->size
= size
;
151 JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
158 * Called when there is no overlapping fragment exist. Inserts a hole before the new
159 * fragment and inserts the new fragment to the fragtree.
161 static int no_overlapping_node(struct jffs2_sb_info
*c
, struct rb_root
*root
,
162 struct jffs2_node_frag
*newfrag
,
163 struct jffs2_node_frag
*this, uint32_t lastend
)
165 if (lastend
< newfrag
->node
->ofs
) {
166 /* put a hole in before the new fragment */
167 struct jffs2_node_frag
*holefrag
;
169 holefrag
= new_fragment(NULL
, lastend
, newfrag
->node
->ofs
- lastend
);
170 if (unlikely(!holefrag
)) {
171 jffs2_free_node_frag(newfrag
);
176 /* By definition, the 'this' node has no right-hand child,
177 because there are no frags with offset greater than it.
178 So that's where we want to put the hole */
179 dbg_fragtree2("add hole frag %#04x-%#04x on the right of the new frag.\n",
180 holefrag
->ofs
, holefrag
->ofs
+ holefrag
->size
);
181 rb_link_node(&holefrag
->rb
, &this->rb
, &this->rb
.rb_right
);
183 dbg_fragtree2("Add hole frag %#04x-%#04x to the root of the tree.\n",
184 holefrag
->ofs
, holefrag
->ofs
+ holefrag
->size
);
185 rb_link_node(&holefrag
->rb
, NULL
, &root
->rb_node
);
187 rb_insert_color(&holefrag
->rb
, root
);
192 /* By definition, the 'this' node has no right-hand child,
193 because there are no frags with offset greater than it.
194 So that's where we want to put new fragment */
195 dbg_fragtree2("add the new node at the right\n");
196 rb_link_node(&newfrag
->rb
, &this->rb
, &this->rb
.rb_right
);
198 dbg_fragtree2("insert the new node at the root of the tree\n");
199 rb_link_node(&newfrag
->rb
, NULL
, &root
->rb_node
);
201 rb_insert_color(&newfrag
->rb
, root
);
206 /* Doesn't set inode->i_size */
207 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info
*c
, struct rb_root
*root
, struct jffs2_node_frag
*newfrag
)
209 struct jffs2_node_frag
*this;
212 /* Skip all the nodes which are completed before this one starts */
213 this = jffs2_lookup_node_frag(root
, newfrag
->node
->ofs
);
216 dbg_fragtree2("lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
217 this->ofs
, this->ofs
+this->size
, this->node
?(ref_offset(this->node
->raw
)):0xffffffff, this);
218 lastend
= this->ofs
+ this->size
;
220 dbg_fragtree2("lookup gave no frag\n");
224 /* See if we ran off the end of the fragtree */
225 if (lastend
<= newfrag
->ofs
) {
228 /* Check if 'this' node was on the same page as the new node.
229 If so, both 'this' and the new node get marked REF_NORMAL so
230 the GC can take a look.
232 if (lastend
&& (lastend
-1) >> PAGE_CACHE_SHIFT
== newfrag
->ofs
>> PAGE_CACHE_SHIFT
) {
234 mark_ref_normal(this->node
->raw
);
235 mark_ref_normal(newfrag
->node
->raw
);
238 return no_overlapping_node(c
, root
, newfrag
, this, lastend
);
242 dbg_fragtree2("dealing with frag %u-%u, phys %#08x(%d).\n",
243 this->ofs
, this->ofs
+ this->size
,
244 ref_offset(this->node
->raw
), ref_flags(this->node
->raw
));
246 dbg_fragtree2("dealing with hole frag %u-%u.\n",
247 this->ofs
, this->ofs
+ this->size
);
249 /* OK. 'this' is pointing at the first frag that newfrag->ofs at least partially obsoletes,
250 * - i.e. newfrag->ofs < this->ofs+this->size && newfrag->ofs >= this->ofs
252 if (newfrag
->ofs
> this->ofs
) {
253 /* This node isn't completely obsoleted. The start of it remains valid */
255 /* Mark the new node and the partially covered node REF_NORMAL -- let
256 the GC take a look at them */
257 mark_ref_normal(newfrag
->node
->raw
);
259 mark_ref_normal(this->node
->raw
);
261 if (this->ofs
+ this->size
> newfrag
->ofs
+ newfrag
->size
) {
262 /* The new node splits 'this' frag into two */
263 struct jffs2_node_frag
*newfrag2
;
266 dbg_fragtree2("split old frag 0x%04x-0x%04x, phys 0x%08x\n",
267 this->ofs
, this->ofs
+this->size
, ref_offset(this->node
->raw
));
269 dbg_fragtree2("split old hole frag 0x%04x-0x%04x\n",
270 this->ofs
, this->ofs
+this->size
);
272 /* New second frag pointing to this's node */
273 newfrag2
= new_fragment(this->node
, newfrag
->ofs
+ newfrag
->size
,
274 this->ofs
+ this->size
- newfrag
->ofs
- newfrag
->size
);
275 if (unlikely(!newfrag2
))
280 /* Adjust size of original 'this' */
281 this->size
= newfrag
->ofs
- this->ofs
;
283 /* Now, we know there's no node with offset
284 greater than this->ofs but smaller than
285 newfrag2->ofs or newfrag->ofs, for obvious
286 reasons. So we can do a tree insert from
287 'this' to insert newfrag, and a tree insert
288 from newfrag to insert newfrag2. */
289 jffs2_fragtree_insert(newfrag
, this);
290 rb_insert_color(&newfrag
->rb
, root
);
292 jffs2_fragtree_insert(newfrag2
, newfrag
);
293 rb_insert_color(&newfrag2
->rb
, root
);
297 /* New node just reduces 'this' frag in size, doesn't split it */
298 this->size
= newfrag
->ofs
- this->ofs
;
300 /* Again, we know it lives down here in the tree */
301 jffs2_fragtree_insert(newfrag
, this);
302 rb_insert_color(&newfrag
->rb
, root
);
304 /* New frag starts at the same point as 'this' used to. Replace
305 it in the tree without doing a delete and insertion */
306 dbg_fragtree2("inserting newfrag (*%p),%d-%d in before 'this' (*%p),%d-%d\n",
307 newfrag
, newfrag
->ofs
, newfrag
->ofs
+newfrag
->size
, this, this->ofs
, this->ofs
+this->size
);
309 rb_replace_node(&this->rb
, &newfrag
->rb
, root
);
311 if (newfrag
->ofs
+ newfrag
->size
>= this->ofs
+this->size
) {
312 dbg_fragtree2("obsoleting node frag %p (%x-%x)\n", this, this->ofs
, this->ofs
+this->size
);
313 jffs2_obsolete_node_frag(c
, this);
315 this->ofs
+= newfrag
->size
;
316 this->size
-= newfrag
->size
;
318 jffs2_fragtree_insert(this, newfrag
);
319 rb_insert_color(&this->rb
, root
);
323 /* OK, now we have newfrag added in the correct place in the tree, but
324 frag_next(newfrag) may be a fragment which is overlapped by it
326 while ((this = frag_next(newfrag
)) && newfrag
->ofs
+ newfrag
->size
>= this->ofs
+ this->size
) {
327 /* 'this' frag is obsoleted completely. */
328 dbg_fragtree2("obsoleting node frag %p (%x-%x) and removing from tree\n",
329 this, this->ofs
, this->ofs
+this->size
);
330 rb_erase(&this->rb
, root
);
331 jffs2_obsolete_node_frag(c
, this);
333 /* Now we're pointing at the first frag which isn't totally obsoleted by
336 if (!this || newfrag
->ofs
+ newfrag
->size
== this->ofs
)
339 /* Still some overlap but we don't need to move it in the tree */
340 this->size
= (this->ofs
+ this->size
) - (newfrag
->ofs
+ newfrag
->size
);
341 this->ofs
= newfrag
->ofs
+ newfrag
->size
;
343 /* And mark them REF_NORMAL so the GC takes a look at them */
345 mark_ref_normal(this->node
->raw
);
346 mark_ref_normal(newfrag
->node
->raw
);
352 * Given an inode, probably with existing tree of fragments, add the new node
353 * to the fragment tree.
355 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*f
, struct jffs2_full_dnode
*fn
)
358 struct jffs2_node_frag
*newfrag
;
360 if (unlikely(!fn
->size
))
363 newfrag
= new_fragment(fn
, fn
->ofs
, fn
->size
);
364 if (unlikely(!newfrag
))
366 newfrag
->node
->frags
= 1;
368 dbg_fragtree("adding node %#04x-%#04x @0x%08x on flash, newfrag *%p\n",
369 fn
->ofs
, fn
->ofs
+fn
->size
, ref_offset(fn
->raw
), newfrag
);
371 ret
= jffs2_add_frag_to_fragtree(c
, &f
->fragtree
, newfrag
);
375 /* If we now share a page with other nodes, mark either previous
376 or next node REF_NORMAL, as appropriate. */
377 if (newfrag
->ofs
& (PAGE_CACHE_SIZE
-1)) {
378 struct jffs2_node_frag
*prev
= frag_prev(newfrag
);
380 mark_ref_normal(fn
->raw
);
381 /* If we don't start at zero there's _always_ a previous */
383 mark_ref_normal(prev
->node
->raw
);
386 if ((newfrag
->ofs
+newfrag
->size
) & (PAGE_CACHE_SIZE
-1)) {
387 struct jffs2_node_frag
*next
= frag_next(newfrag
);
390 mark_ref_normal(fn
->raw
);
392 mark_ref_normal(next
->node
->raw
);
395 jffs2_dbg_fragtree_paranoia_check_nolock(f
);
400 void jffs2_set_inocache_state(struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*ic
, int state
)
402 spin_lock(&c
->inocache_lock
);
404 wake_up(&c
->inocache_wq
);
405 spin_unlock(&c
->inocache_lock
);
408 /* During mount, this needs no locking. During normal operation, its
409 callers want to do other stuff while still holding the inocache_lock.
410 Rather than introducing special case get_ino_cache functions or
411 callbacks, we just let the caller do the locking itself. */
413 struct jffs2_inode_cache
*jffs2_get_ino_cache(struct jffs2_sb_info
*c
, uint32_t ino
)
415 struct jffs2_inode_cache
*ret
;
417 ret
= c
->inocache_list
[ino
% INOCACHE_HASHSIZE
];
418 while (ret
&& ret
->ino
< ino
) {
422 if (ret
&& ret
->ino
!= ino
)
428 void jffs2_add_ino_cache (struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*new)
430 struct jffs2_inode_cache
**prev
;
432 spin_lock(&c
->inocache_lock
);
434 new->ino
= ++c
->highest_ino
;
436 dbg_inocache("add %p (ino #%u)\n", new, new->ino
);
438 prev
= &c
->inocache_list
[new->ino
% INOCACHE_HASHSIZE
];
440 while ((*prev
) && (*prev
)->ino
< new->ino
) {
441 prev
= &(*prev
)->next
;
446 spin_unlock(&c
->inocache_lock
);
449 void jffs2_del_ino_cache(struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*old
)
451 struct jffs2_inode_cache
**prev
;
453 #ifdef CONFIG_JFFS2_FS_XATTR
456 dbg_inocache("del %p (ino #%u)\n", old
, old
->ino
);
457 spin_lock(&c
->inocache_lock
);
459 prev
= &c
->inocache_list
[old
->ino
% INOCACHE_HASHSIZE
];
461 while ((*prev
) && (*prev
)->ino
< old
->ino
) {
462 prev
= &(*prev
)->next
;
464 if ((*prev
) == old
) {
468 /* Free it now unless it's in READING or CLEARING state, which
469 are the transitions upon read_inode() and clear_inode(). The
470 rest of the time we know nobody else is looking at it, and
471 if it's held by read_inode() or clear_inode() they'll free it
473 if (old
->state
!= INO_STATE_READING
&& old
->state
!= INO_STATE_CLEARING
)
474 jffs2_free_inode_cache(old
);
476 spin_unlock(&c
->inocache_lock
);
479 void jffs2_free_ino_caches(struct jffs2_sb_info
*c
)
482 struct jffs2_inode_cache
*this, *next
;
484 for (i
=0; i
<INOCACHE_HASHSIZE
; i
++) {
485 this = c
->inocache_list
[i
];
488 jffs2_xattr_free_inode(c
, this);
489 jffs2_free_inode_cache(this);
492 c
->inocache_list
[i
] = NULL
;
496 void jffs2_free_raw_node_refs(struct jffs2_sb_info
*c
)
499 struct jffs2_raw_node_ref
*this, *next
;
501 for (i
=0; i
<c
->nr_blocks
; i
++) {
502 this = c
->blocks
[i
].first_node
;
504 if (this[REFS_PER_BLOCK
].flash_offset
== REF_LINK_NODE
)
505 next
= this[REFS_PER_BLOCK
].next_in_ino
;
509 jffs2_free_refblock(this);
512 c
->blocks
[i
].first_node
= c
->blocks
[i
].last_node
= NULL
;
516 struct jffs2_node_frag
*jffs2_lookup_node_frag(struct rb_root
*fragtree
, uint32_t offset
)
518 /* The common case in lookup is that there will be a node
519 which precisely matches. So we go looking for that first */
520 struct rb_node
*next
;
521 struct jffs2_node_frag
*prev
= NULL
;
522 struct jffs2_node_frag
*frag
= NULL
;
524 dbg_fragtree2("root %p, offset %d\n", fragtree
, offset
);
526 next
= fragtree
->rb_node
;
529 frag
= rb_entry(next
, struct jffs2_node_frag
, rb
);
531 if (frag
->ofs
+ frag
->size
<= offset
) {
532 /* Remember the closest smaller match on the way down */
533 if (!prev
|| frag
->ofs
> prev
->ofs
)
535 next
= frag
->rb
.rb_right
;
536 } else if (frag
->ofs
> offset
) {
537 next
= frag
->rb
.rb_left
;
543 /* Exact match not found. Go back up looking at each parent,
544 and return the closest smaller one */
547 dbg_fragtree2("no match. Returning frag %#04x-%#04x, closest previous\n",
548 prev
->ofs
, prev
->ofs
+prev
->size
);
550 dbg_fragtree2("returning NULL, empty fragtree\n");
555 /* Pass 'c' argument to indicate that nodes should be marked obsolete as
557 void jffs2_kill_fragtree(struct rb_root
*root
, struct jffs2_sb_info
*c
)
559 struct jffs2_node_frag
*frag
;
560 struct jffs2_node_frag
*parent
;
565 dbg_fragtree("killing\n");
567 frag
= (rb_entry(root
->rb_node
, struct jffs2_node_frag
, rb
));
569 if (frag
->rb
.rb_left
) {
570 frag
= frag_left(frag
);
573 if (frag
->rb
.rb_right
) {
574 frag
= frag_right(frag
);
578 if (frag
->node
&& !(--frag
->node
->frags
)) {
579 /* Not a hole, and it's the final remaining frag
580 of this node. Free the node */
582 jffs2_mark_node_obsolete(c
, frag
->node
->raw
);
584 jffs2_free_full_dnode(frag
->node
);
586 parent
= frag_parent(frag
);
588 if (frag_left(parent
) == frag
)
589 parent
->rb
.rb_left
= NULL
;
591 parent
->rb
.rb_right
= NULL
;
594 jffs2_free_node_frag(frag
);
601 struct jffs2_raw_node_ref
*jffs2_link_node_ref(struct jffs2_sb_info
*c
,
602 struct jffs2_eraseblock
*jeb
,
603 uint32_t ofs
, uint32_t len
,
604 struct jffs2_inode_cache
*ic
)
606 struct jffs2_raw_node_ref
*ref
;
608 BUG_ON(!jeb
->allocated_refs
);
609 jeb
->allocated_refs
--;
611 ref
= jeb
->last_node
;
613 dbg_noderef("Last node at %p is (%08x,%p)\n", ref
, ref
->flash_offset
,
616 while (ref
->flash_offset
!= REF_EMPTY_NODE
) {
617 if (ref
->flash_offset
== REF_LINK_NODE
)
618 ref
= ref
->next_in_ino
;
623 dbg_noderef("New ref is %p (%08x becomes %08x,%p) len 0x%x\n", ref
,
624 ref
->flash_offset
, ofs
, ref
->next_in_ino
, len
);
626 ref
->flash_offset
= ofs
;
628 if (!jeb
->first_node
) {
629 jeb
->first_node
= ref
;
630 BUG_ON(ref_offset(ref
) != jeb
->offset
);
631 } else if (unlikely(ref_offset(ref
) != jeb
->offset
+ c
->sector_size
- jeb
->free_size
)) {
632 uint32_t last_len
= ref_totlen(c
, jeb
, jeb
->last_node
);
634 JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
635 ref
, ref_offset(ref
), ref_offset(ref
)+len
,
636 ref_offset(jeb
->last_node
),
637 ref_offset(jeb
->last_node
)+last_len
);
640 jeb
->last_node
= ref
;
643 ref
->next_in_ino
= ic
->nodes
;
646 ref
->next_in_ino
= NULL
;
649 switch(ref_flags(ref
)) {
651 c
->unchecked_size
+= len
;
652 jeb
->unchecked_size
+= len
;
658 jeb
->used_size
+= len
;
662 c
->dirty_size
+= len
;
663 jeb
->dirty_size
+= len
;
667 jeb
->free_size
-= len
;
670 /* Set (and test) __totlen field... for now */
672 ref_totlen(c
, jeb
, ref
);
677 /* No locking, no reservation of 'ref'. Do not use on a live file system */
678 int jffs2_scan_dirty_space(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
683 if (unlikely(size
> jeb
->free_size
)) {
684 printk(KERN_CRIT
"Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
685 size
, jeb
->free_size
, jeb
->wasted_size
);
688 /* REF_EMPTY_NODE is !obsolete, so that works OK */
689 if (jeb
->last_node
&& ref_obsolete(jeb
->last_node
)) {
691 jeb
->last_node
->__totlen
+= size
;
693 c
->dirty_size
+= size
;
694 c
->free_size
-= size
;
695 jeb
->dirty_size
+= size
;
696 jeb
->free_size
-= size
;
698 uint32_t ofs
= jeb
->offset
+ c
->sector_size
- jeb
->free_size
;
701 jffs2_link_node_ref(c
, jeb
, ofs
, size
, NULL
);
707 /* Calculate totlen from surrounding nodes or eraseblock */
708 static inline uint32_t __ref_totlen(struct jffs2_sb_info
*c
,
709 struct jffs2_eraseblock
*jeb
,
710 struct jffs2_raw_node_ref
*ref
)
713 struct jffs2_raw_node_ref
*next_ref
= ref_next(ref
);
716 ref_end
= ref_offset(next_ref
);
719 jeb
= &c
->blocks
[ref
->flash_offset
/ c
->sector_size
];
721 /* Last node in block. Use free_space */
722 if (unlikely(ref
!= jeb
->last_node
)) {
723 printk(KERN_CRIT
"ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
724 ref
, ref_offset(ref
), jeb
->last_node
, jeb
->last_node
?ref_offset(jeb
->last_node
):0);
727 ref_end
= jeb
->offset
+ c
->sector_size
- jeb
->free_size
;
729 return ref_end
- ref_offset(ref
);
732 uint32_t __jffs2_ref_totlen(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
733 struct jffs2_raw_node_ref
*ref
)
737 ret
= __ref_totlen(c
, jeb
, ref
);
740 if (unlikely(ret
!= ref
->__totlen
)) {
742 jeb
= &c
->blocks
[ref
->flash_offset
/ c
->sector_size
];
744 printk(KERN_CRIT
"Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n",
745 ref
, ref_offset(ref
), ref_offset(ref
)+ref
->__totlen
,
748 printk(KERN_CRIT
"next %p (0x%08x-0x%08x)\n", ref_next(ref
), ref_offset(ref_next(ref
)),
749 ref_offset(ref_next(ref
))+ref
->__totlen
);
751 printk(KERN_CRIT
"No next ref. jeb->last_node is %p\n", jeb
->last_node
);
753 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
);
755 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
756 __jffs2_dbg_dump_node_refs_nolock(c
, jeb
);
763 #endif /* TEST_TOTLEN */
This page took 0.050515 seconds and 6 git commands to generate.