gc.c (e631ddba588783edd521c5a89f7b2902772fb691) gc.c (182ec4eee397543101a6db8906ed88727d3f7e53)
1/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
1/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 *
6 * Created by David Woodhouse <dwmw2@infradead.org>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
10 * $Id: gc.c,v 1.154 2005/09/07 08:34:54 havasi Exp $
10 * $Id: gc.c,v 1.155 2005/11/07 11:14:39 gleixner Exp $
11 *
12 */
13
14#include <linux/kernel.h>
15#include <linux/mtd/mtd.h>
16#include <linux/slab.h>
17#include <linux/pagemap.h>
18#include <linux/crc32.h>
19#include <linux/compiler.h>
20#include <linux/stat.h>
21#include "nodelist.h"
22#include "compr.h"
23
11 *
12 */
13
14#include <linux/kernel.h>
15#include <linux/mtd/mtd.h>
16#include <linux/slab.h>
17#include <linux/pagemap.h>
18#include <linux/crc32.h>
19#include <linux/compiler.h>
20#include <linux/stat.h>
21#include "nodelist.h"
22#include "compr.h"
23
24static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
24static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
25 struct jffs2_inode_cache *ic,
26 struct jffs2_raw_node_ref *raw);
25 struct jffs2_inode_cache *ic,
26 struct jffs2_raw_node_ref *raw);
27static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
27static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
28 struct jffs2_inode_info *f, struct jffs2_full_dnode *fd);
28 struct jffs2_inode_info *f, struct jffs2_full_dnode *fd);
29static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
29static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
30 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
30 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
31static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
31static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
32 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
33static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
34 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
35 uint32_t start, uint32_t end);
36static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
37 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
38 uint32_t start, uint32_t end);
39static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,

--- 10 unchanged lines hidden (view full) ---

50 put the clever wear-levelling algorithms. Eventually. */
51 /* We possibly want to favour the dirtier blocks more when the
52 number of free blocks is low. */
53again:
54 if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
55 D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n"));
56 nextlist = &c->bad_used_list;
57 } else if (n < 50 && !list_empty(&c->erasable_list)) {
32 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
33static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
34 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
35 uint32_t start, uint32_t end);
36static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
37 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
38 uint32_t start, uint32_t end);
39static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,

--- 10 unchanged lines hidden (view full) ---

50 put the clever wear-levelling algorithms. Eventually. */
51 /* We possibly want to favour the dirtier blocks more when the
52 number of free blocks is low. */
53again:
54 if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
55 D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n"));
56 nextlist = &c->bad_used_list;
57 } else if (n < 50 && !list_empty(&c->erasable_list)) {
58 /* Note that most of them will have gone directly to be erased.
58 /* Note that most of them will have gone directly to be erased.
59 So don't favour the erasable_list _too_ much. */
60 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n"));
61 nextlist = &c->erasable_list;
62 } else if (n < 110 && !list_empty(&c->very_dirty_list)) {
63 /* Most of the time, pick one off the very_dirty list */
64 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n"));
65 nextlist = &c->very_dirty_list;
66 } else if (n < 126 && !list_empty(&c->dirty_list)) {

--- 29 unchanged lines hidden (view full) ---

96 ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
97 list_del(&ret->list);
98 c->gcblock = ret;
99 ret->gc_node = ret->first_node;
100 if (!ret->gc_node) {
101 printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset);
102 BUG();
103 }
59 So don't favour the erasable_list _too_ much. */
60 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n"));
61 nextlist = &c->erasable_list;
62 } else if (n < 110 && !list_empty(&c->very_dirty_list)) {
63 /* Most of the time, pick one off the very_dirty list */
64 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n"));
65 nextlist = &c->very_dirty_list;
66 } else if (n < 126 && !list_empty(&c->dirty_list)) {

--- 29 unchanged lines hidden (view full) ---

96 ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
97 list_del(&ret->list);
98 c->gcblock = ret;
99 ret->gc_node = ret->first_node;
100 if (!ret->gc_node) {
101 printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset);
102 BUG();
103 }
104
104
105 /* Have we accidentally picked a clean block with wasted space ? */
106 if (ret->wasted_size) {
107 D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size));
108 ret->dirty_size += ret->wasted_size;
109 c->wasted_size -= ret->wasted_size;
110 c->dirty_size += ret->wasted_size;
111 ret->wasted_size = 0;
112 }

--- 18 unchanged lines hidden (view full) ---

131
132 for (;;) {
133 spin_lock(&c->erase_completion_lock);
134 if (!c->unchecked_size)
135 break;
136
137 /* We can't start doing GC yet. We haven't finished checking
138 the node CRCs etc. Do it now. */
105 /* Have we accidentally picked a clean block with wasted space ? */
106 if (ret->wasted_size) {
107 D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size));
108 ret->dirty_size += ret->wasted_size;
109 c->wasted_size -= ret->wasted_size;
110 c->dirty_size += ret->wasted_size;
111 ret->wasted_size = 0;
112 }

--- 18 unchanged lines hidden (view full) ---

131
132 for (;;) {
133 spin_lock(&c->erase_completion_lock);
134 if (!c->unchecked_size)
135 break;
136
137 /* We can't start doing GC yet. We haven't finished checking
138 the node CRCs etc. Do it now. */
139
139
140 /* checked_ino is protected by the alloc_sem */
141 if (c->checked_ino > c->highest_ino) {
142 printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
143 c->unchecked_size);
144 jffs2_dbg_dump_block_lists_nolock(c);
145 spin_unlock(&c->erase_completion_lock);
146 BUG();
147 }

--- 25 unchanged lines hidden (view full) ---

173 case INO_STATE_GC:
174 case INO_STATE_CHECKING:
175 printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state);
176 spin_unlock(&c->inocache_lock);
177 BUG();
178
179 case INO_STATE_READING:
180 /* We need to wait for it to finish, lest we move on
140 /* checked_ino is protected by the alloc_sem */
141 if (c->checked_ino > c->highest_ino) {
142 printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
143 c->unchecked_size);
144 jffs2_dbg_dump_block_lists_nolock(c);
145 spin_unlock(&c->erase_completion_lock);
146 BUG();
147 }

--- 25 unchanged lines hidden (view full) ---

173 case INO_STATE_GC:
174 case INO_STATE_CHECKING:
175 printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state);
176 spin_unlock(&c->inocache_lock);
177 BUG();
178
179 case INO_STATE_READING:
180 /* We need to wait for it to finish, lest we move on
181 and trigger the BUG() above while we haven't yet
181 and trigger the BUG() above while we haven't yet
182 finished checking all its nodes */
183 D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino));
184 up(&c->alloc_sem);
185 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
186 return 0;
187
188 default:
189 BUG();

--- 33 unchanged lines hidden (view full) ---

223 printk(KERN_DEBUG "Nextblock at %08x, used_size %08x, dirty_size %08x, wasted_size %08x, free_size %08x\n", c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->free_size));
224
225 if (!jeb->used_size) {
226 up(&c->alloc_sem);
227 goto eraseit;
228 }
229
230 raw = jeb->gc_node;
182 finished checking all its nodes */
183 D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino));
184 up(&c->alloc_sem);
185 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
186 return 0;
187
188 default:
189 BUG();

--- 33 unchanged lines hidden (view full) ---

223 printk(KERN_DEBUG "Nextblock at %08x, used_size %08x, dirty_size %08x, wasted_size %08x, free_size %08x\n", c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->free_size));
224
225 if (!jeb->used_size) {
226 up(&c->alloc_sem);
227 goto eraseit;
228 }
229
230 raw = jeb->gc_node;
231
231
232 while(ref_obsolete(raw)) {
233 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw)));
234 raw = raw->next_phys;
235 if (unlikely(!raw)) {
236 printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n");
232 while(ref_obsolete(raw)) {
233 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw)));
234 raw = raw->next_phys;
235 if (unlikely(!raw)) {
236 printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n");
237 printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
237 printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
238 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size);
239 jeb->gc_node = raw;
240 spin_unlock(&c->erase_completion_lock);
241 up(&c->alloc_sem);
242 BUG();
243 }
244 }
245 jeb->gc_node = raw;

--- 8 unchanged lines hidden (view full) ---

254 jffs2_mark_node_obsolete(c, raw);
255 up(&c->alloc_sem);
256 goto eraseit_lock;
257 }
258
259 ic = jffs2_raw_ref_to_ic(raw);
260
261 /* We need to hold the inocache. Either the erase_completion_lock or
238 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size);
239 jeb->gc_node = raw;
240 spin_unlock(&c->erase_completion_lock);
241 up(&c->alloc_sem);
242 BUG();
243 }
244 }
245 jeb->gc_node = raw;

--- 8 unchanged lines hidden (view full) ---

254 jffs2_mark_node_obsolete(c, raw);
255 up(&c->alloc_sem);
256 goto eraseit_lock;
257 }
258
259 ic = jffs2_raw_ref_to_ic(raw);
260
261 /* We need to hold the inocache. Either the erase_completion_lock or
262 the inocache_lock are sufficient; we trade down since the inocache_lock
262 the inocache_lock are sufficient; we trade down since the inocache_lock
263 causes less contention. */
264 spin_lock(&c->inocache_lock);
265
266 spin_unlock(&c->erase_completion_lock);
267
268 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", jeb->offset, ref_offset(raw), ref_flags(raw), ic->ino));
269
270 /* Three possibilities:
271 1. Inode is already in-core. We must iget it and do proper
272 updating to its fragtree, etc.
273 2. Inode is not in-core, node is REF_PRISTINE. We lock the
274 inocache to prevent a read_inode(), copy the node intact.
275 3. Inode is not in-core, node is not pristine. We must iget()
276 and take the slow path.
277 */
278
279 switch(ic->state) {
280 case INO_STATE_CHECKEDABSENT:
263 causes less contention. */
264 spin_lock(&c->inocache_lock);
265
266 spin_unlock(&c->erase_completion_lock);
267
268 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", jeb->offset, ref_offset(raw), ref_flags(raw), ic->ino));
269
270 /* Three possibilities:
271 1. Inode is already in-core. We must iget it and do proper
272 updating to its fragtree, etc.
273 2. Inode is not in-core, node is REF_PRISTINE. We lock the
274 inocache to prevent a read_inode(), copy the node intact.
275 3. Inode is not in-core, node is not pristine. We must iget()
276 and take the slow path.
277 */
278
279 switch(ic->state) {
280 case INO_STATE_CHECKEDABSENT:
281 /* It's been checked, but it's not currently in-core.
281 /* It's been checked, but it's not currently in-core.
282 We can just copy any pristine nodes, but have
283 to prevent anyone else from doing read_inode() while
284 we're at it, so we set the state accordingly */
285 if (ref_flags(raw) == REF_PRISTINE)
286 ic->state = INO_STATE_GC;
287 else {
282 We can just copy any pristine nodes, but have
283 to prevent anyone else from doing read_inode() while
284 we're at it, so we set the state accordingly */
285 if (ref_flags(raw) == REF_PRISTINE)
286 ic->state = INO_STATE_GC;
287 else {
288 D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n",
288 D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n",
289 ic->ino));
290 }
291 break;
292
293 case INO_STATE_PRESENT:
294 /* It's in-core. GC must iget() it. */
295 break;
296
297 case INO_STATE_UNCHECKED:
298 case INO_STATE_CHECKING:
299 case INO_STATE_GC:
300 /* Should never happen. We should have finished checking
289 ic->ino));
290 }
291 break;
292
293 case INO_STATE_PRESENT:
294 /* It's in-core. GC must iget() it. */
295 break;
296
297 case INO_STATE_UNCHECKED:
298 case INO_STATE_CHECKING:
299 case INO_STATE_GC:
300 /* Should never happen. We should have finished checking
301 by the time we actually start doing any GC, and since
302 we're holding the alloc_sem, no other garbage collection
301 by the time we actually start doing any GC, and since
302 we're holding the alloc_sem, no other garbage collection
303 can happen.
304 */
305 printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
306 ic->ino, ic->state);
307 up(&c->alloc_sem);
308 spin_unlock(&c->inocache_lock);
309 BUG();
310
311 case INO_STATE_READING:
312 /* Someone's currently trying to read it. We must wait for
313 them to finish and then go through the full iget() route
314 to do the GC. However, sometimes read_inode() needs to get
315 the alloc_sem() (for marking nodes invalid) so we must
316 drop the alloc_sem before sleeping. */
317
318 up(&c->alloc_sem);
319 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n",
320 ic->ino, ic->state));
321 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
303 can happen.
304 */
305 printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
306 ic->ino, ic->state);
307 up(&c->alloc_sem);
308 spin_unlock(&c->inocache_lock);
309 BUG();
310
311 case INO_STATE_READING:
312 /* Someone's currently trying to read it. We must wait for
313 them to finish and then go through the full iget() route
314 to do the GC. However, sometimes read_inode() needs to get
315 the alloc_sem() (for marking nodes invalid) so we must
316 drop the alloc_sem before sleeping. */
317
318 up(&c->alloc_sem);
319 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n",
320 ic->ino, ic->state));
321 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
322 /* And because we dropped the alloc_sem we must start again from the
322 /* And because we dropped the alloc_sem we must start again from the
323 beginning. Ponder chance of livelock here -- we're returning success
324 without actually making any progress.
325
323 beginning. Ponder chance of livelock here -- we're returning success
324 without actually making any progress.
325
326 Q: What are the chances that the inode is back in INO_STATE_READING
326 Q: What are the chances that the inode is back in INO_STATE_READING
327 again by the time we next enter this function? And that this happens
328 enough times to cause a real delay?
329
327 again by the time we next enter this function? And that this happens
328 enough times to cause a real delay?
329
330 A: Small enough that I don't care :)
330 A: Small enough that I don't care :)
331 */
332 return 0;
333 }
334
335 /* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the
331 */
332 return 0;
333 }
334
335 /* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the
336 node intact, and we don't have to muck about with the fragtree etc.
336 node intact, and we don't have to muck about with the fragtree etc.
337 because we know it's not in-core. If it _was_ in-core, we go through
338 all the iget() crap anyway */
339
340 if (ic->state == INO_STATE_GC) {
341 spin_unlock(&c->inocache_lock);
342
343 ret = jffs2_garbage_collect_pristine(c, ic, raw);
344

--- 103 unchanged lines hidden (view full) ---

448 }
449 }
450 if (fn) {
451 if (ref_flags(raw) == REF_PRISTINE) {
452 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
453 if (!ret) {
454 /* Urgh. Return it sensibly. */
455 frag->node->raw = f->inocache->nodes;
337 because we know it's not in-core. If it _was_ in-core, we go through
338 all the iget() crap anyway */
339
340 if (ic->state == INO_STATE_GC) {
341 spin_unlock(&c->inocache_lock);
342
343 ret = jffs2_garbage_collect_pristine(c, ic, raw);
344

--- 103 unchanged lines hidden (view full) ---

448 }
449 }
450 if (fn) {
451 if (ref_flags(raw) == REF_PRISTINE) {
452 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
453 if (!ret) {
454 /* Urgh. Return it sensibly. */
455 frag->node->raw = f->inocache->nodes;
456 }
456 }
457 if (ret != -EBADFD)
458 goto upnout;
459 }
460 /* We found a datanode. Do the GC */
461 if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) {
462 /* It crosses a page boundary. Therefore, it must be a hole. */
463 ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end);
464 } else {
465 /* It could still be a hole. But we GC the page this way anyway */
466 ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end);
467 }
468 goto upnout;
469 }
457 if (ret != -EBADFD)
458 goto upnout;
459 }
460 /* We found a datanode. Do the GC */
461 if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) {
462 /* It crosses a page boundary. Therefore, it must be a hole. */
463 ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end);
464 } else {
465 /* It could still be a hole. But we GC the page this way anyway */
466 ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end);
467 }
468 goto upnout;
469 }
470
470
471 /* Wasn't a dnode. Try dirent */
472 for (fd = f->dents; fd; fd=fd->next) {
473 if (fd->raw == raw)
474 break;
475 }
476
477 if (fd && fd->ino) {
478 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);

--- 10 unchanged lines hidden (view full) ---

489 }
490 }
491 upnout:
492 up(&f->sem);
493
494 return ret;
495}
496
471 /* Wasn't a dnode. Try dirent */
472 for (fd = f->dents; fd; fd=fd->next) {
473 if (fd->raw == raw)
474 break;
475 }
476
477 if (fd && fd->ino) {
478 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);

--- 10 unchanged lines hidden (view full) ---

489 }
490 }
491 upnout:
492 up(&f->sem);
493
494 return ret;
495}
496
497static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
497static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
498 struct jffs2_inode_cache *ic,
499 struct jffs2_raw_node_ref *raw)
500{
501 union jffs2_node_union *node;
502 struct jffs2_raw_node_ref *nraw;
503 size_t retlen;
504 int ret;
505 uint32_t phys_ofs, alloclen;

--- 69 unchanged lines hidden (view full) ---

575 if (je32_to_cpu(node->d.name_crc) != crc) {
576 printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent ode at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
577 ref_offset(raw), je32_to_cpu(node->d.name_crc), crc);
578 goto bail;
579 }
580 }
581 break;
582 default:
498 struct jffs2_inode_cache *ic,
499 struct jffs2_raw_node_ref *raw)
500{
501 union jffs2_node_union *node;
502 struct jffs2_raw_node_ref *nraw;
503 size_t retlen;
504 int ret;
505 uint32_t phys_ofs, alloclen;

--- 69 unchanged lines hidden (view full) ---

575 if (je32_to_cpu(node->d.name_crc) != crc) {
576 printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent ode at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
577 ref_offset(raw), je32_to_cpu(node->d.name_crc), crc);
578 goto bail;
579 }
580 }
581 break;
582 default:
583 printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
583 printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
584 ref_offset(raw), je16_to_cpu(node->u.nodetype));
585 goto bail;
586 }
587
588 nraw = jffs2_alloc_raw_node_ref();
589 if (!nraw) {
590 ret = -ENOMEM;
591 goto out_node;

--- 24 unchanged lines hidden (view full) ---

616 if (!retried && (nraw = jffs2_alloc_raw_node_ref())) {
617 /* Try to reallocate space and retry */
618 uint32_t dummy;
619 struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
620
621 retried = 1;
622
623 D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n"));
584 ref_offset(raw), je16_to_cpu(node->u.nodetype));
585 goto bail;
586 }
587
588 nraw = jffs2_alloc_raw_node_ref();
589 if (!nraw) {
590 ret = -ENOMEM;
591 goto out_node;

--- 24 unchanged lines hidden (view full) ---

616 if (!retried && (nraw = jffs2_alloc_raw_node_ref())) {
617 /* Try to reallocate space and retry */
618 uint32_t dummy;
619 struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
620
621 retried = 1;
622
623 D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n"));
624
624
625 jffs2_dbg_acct_sanity_check(c,jeb);
626 jffs2_dbg_acct_paranoia_check(c, jeb);
627
628 ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy, rawlen);
629 /* this is not the exact summary size of it,
630 it is only an upper estimation */
631
632 if (!ret) {

--- 31 unchanged lines hidden (view full) ---

664 out_node:
665 kfree(node);
666 return ret;
667 bail:
668 ret = -EBADFD;
669 goto out_node;
670}
671
625 jffs2_dbg_acct_sanity_check(c,jeb);
626 jffs2_dbg_acct_paranoia_check(c, jeb);
627
628 ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy, rawlen);
629 /* this is not the exact summary size of it,
630 it is only an upper estimation */
631
632 if (!ret) {

--- 31 unchanged lines hidden (view full) ---

664 out_node:
665 kfree(node);
666 return ret;
667 bail:
668 ret = -EBADFD;
669 goto out_node;
670}
671
672static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
672static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
673 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
674{
675 struct jffs2_full_dnode *new_fn;
676 struct jffs2_raw_inode ri;
677 struct jffs2_node_frag *last_frag;
678 jint16_t dev;
679 char *mdata = NULL, mdatalen = 0;
680 uint32_t alloclen, phys_ofs, ilen;
681 int ret;
682
683 if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
684 S_ISCHR(JFFS2_F_I_MODE(f)) ) {
685 /* For these, we don't actually need to read the old node */
686 /* FIXME: for minor or major > 255. */
673 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
674{
675 struct jffs2_full_dnode *new_fn;
676 struct jffs2_raw_inode ri;
677 struct jffs2_node_frag *last_frag;
678 jint16_t dev;
679 char *mdata = NULL, mdatalen = 0;
680 uint32_t alloclen, phys_ofs, ilen;
681 int ret;
682
683 if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
684 S_ISCHR(JFFS2_F_I_MODE(f)) ) {
685 /* For these, we don't actually need to read the old node */
686 /* FIXME: for minor or major > 255. */
687 dev = cpu_to_je16(((JFFS2_F_I_RDEV_MAJ(f) << 8) |
687 dev = cpu_to_je16(((JFFS2_F_I_RDEV_MAJ(f) << 8) |
688 JFFS2_F_I_RDEV_MIN(f)));
689 mdata = (char *)&dev;
690 mdatalen = sizeof(dev);
691 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen));
692 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
693 mdatalen = fn->size;
694 mdata = kmalloc(fn->size, GFP_KERNEL);
695 if (!mdata) {

--- 4 unchanged lines hidden (view full) ---

700 if (ret) {
701 printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret);
702 kfree(mdata);
703 return ret;
704 }
705 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen));
706
707 }
688 JFFS2_F_I_RDEV_MIN(f)));
689 mdata = (char *)&dev;
690 mdatalen = sizeof(dev);
691 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen));
692 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
693 mdatalen = fn->size;
694 mdata = kmalloc(fn->size, GFP_KERNEL);
695 if (!mdata) {

--- 4 unchanged lines hidden (view full) ---

700 if (ret) {
701 printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret);
702 kfree(mdata);
703 return ret;
704 }
705 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen));
706
707 }
708
708
709 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &phys_ofs, &alloclen,
710 JFFS2_SUMMARY_INODE_SIZE);
711 if (ret) {
712 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
713 sizeof(ri)+ mdatalen, ret);
714 goto out;
715 }
709 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &phys_ofs, &alloclen,
710 JFFS2_SUMMARY_INODE_SIZE);
711 if (ret) {
712 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
713 sizeof(ri)+ mdatalen, ret);
714 goto out;
715 }
716
716
717 last_frag = frag_last(&f->fragtree);
718 if (last_frag)
719 /* Fetch the inode length from the fragtree rather then
720 * from i_size since i_size may have not been updated yet */
721 ilen = last_frag->ofs + last_frag->size;
722 else
723 ilen = JFFS2_F_I_SIZE(f);
717 last_frag = frag_last(&f->fragtree);
718 if (last_frag)
719 /* Fetch the inode length from the fragtree rather then
720 * from i_size since i_size may have not been updated yet */
721 ilen = last_frag->ofs + last_frag->size;
722 else
723 ilen = JFFS2_F_I_SIZE(f);
724
724
725 memset(&ri, 0, sizeof(ri));
726 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
727 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
728 ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
729 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
730
731 ri.ino = cpu_to_je32(f->inocache->ino);
732 ri.version = cpu_to_je32(++f->highest_version);

--- 22 unchanged lines hidden (view full) ---

755 jffs2_free_full_dnode(fn);
756 f->metadata = new_fn;
757 out:
758 if (S_ISLNK(JFFS2_F_I_MODE(f)))
759 kfree(mdata);
760 return ret;
761}
762
725 memset(&ri, 0, sizeof(ri));
726 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
727 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
728 ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
729 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
730
731 ri.ino = cpu_to_je32(f->inocache->ino);
732 ri.version = cpu_to_je32(++f->highest_version);

--- 22 unchanged lines hidden (view full) ---

755 jffs2_free_full_dnode(fn);
756 f->metadata = new_fn;
757 out:
758 if (S_ISLNK(JFFS2_F_I_MODE(f)))
759 kfree(mdata);
760 return ret;
761}
762
763static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
763static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
764 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
765{
766 struct jffs2_full_dirent *new_fd;
767 struct jffs2_raw_dirent rd;
768 uint32_t alloclen, phys_ofs;
769 int ret;
770
771 rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);

--- 4 unchanged lines hidden (view full) ---

776
777 rd.pino = cpu_to_je32(f->inocache->ino);
778 rd.version = cpu_to_je32(++f->highest_version);
779 rd.ino = cpu_to_je32(fd->ino);
780 /* If the times on this inode were set by explicit utime() they can be different,
781 so refrain from splatting them. */
782 if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
783 rd.mctime = cpu_to_je32(JFFS2_F_I_MTIME(f));
764 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
765{
766 struct jffs2_full_dirent *new_fd;
767 struct jffs2_raw_dirent rd;
768 uint32_t alloclen, phys_ofs;
769 int ret;
770
771 rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);

--- 4 unchanged lines hidden (view full) ---

776
777 rd.pino = cpu_to_je32(f->inocache->ino);
778 rd.version = cpu_to_je32(++f->highest_version);
779 rd.ino = cpu_to_je32(fd->ino);
780 /* If the times on this inode were set by explicit utime() they can be different,
781 so refrain from splatting them. */
782 if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
783 rd.mctime = cpu_to_je32(JFFS2_F_I_MTIME(f));
784 else
784 else
785 rd.mctime = cpu_to_je32(0);
786 rd.type = fd->type;
787 rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
788 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
785 rd.mctime = cpu_to_je32(0);
786 rd.type = fd->type;
787 rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
788 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
789
789
790 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &phys_ofs, &alloclen,
791 JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize));
792 if (ret) {
793 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
794 sizeof(rd)+rd.nsize, ret);
795 return ret;
796 }
797 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, phys_ofs, ALLOC_GC);
798
799 if (IS_ERR(new_fd)) {
800 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd));
801 return PTR_ERR(new_fd);
802 }
803 jffs2_add_fd_to_list(c, new_fd, &f->dents);
804 return 0;
805}
806
790 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &phys_ofs, &alloclen,
791 JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize));
792 if (ret) {
793 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
794 sizeof(rd)+rd.nsize, ret);
795 return ret;
796 }
797 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, phys_ofs, ALLOC_GC);
798
799 if (IS_ERR(new_fd)) {
800 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd));
801 return PTR_ERR(new_fd);
802 }
803 jffs2_add_fd_to_list(c, new_fd, &f->dents);
804 return 0;
805}
806
807static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
807static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
808 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
809{
810 struct jffs2_full_dirent **fdp = &f->dents;
811 int found = 0;
812
813 /* On a medium where we can't actually mark nodes obsolete
814 pernamently, such as NAND flash, we need to work out
815 whether this deletion dirent is still needed to actively

--- 22 unchanged lines hidden (view full) ---

838 /* We only care about obsolete ones */
839 if (!(ref_obsolete(raw)))
840 continue;
841
842 /* Any dirent with the same name is going to have the same length... */
843 if (ref_totlen(c, NULL, raw) != rawlen)
844 continue;
845
808 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
809{
810 struct jffs2_full_dirent **fdp = &f->dents;
811 int found = 0;
812
813 /* On a medium where we can't actually mark nodes obsolete
814 pernamently, such as NAND flash, we need to work out
815 whether this deletion dirent is still needed to actively

--- 22 unchanged lines hidden (view full) ---

838 /* We only care about obsolete ones */
839 if (!(ref_obsolete(raw)))
840 continue;
841
842 /* Any dirent with the same name is going to have the same length... */
843 if (ref_totlen(c, NULL, raw) != rawlen)
844 continue;
845
846 /* Doesn't matter if there's one in the same erase block. We're going to
846 /* Doesn't matter if there's one in the same erase block. We're going to
847 delete it too at the same time. */
848 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset))
849 continue;
850
851 D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw)));
852
853 /* This is an obsolete node belonging to the same directory, and it's of the right
854 length. We need to take a closer look...*/

--- 35 unchanged lines hidden (view full) ---

890
891 return jffs2_garbage_collect_dirent(c, jeb, f, fd);
892 }
893
894 up(&c->erase_free_sem);
895 kfree(rd);
896 }
897
847 delete it too at the same time. */
848 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset))
849 continue;
850
851 D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw)));
852
853 /* This is an obsolete node belonging to the same directory, and it's of the right
854 length. We need to take a closer look...*/

--- 35 unchanged lines hidden (view full) ---

890
891 return jffs2_garbage_collect_dirent(c, jeb, f, fd);
892 }
893
894 up(&c->erase_free_sem);
895 kfree(rd);
896 }
897
898 /* FIXME: If we're deleting a dirent which contains the current mtime and ctime,
898 /* FIXME: If we're deleting a dirent which contains the current mtime and ctime,
899 we should update the metadata node with those times accordingly */
900
901 /* No need for it any more. Just mark it obsolete and remove it from the list */
902 while (*fdp) {
903 if ((*fdp) == fd) {
904 found = 1;
905 *fdp = fd->next;
906 break;

--- 15 unchanged lines hidden (view full) ---

922 struct jffs2_raw_inode ri;
923 struct jffs2_node_frag *frag;
924 struct jffs2_full_dnode *new_fn;
925 uint32_t alloclen, phys_ofs, ilen;
926 int ret;
927
928 D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
929 f->inocache->ino, start, end));
899 we should update the metadata node with those times accordingly */
900
901 /* No need for it any more. Just mark it obsolete and remove it from the list */
902 while (*fdp) {
903 if ((*fdp) == fd) {
904 found = 1;
905 *fdp = fd->next;
906 break;

--- 15 unchanged lines hidden (view full) ---

922 struct jffs2_raw_inode ri;
923 struct jffs2_node_frag *frag;
924 struct jffs2_full_dnode *new_fn;
925 uint32_t alloclen, phys_ofs, ilen;
926 int ret;
927
928 D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
929 f->inocache->ino, start, end));
930
930
931 memset(&ri, 0, sizeof(ri));
932
933 if(fn->frags > 1) {
934 size_t readlen;
935 uint32_t crc;
931 memset(&ri, 0, sizeof(ri));
932
933 if(fn->frags > 1) {
934 size_t readlen;
935 uint32_t crc;
936 /* It's partially obsoleted by a later write. So we have to
936 /* It's partially obsoleted by a later write. So we have to
937 write it out again with the _same_ version as before */
938 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri);
939 if (readlen != sizeof(ri) || ret) {
940 printk(KERN_WARNING "Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen);
941 goto fill;
942 }
943 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) {
944 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",

--- 5 unchanged lines hidden (view full) ---

950 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
951 ref_offset(fn->raw),
952 je32_to_cpu(ri.totlen), sizeof(ri));
953 return -EIO;
954 }
955 crc = crc32(0, &ri, sizeof(ri)-8);
956 if (crc != je32_to_cpu(ri.node_crc)) {
957 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
937 write it out again with the _same_ version as before */
938 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri);
939 if (readlen != sizeof(ri) || ret) {
940 printk(KERN_WARNING "Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen);
941 goto fill;
942 }
943 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) {
944 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",

--- 5 unchanged lines hidden (view full) ---

950 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
951 ref_offset(fn->raw),
952 je32_to_cpu(ri.totlen), sizeof(ri));
953 return -EIO;
954 }
955 crc = crc32(0, &ri, sizeof(ri)-8);
956 if (crc != je32_to_cpu(ri.node_crc)) {
957 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
958 ref_offset(fn->raw),
958 ref_offset(fn->raw),
959 je32_to_cpu(ri.node_crc), crc);
960 /* FIXME: We could possibly deal with this by writing new holes for each frag */
959 je32_to_cpu(ri.node_crc), crc);
960 /* FIXME: We could possibly deal with this by writing new holes for each frag */
961 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
961 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
962 start, end, f->inocache->ino);
963 goto fill;
964 }
965 if (ri.compr != JFFS2_COMPR_ZERO) {
966 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw));
962 start, end, f->inocache->ino);
963 goto fill;
964 }
965 if (ri.compr != JFFS2_COMPR_ZERO) {
966 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw));
967 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
967 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
968 start, end, f->inocache->ino);
969 goto fill;
970 }
971 } else {
972 fill:
973 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
974 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
975 ri.totlen = cpu_to_je32(sizeof(ri));
976 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
977
978 ri.ino = cpu_to_je32(f->inocache->ino);
979 ri.version = cpu_to_je32(++f->highest_version);
980 ri.offset = cpu_to_je32(start);
981 ri.dsize = cpu_to_je32(end - start);
982 ri.csize = cpu_to_je32(0);
983 ri.compr = JFFS2_COMPR_ZERO;
984 }
968 start, end, f->inocache->ino);
969 goto fill;
970 }
971 } else {
972 fill:
973 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
974 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
975 ri.totlen = cpu_to_je32(sizeof(ri));
976 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
977
978 ri.ino = cpu_to_je32(f->inocache->ino);
979 ri.version = cpu_to_je32(++f->highest_version);
980 ri.offset = cpu_to_je32(start);
981 ri.dsize = cpu_to_je32(end - start);
982 ri.csize = cpu_to_je32(0);
983 ri.compr = JFFS2_COMPR_ZERO;
984 }
985
985
986 frag = frag_last(&f->fragtree);
987 if (frag)
988 /* Fetch the inode length from the fragtree rather then
989 * from i_size since i_size may have not been updated yet */
990 ilen = frag->ofs + frag->size;
991 else
992 ilen = JFFS2_F_I_SIZE(f);
993

--- 25 unchanged lines hidden (view full) ---

1019 if (f->metadata) {
1020 jffs2_mark_node_obsolete(c, f->metadata->raw);
1021 jffs2_free_full_dnode(f->metadata);
1022 f->metadata = NULL;
1023 }
1024 return 0;
1025 }
1026
986 frag = frag_last(&f->fragtree);
987 if (frag)
988 /* Fetch the inode length from the fragtree rather then
989 * from i_size since i_size may have not been updated yet */
990 ilen = frag->ofs + frag->size;
991 else
992 ilen = JFFS2_F_I_SIZE(f);
993

--- 25 unchanged lines hidden (view full) ---

1019 if (f->metadata) {
1020 jffs2_mark_node_obsolete(c, f->metadata->raw);
1021 jffs2_free_full_dnode(f->metadata);
1022 f->metadata = NULL;
1023 }
1024 return 0;
1025 }
1026
1027 /*
1027 /*
1028 * We should only get here in the case where the node we are
1029 * replacing had more than one frag, so we kept the same version
1028 * We should only get here in the case where the node we are
1029 * replacing had more than one frag, so we kept the same version
1030 * number as before. (Except in case of error -- see 'goto fill;'
1030 * number as before. (Except in case of error -- see 'goto fill;'
1031 * above.)
1032 */
1033 D1(if(unlikely(fn->frags <= 1)) {
1034 printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n",
1035 fn->frags, je32_to_cpu(ri.version), f->highest_version,
1036 je32_to_cpu(ri.ino));
1037 });
1038
1039 /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */
1040 mark_ref_normal(new_fn->raw);
1041
1031 * above.)
1032 */
1033 D1(if(unlikely(fn->frags <= 1)) {
1034 printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n",
1035 fn->frags, je32_to_cpu(ri.version), f->highest_version,
1036 je32_to_cpu(ri.ino));
1037 });
1038
1039 /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */
1040 mark_ref_normal(new_fn->raw);
1041
1042 for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
1042 for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
1043 frag; frag = frag_next(frag)) {
1044 if (frag->ofs > fn->size + fn->ofs)
1045 break;
1046 if (frag->node == fn) {
1047 frag->node = new_fn;
1048 new_fn->frags++;
1049 fn->frags--;
1050 }
1051 }
1052 if (fn->frags) {
1053 printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n");
1054 BUG();
1055 }
1056 if (!new_fn->frags) {
1057 printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n");
1058 BUG();
1059 }
1043 frag; frag = frag_next(frag)) {
1044 if (frag->ofs > fn->size + fn->ofs)
1045 break;
1046 if (frag->node == fn) {
1047 frag->node = new_fn;
1048 new_fn->frags++;
1049 fn->frags--;
1050 }
1051 }
1052 if (fn->frags) {
1053 printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n");
1054 BUG();
1055 }
1056 if (!new_fn->frags) {
1057 printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n");
1058 BUG();
1059 }
1060
1060
1061 jffs2_mark_node_obsolete(c, fn->raw);
1062 jffs2_free_full_dnode(fn);
1061 jffs2_mark_node_obsolete(c, fn->raw);
1062 jffs2_free_full_dnode(fn);
1063
1063
1064 return 0;
1065}
1066
1067static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
1068 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
1069 uint32_t start, uint32_t end)
1070{
1071 struct jffs2_full_dnode *new_fn;
1072 struct jffs2_raw_inode ri;
1064 return 0;
1065}
1066
1067static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
1068 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
1069 uint32_t start, uint32_t end)
1070{
1071 struct jffs2_full_dnode *new_fn;
1072 struct jffs2_raw_inode ri;
1073 uint32_t alloclen, phys_ofs, offset, orig_end, orig_start;
1073 uint32_t alloclen, phys_ofs, offset, orig_end, orig_start;
1074 int ret = 0;
1075 unsigned char *comprbuf = NULL, *writebuf;
1076 unsigned long pg;
1077 unsigned char *pg_ptr;
1074 int ret = 0;
1075 unsigned char *comprbuf = NULL, *writebuf;
1076 unsigned long pg;
1077 unsigned char *pg_ptr;
1078
1078
1079 memset(&ri, 0, sizeof(ri));
1080
1081 D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n",
1082 f->inocache->ino, start, end));
1083
1084 orig_end = end;
1085 orig_start = start;
1086
1087 if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
1088 /* Attempt to do some merging. But only expand to cover logically
1089 adjacent frags if the block containing them is already considered
1079 memset(&ri, 0, sizeof(ri));
1080
1081 D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n",
1082 f->inocache->ino, start, end));
1083
1084 orig_end = end;
1085 orig_start = start;
1086
1087 if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
1088 /* Attempt to do some merging. But only expand to cover logically
1089 adjacent frags if the block containing them is already considered
1090 to be dirty. Otherwise we end up with GC just going round in
1091 circles dirtying the nodes it already wrote out, especially
1090 to be dirty. Otherwise we end up with GC just going round in
1091 circles dirtying the nodes it already wrote out, especially
1092 on NAND where we have small eraseblocks and hence a much higher
1093 chance of nodes having to be split to cross boundaries. */
1094
1095 struct jffs2_node_frag *frag;
1096 uint32_t min, max;
1097
1098 min = start & ~(PAGE_CACHE_SIZE-1);
1099 max = min + PAGE_CACHE_SIZE;

--- 17 unchanged lines hidden (view full) ---

1117 }
1118 /* OK. This frag holds the first byte of the page. */
1119 if (!frag->node || !frag->node->raw) {
1120 D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n",
1121 frag->ofs, frag->ofs+frag->size));
1122 break;
1123 } else {
1124
1092 on NAND where we have small eraseblocks and hence a much higher
1093 chance of nodes having to be split to cross boundaries. */
1094
1095 struct jffs2_node_frag *frag;
1096 uint32_t min, max;
1097
1098 min = start & ~(PAGE_CACHE_SIZE-1);
1099 max = min + PAGE_CACHE_SIZE;

--- 17 unchanged lines hidden (view full) ---

1117 }
1118 /* OK. This frag holds the first byte of the page. */
1119 if (!frag->node || !frag->node->raw) {
1120 D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n",
1121 frag->ofs, frag->ofs+frag->size));
1122 break;
1123 } else {
1124
1125 /* OK, it's a frag which extends to the beginning of the page. Does it live
1125 /* OK, it's a frag which extends to the beginning of the page. Does it live
1126 in a block which is still considered clean? If so, don't obsolete it.
1127 If not, cover it anyway. */
1128
1129 struct jffs2_raw_node_ref *raw = frag->node->raw;
1130 struct jffs2_eraseblock *jeb;
1131
1132 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1133

--- 33 unchanged lines hidden (view full) ---

1167 }
1168
1169 if (!frag->node || !frag->node->raw) {
1170 D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n",
1171 frag->ofs, frag->ofs+frag->size));
1172 break;
1173 } else {
1174
1126 in a block which is still considered clean? If so, don't obsolete it.
1127 If not, cover it anyway. */
1128
1129 struct jffs2_raw_node_ref *raw = frag->node->raw;
1130 struct jffs2_eraseblock *jeb;
1131
1132 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1133

--- 33 unchanged lines hidden (view full) ---

1167 }
1168
1169 if (!frag->node || !frag->node->raw) {
1170 D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n",
1171 frag->ofs, frag->ofs+frag->size));
1172 break;
1173 } else {
1174
1175 /* OK, it's a frag which extends to the beginning of the page. Does it live
1175 /* OK, it's a frag which extends to the beginning of the page. Does it live
1176 in a block which is still considered clean? If so, don't obsolete it.
1177 If not, cover it anyway. */
1178
1179 struct jffs2_raw_node_ref *raw = frag->node->raw;
1180 struct jffs2_eraseblock *jeb;
1181
1182 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1183

--- 10 unchanged lines hidden (view full) ---

1194 }
1195
1196 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n",
1197 frag->ofs, frag->ofs+frag->size, jeb->offset));
1198 end = frag->ofs + frag->size;
1199 break;
1200 }
1201 }
1176 in a block which is still considered clean? If so, don't obsolete it.
1177 If not, cover it anyway. */
1178
1179 struct jffs2_raw_node_ref *raw = frag->node->raw;
1180 struct jffs2_eraseblock *jeb;
1181
1182 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1183

--- 10 unchanged lines hidden (view full) ---

1194 }
1195
1196 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n",
1197 frag->ofs, frag->ofs+frag->size, jeb->offset));
1198 end = frag->ofs + frag->size;
1199 break;
1200 }
1201 }
1202 D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n",
1202 D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n",
1203 orig_start, orig_end, start, end));
1204
1205 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size));
1206 BUG_ON(end < orig_end);
1207 BUG_ON(start > orig_start);
1208 }
1203 orig_start, orig_end, start, end));
1204
1205 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size));
1206 BUG_ON(end < orig_end);
1207 BUG_ON(start > orig_start);
1208 }
1209
1209
1210 /* First, use readpage() to read the appropriate page into the page cache */
1211 /* Q: What happens if we actually try to GC the _same_ page for which commit_write()
1212 * triggered garbage collection in the first place?
1213 * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the
1214 * page OK. We'll actually write it out again in commit_write, which is a little
1215 * suboptimal, but at least we're correct.
1216 */
1217 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);

--- 40 unchanged lines hidden (view full) ---

1258 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1259 ri.offset = cpu_to_je32(offset);
1260 ri.csize = cpu_to_je32(cdatalen);
1261 ri.dsize = cpu_to_je32(datalen);
1262 ri.compr = comprtype & 0xff;
1263 ri.usercompr = (comprtype >> 8) & 0xff;
1264 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1265 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1210 /* First, use readpage() to read the appropriate page into the page cache */
1211 /* Q: What happens if we actually try to GC the _same_ page for which commit_write()
1212 * triggered garbage collection in the first place?
1213 * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the
1214 * page OK. We'll actually write it out again in commit_write, which is a little
1215 * suboptimal, but at least we're correct.
1216 */
1217 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);

--- 40 unchanged lines hidden (view full) ---

1258 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1259 ri.offset = cpu_to_je32(offset);
1260 ri.csize = cpu_to_je32(cdatalen);
1261 ri.dsize = cpu_to_je32(datalen);
1262 ri.compr = comprtype & 0xff;
1263 ri.usercompr = (comprtype >> 8) & 0xff;
1264 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1265 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1266
1266
1267 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, phys_ofs, ALLOC_GC);
1268
1269 jffs2_free_comprbuf(comprbuf, writebuf);
1270
1271 if (IS_ERR(new_fn)) {
1272 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1273 ret = PTR_ERR(new_fn);
1274 break;

--- 13 unchanged lines hidden --- 		1267 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, phys_ofs, ALLOC_GC);
1268
1269 jffs2_free_comprbuf(comprbuf, writebuf);
1270
1271 if (IS_ERR(new_fn)) {
1272 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1273 ret = PTR_ERR(new_fn);
1274 break;

--- 13 unchanged lines hidden ---