aboutsummaryrefslogtreecommitdiffstats
path: root/fs/jffs2/gc.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/jffs2/gc.c')
-rw-r--r--fs/jffs2/gc.c1246
1 files changed, 1246 insertions, 0 deletions
diff --git a/fs/jffs2/gc.c b/fs/jffs2/gc.c
new file mode 100644
index 000000000000..87ec74ff5930
--- /dev/null
+++ b/fs/jffs2/gc.c
@@ -0,0 +1,1246 @@
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.144 2004/12/21 11:18:50 dwmw2 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
24static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
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,
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,
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,
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,
40 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f);
41
42/* Called with erase_completion_lock held */
43static struct jffs2_eraseblock *jffs2_find_gc_block(struct jffs2_sb_info *c)
44{
45 struct jffs2_eraseblock *ret;
46 struct list_head *nextlist = NULL;
47 int n = jiffies % 128;
48
49 /* Pick an eraseblock to garbage collect next. This is where we'll
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. */
53 if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
54 D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n"));
55 nextlist = &c->bad_used_list;
56 } else if (n < 50 && !list_empty(&c->erasable_list)) {
57 /* Note that most of them will have gone directly to be erased.
58 So don't favour the erasable_list _too_ much. */
59 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n"));
60 nextlist = &c->erasable_list;
61 } else if (n < 110 && !list_empty(&c->very_dirty_list)) {
62 /* Most of the time, pick one off the very_dirty list */
63 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n"));
64 nextlist = &c->very_dirty_list;
65 } else if (n < 126 && !list_empty(&c->dirty_list)) {
66 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next\n"));
67 nextlist = &c->dirty_list;
68 } else if (!list_empty(&c->clean_list)) {
69 D1(printk(KERN_DEBUG "Picking block from clean_list to GC next\n"));
70 nextlist = &c->clean_list;
71 } else if (!list_empty(&c->dirty_list)) {
72 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next (clean_list was empty)\n"));
73
74 nextlist = &c->dirty_list;
75 } else if (!list_empty(&c->very_dirty_list)) {
76 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n"));
77 nextlist = &c->very_dirty_list;
78 } else if (!list_empty(&c->erasable_list)) {
79 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n"));
80
81 nextlist = &c->erasable_list;
82 } else {
83 /* Eep. All were empty */
84 D1(printk(KERN_NOTICE "jffs2: No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n"));
85 return NULL;
86 }
87
88 ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
89 list_del(&ret->list);
90 c->gcblock = ret;
91 ret->gc_node = ret->first_node;
92 if (!ret->gc_node) {
93 printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset);
94 BUG();
95 }
96
97 /* Have we accidentally picked a clean block with wasted space ? */
98 if (ret->wasted_size) {
99 D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size));
100 ret->dirty_size += ret->wasted_size;
101 c->wasted_size -= ret->wasted_size;
102 c->dirty_size += ret->wasted_size;
103 ret->wasted_size = 0;
104 }
105
106 D2(jffs2_dump_block_lists(c));
107 return ret;
108}
109
110/* jffs2_garbage_collect_pass
111 * Make a single attempt to progress GC. Move one node, and possibly
112 * start erasing one eraseblock.
113 */
114int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
115{
116 struct jffs2_inode_info *f;
117 struct jffs2_inode_cache *ic;
118 struct jffs2_eraseblock *jeb;
119 struct jffs2_raw_node_ref *raw;
120 int ret = 0, inum, nlink;
121
122 if (down_interruptible(&c->alloc_sem))
123 return -EINTR;
124
125 for (;;) {
126 spin_lock(&c->erase_completion_lock);
127 if (!c->unchecked_size)
128 break;
129
130 /* We can't start doing GC yet. We haven't finished checking
131 the node CRCs etc. Do it now. */
132
133 /* checked_ino is protected by the alloc_sem */
134 if (c->checked_ino > c->highest_ino) {
135 printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
136 c->unchecked_size);
137 D2(jffs2_dump_block_lists(c));
138 spin_unlock(&c->erase_completion_lock);
139 BUG();
140 }
141
142 spin_unlock(&c->erase_completion_lock);
143
144 spin_lock(&c->inocache_lock);
145
146 ic = jffs2_get_ino_cache(c, c->checked_ino++);
147
148 if (!ic) {
149 spin_unlock(&c->inocache_lock);
150 continue;
151 }
152
153 if (!ic->nlink) {
154 D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink zero\n",
155 ic->ino));
156 spin_unlock(&c->inocache_lock);
157 continue;
158 }
159 switch(ic->state) {
160 case INO_STATE_CHECKEDABSENT:
161 case INO_STATE_PRESENT:
162 D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino));
163 spin_unlock(&c->inocache_lock);
164 continue;
165
166 case INO_STATE_GC:
167 case INO_STATE_CHECKING:
168 printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state);
169 spin_unlock(&c->inocache_lock);
170 BUG();
171
172 case INO_STATE_READING:
173 /* We need to wait for it to finish, lest we move on
174 and trigger the BUG() above while we haven't yet
175 finished checking all its nodes */
176 D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino));
177 up(&c->alloc_sem);
178 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
179 return 0;
180
181 default:
182 BUG();
183
184 case INO_STATE_UNCHECKED:
185 ;
186 }
187 ic->state = INO_STATE_CHECKING;
188 spin_unlock(&c->inocache_lock);
189
190 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino));
191
192 ret = jffs2_do_crccheck_inode(c, ic);
193 if (ret)
194 printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino);
195
196 jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
197 up(&c->alloc_sem);
198 return ret;
199 }
200
201 /* First, work out which block we're garbage-collecting */
202 jeb = c->gcblock;
203
204 if (!jeb)
205 jeb = jffs2_find_gc_block(c);
206
207 if (!jeb) {
208 D1 (printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n"));
209 spin_unlock(&c->erase_completion_lock);
210 up(&c->alloc_sem);
211 return -EIO;
212 }
213
214 D1(printk(KERN_DEBUG "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n", jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size));
215 D1(if (c->nextblock)
216 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));
217
218 if (!jeb->used_size) {
219 up(&c->alloc_sem);
220 goto eraseit;
221 }
222
223 raw = jeb->gc_node;
224
225 while(ref_obsolete(raw)) {
226 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw)));
227 raw = raw->next_phys;
228 if (unlikely(!raw)) {
229 printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n");
230 printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
231 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size);
232 jeb->gc_node = raw;
233 spin_unlock(&c->erase_completion_lock);
234 up(&c->alloc_sem);
235 BUG();
236 }
237 }
238 jeb->gc_node = raw;
239
240 D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw)));
241
242 if (!raw->next_in_ino) {
243 /* Inode-less node. Clean marker, snapshot or something like that */
244 /* FIXME: If it's something that needs to be copied, including something
245 we don't grok that has JFFS2_NODETYPE_RWCOMPAT_COPY, we should do so */
246 spin_unlock(&c->erase_completion_lock);
247 jffs2_mark_node_obsolete(c, raw);
248 up(&c->alloc_sem);
249 goto eraseit_lock;
250 }
251
252 ic = jffs2_raw_ref_to_ic(raw);
253
254 /* We need to hold the inocache. Either the erase_completion_lock or
255 the inocache_lock are sufficient; we trade down since the inocache_lock
256 causes less contention. */
257 spin_lock(&c->inocache_lock);
258
259 spin_unlock(&c->erase_completion_lock);
260
261 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));
262
263 /* Three possibilities:
264 1. Inode is already in-core. We must iget it and do proper
265 updating to its fragtree, etc.
266 2. Inode is not in-core, node is REF_PRISTINE. We lock the
267 inocache to prevent a read_inode(), copy the node intact.
268 3. Inode is not in-core, node is not pristine. We must iget()
269 and take the slow path.
270 */
271
272 switch(ic->state) {
273 case INO_STATE_CHECKEDABSENT:
274 /* It's been checked, but it's not currently in-core.
275 We can just copy any pristine nodes, but have
276 to prevent anyone else from doing read_inode() while
277 we're at it, so we set the state accordingly */
278 if (ref_flags(raw) == REF_PRISTINE)
279 ic->state = INO_STATE_GC;
280 else {
281 D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n",
282 ic->ino));
283 }
284 break;
285
286 case INO_STATE_PRESENT:
287 /* It's in-core. GC must iget() it. */
288 break;
289
290 case INO_STATE_UNCHECKED:
291 case INO_STATE_CHECKING:
292 case INO_STATE_GC:
293 /* Should never happen. We should have finished checking
294 by the time we actually start doing any GC, and since
295 we're holding the alloc_sem, no other garbage collection
296 can happen.
297 */
298 printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
299 ic->ino, ic->state);
300 up(&c->alloc_sem);
301 spin_unlock(&c->inocache_lock);
302 BUG();
303
304 case INO_STATE_READING:
305 /* Someone's currently trying to read it. We must wait for
306 them to finish and then go through the full iget() route
307 to do the GC. However, sometimes read_inode() needs to get
308 the alloc_sem() (for marking nodes invalid) so we must
309 drop the alloc_sem before sleeping. */
310
311 up(&c->alloc_sem);
312 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n",
313 ic->ino, ic->state));
314 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
315 /* And because we dropped the alloc_sem we must start again from the
316 beginning. Ponder chance of livelock here -- we're returning success
317 without actually making any progress.
318
319 Q: What are the chances that the inode is back in INO_STATE_READING
320 again by the time we next enter this function? And that this happens
321 enough times to cause a real delay?
322
323 A: Small enough that I don't care :)
324 */
325 return 0;
326 }
327
328 /* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the
329 node intact, and we don't have to muck about with the fragtree etc.
330 because we know it's not in-core. If it _was_ in-core, we go through
331 all the iget() crap anyway */
332
333 if (ic->state == INO_STATE_GC) {
334 spin_unlock(&c->inocache_lock);
335
336 ret = jffs2_garbage_collect_pristine(c, ic, raw);
337
338 spin_lock(&c->inocache_lock);
339 ic->state = INO_STATE_CHECKEDABSENT;
340 wake_up(&c->inocache_wq);
341
342 if (ret != -EBADFD) {
343 spin_unlock(&c->inocache_lock);
344 goto release_sem;
345 }
346
347 /* Fall through if it wanted us to, with inocache_lock held */
348 }
349
350 /* Prevent the fairly unlikely race where the gcblock is
351 entirely obsoleted by the final close of a file which had
352 the only valid nodes in the block, followed by erasure,
353 followed by freeing of the ic because the erased block(s)
354 held _all_ the nodes of that inode.... never been seen but
355 it's vaguely possible. */
356
357 inum = ic->ino;
358 nlink = ic->nlink;
359 spin_unlock(&c->inocache_lock);
360
361 f = jffs2_gc_fetch_inode(c, inum, nlink);
362 if (IS_ERR(f)) {
363 ret = PTR_ERR(f);
364 goto release_sem;
365 }
366 if (!f) {
367 ret = 0;
368 goto release_sem;
369 }
370
371 ret = jffs2_garbage_collect_live(c, jeb, raw, f);
372
373 jffs2_gc_release_inode(c, f);
374
375 release_sem:
376 up(&c->alloc_sem);
377
378 eraseit_lock:
379 /* If we've finished this block, start it erasing */
380 spin_lock(&c->erase_completion_lock);
381
382 eraseit:
383 if (c->gcblock && !c->gcblock->used_size) {
384 D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset));
385 /* We're GC'ing an empty block? */
386 list_add_tail(&c->gcblock->list, &c->erase_pending_list);
387 c->gcblock = NULL;
388 c->nr_erasing_blocks++;
389 jffs2_erase_pending_trigger(c);
390 }
391 spin_unlock(&c->erase_completion_lock);
392
393 return ret;
394}
395
396static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
397 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f)
398{
399 struct jffs2_node_frag *frag;
400 struct jffs2_full_dnode *fn = NULL;
401 struct jffs2_full_dirent *fd;
402 uint32_t start = 0, end = 0, nrfrags = 0;
403 int ret = 0;
404
405 down(&f->sem);
406
407 /* Now we have the lock for this inode. Check that it's still the one at the head
408 of the list. */
409
410 spin_lock(&c->erase_completion_lock);
411
412 if (c->gcblock != jeb) {
413 spin_unlock(&c->erase_completion_lock);
414 D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n"));
415 goto upnout;
416 }
417 if (ref_obsolete(raw)) {
418 spin_unlock(&c->erase_completion_lock);
419 D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n"));
420 /* They'll call again */
421 goto upnout;
422 }
423 spin_unlock(&c->erase_completion_lock);
424
425 /* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */
426 if (f->metadata && f->metadata->raw == raw) {
427 fn = f->metadata;
428 ret = jffs2_garbage_collect_metadata(c, jeb, f, fn);
429 goto upnout;
430 }
431
432 /* FIXME. Read node and do lookup? */
433 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
434 if (frag->node && frag->node->raw == raw) {
435 fn = frag->node;
436 end = frag->ofs + frag->size;
437 if (!nrfrags++)
438 start = frag->ofs;
439 if (nrfrags == frag->node->frags)
440 break; /* We've found them all */
441 }
442 }
443 if (fn) {
444 if (ref_flags(raw) == REF_PRISTINE) {
445 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
446 if (!ret) {
447 /* Urgh. Return it sensibly. */
448 frag->node->raw = f->inocache->nodes;
449 }
450 if (ret != -EBADFD)
451 goto upnout;
452 }
453 /* We found a datanode. Do the GC */
454 if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) {
455 /* It crosses a page boundary. Therefore, it must be a hole. */
456 ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end);
457 } else {
458 /* It could still be a hole. But we GC the page this way anyway */
459 ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end);
460 }
461 goto upnout;
462 }
463
464 /* Wasn't a dnode. Try dirent */
465 for (fd = f->dents; fd; fd=fd->next) {
466 if (fd->raw == raw)
467 break;
468 }
469
470 if (fd && fd->ino) {
471 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
472 } else if (fd) {
473 ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
474 } else {
475 printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n",
476 ref_offset(raw), f->inocache->ino);
477 if (ref_obsolete(raw)) {
478 printk(KERN_WARNING "But it's obsolete so we don't mind too much\n");
479 } else {
480 ret = -EIO;
481 }
482 }
483 upnout:
484 up(&f->sem);
485
486 return ret;
487}
488
489static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
490 struct jffs2_inode_cache *ic,
491 struct jffs2_raw_node_ref *raw)
492{
493 union jffs2_node_union *node;
494 struct jffs2_raw_node_ref *nraw;
495 size_t retlen;
496 int ret;
497 uint32_t phys_ofs, alloclen;
498 uint32_t crc, rawlen;
499 int retried = 0;
500
501 D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw)));
502
503 rawlen = ref_totlen(c, c->gcblock, raw);
504
505 /* Ask for a small amount of space (or the totlen if smaller) because we
506 don't want to force wastage of the end of a block if splitting would
507 work. */
508 ret = jffs2_reserve_space_gc(c, min_t(uint32_t, sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN,
509 rawlen), &phys_ofs, &alloclen);
510 if (ret)
511 return ret;
512
513 if (alloclen < rawlen) {
514 /* Doesn't fit untouched. We'll go the old route and split it */
515 return -EBADFD;
516 }
517
518 node = kmalloc(rawlen, GFP_KERNEL);
519 if (!node)
520 return -ENOMEM;
521
522 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)node);
523 if (!ret && retlen != rawlen)
524 ret = -EIO;
525 if (ret)
526 goto out_node;
527
528 crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4);
529 if (je32_to_cpu(node->u.hdr_crc) != crc) {
530 printk(KERN_WARNING "Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
531 ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc);
532 goto bail;
533 }
534
535 switch(je16_to_cpu(node->u.nodetype)) {
536 case JFFS2_NODETYPE_INODE:
537 crc = crc32(0, node, sizeof(node->i)-8);
538 if (je32_to_cpu(node->i.node_crc) != crc) {
539 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
540 ref_offset(raw), je32_to_cpu(node->i.node_crc), crc);
541 goto bail;
542 }
543
544 if (je32_to_cpu(node->i.dsize)) {
545 crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize));
546 if (je32_to_cpu(node->i.data_crc) != crc) {
547 printk(KERN_WARNING "Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
548 ref_offset(raw), je32_to_cpu(node->i.data_crc), crc);
549 goto bail;
550 }
551 }
552 break;
553
554 case JFFS2_NODETYPE_DIRENT:
555 crc = crc32(0, node, sizeof(node->d)-8);
556 if (je32_to_cpu(node->d.node_crc) != crc) {
557 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
558 ref_offset(raw), je32_to_cpu(node->d.node_crc), crc);
559 goto bail;
560 }
561
562 if (node->d.nsize) {
563 crc = crc32(0, node->d.name, node->d.nsize);
564 if (je32_to_cpu(node->d.name_crc) != crc) {
565 printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent ode at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
566 ref_offset(raw), je32_to_cpu(node->d.name_crc), crc);
567 goto bail;
568 }
569 }
570 break;
571 default:
572 printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
573 ref_offset(raw), je16_to_cpu(node->u.nodetype));
574 goto bail;
575 }
576
577 nraw = jffs2_alloc_raw_node_ref();
578 if (!nraw) {
579 ret = -ENOMEM;
580 goto out_node;
581 }
582
583 /* OK, all the CRCs are good; this node can just be copied as-is. */
584 retry:
585 nraw->flash_offset = phys_ofs;
586 nraw->__totlen = rawlen;
587 nraw->next_phys = NULL;
588
589 ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node);
590
591 if (ret || (retlen != rawlen)) {
592 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n",
593 rawlen, phys_ofs, ret, retlen);
594 if (retlen) {
595 /* Doesn't belong to any inode */
596 nraw->next_in_ino = NULL;
597
598 nraw->flash_offset |= REF_OBSOLETE;
599 jffs2_add_physical_node_ref(c, nraw);
600 jffs2_mark_node_obsolete(c, nraw);
601 } else {
602 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", nraw->flash_offset);
603 jffs2_free_raw_node_ref(nraw);
604 }
605 if (!retried && (nraw = jffs2_alloc_raw_node_ref())) {
606 /* Try to reallocate space and retry */
607 uint32_t dummy;
608 struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
609
610 retried = 1;
611
612 D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n"));
613
614 ACCT_SANITY_CHECK(c,jeb);
615 D1(ACCT_PARANOIA_CHECK(jeb));
616
617 ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy);
618
619 if (!ret) {
620 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs));
621
622 ACCT_SANITY_CHECK(c,jeb);
623 D1(ACCT_PARANOIA_CHECK(jeb));
624
625 goto retry;
626 }
627 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
628 jffs2_free_raw_node_ref(nraw);
629 }
630
631 jffs2_free_raw_node_ref(nraw);
632 if (!ret)
633 ret = -EIO;
634 goto out_node;
635 }
636 nraw->flash_offset |= REF_PRISTINE;
637 jffs2_add_physical_node_ref(c, nraw);
638
639 /* Link into per-inode list. This is safe because of the ic
640 state being INO_STATE_GC. Note that if we're doing this
641 for an inode which is in-core, the 'nraw' pointer is then
642 going to be fetched from ic->nodes by our caller. */
643 spin_lock(&c->erase_completion_lock);
644 nraw->next_in_ino = ic->nodes;
645 ic->nodes = nraw;
646 spin_unlock(&c->erase_completion_lock);
647
648 jffs2_mark_node_obsolete(c, raw);
649 D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw)));
650
651 out_node:
652 kfree(node);
653 return ret;
654 bail:
655 ret = -EBADFD;
656 goto out_node;
657}
658
659static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
660 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
661{
662 struct jffs2_full_dnode *new_fn;
663 struct jffs2_raw_inode ri;
664 jint16_t dev;
665 char *mdata = NULL, mdatalen = 0;
666 uint32_t alloclen, phys_ofs;
667 int ret;
668
669 if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
670 S_ISCHR(JFFS2_F_I_MODE(f)) ) {
671 /* For these, we don't actually need to read the old node */
672 /* FIXME: for minor or major > 255. */
673 dev = cpu_to_je16(((JFFS2_F_I_RDEV_MAJ(f) << 8) |
674 JFFS2_F_I_RDEV_MIN(f)));
675 mdata = (char *)&dev;
676 mdatalen = sizeof(dev);
677 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen));
678 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
679 mdatalen = fn->size;
680 mdata = kmalloc(fn->size, GFP_KERNEL);
681 if (!mdata) {
682 printk(KERN_WARNING "kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
683 return -ENOMEM;
684 }
685 ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen);
686 if (ret) {
687 printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret);
688 kfree(mdata);
689 return ret;
690 }
691 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen));
692
693 }
694
695 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &phys_ofs, &alloclen);
696 if (ret) {
697 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
698 sizeof(ri)+ mdatalen, ret);
699 goto out;
700 }
701
702 memset(&ri, 0, sizeof(ri));
703 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
704 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
705 ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
706 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
707
708 ri.ino = cpu_to_je32(f->inocache->ino);
709 ri.version = cpu_to_je32(++f->highest_version);
710 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
711 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
712 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
713 ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
714 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
715 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
716 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
717 ri.offset = cpu_to_je32(0);
718 ri.csize = cpu_to_je32(mdatalen);
719 ri.dsize = cpu_to_je32(mdatalen);
720 ri.compr = JFFS2_COMPR_NONE;
721 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
722 ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
723
724 new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, phys_ofs, ALLOC_GC);
725
726 if (IS_ERR(new_fn)) {
727 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
728 ret = PTR_ERR(new_fn);
729 goto out;
730 }
731 jffs2_mark_node_obsolete(c, fn->raw);
732 jffs2_free_full_dnode(fn);
733 f->metadata = new_fn;
734 out:
735 if (S_ISLNK(JFFS2_F_I_MODE(f)))
736 kfree(mdata);
737 return ret;
738}
739
740static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
741 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
742{
743 struct jffs2_full_dirent *new_fd;
744 struct jffs2_raw_dirent rd;
745 uint32_t alloclen, phys_ofs;
746 int ret;
747
748 rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
749 rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
750 rd.nsize = strlen(fd->name);
751 rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
752 rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
753
754 rd.pino = cpu_to_je32(f->inocache->ino);
755 rd.version = cpu_to_je32(++f->highest_version);
756 rd.ino = cpu_to_je32(fd->ino);
757 rd.mctime = cpu_to_je32(max(JFFS2_F_I_MTIME(f), JFFS2_F_I_CTIME(f)));
758 rd.type = fd->type;
759 rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
760 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
761
762 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &phys_ofs, &alloclen);
763 if (ret) {
764 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
765 sizeof(rd)+rd.nsize, ret);
766 return ret;
767 }
768 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, phys_ofs, ALLOC_GC);
769
770 if (IS_ERR(new_fd)) {
771 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd));
772 return PTR_ERR(new_fd);
773 }
774 jffs2_add_fd_to_list(c, new_fd, &f->dents);
775 return 0;
776}
777
778static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
779 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
780{
781 struct jffs2_full_dirent **fdp = &f->dents;
782 int found = 0;
783
784 /* On a medium where we can't actually mark nodes obsolete
785 pernamently, such as NAND flash, we need to work out
786 whether this deletion dirent is still needed to actively
787 delete a 'real' dirent with the same name that's still
788 somewhere else on the flash. */
789 if (!jffs2_can_mark_obsolete(c)) {
790 struct jffs2_raw_dirent *rd;
791 struct jffs2_raw_node_ref *raw;
792 int ret;
793 size_t retlen;
794 int name_len = strlen(fd->name);
795 uint32_t name_crc = crc32(0, fd->name, name_len);
796 uint32_t rawlen = ref_totlen(c, jeb, fd->raw);
797
798 rd = kmalloc(rawlen, GFP_KERNEL);
799 if (!rd)
800 return -ENOMEM;
801
802 /* Prevent the erase code from nicking the obsolete node refs while
803 we're looking at them. I really don't like this extra lock but
804 can't see any alternative. Suggestions on a postcard to... */
805 down(&c->erase_free_sem);
806
807 for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) {
808
809 /* We only care about obsolete ones */
810 if (!(ref_obsolete(raw)))
811 continue;
812
813 /* Any dirent with the same name is going to have the same length... */
814 if (ref_totlen(c, NULL, raw) != rawlen)
815 continue;
816
817 /* Doesn't matter if there's one in the same erase block. We're going to
818 delete it too at the same time. */
819 if ((raw->flash_offset & ~(c->sector_size-1)) ==
820 (fd->raw->flash_offset & ~(c->sector_size-1)))
821 continue;
822
823 D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw)));
824
825 /* This is an obsolete node belonging to the same directory, and it's of the right
826 length. We need to take a closer look...*/
827 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)rd);
828 if (ret) {
829 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Read error (%d) reading obsolete node at %08x\n", ret, ref_offset(raw));
830 /* If we can't read it, we don't need to continue to obsolete it. Continue */
831 continue;
832 }
833 if (retlen != rawlen) {
834 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Short read (%zd not %u) reading header from obsolete node at %08x\n",
835 retlen, rawlen, ref_offset(raw));
836 continue;
837 }
838
839 if (je16_to_cpu(rd->nodetype) != JFFS2_NODETYPE_DIRENT)
840 continue;
841
842 /* If the name CRC doesn't match, skip */
843 if (je32_to_cpu(rd->name_crc) != name_crc)
844 continue;
845
846 /* If the name length doesn't match, or it's another deletion dirent, skip */
847 if (rd->nsize != name_len || !je32_to_cpu(rd->ino))
848 continue;
849
850 /* OK, check the actual name now */
851 if (memcmp(rd->name, fd->name, name_len))
852 continue;
853
854 /* OK. The name really does match. There really is still an older node on
855 the flash which our deletion dirent obsoletes. So we have to write out
856 a new deletion dirent to replace it */
857 up(&c->erase_free_sem);
858
859 D1(printk(KERN_DEBUG "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n",
860 ref_offset(fd->raw), fd->name, ref_offset(raw), je32_to_cpu(rd->ino)));
861 kfree(rd);
862
863 return jffs2_garbage_collect_dirent(c, jeb, f, fd);
864 }
865
866 up(&c->erase_free_sem);
867 kfree(rd);
868 }
869
870 /* No need for it any more. Just mark it obsolete and remove it from the list */
871 while (*fdp) {
872 if ((*fdp) == fd) {
873 found = 1;
874 *fdp = fd->next;
875 break;
876 }
877 fdp = &(*fdp)->next;
878 }
879 if (!found) {
880 printk(KERN_WARNING "Deletion dirent \"%s\" not found in list for ino #%u\n", fd->name, f->inocache->ino);
881 }
882 jffs2_mark_node_obsolete(c, fd->raw);
883 jffs2_free_full_dirent(fd);
884 return 0;
885}
886
887static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
888 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
889 uint32_t start, uint32_t end)
890{
891 struct jffs2_raw_inode ri;
892 struct jffs2_node_frag *frag;
893 struct jffs2_full_dnode *new_fn;
894 uint32_t alloclen, phys_ofs;
895 int ret;
896
897 D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
898 f->inocache->ino, start, end));
899
900 memset(&ri, 0, sizeof(ri));
901
902 if(fn->frags > 1) {
903 size_t readlen;
904 uint32_t crc;
905 /* It's partially obsoleted by a later write. So we have to
906 write it out again with the _same_ version as before */
907 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri);
908 if (readlen != sizeof(ri) || ret) {
909 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);
910 goto fill;
911 }
912 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) {
913 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",
914 ref_offset(fn->raw),
915 je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE);
916 return -EIO;
917 }
918 if (je32_to_cpu(ri.totlen) != sizeof(ri)) {
919 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
920 ref_offset(fn->raw),
921 je32_to_cpu(ri.totlen), sizeof(ri));
922 return -EIO;
923 }
924 crc = crc32(0, &ri, sizeof(ri)-8);
925 if (crc != je32_to_cpu(ri.node_crc)) {
926 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
927 ref_offset(fn->raw),
928 je32_to_cpu(ri.node_crc), crc);
929 /* FIXME: We could possibly deal with this by writing new holes for each frag */
930 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
931 start, end, f->inocache->ino);
932 goto fill;
933 }
934 if (ri.compr != JFFS2_COMPR_ZERO) {
935 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw));
936 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
937 start, end, f->inocache->ino);
938 goto fill;
939 }
940 } else {
941 fill:
942 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
943 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
944 ri.totlen = cpu_to_je32(sizeof(ri));
945 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
946
947 ri.ino = cpu_to_je32(f->inocache->ino);
948 ri.version = cpu_to_je32(++f->highest_version);
949 ri.offset = cpu_to_je32(start);
950 ri.dsize = cpu_to_je32(end - start);
951 ri.csize = cpu_to_je32(0);
952 ri.compr = JFFS2_COMPR_ZERO;
953 }
954 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
955 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
956 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
957 ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
958 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
959 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
960 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
961 ri.data_crc = cpu_to_je32(0);
962 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
963
964 ret = jffs2_reserve_space_gc(c, sizeof(ri), &phys_ofs, &alloclen);
965 if (ret) {
966 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
967 sizeof(ri), ret);
968 return ret;
969 }
970 new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, phys_ofs, ALLOC_GC);
971
972 if (IS_ERR(new_fn)) {
973 printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn));
974 return PTR_ERR(new_fn);
975 }
976 if (je32_to_cpu(ri.version) == f->highest_version) {
977 jffs2_add_full_dnode_to_inode(c, f, new_fn);
978 if (f->metadata) {
979 jffs2_mark_node_obsolete(c, f->metadata->raw);
980 jffs2_free_full_dnode(f->metadata);
981 f->metadata = NULL;
982 }
983 return 0;
984 }
985
986 /*
987 * We should only get here in the case where the node we are
988 * replacing had more than one frag, so we kept the same version
989 * number as before. (Except in case of error -- see 'goto fill;'
990 * above.)
991 */
992 D1(if(unlikely(fn->frags <= 1)) {
993 printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n",
994 fn->frags, je32_to_cpu(ri.version), f->highest_version,
995 je32_to_cpu(ri.ino));
996 });
997
998 /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */
999 mark_ref_normal(new_fn->raw);
1000
1001 for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
1002 frag; frag = frag_next(frag)) {
1003 if (frag->ofs > fn->size + fn->ofs)
1004 break;
1005 if (frag->node == fn) {
1006 frag->node = new_fn;
1007 new_fn->frags++;
1008 fn->frags--;
1009 }
1010 }
1011 if (fn->frags) {
1012 printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n");
1013 BUG();
1014 }
1015 if (!new_fn->frags) {
1016 printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n");
1017 BUG();
1018 }
1019
1020 jffs2_mark_node_obsolete(c, fn->raw);
1021 jffs2_free_full_dnode(fn);
1022
1023 return 0;
1024}
1025
1026static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
1027 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
1028 uint32_t start, uint32_t end)
1029{
1030 struct jffs2_full_dnode *new_fn;
1031 struct jffs2_raw_inode ri;
1032 uint32_t alloclen, phys_ofs, offset, orig_end, orig_start;
1033 int ret = 0;
1034 unsigned char *comprbuf = NULL, *writebuf;
1035 unsigned long pg;
1036 unsigned char *pg_ptr;
1037
1038 memset(&ri, 0, sizeof(ri));
1039
1040 D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n",
1041 f->inocache->ino, start, end));
1042
1043 orig_end = end;
1044 orig_start = start;
1045
1046 if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
1047 /* Attempt to do some merging. But only expand to cover logically
1048 adjacent frags if the block containing them is already considered
1049 to be dirty. Otherwise we end up with GC just going round in
1050 circles dirtying the nodes it already wrote out, especially
1051 on NAND where we have small eraseblocks and hence a much higher
1052 chance of nodes having to be split to cross boundaries. */
1053
1054 struct jffs2_node_frag *frag;
1055 uint32_t min, max;
1056
1057 min = start & ~(PAGE_CACHE_SIZE-1);
1058 max = min + PAGE_CACHE_SIZE;
1059
1060 frag = jffs2_lookup_node_frag(&f->fragtree, start);
1061
1062 /* BUG_ON(!frag) but that'll happen anyway... */
1063
1064 BUG_ON(frag->ofs != start);
1065
1066 /* First grow down... */
1067 while((frag = frag_prev(frag)) && frag->ofs >= min) {
1068
1069 /* If the previous frag doesn't even reach the beginning, there's
1070 excessive fragmentation. Just merge. */
1071 if (frag->ofs > min) {
1072 D1(printk(KERN_DEBUG "Expanding down to cover partial frag (0x%x-0x%x)\n",
1073 frag->ofs, frag->ofs+frag->size));
1074 start = frag->ofs;
1075 continue;
1076 }
1077 /* OK. This frag holds the first byte of the page. */
1078 if (!frag->node || !frag->node->raw) {
1079 D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n",
1080 frag->ofs, frag->ofs+frag->size));
1081 break;
1082 } else {
1083
1084 /* OK, it's a frag which extends to the beginning of the page. Does it live
1085 in a block which is still considered clean? If so, don't obsolete it.
1086 If not, cover it anyway. */
1087
1088 struct jffs2_raw_node_ref *raw = frag->node->raw;
1089 struct jffs2_eraseblock *jeb;
1090
1091 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1092
1093 if (jeb == c->gcblock) {
1094 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1095 frag->ofs, frag->ofs+frag->size, ref_offset(raw)));
1096 start = frag->ofs;
1097 break;
1098 }
1099 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1100 D1(printk(KERN_DEBUG "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n",
1101 frag->ofs, frag->ofs+frag->size, jeb->offset));
1102 break;
1103 }
1104
1105 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n",
1106 frag->ofs, frag->ofs+frag->size, jeb->offset));
1107 start = frag->ofs;
1108 break;
1109 }
1110 }
1111
1112 /* ... then up */
1113
1114 /* Find last frag which is actually part of the node we're to GC. */
1115 frag = jffs2_lookup_node_frag(&f->fragtree, end-1);
1116
1117 while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
1118
1119 /* If the previous frag doesn't even reach the beginning, there's lots
1120 of fragmentation. Just merge. */
1121 if (frag->ofs+frag->size < max) {
1122 D1(printk(KERN_DEBUG "Expanding up to cover partial frag (0x%x-0x%x)\n",
1123 frag->ofs, frag->ofs+frag->size));
1124 end = frag->ofs + frag->size;
1125 continue;
1126 }
1127
1128 if (!frag->node || !frag->node->raw) {
1129 D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n",
1130 frag->ofs, frag->ofs+frag->size));
1131 break;
1132 } else {
1133
1134 /* OK, it's a frag which extends to the beginning of the page. Does it live
1135 in a block which is still considered clean? If so, don't obsolete it.
1136 If not, cover it anyway. */
1137
1138 struct jffs2_raw_node_ref *raw = frag->node->raw;
1139 struct jffs2_eraseblock *jeb;
1140
1141 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1142
1143 if (jeb == c->gcblock) {
1144 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1145 frag->ofs, frag->ofs+frag->size, ref_offset(raw)));
1146 end = frag->ofs + frag->size;
1147 break;
1148 }
1149 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1150 D1(printk(KERN_DEBUG "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n",
1151 frag->ofs, frag->ofs+frag->size, jeb->offset));
1152 break;
1153 }
1154
1155 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n",
1156 frag->ofs, frag->ofs+frag->size, jeb->offset));
1157 end = frag->ofs + frag->size;
1158 break;
1159 }
1160 }
1161 D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n",
1162 orig_start, orig_end, start, end));
1163
1164 BUG_ON(end > JFFS2_F_I_SIZE(f));
1165 BUG_ON(end < orig_end);
1166 BUG_ON(start > orig_start);
1167 }
1168
1169 /* First, use readpage() to read the appropriate page into the page cache */
1170 /* Q: What happens if we actually try to GC the _same_ page for which commit_write()
1171 * triggered garbage collection in the first place?
1172 * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the
1173 * page OK. We'll actually write it out again in commit_write, which is a little
1174 * suboptimal, but at least we're correct.
1175 */
1176 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);
1177
1178 if (IS_ERR(pg_ptr)) {
1179 printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(pg_ptr));
1180 return PTR_ERR(pg_ptr);
1181 }
1182
1183 offset = start;
1184 while(offset < orig_end) {
1185 uint32_t datalen;
1186 uint32_t cdatalen;
1187 uint16_t comprtype = JFFS2_COMPR_NONE;
1188
1189 ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen);
1190
1191 if (ret) {
1192 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n",
1193 sizeof(ri)+ JFFS2_MIN_DATA_LEN, ret);
1194 break;
1195 }
1196 cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
1197 datalen = end - offset;
1198
1199 writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1));
1200
1201 comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
1202
1203 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1204 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
1205 ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
1206 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
1207
1208 ri.ino = cpu_to_je32(f->inocache->ino);
1209 ri.version = cpu_to_je32(++f->highest_version);
1210 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1211 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
1212 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
1213 ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
1214 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
1215 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
1216 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1217 ri.offset = cpu_to_je32(offset);
1218 ri.csize = cpu_to_je32(cdatalen);
1219 ri.dsize = cpu_to_je32(datalen);
1220 ri.compr = comprtype & 0xff;
1221 ri.usercompr = (comprtype >> 8) & 0xff;
1222 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1223 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1224
1225 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, phys_ofs, ALLOC_GC);
1226
1227 jffs2_free_comprbuf(comprbuf, writebuf);
1228
1229 if (IS_ERR(new_fn)) {
1230 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1231 ret = PTR_ERR(new_fn);
1232 break;
1233 }
1234 ret = jffs2_add_full_dnode_to_inode(c, f, new_fn);
1235 offset += datalen;
1236 if (f->metadata) {
1237 jffs2_mark_node_obsolete(c, f->metadata->raw);
1238 jffs2_free_full_dnode(f->metadata);
1239 f->metadata = NULL;
1240 }
1241 }
1242
1243 jffs2_gc_release_page(c, pg_ptr, &pg);
1244 return ret;
1245}
1246
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-24 17:28:19 -0500