]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/jffs2/nodelist.c
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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/pagemap.h>
23 static void jffs2_obsolete_node_frag(struct jffs2_sb_info
*c
,
24 struct jffs2_node_frag
*this);
26 void jffs2_add_fd_to_list(struct jffs2_sb_info
*c
, struct jffs2_full_dirent
*new, struct jffs2_full_dirent
**list
)
28 struct jffs2_full_dirent
**prev
= list
;
30 dbg_dentlist("add dirent \"%s\", ino #%u\n", new->name
, new->ino
);
32 while ((*prev
) && (*prev
)->nhash
<= new->nhash
) {
33 if ((*prev
)->nhash
== new->nhash
&& !strcmp((*prev
)->name
, new->name
)) {
34 /* Duplicate. Free one */
35 if (new->version
< (*prev
)->version
) {
36 dbg_dentlist("Eep! Marking new dirent node obsolete, old is \"%s\", ino #%u\n",
37 (*prev
)->name
, (*prev
)->ino
);
38 jffs2_mark_node_obsolete(c
, new->raw
);
39 jffs2_free_full_dirent(new);
41 dbg_dentlist("marking old dirent \"%s\", ino #%u obsolete\n",
42 (*prev
)->name
, (*prev
)->ino
);
43 new->next
= (*prev
)->next
;
44 /* It may have been a 'placeholder' deletion dirent,
45 if jffs2_can_mark_obsolete() (see jffs2_do_unlink()) */
47 jffs2_mark_node_obsolete(c
, ((*prev
)->raw
));
48 jffs2_free_full_dirent(*prev
);
53 prev
= &((*prev
)->next
);
59 uint32_t jffs2_truncate_fragtree(struct jffs2_sb_info
*c
, struct rb_root
*list
, uint32_t size
)
61 struct jffs2_node_frag
*frag
= jffs2_lookup_node_frag(list
, size
);
63 dbg_fragtree("truncating fragtree to 0x%08x bytes\n", size
);
65 /* We know frag->ofs <= size. That's what lookup does for us */
66 if (frag
&& frag
->ofs
!= size
) {
67 if (frag
->ofs
+frag
->size
> size
) {
68 frag
->size
= size
- frag
->ofs
;
70 frag
= frag_next(frag
);
72 while (frag
&& frag
->ofs
>= size
) {
73 struct jffs2_node_frag
*next
= frag_next(frag
);
75 frag_erase(frag
, list
);
76 jffs2_obsolete_node_frag(c
, frag
);
83 frag
= frag_last(list
);
85 /* Sanity check for truncation to longer than we started with... */
88 if (frag
->ofs
+ frag
->size
< size
)
89 return frag
->ofs
+ frag
->size
;
91 /* If the last fragment starts at the RAM page boundary, it is
92 * REF_PRISTINE irrespective of its size. */
93 if (frag
->node
&& (frag
->ofs
& (PAGE_CACHE_SIZE
- 1)) == 0) {
94 dbg_fragtree2("marking the last fragment 0x%08x-0x%08x REF_PRISTINE.\n",
95 frag
->ofs
, frag
->ofs
+ frag
->size
);
96 frag
->node
->raw
->flash_offset
= ref_offset(frag
->node
->raw
) | REF_PRISTINE
;
101 static void jffs2_obsolete_node_frag(struct jffs2_sb_info
*c
,
102 struct jffs2_node_frag
*this)
106 if (!this->node
->frags
) {
107 /* The node has no valid frags left. It's totally obsoleted */
108 dbg_fragtree2("marking old node @0x%08x (0x%04x-0x%04x) obsolete\n",
109 ref_offset(this->node
->raw
), this->node
->ofs
, this->node
->ofs
+this->node
->size
);
110 jffs2_mark_node_obsolete(c
, this->node
->raw
);
111 jffs2_free_full_dnode(this->node
);
113 dbg_fragtree2("marking old node @0x%08x (0x%04x-0x%04x) REF_NORMAL. frags is %d\n",
114 ref_offset(this->node
->raw
), this->node
->ofs
, this->node
->ofs
+this->node
->size
, this->node
->frags
);
115 mark_ref_normal(this->node
->raw
);
119 jffs2_free_node_frag(this);
122 static void jffs2_fragtree_insert(struct jffs2_node_frag
*newfrag
, struct jffs2_node_frag
*base
)
124 struct rb_node
*parent
= &base
->rb
;
125 struct rb_node
**link
= &parent
;
127 dbg_fragtree2("insert frag (0x%04x-0x%04x)\n", newfrag
->ofs
, newfrag
->ofs
+ newfrag
->size
);
131 base
= rb_entry(parent
, struct jffs2_node_frag
, rb
);
133 if (newfrag
->ofs
> base
->ofs
)
134 link
= &base
->rb
.rb_right
;
135 else if (newfrag
->ofs
< base
->ofs
)
136 link
= &base
->rb
.rb_left
;
138 JFFS2_ERROR("duplicate frag at %08x (%p,%p)\n", newfrag
->ofs
, newfrag
, base
);
143 rb_link_node(&newfrag
->rb
, &base
->rb
, link
);
147 * Allocate and initializes a new fragment.
149 static struct jffs2_node_frag
* new_fragment(struct jffs2_full_dnode
*fn
, uint32_t ofs
, uint32_t size
)
151 struct jffs2_node_frag
*newfrag
;
153 newfrag
= jffs2_alloc_node_frag();
154 if (likely(newfrag
)) {
156 newfrag
->size
= size
;
159 JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
166 * Called when there is no overlapping fragment exist. Inserts a hole before the new
167 * fragment and inserts the new fragment to the fragtree.
169 static int no_overlapping_node(struct jffs2_sb_info
*c
, struct rb_root
*root
,
170 struct jffs2_node_frag
*newfrag
,
171 struct jffs2_node_frag
*this, uint32_t lastend
)
173 if (lastend
< newfrag
->node
->ofs
) {
174 /* put a hole in before the new fragment */
175 struct jffs2_node_frag
*holefrag
;
177 holefrag
= new_fragment(NULL
, lastend
, newfrag
->node
->ofs
- lastend
);
178 if (unlikely(!holefrag
)) {
179 jffs2_free_node_frag(newfrag
);
184 /* By definition, the 'this' node has no right-hand child,
185 because there are no frags with offset greater than it.
186 So that's where we want to put the hole */
187 dbg_fragtree2("add hole frag %#04x-%#04x on the right of the new frag.\n",
188 holefrag
->ofs
, holefrag
->ofs
+ holefrag
->size
);
189 rb_link_node(&holefrag
->rb
, &this->rb
, &this->rb
.rb_right
);
191 dbg_fragtree2("Add hole frag %#04x-%#04x to the root of the tree.\n",
192 holefrag
->ofs
, holefrag
->ofs
+ holefrag
->size
);
193 rb_link_node(&holefrag
->rb
, NULL
, &root
->rb_node
);
195 rb_insert_color(&holefrag
->rb
, root
);
200 /* By definition, the 'this' node has no right-hand child,
201 because there are no frags with offset greater than it.
202 So that's where we want to put new fragment */
203 dbg_fragtree2("add the new node at the right\n");
204 rb_link_node(&newfrag
->rb
, &this->rb
, &this->rb
.rb_right
);
206 dbg_fragtree2("insert the new node at the root of the tree\n");
207 rb_link_node(&newfrag
->rb
, NULL
, &root
->rb_node
);
209 rb_insert_color(&newfrag
->rb
, root
);
214 /* Doesn't set inode->i_size */
215 static int jffs2_add_frag_to_fragtree(struct jffs2_sb_info
*c
, struct rb_root
*root
, struct jffs2_node_frag
*newfrag
)
217 struct jffs2_node_frag
*this;
220 /* Skip all the nodes which are completed before this one starts */
221 this = jffs2_lookup_node_frag(root
, newfrag
->node
->ofs
);
224 dbg_fragtree2("lookup gave frag 0x%04x-0x%04x; phys 0x%08x (*%p)\n",
225 this->ofs
, this->ofs
+this->size
, this->node
?(ref_offset(this->node
->raw
)):0xffffffff, this);
226 lastend
= this->ofs
+ this->size
;
228 dbg_fragtree2("lookup gave no frag\n");
232 /* See if we ran off the end of the fragtree */
233 if (lastend
<= newfrag
->ofs
) {
236 /* Check if 'this' node was on the same page as the new node.
237 If so, both 'this' and the new node get marked REF_NORMAL so
238 the GC can take a look.
240 if (lastend
&& (lastend
-1) >> PAGE_CACHE_SHIFT
== newfrag
->ofs
>> PAGE_CACHE_SHIFT
) {
242 mark_ref_normal(this->node
->raw
);
243 mark_ref_normal(newfrag
->node
->raw
);
246 return no_overlapping_node(c
, root
, newfrag
, this, lastend
);
250 dbg_fragtree2("dealing with frag %u-%u, phys %#08x(%d).\n",
251 this->ofs
, this->ofs
+ this->size
,
252 ref_offset(this->node
->raw
), ref_flags(this->node
->raw
));
254 dbg_fragtree2("dealing with hole frag %u-%u.\n",
255 this->ofs
, this->ofs
+ this->size
);
257 /* OK. 'this' is pointing at the first frag that newfrag->ofs at least partially obsoletes,
258 * - i.e. newfrag->ofs < this->ofs+this->size && newfrag->ofs >= this->ofs
260 if (newfrag
->ofs
> this->ofs
) {
261 /* This node isn't completely obsoleted. The start of it remains valid */
263 /* Mark the new node and the partially covered node REF_NORMAL -- let
264 the GC take a look at them */
265 mark_ref_normal(newfrag
->node
->raw
);
267 mark_ref_normal(this->node
->raw
);
269 if (this->ofs
+ this->size
> newfrag
->ofs
+ newfrag
->size
) {
270 /* The new node splits 'this' frag into two */
271 struct jffs2_node_frag
*newfrag2
;
274 dbg_fragtree2("split old frag 0x%04x-0x%04x, phys 0x%08x\n",
275 this->ofs
, this->ofs
+this->size
, ref_offset(this->node
->raw
));
277 dbg_fragtree2("split old hole frag 0x%04x-0x%04x\n",
278 this->ofs
, this->ofs
+this->size
);
280 /* New second frag pointing to this's node */
281 newfrag2
= new_fragment(this->node
, newfrag
->ofs
+ newfrag
->size
,
282 this->ofs
+ this->size
- newfrag
->ofs
- newfrag
->size
);
283 if (unlikely(!newfrag2
))
288 /* Adjust size of original 'this' */
289 this->size
= newfrag
->ofs
- this->ofs
;
291 /* Now, we know there's no node with offset
292 greater than this->ofs but smaller than
293 newfrag2->ofs or newfrag->ofs, for obvious
294 reasons. So we can do a tree insert from
295 'this' to insert newfrag, and a tree insert
296 from newfrag to insert newfrag2. */
297 jffs2_fragtree_insert(newfrag
, this);
298 rb_insert_color(&newfrag
->rb
, root
);
300 jffs2_fragtree_insert(newfrag2
, newfrag
);
301 rb_insert_color(&newfrag2
->rb
, root
);
305 /* New node just reduces 'this' frag in size, doesn't split it */
306 this->size
= newfrag
->ofs
- this->ofs
;
308 /* Again, we know it lives down here in the tree */
309 jffs2_fragtree_insert(newfrag
, this);
310 rb_insert_color(&newfrag
->rb
, root
);
312 /* New frag starts at the same point as 'this' used to. Replace
313 it in the tree without doing a delete and insertion */
314 dbg_fragtree2("inserting newfrag (*%p),%d-%d in before 'this' (*%p),%d-%d\n",
315 newfrag
, newfrag
->ofs
, newfrag
->ofs
+newfrag
->size
, this, this->ofs
, this->ofs
+this->size
);
317 rb_replace_node(&this->rb
, &newfrag
->rb
, root
);
319 if (newfrag
->ofs
+ newfrag
->size
>= this->ofs
+this->size
) {
320 dbg_fragtree2("obsoleting node frag %p (%x-%x)\n", this, this->ofs
, this->ofs
+this->size
);
321 jffs2_obsolete_node_frag(c
, this);
323 this->ofs
+= newfrag
->size
;
324 this->size
-= newfrag
->size
;
326 jffs2_fragtree_insert(this, newfrag
);
327 rb_insert_color(&this->rb
, root
);
331 /* OK, now we have newfrag added in the correct place in the tree, but
332 frag_next(newfrag) may be a fragment which is overlapped by it
334 while ((this = frag_next(newfrag
)) && newfrag
->ofs
+ newfrag
->size
>= this->ofs
+ this->size
) {
335 /* 'this' frag is obsoleted completely. */
336 dbg_fragtree2("obsoleting node frag %p (%x-%x) and removing from tree\n",
337 this, this->ofs
, this->ofs
+this->size
);
338 rb_erase(&this->rb
, root
);
339 jffs2_obsolete_node_frag(c
, this);
341 /* Now we're pointing at the first frag which isn't totally obsoleted by
344 if (!this || newfrag
->ofs
+ newfrag
->size
== this->ofs
)
347 /* Still some overlap but we don't need to move it in the tree */
348 this->size
= (this->ofs
+ this->size
) - (newfrag
->ofs
+ newfrag
->size
);
349 this->ofs
= newfrag
->ofs
+ newfrag
->size
;
351 /* And mark them REF_NORMAL so the GC takes a look at them */
353 mark_ref_normal(this->node
->raw
);
354 mark_ref_normal(newfrag
->node
->raw
);
360 * Given an inode, probably with existing tree of fragments, add the new node
361 * to the fragment tree.
363 int jffs2_add_full_dnode_to_inode(struct jffs2_sb_info
*c
, struct jffs2_inode_info
*f
, struct jffs2_full_dnode
*fn
)
366 struct jffs2_node_frag
*newfrag
;
368 if (unlikely(!fn
->size
))
371 newfrag
= new_fragment(fn
, fn
->ofs
, fn
->size
);
372 if (unlikely(!newfrag
))
374 newfrag
->node
->frags
= 1;
376 dbg_fragtree("adding node %#04x-%#04x @0x%08x on flash, newfrag *%p\n",
377 fn
->ofs
, fn
->ofs
+fn
->size
, ref_offset(fn
->raw
), newfrag
);
379 ret
= jffs2_add_frag_to_fragtree(c
, &f
->fragtree
, newfrag
);
383 /* If we now share a page with other nodes, mark either previous
384 or next node REF_NORMAL, as appropriate. */
385 if (newfrag
->ofs
& (PAGE_CACHE_SIZE
-1)) {
386 struct jffs2_node_frag
*prev
= frag_prev(newfrag
);
388 mark_ref_normal(fn
->raw
);
389 /* If we don't start at zero there's _always_ a previous */
391 mark_ref_normal(prev
->node
->raw
);
394 if ((newfrag
->ofs
+newfrag
->size
) & (PAGE_CACHE_SIZE
-1)) {
395 struct jffs2_node_frag
*next
= frag_next(newfrag
);
398 mark_ref_normal(fn
->raw
);
400 mark_ref_normal(next
->node
->raw
);
403 jffs2_dbg_fragtree_paranoia_check_nolock(f
);
408 void jffs2_set_inocache_state(struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*ic
, int state
)
410 spin_lock(&c
->inocache_lock
);
412 wake_up(&c
->inocache_wq
);
413 spin_unlock(&c
->inocache_lock
);
416 /* During mount, this needs no locking. During normal operation, its
417 callers want to do other stuff while still holding the inocache_lock.
418 Rather than introducing special case get_ino_cache functions or
419 callbacks, we just let the caller do the locking itself. */
421 struct jffs2_inode_cache
*jffs2_get_ino_cache(struct jffs2_sb_info
*c
, uint32_t ino
)
423 struct jffs2_inode_cache
*ret
;
425 ret
= c
->inocache_list
[ino
% c
->inocache_hashsize
];
426 while (ret
&& ret
->ino
< ino
) {
430 if (ret
&& ret
->ino
!= ino
)
436 void jffs2_add_ino_cache (struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*new)
438 struct jffs2_inode_cache
**prev
;
440 spin_lock(&c
->inocache_lock
);
442 new->ino
= ++c
->highest_ino
;
444 dbg_inocache("add %p (ino #%u)\n", new, new->ino
);
446 prev
= &c
->inocache_list
[new->ino
% c
->inocache_hashsize
];
448 while ((*prev
) && (*prev
)->ino
< new->ino
) {
449 prev
= &(*prev
)->next
;
454 spin_unlock(&c
->inocache_lock
);
457 void jffs2_del_ino_cache(struct jffs2_sb_info
*c
, struct jffs2_inode_cache
*old
)
459 struct jffs2_inode_cache
**prev
;
461 #ifdef CONFIG_JFFS2_FS_XATTR
464 dbg_inocache("del %p (ino #%u)\n", old
, old
->ino
);
465 spin_lock(&c
->inocache_lock
);
467 prev
= &c
->inocache_list
[old
->ino
% c
->inocache_hashsize
];
469 while ((*prev
) && (*prev
)->ino
< old
->ino
) {
470 prev
= &(*prev
)->next
;
472 if ((*prev
) == old
) {
476 /* Free it now unless it's in READING or CLEARING state, which
477 are the transitions upon read_inode() and clear_inode(). The
478 rest of the time we know nobody else is looking at it, and
479 if it's held by read_inode() or clear_inode() they'll free it
481 if (old
->state
!= INO_STATE_READING
&& old
->state
!= INO_STATE_CLEARING
)
482 jffs2_free_inode_cache(old
);
484 spin_unlock(&c
->inocache_lock
);
487 void jffs2_free_ino_caches(struct jffs2_sb_info
*c
)
490 struct jffs2_inode_cache
*this, *next
;
492 for (i
=0; i
< c
->inocache_hashsize
; i
++) {
493 this = c
->inocache_list
[i
];
496 jffs2_xattr_free_inode(c
, this);
497 jffs2_free_inode_cache(this);
500 c
->inocache_list
[i
] = NULL
;
504 void jffs2_free_raw_node_refs(struct jffs2_sb_info
*c
)
507 struct jffs2_raw_node_ref
*this, *next
;
509 for (i
=0; i
<c
->nr_blocks
; i
++) {
510 this = c
->blocks
[i
].first_node
;
512 if (this[REFS_PER_BLOCK
].flash_offset
== REF_LINK_NODE
)
513 next
= this[REFS_PER_BLOCK
].next_in_ino
;
517 jffs2_free_refblock(this);
520 c
->blocks
[i
].first_node
= c
->blocks
[i
].last_node
= NULL
;
524 struct jffs2_node_frag
*jffs2_lookup_node_frag(struct rb_root
*fragtree
, uint32_t offset
)
526 /* The common case in lookup is that there will be a node
527 which precisely matches. So we go looking for that first */
528 struct rb_node
*next
;
529 struct jffs2_node_frag
*prev
= NULL
;
530 struct jffs2_node_frag
*frag
= NULL
;
532 dbg_fragtree2("root %p, offset %d\n", fragtree
, offset
);
534 next
= fragtree
->rb_node
;
537 frag
= rb_entry(next
, struct jffs2_node_frag
, rb
);
539 if (frag
->ofs
+ frag
->size
<= offset
) {
540 /* Remember the closest smaller match on the way down */
541 if (!prev
|| frag
->ofs
> prev
->ofs
)
543 next
= frag
->rb
.rb_right
;
544 } else if (frag
->ofs
> offset
) {
545 next
= frag
->rb
.rb_left
;
551 /* Exact match not found. Go back up looking at each parent,
552 and return the closest smaller one */
555 dbg_fragtree2("no match. Returning frag %#04x-%#04x, closest previous\n",
556 prev
->ofs
, prev
->ofs
+prev
->size
);
558 dbg_fragtree2("returning NULL, empty fragtree\n");
563 /* Pass 'c' argument to indicate that nodes should be marked obsolete as
565 void jffs2_kill_fragtree(struct rb_root
*root
, struct jffs2_sb_info
*c
)
567 struct jffs2_node_frag
*frag
, *next
;
569 dbg_fragtree("killing\n");
570 rbtree_postorder_for_each_entry_safe(frag
, next
, root
, rb
) {
571 if (frag
->node
&& !(--frag
->node
->frags
)) {
572 /* Not a hole, and it's the final remaining frag
573 of this node. Free the node */
575 jffs2_mark_node_obsolete(c
, frag
->node
->raw
);
577 jffs2_free_full_dnode(frag
->node
);
580 jffs2_free_node_frag(frag
);
585 struct jffs2_raw_node_ref
*jffs2_link_node_ref(struct jffs2_sb_info
*c
,
586 struct jffs2_eraseblock
*jeb
,
587 uint32_t ofs
, uint32_t len
,
588 struct jffs2_inode_cache
*ic
)
590 struct jffs2_raw_node_ref
*ref
;
592 BUG_ON(!jeb
->allocated_refs
);
593 jeb
->allocated_refs
--;
595 ref
= jeb
->last_node
;
597 dbg_noderef("Last node at %p is (%08x,%p)\n", ref
, ref
->flash_offset
,
600 while (ref
->flash_offset
!= REF_EMPTY_NODE
) {
601 if (ref
->flash_offset
== REF_LINK_NODE
)
602 ref
= ref
->next_in_ino
;
607 dbg_noderef("New ref is %p (%08x becomes %08x,%p) len 0x%x\n", ref
,
608 ref
->flash_offset
, ofs
, ref
->next_in_ino
, len
);
610 ref
->flash_offset
= ofs
;
612 if (!jeb
->first_node
) {
613 jeb
->first_node
= ref
;
614 BUG_ON(ref_offset(ref
) != jeb
->offset
);
615 } else if (unlikely(ref_offset(ref
) != jeb
->offset
+ c
->sector_size
- jeb
->free_size
)) {
616 uint32_t last_len
= ref_totlen(c
, jeb
, jeb
->last_node
);
618 JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
619 ref
, ref_offset(ref
), ref_offset(ref
)+len
,
620 ref_offset(jeb
->last_node
),
621 ref_offset(jeb
->last_node
)+last_len
);
624 jeb
->last_node
= ref
;
627 ref
->next_in_ino
= ic
->nodes
;
630 ref
->next_in_ino
= NULL
;
633 switch(ref_flags(ref
)) {
635 c
->unchecked_size
+= len
;
636 jeb
->unchecked_size
+= len
;
642 jeb
->used_size
+= len
;
646 c
->dirty_size
+= len
;
647 jeb
->dirty_size
+= len
;
651 jeb
->free_size
-= len
;
654 /* Set (and test) __totlen field... for now */
656 ref_totlen(c
, jeb
, ref
);
661 /* No locking, no reservation of 'ref'. Do not use on a live file system */
662 int jffs2_scan_dirty_space(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
667 if (unlikely(size
> jeb
->free_size
)) {
668 pr_crit("Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
669 size
, jeb
->free_size
, jeb
->wasted_size
);
672 /* REF_EMPTY_NODE is !obsolete, so that works OK */
673 if (jeb
->last_node
&& ref_obsolete(jeb
->last_node
)) {
675 jeb
->last_node
->__totlen
+= size
;
677 c
->dirty_size
+= size
;
678 c
->free_size
-= size
;
679 jeb
->dirty_size
+= size
;
680 jeb
->free_size
-= size
;
682 uint32_t ofs
= jeb
->offset
+ c
->sector_size
- jeb
->free_size
;
685 jffs2_link_node_ref(c
, jeb
, ofs
, size
, NULL
);
691 /* Calculate totlen from surrounding nodes or eraseblock */
692 static inline uint32_t __ref_totlen(struct jffs2_sb_info
*c
,
693 struct jffs2_eraseblock
*jeb
,
694 struct jffs2_raw_node_ref
*ref
)
697 struct jffs2_raw_node_ref
*next_ref
= ref_next(ref
);
700 ref_end
= ref_offset(next_ref
);
703 jeb
= &c
->blocks
[ref
->flash_offset
/ c
->sector_size
];
705 /* Last node in block. Use free_space */
706 if (unlikely(ref
!= jeb
->last_node
)) {
707 pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
708 ref
, ref_offset(ref
), jeb
->last_node
,
710 ref_offset(jeb
->last_node
) : 0);
713 ref_end
= jeb
->offset
+ c
->sector_size
- jeb
->free_size
;
715 return ref_end
- ref_offset(ref
);
718 uint32_t __jffs2_ref_totlen(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
,
719 struct jffs2_raw_node_ref
*ref
)
723 ret
= __ref_totlen(c
, jeb
, ref
);
726 if (unlikely(ret
!= ref
->__totlen
)) {
728 jeb
= &c
->blocks
[ref
->flash_offset
/ c
->sector_size
];
730 pr_crit("Totlen for ref at %p (0x%08x-0x%08x) miscalculated as 0x%x instead of %x\n",
731 ref
, ref_offset(ref
), ref_offset(ref
) + ref
->__totlen
,
734 pr_crit("next %p (0x%08x-0x%08x)\n",
735 ref_next(ref
), ref_offset(ref_next(ref
)),
736 ref_offset(ref_next(ref
)) + ref
->__totlen
);
738 pr_crit("No next ref. jeb->last_node is %p\n",
741 pr_crit("jeb->wasted_size %x, dirty_size %x, used_size %x, free_size %x\n",
742 jeb
->wasted_size
, jeb
->dirty_size
, jeb
->used_size
,
745 #if defined(JFFS2_DBG_DUMPS) || defined(JFFS2_DBG_PARANOIA_CHECKS)
746 __jffs2_dbg_dump_node_refs_nolock(c
, jeb
);
753 #endif /* TEST_TOTLEN */