2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright © 2001-2007 Red Hat, Inc.
6 * Created by David Woodhouse <dwmw2@infradead.org>
8 * For licensing information, see the file 'LICENCE' in this directory.
12 #include <linux/kernel.h>
13 #include <linux/sched.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>
22 static void jffs2_obsolete_node_frag(struct jffs2_sb_info
*c
,
23 struct jffs2_node_frag
*this);
25 void jffs2_add_fd_to_list(struct jffs2_sb_info
*c
, struct jffs2_full_dirent
*new, struct jffs2_full_dirent
**list
)
27 struct jffs2_full_dirent
**prev
= list
;
29 dbg_dentlist("add dirent \"%s\", ino #%u\n", new->name
, new->ino
);
31 while ((*prev
) && (*prev
)->nhash
<= new->nhash
) {
32 if ((*prev
)->nhash
== new->nhash
&& !strcmp((*prev
)->name
, new->name
)) {
33 /* Duplicate. Free one */
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);
40 dbg_dentlist("marking old dirent \"%s\", ino #%u obsolete\n",
41 (*prev
)->name
, (*prev
)->ino
);
42 new->next
= (*prev
)->next
;
43 /* It may have been a 'placeholder' deletion dirent,
44 if jffs2_can_mark_obsolete() (see jffs2_do_unlink()) */
46 jffs2_mark_node_obsolete(c
, ((*prev
)->raw
));
47 jffs2_free_full_dirent(*prev
);
52 prev
= &((*prev
)->next
);
58 uint32_t jffs2_truncate_fragtree(struct jffs2_sb_info
*c
, struct rb_root
*list
, uint32_t size
)
60 struct jffs2_node_frag
*frag
= jffs2_lookup_node_frag(list
, size
);
62 dbg_fragtree("truncating fragtree to 0x%08x bytes\n", size
);
64 /* We know frag->ofs <= size. That's what lookup does for us */
65 if (frag
&& frag
->ofs
!= size
) {
66 if (frag
->ofs
+frag
->size
> size
) {
67 frag
->size
= size
- frag
->ofs
;
69 frag
= frag_next(frag
);
71 while (frag
&& frag
->ofs
>= size
) {
72 struct jffs2_node_frag
*next
= frag_next(frag
);
74 frag_erase(frag
, list
);
75 jffs2_obsolete_node_frag(c
, frag
);
82 frag
= frag_last(list
);
84 /* Sanity check for truncation to longer than we started with... */
87 if (frag
->ofs
+ frag
->size
< size
)
88 return frag
->ofs
+ frag
->size
;
90 /* If the last fragment starts at the RAM page boundary, it is
91 * REF_PRISTINE irrespective of its size. */
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
;
100 static void jffs2_obsolete_node_frag(struct jffs2_sb_info
*c
,
101 struct jffs2_node_frag
*this)
105 if (!this->node
->frags
) {
106 /* The node has no valid frags left. It's totally obsoleted */
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
);
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
);
118 jffs2_free_node_frag(this);
121 static void jffs2_fragtree_insert(struct jffs2_node_frag
*newfrag
, struct jffs2_node_frag
*base
)
123 struct rb_node
*parent
= &base
->rb
;
124 struct rb_node
**link
= &parent
;
126 dbg_fragtree2("insert frag (0x%04x-0x%04x)\n", newfrag
->ofs
, newfrag
->ofs
+ newfrag
->size
);
130 base
= rb_entry(parent
, struct jffs2_node_frag
, rb
);
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
;
137 JFFS2_ERROR("duplicate frag at %08x (%p,%p)\n", newfrag
->ofs
, newfrag
, base
);
142 rb_link_node(&newfrag
->rb
, &base
->rb
, link
);
146 * Allocate and initializes a new fragment.
148 static struct jffs2_node_frag
* new_fragment(struct jffs2_full_dnode
*fn
, uint32_t ofs
, uint32_t size
)
150 struct jffs2_node_frag
*newfrag
;
152 newfrag
= jffs2_alloc_node_frag();
153 if (likely(newfrag
)) {
155 newfrag
->size
= size
;
158 JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
165 * Called when there is no overlapping fragment exist. Inserts a hole before the new
166 * fragment and inserts the new fragment to the fragtree.
168 static 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
)
172 if (lastend
< newfrag
->node
->ofs
) {
173 /* put a hole in before the new fragment */
174 struct jffs2_node_frag
*holefrag
;
176 holefrag
= new_fragment(NULL
, lastend
, newfrag
->node
->ofs
- lastend
);
177 if (unlikely(!holefrag
)) {
178 jffs2_free_node_frag(newfrag
);
183 /* By definition, the 'this' node has no right-hand child,
184 because there are no frags with offset greater than it.
185 So that's where we want to put the hole */
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
);
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
);
194 rb_insert_color(&holefrag
->rb
, root
);
199 /* By definition, the 'this' node has no right-hand child,
200 because there are no frags with offset greater than it.
201 So that's where we want to put new fragment */
202 dbg_fragtree2("add the new node at the right\n");
203 rb_link_node(&newfrag
->rb
, &this->rb
, &this->rb
.rb_right
);
205 dbg_fragtree2("insert the new node at the root of the tree\n");
206 rb_link_node(&newfrag
->rb
, NULL
, &root
->rb_node
);
208 rb_insert_color(&newfrag
->rb
, root
);
213 /* Doesn't set inode->i_size */
214 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info
*c
, struct rb_root
*root
, struct jffs2_node_frag
*newfrag
)
216 struct jffs2_node_frag
*this;
219 /* Skip all the nodes which are completed before this one starts */
220 this = jffs2_lookup_node_frag(root
, newfrag
->node
->ofs
);
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
;
227 dbg_fragtree2("lookup gave no frag\n");
231 /* See if we ran off the end of the fragtree */
232 if (lastend
<= newfrag
->ofs
) {
235 /* Check if 'this' node was on the same page as the new node.
236 If so, both 'this' and the new node get marked REF_NORMAL so
237 the GC can take a look.
239 if (lastend
&& (lastend
-1) >> PAGE_CACHE_SHIFT
== newfrag
->ofs
>> PAGE_CACHE_SHIFT
) {
241 mark_ref_normal(this->node
->raw
);
242 mark_ref_normal(newfrag
->node
->raw
);
245 return no_overlapping_node(c
, root
, newfrag
, this, lastend
);
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
));
253 dbg_fragtree2("dealing with hole frag %u-%u.\n",
254 this->ofs
, this->ofs
+ this->size
);
256 /* OK. 'this' is pointing at the first frag that newfrag->ofs at least partially obsoletes,
257 * - i.e. newfrag->ofs < this->ofs+this->size && newfrag->ofs >= this->ofs
259 if (newfrag
->ofs
> this->ofs
) {
260 /* This node isn't completely obsoleted. The start of it remains valid */
262 /* Mark the new node and the partially covered node REF_NORMAL -- let
263 the GC take a look at them */
264 mark_ref_normal(newfrag
->node
->raw
);
266 mark_ref_normal(this->node
->raw
);
268 if (this->ofs
+ this->size
> newfrag
->ofs
+ newfrag
->size
) {
269 /* The new node splits 'this' frag into two */
270 struct jffs2_node_frag
*newfrag2
;
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
));
276 dbg_fragtree2("split old hole frag 0x%04x-0x%04x\n",
277 this->ofs
, this->ofs
+this->size
);
279 /* New second frag pointing to this's node */
280 newfrag2
= new_fragment(this->node
, newfrag
->ofs
+ newfrag
->size
,
281 this->ofs
+ this->size
- newfrag
->ofs
- newfrag
->size
);
282 if (unlikely(!newfrag2
))
287 /* Adjust size of original 'this' */
288 this->size
= newfrag
->ofs
- this->ofs
;
290 /* Now, we know there's no node with offset
291 greater than this->ofs but smaller than
292 newfrag2->ofs or newfrag->ofs, for obvious
293 reasons. So we can do a tree insert from
294 'this' to insert newfrag, and a tree insert
295 from newfrag to insert newfrag2. */
296 jffs2_fragtree_insert(newfrag
, this);
297 rb_insert_color(&newfrag
->rb
, root
);
299 jffs2_fragtree_insert(newfrag2
, newfrag
);
300 rb_insert_color(&newfrag2
->rb
, root
);
304 /* New node just reduces 'this' frag in size, doesn't split it */
305 this->size
= newfrag
->ofs
- this->ofs
;
307 /* Again, we know it lives down here in the tree */
308 jffs2_fragtree_insert(newfrag
, this);
309 rb_insert_color(&newfrag
->rb
, root
);
311 /* New frag starts at the same point as 'this' used to. Replace
312 it in the tree without doing a delete and insertion */
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
);
316 rb_replace_node(&this->rb
, &newfrag
->rb
, root
);
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);
322 this->ofs
+= newfrag
->size
;
323 this->size
-= newfrag
->size
;
325 jffs2_fragtree_insert(this, newfrag
);
326 rb_insert_color(&this->rb
, root
);
330 /* OK, now we have newfrag added in the correct place in the tree, but
331 frag_next(newfrag) may be a fragment which is overlapped by it
333 while ((this = frag_next(newfrag
)) && newfrag
->ofs
+ newfrag
->size
>= this->ofs
+ this->size
) {
334 /* 'this' frag is obsoleted completely. */
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);
340 /* Now we're pointing at the first frag which isn't totally obsoleted by
343 if (!this || newfrag
->ofs
+ newfrag
->size
== this->ofs
)
346 /* Still some overlap but we don't need to move it in the tree */
347 this->size
= (this->ofs
+ this->size
) - (newfrag
->ofs
+ newfrag
->size
);
348 this->ofs
= newfrag
->ofs
+ newfrag
->size
;
350 /* And mark them REF_NORMAL so the GC takes a look at them */
352 mark_ref_normal(this->node
->raw
);
353 mark_ref_normal(newfrag
->node
->raw
);
359 * Given an inode, probably with existing tree of fragments, add the new node
360 * to the fragment tree.
362 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*f
, struct jffs2_full_dnode
*fn
)
365 struct jffs2_node_frag
*newfrag
;
367 if (unlikely(!fn
->size
))
370 newfrag
= new_fragment(fn
, fn
->ofs
, fn
->size
);
371 if (unlikely(!newfrag
))
373 newfrag
->node
->frags
= 1;
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
);
378 ret
= jffs2_add_frag_to_fragtree(c
, &f
->fragtree
, newfrag
);
382 /* If we now share a page with other nodes, mark either previous
383 or next node REF_NORMAL, as appropriate. */
384 if (newfrag
->ofs
& (PAGE_CACHE_SIZE
-1)) {
385 struct jffs2_node_frag
*prev
= frag_prev(newfrag
);
387 mark_ref_normal(fn
->raw
);
388 /* If we don't start at zero there's _always_ a previous */
390 mark_ref_normal(prev
->node
->raw
);
393 if ((newfrag
->ofs
+newfrag
->size
) & (PAGE_CACHE_SIZE
-1)) {
394 struct jffs2_node_frag
*next
= frag_next(newfrag
);
397 mark_ref_normal(fn
->raw
);
399 mark_ref_normal(next
->node
->raw
);
402 jffs2_dbg_fragtree_paranoia_check_nolock(f
);
407 void jffs2_set_inocache_state(struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*ic
, int state
)
409 spin_lock(&c
->inocache_lock
);
411 wake_up(&c
->inocache_wq
);
412 spin_unlock(&c
->inocache_lock
);
415 /* During mount, this needs no locking. During normal operation, its
416 callers want to do other stuff while still holding the inocache_lock.
417 Rather than introducing special case get_ino_cache functions or
418 callbacks, we just let the caller do the locking itself. */
420 struct jffs2_inode_cache
*jffs2_get_ino_cache(struct jffs2_sb_info
*c
, uint32_t ino
)
422 struct jffs2_inode_cache
*ret
;
424 ret
= c
->inocache_list
[ino
% INOCACHE_HASHSIZE
];
425 while (ret
&& ret
->ino
< ino
) {
429 if (ret
&& ret
->ino
!= ino
)
435 void jffs2_add_ino_cache (struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*new)
437 struct jffs2_inode_cache
**prev
;
439 spin_lock(&c
->inocache_lock
);
441 new->ino
= ++c
->highest_ino
;
443 dbg_inocache("add %p (ino #%u)\n", new, new->ino
);
445 prev
= &c
->inocache_list
[new->ino
% INOCACHE_HASHSIZE
];
447 while ((*prev
) && (*prev
)->ino
< new->ino
) {
448 prev
= &(*prev
)->next
;
453 spin_unlock(&c
->inocache_lock
);
456 void jffs2_del_ino_cache(struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*old
)
458 struct jffs2_inode_cache
**prev
;
460 #ifdef CONFIG_JFFS2_FS_XATTR
463 dbg_inocache("del %p (ino #%u)\n", old
, old
->ino
);
464 spin_lock(&c
->inocache_lock
);
466 prev
= &c
->inocache_list
[old
->ino
% INOCACHE_HASHSIZE
];
468 while ((*prev
) && (*prev
)->ino
< old
->ino
) {
469 prev
= &(*prev
)->next
;
471 if ((*prev
) == old
) {
475 /* Free it now unless it's in READING or CLEARING state, which
476 are the transitions upon read_inode() and clear_inode(). The
477 rest of the time we know nobody else is looking at it, and
478 if it's held by read_inode() or clear_inode() they'll free it
480 if (old
->state
!= INO_STATE_READING
&& old
->state
!= INO_STATE_CLEARING
)
481 jffs2_free_inode_cache(old
);
483 spin_unlock(&c
->inocache_lock
);
486 void jffs2_free_ino_caches(struct jffs2_sb_info
*c
)
489 struct jffs2_inode_cache
*this, *next
;
491 for (i
=0; i
<INOCACHE_HASHSIZE
; i
++) {
492 this = c
->inocache_list
[i
];
495 jffs2_xattr_free_inode(c
, this);
496 jffs2_free_inode_cache(this);
499 c
->inocache_list
[i
] = NULL
;
503 void jffs2_free_raw_node_refs(struct jffs2_sb_info
*c
)
506 struct jffs2_raw_node_ref
*this, *next
;
508 for (i
=0; i
<c
->nr_blocks
; i
++) {
509 this = c
->blocks
[i
].first_node
;
511 if (this[REFS_PER_BLOCK
].flash_offset
== REF_LINK_NODE
)
512 next
= this[REFS_PER_BLOCK
].next_in_ino
;
516 jffs2_free_refblock(this);
519 c
->blocks
[i
].first_node
= c
->blocks
[i
].last_node
= NULL
;
523 struct jffs2_node_frag
*jffs2_lookup_node_frag(struct rb_root
*fragtree
, uint32_t offset
)
525 /* The common case in lookup is that there will be a node
526 which precisely matches. So we go looking for that first */
527 struct rb_node
*next
;
528 struct jffs2_node_frag
*prev
= NULL
;
529 struct jffs2_node_frag
*frag
= NULL
;
531 dbg_fragtree2("root %p, offset %d\n", fragtree
, offset
);
533 next
= fragtree
->rb_node
;
536 frag
= rb_entry(next
, struct jffs2_node_frag
, rb
);
538 if (frag
->ofs
+ frag
->size
<= offset
) {
539 /* Remember the closest smaller match on the way down */
540 if (!prev
|| frag
->ofs
> prev
->ofs
)
542 next
= frag
->rb
.rb_right
;
543 } else if (frag
->ofs
> offset
) {
544 next
= frag
->rb
.rb_left
;
550 /* Exact match not found. Go back up looking at each parent,
551 and return the closest smaller one */
554 dbg_fragtree2("no match. Returning frag %#04x-%#04x, closest previous\n",
555 prev
->ofs
, prev
->ofs
+prev
->size
);
557 dbg_fragtree2("returning NULL, empty fragtree\n");
562 /* Pass 'c' argument to indicate that nodes should be marked obsolete as
564 void jffs2_kill_fragtree(struct rb_root
*root
, struct jffs2_sb_info
*c
)
566 struct jffs2_node_frag
*frag
;
567 struct jffs2_node_frag
*parent
;
572 dbg_fragtree("killing\n");
574 frag
= (rb_entry(root
->rb_node
, struct jffs2_node_frag
, rb
));
576 if (frag
->rb
.rb_left
) {
577 frag
= frag_left(frag
);
580 if (frag
->rb
.rb_right
) {
581 frag
= frag_right(frag
);
585 if (frag
->node
&& !(--frag
->node
->frags
)) {
586 /* Not a hole, and it's the final remaining frag
587 of this node. Free the node */
589 jffs2_mark_node_obsolete(c
, frag
->node
->raw
);
591 jffs2_free_full_dnode(frag
->node
);
593 parent
= frag_parent(frag
);
595 if (frag_left(parent
) == frag
)
596 parent
->rb
.rb_left
= NULL
;
598 parent
->rb
.rb_right
= NULL
;
601 jffs2_free_node_frag(frag
);
608 struct 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
)
613 struct jffs2_raw_node_ref
*ref
;
615 BUG_ON(!jeb
->allocated_refs
);
616 jeb
->allocated_refs
--;
618 ref
= jeb
->last_node
;
620 dbg_noderef("Last node at %p is (%08x,%p)\n", ref
, ref
->flash_offset
,
623 while (ref
->flash_offset
!= REF_EMPTY_NODE
) {
624 if (ref
->flash_offset
== REF_LINK_NODE
)
625 ref
= ref
->next_in_ino
;
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
);
633 ref
->flash_offset
= ofs
;
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
);
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
);
647 jeb
->last_node
= ref
;
650 ref
->next_in_ino
= ic
->nodes
;
653 ref
->next_in_ino
= NULL
;
656 switch(ref_flags(ref
)) {
658 c
->unchecked_size
+= len
;
659 jeb
->unchecked_size
+= len
;
665 jeb
->used_size
+= len
;
669 c
->dirty_size
+= len
;
670 jeb
->dirty_size
+= len
;
674 jeb
->free_size
-= len
;
677 /* Set (and test) __totlen field... for now */
679 ref_totlen(c
, jeb
, ref
);
684 /* No locking, no reservation of 'ref'. Do not use on a live file system */
685 int jffs2_scan_dirty_space(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
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
);
695 /* REF_EMPTY_NODE is !obsolete, so that works OK */
696 if (jeb
->last_node
&& ref_obsolete(jeb
->last_node
)) {
698 jeb
->last_node
->__totlen
+= size
;
700 c
->dirty_size
+= size
;
701 c
->free_size
-= size
;
702 jeb
->dirty_size
+= size
;
703 jeb
->free_size
-= size
;
705 uint32_t ofs
= jeb
->offset
+ c
->sector_size
- jeb
->free_size
;
708 jffs2_link_node_ref(c
, jeb
, ofs
, size
, NULL
);
714 /* Calculate totlen from surrounding nodes or eraseblock */
715 static inline uint32_t __ref_totlen(struct jffs2_sb_info
*c
,
716 struct jffs2_eraseblock
*jeb
,
717 struct jffs2_raw_node_ref
*ref
)
720 struct jffs2_raw_node_ref
*next_ref
= ref_next(ref
);
723 ref_end
= ref_offset(next_ref
);
726 jeb
= &c
->blocks
[ref
->flash_offset
/ c
->sector_size
];
728 /* Last node in block. Use free_space */
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);
734 ref_end
= jeb
->offset
+ c
->sector_size
- jeb
->free_size
;
736 return ref_end
- ref_offset(ref
);
739 uint32_t __jffs2_ref_totlen(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
740 struct jffs2_raw_node_ref
*ref
)
744 ret
= __ref_totlen(c
, jeb
, ref
);
747 if (unlikely(ret
!= ref
->__totlen
)) {
749 jeb
= &c
->blocks
[ref
->flash_offset
/ c
->sector_size
];
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
,
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
);
758 printk(KERN_CRIT
"No next ref. jeb->last_node is %p\n", jeb
->last_node
);
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
);
762 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
763 __jffs2_dbg_dump_node_refs_nolock(c
, jeb
);
770 #endif /* TEST_TOTLEN */
This page took 0.047226 seconds and 5 git commands to generate.