1 /*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 *
6 * Created by David Woodhouse <[email protected]>
7 *
8 * For licensing information, see the file 'LICENCE' in this directory.
9 *
10 * $Id: gc.c,v 1.152 2005/07/24 15:14:14 dedekind 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
24 static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
25 struct jffs2_inode_cache *ic,
26 struct jffs2_raw_node_ref *raw);
27 static 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);
29 static 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);
31 static 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);
33 static 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);
36 static 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);
39 static 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 */
jffs2_find_gc_block(struct jffs2_sb_info * c)43 static 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 again:
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.
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)) {
67 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next\n"));
68 nextlist = &c->dirty_list;
69 } else if (!list_empty(&c->clean_list)) {
70 D1(printk(KERN_DEBUG "Picking block from clean_list to GC next\n"));
71 nextlist = &c->clean_list;
72 } else if (!list_empty(&c->dirty_list)) {
73 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next (clean_list was empty)\n"));
74
75 nextlist = &c->dirty_list;
76 } else if (!list_empty(&c->very_dirty_list)) {
77 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n"));
78 nextlist = &c->very_dirty_list;
79 } else if (!list_empty(&c->erasable_list)) {
80 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n"));
81
82 nextlist = &c->erasable_list;
83 } else if (!list_empty(&c->erasable_pending_wbuf_list)) {
84 /* There are blocks are wating for the wbuf sync */
85 D1(printk(KERN_DEBUG "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n"));
86 spin_unlock(&c->erase_completion_lock);
87 jffs2_flush_wbuf_pad(c);
88 spin_lock(&c->erase_completion_lock);
89 goto again;
90 } else {
91 /* Eep. All were empty */
92 D1(printk(KERN_NOTICE "jffs2: No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n"));
93 return NULL;
94 }
95
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
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 }
113
114 return ret;
115 }
116
117 /* jffs2_garbage_collect_pass
118 * Make a single attempt to progress GC. Move one node, and possibly
119 * start erasing one eraseblock.
120 */
jffs2_garbage_collect_pass(struct jffs2_sb_info * c)121 int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
122 {
123 struct jffs2_inode_info *f;
124 struct jffs2_inode_cache *ic;
125 struct jffs2_eraseblock *jeb;
126 struct jffs2_raw_node_ref *raw;
127 int ret = 0, inum, nlink;
128
129 if (down_interruptible(&c->alloc_sem))
130 return -EINTR;
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
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 }
148
149 spin_unlock(&c->erase_completion_lock);
150
151 spin_lock(&c->inocache_lock);
152
153 ic = jffs2_get_ino_cache(c, c->checked_ino++);
154
155 if (!ic) {
156 spin_unlock(&c->inocache_lock);
157 continue;
158 }
159
160 if (!ic->nlink) {
161 D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink zero\n",
162 ic->ino));
163 spin_unlock(&c->inocache_lock);
164 continue;
165 }
166 switch(ic->state) {
167 case INO_STATE_CHECKEDABSENT:
168 case INO_STATE_PRESENT:
169 D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino));
170 spin_unlock(&c->inocache_lock);
171 continue;
172
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
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();
190
191 case INO_STATE_UNCHECKED:
192 ;
193 }
194 ic->state = INO_STATE_CHECKING;
195 spin_unlock(&c->inocache_lock);
196
197 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino));
198
199 ret = jffs2_do_crccheck_inode(c, ic);
200 if (ret)
201 printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino);
202
203 jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
204 up(&c->alloc_sem);
205 return ret;
206 }
207
208 /* First, work out which block we're garbage-collecting */
209 jeb = c->gcblock;
210
211 if (!jeb)
212 jeb = jffs2_find_gc_block(c);
213
214 if (!jeb) {
215 D1 (printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n"));
216 spin_unlock(&c->erase_completion_lock);
217 up(&c->alloc_sem);
218 return -EIO;
219 }
220
221 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));
222 D1(if (c->nextblock)
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
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",
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;
246
247 D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw)));
248
249 if (!raw->next_in_ino) {
250 /* Inode-less node. Clean marker, snapshot or something like that */
251 /* FIXME: If it's something that needs to be copied, including something
252 we don't grok that has JFFS2_NODETYPE_RWCOMPAT_COPY, we should do so */
253 spin_unlock(&c->erase_completion_lock);
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
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.
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",
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
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
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
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 :)
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.
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
345 spin_lock(&c->inocache_lock);
346 ic->state = INO_STATE_CHECKEDABSENT;
347 wake_up(&c->inocache_wq);
348
349 if (ret != -EBADFD) {
350 spin_unlock(&c->inocache_lock);
351 goto release_sem;
352 }
353
354 /* Fall through if it wanted us to, with inocache_lock held */
355 }
356
357 /* Prevent the fairly unlikely race where the gcblock is
358 entirely obsoleted by the final close of a file which had
359 the only valid nodes in the block, followed by erasure,
360 followed by freeing of the ic because the erased block(s)
361 held _all_ the nodes of that inode.... never been seen but
362 it's vaguely possible. */
363
364 inum = ic->ino;
365 nlink = ic->nlink;
366 spin_unlock(&c->inocache_lock);
367
368 f = jffs2_gc_fetch_inode(c, inum, nlink);
369 if (IS_ERR(f)) {
370 ret = PTR_ERR(f);
371 goto release_sem;
372 }
373 if (!f) {
374 ret = 0;
375 goto release_sem;
376 }
377
378 ret = jffs2_garbage_collect_live(c, jeb, raw, f);
379
380 jffs2_gc_release_inode(c, f);
381
382 release_sem:
383 up(&c->alloc_sem);
384
385 eraseit_lock:
386 /* If we've finished this block, start it erasing */
387 spin_lock(&c->erase_completion_lock);
388
389 eraseit:
390 if (c->gcblock && !c->gcblock->used_size) {
391 D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset));
392 /* We're GC'ing an empty block? */
393 list_add_tail(&c->gcblock->list, &c->erase_pending_list);
394 c->gcblock = NULL;
395 c->nr_erasing_blocks++;
396 jffs2_erase_pending_trigger(c);
397 }
398 spin_unlock(&c->erase_completion_lock);
399
400 return ret;
401 }
402
jffs2_garbage_collect_live(struct jffs2_sb_info * c,struct jffs2_eraseblock * jeb,struct jffs2_raw_node_ref * raw,struct jffs2_inode_info * f)403 static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
404 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f)
405 {
406 struct jffs2_node_frag *frag;
407 struct jffs2_full_dnode *fn = NULL;
408 struct jffs2_full_dirent *fd;
409 uint32_t start = 0, end = 0, nrfrags = 0;
410 int ret = 0;
411
412 down(&f->sem);
413
414 /* Now we have the lock for this inode. Check that it's still the one at the head
415 of the list. */
416
417 spin_lock(&c->erase_completion_lock);
418
419 if (c->gcblock != jeb) {
420 spin_unlock(&c->erase_completion_lock);
421 D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n"));
422 goto upnout;
423 }
424 if (ref_obsolete(raw)) {
425 spin_unlock(&c->erase_completion_lock);
426 D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n"));
427 /* They'll call again */
428 goto upnout;
429 }
430 spin_unlock(&c->erase_completion_lock);
431
432 /* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */
433 if (f->metadata && f->metadata->raw == raw) {
434 fn = f->metadata;
435 ret = jffs2_garbage_collect_metadata(c, jeb, f, fn);
436 goto upnout;
437 }
438
439 /* FIXME. Read node and do lookup? */
440 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
441 if (frag->node && frag->node->raw == raw) {
442 fn = frag->node;
443 end = frag->ofs + frag->size;
444 if (!nrfrags++)
445 start = frag->ofs;
446 if (nrfrags == frag->node->frags)
447 break; /* We've found them all */
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 }
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
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);
479 } else if (fd) {
480 ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
481 } else {
482 printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n",
483 ref_offset(raw), f->inocache->ino);
484 if (ref_obsolete(raw)) {
485 printk(KERN_WARNING "But it's obsolete so we don't mind too much\n");
486 } else {
487 jffs2_dbg_dump_node(c, ref_offset(raw));
488 BUG();
489 }
490 }
491 upnout:
492 up(&f->sem);
493
494 return ret;
495 }
496
jffs2_garbage_collect_pristine(struct jffs2_sb_info * c,struct jffs2_inode_cache * ic,struct jffs2_raw_node_ref * raw)497 static 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;
506 uint32_t crc, rawlen;
507 int retried = 0;
508
509 D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw)));
510
511 rawlen = ref_totlen(c, c->gcblock, raw);
512
513 /* Ask for a small amount of space (or the totlen if smaller) because we
514 don't want to force wastage of the end of a block if splitting would
515 work. */
516 ret = jffs2_reserve_space_gc(c, min_t(uint32_t, sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN,
517 rawlen), &phys_ofs, &alloclen);
518 if (ret)
519 return ret;
520
521 if (alloclen < rawlen) {
522 /* Doesn't fit untouched. We'll go the old route and split it */
523 return -EBADFD;
524 }
525
526 node = kmalloc(rawlen, GFP_KERNEL);
527 if (!node)
528 return -ENOMEM;
529
530 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (unsigned char *)node);
531 if (!ret && retlen != rawlen)
532 ret = -EIO;
533 if (ret)
534 goto out_node;
535
536 crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4);
537 if (je32_to_cpu(node->u.hdr_crc) != crc) {
538 printk(KERN_WARNING "Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
539 ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc);
540 goto bail;
541 }
542
543 switch(je16_to_cpu(node->u.nodetype)) {
544 case JFFS2_NODETYPE_INODE:
545 crc = crc32(0, node, sizeof(node->i)-8);
546 if (je32_to_cpu(node->i.node_crc) != crc) {
547 printk(KERN_WARNING "Node 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.node_crc), crc);
549 goto bail;
550 }
551
552 if (je32_to_cpu(node->i.dsize)) {
553 crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize));
554 if (je32_to_cpu(node->i.data_crc) != crc) {
555 printk(KERN_WARNING "Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
556 ref_offset(raw), je32_to_cpu(node->i.data_crc), crc);
557 goto bail;
558 }
559 }
560 break;
561
562 case JFFS2_NODETYPE_DIRENT:
563 crc = crc32(0, node, sizeof(node->d)-8);
564 if (je32_to_cpu(node->d.node_crc) != crc) {
565 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
566 ref_offset(raw), je32_to_cpu(node->d.node_crc), crc);
567 goto bail;
568 }
569
570 if (node->d.nsize) {
571 crc = crc32(0, node->d.name, node->d.nsize);
572 if (je32_to_cpu(node->d.name_crc) != crc) {
573 printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent ode at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
574 ref_offset(raw), je32_to_cpu(node->d.name_crc), crc);
575 goto bail;
576 }
577 }
578 break;
579 default:
580 printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
581 ref_offset(raw), je16_to_cpu(node->u.nodetype));
582 goto bail;
583 }
584
585 nraw = jffs2_alloc_raw_node_ref();
586 if (!nraw) {
587 ret = -ENOMEM;
588 goto out_node;
589 }
590
591 /* OK, all the CRCs are good; this node can just be copied as-is. */
592 retry:
593 nraw->flash_offset = phys_ofs;
594 nraw->__totlen = rawlen;
595 nraw->next_phys = NULL;
596
597 ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (unsigned char *)node);
598
599 if (ret || (retlen != rawlen)) {
600 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n",
601 rawlen, phys_ofs, ret, retlen);
602 if (retlen) {
603 /* Doesn't belong to any inode */
604 nraw->next_in_ino = NULL;
605
606 nraw->flash_offset |= REF_OBSOLETE;
607 jffs2_add_physical_node_ref(c, nraw);
608 jffs2_mark_node_obsolete(c, nraw);
609 } else {
610 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", nraw->flash_offset);
611 jffs2_free_raw_node_ref(nraw);
612 }
613 if (!retried && (nraw = jffs2_alloc_raw_node_ref())) {
614 /* Try to reallocate space and retry */
615 uint32_t dummy;
616 struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
617
618 retried = 1;
619
620 D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n"));
621
622 jffs2_dbg_acct_sanity_check(c,jeb);
623 jffs2_dbg_acct_paranoia_check(c, jeb);
624
625 ret = jffs2_reserve_space_gc(c, rawlen, &phys_ofs, &dummy);
626
627 if (!ret) {
628 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs));
629
630 jffs2_dbg_acct_sanity_check(c,jeb);
631 jffs2_dbg_acct_paranoia_check(c, jeb);
632
633 goto retry;
634 }
635 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
636 jffs2_free_raw_node_ref(nraw);
637 }
638
639 jffs2_free_raw_node_ref(nraw);
640 if (!ret)
641 ret = -EIO;
642 goto out_node;
643 }
644 nraw->flash_offset |= REF_PRISTINE;
645 jffs2_add_physical_node_ref(c, nraw);
646
647 /* Link into per-inode list. This is safe because of the ic
648 state being INO_STATE_GC. Note that if we're doing this
649 for an inode which is in-core, the 'nraw' pointer is then
650 going to be fetched from ic->nodes by our caller. */
651 spin_lock(&c->erase_completion_lock);
652 nraw->next_in_ino = ic->nodes;
653 ic->nodes = nraw;
654 spin_unlock(&c->erase_completion_lock);
655
656 jffs2_mark_node_obsolete(c, raw);
657 D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw)));
658
659 out_node:
660 kfree(node);
661 return ret;
662 bail:
663 ret = -EBADFD;
664 goto out_node;
665 }
666
jffs2_garbage_collect_metadata(struct jffs2_sb_info * c,struct jffs2_eraseblock * jeb,struct jffs2_inode_info * f,struct jffs2_full_dnode * fn)667 static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
668 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
669 {
670 struct jffs2_full_dnode *new_fn;
671 struct jffs2_raw_inode ri;
672 struct jffs2_node_frag *last_frag;
673 jint16_t dev;
674 char *mdata = NULL, mdatalen = 0;
675 uint32_t alloclen, phys_ofs, ilen;
676 int ret;
677
678 if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
679 S_ISCHR(JFFS2_F_I_MODE(f)) ) {
680 /* For these, we don't actually need to read the old node */
681 /* FIXME: for minor or major > 255. */
682 dev = cpu_to_je16(((JFFS2_F_I_RDEV_MAJ(f) << 8) |
683 JFFS2_F_I_RDEV_MIN(f)));
684 mdata = (char *)&dev;
685 mdatalen = sizeof(dev);
686 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen));
687 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
688 mdatalen = fn->size;
689 mdata = kmalloc(fn->size, GFP_KERNEL);
690 if (!mdata) {
691 printk(KERN_WARNING "kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
692 return -ENOMEM;
693 }
694 ret = jffs2_read_dnode(c, f, fn, (unsigned char *)mdata, 0, mdatalen);
695 if (ret) {
696 printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret);
697 kfree(mdata);
698 return ret;
699 }
700 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen));
701
702 }
703
704 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &phys_ofs, &alloclen);
705 if (ret) {
706 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
707 sizeof(ri)+ mdatalen, ret);
708 goto out;
709 }
710
711 last_frag = frag_last(&f->fragtree);
712 if (last_frag)
713 /* Fetch the inode length from the fragtree rather then
714 * from i_size since i_size may have not been updated yet */
715 ilen = last_frag->ofs + last_frag->size;
716 else
717 ilen = JFFS2_F_I_SIZE(f);
718
719 memset(&ri, 0, sizeof(ri));
720 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
721 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
722 ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
723 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
724
725 ri.ino = cpu_to_je32(f->inocache->ino);
726 ri.version = cpu_to_je32(++f->highest_version);
727 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
728 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
729 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
730 ri.isize = cpu_to_je32(ilen);
731 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
732 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
733 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
734 ri.offset = cpu_to_je32(0);
735 ri.csize = cpu_to_je32(mdatalen);
736 ri.dsize = cpu_to_je32(mdatalen);
737 ri.compr = JFFS2_COMPR_NONE;
738 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
739 ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
740
741 new_fn = jffs2_write_dnode(c, f, &ri, (const unsigned char *)mdata, mdatalen, phys_ofs, ALLOC_GC);
742
743 if (IS_ERR(new_fn)) {
744 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
745 ret = PTR_ERR(new_fn);
746 goto out;
747 }
748 jffs2_mark_node_obsolete(c, fn->raw);
749 jffs2_free_full_dnode(fn);
750 f->metadata = new_fn;
751 out:
752 if (S_ISLNK(JFFS2_F_I_MODE(f)))
753 kfree(mdata);
754 return ret;
755 }
756
jffs2_garbage_collect_dirent(struct jffs2_sb_info * c,struct jffs2_eraseblock * jeb,struct jffs2_inode_info * f,struct jffs2_full_dirent * fd)757 static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
758 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
759 {
760 struct jffs2_full_dirent *new_fd;
761 struct jffs2_raw_dirent rd;
762 uint32_t alloclen, phys_ofs;
763 int ret;
764
765 rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
766 rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
767 rd.nsize = strlen((const char *)fd->name);
768 rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
769 rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
770
771 rd.pino = cpu_to_je32(f->inocache->ino);
772 rd.version = cpu_to_je32(++f->highest_version);
773 rd.ino = cpu_to_je32(fd->ino);
774 rd.mctime = cpu_to_je32(max(JFFS2_F_I_MTIME(f), JFFS2_F_I_CTIME(f)));
775 rd.type = fd->type;
776 rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
777 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
778
779 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &phys_ofs, &alloclen);
780 if (ret) {
781 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
782 sizeof(rd)+rd.nsize, ret);
783 return ret;
784 }
785 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, phys_ofs, ALLOC_GC);
786
787 if (IS_ERR(new_fd)) {
788 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd));
789 return PTR_ERR(new_fd);
790 }
791 jffs2_add_fd_to_list(c, new_fd, &f->dents);
792 return 0;
793 }
794
jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info * c,struct jffs2_eraseblock * jeb,struct jffs2_inode_info * f,struct jffs2_full_dirent * fd)795 static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
796 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
797 {
798 struct jffs2_full_dirent **fdp = &f->dents;
799 int found = 0;
800
801 /* On a medium where we can't actually mark nodes obsolete
802 pernamently, such as NAND flash, we need to work out
803 whether this deletion dirent is still needed to actively
804 delete a 'real' dirent with the same name that's still
805 somewhere else on the flash. */
806 if (!jffs2_can_mark_obsolete(c)) {
807 struct jffs2_raw_dirent *rd;
808 struct jffs2_raw_node_ref *raw;
809 int ret;
810 size_t retlen;
811 int name_len = strlen((const char *)fd->name);
812 uint32_t name_crc = crc32(0, fd->name, name_len);
813 uint32_t rawlen = ref_totlen(c, jeb, fd->raw);
814
815 rd = kmalloc(rawlen, GFP_KERNEL);
816 if (!rd)
817 return -ENOMEM;
818
819 /* Prevent the erase code from nicking the obsolete node refs while
820 we're looking at them. I really don't like this extra lock but
821 can't see any alternative. Suggestions on a postcard to... */
822 down(&c->erase_free_sem);
823
824 for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) {
825
826 /* We only care about obsolete ones */
827 if (!(ref_obsolete(raw)))
828 continue;
829
830 /* Any dirent with the same name is going to have the same length... */
831 if (ref_totlen(c, NULL, raw) != rawlen)
832 continue;
833
834 /* Doesn't matter if there's one in the same erase block. We're going to
835 delete it too at the same time. */
836 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset))
837 continue;
838
839 D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw)));
840
841 /* This is an obsolete node belonging to the same directory, and it's of the right
842 length. We need to take a closer look...*/
843 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (unsigned char *)rd);
844 if (ret) {
845 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Read error (%d) reading obsolete node at %08x\n", ret, ref_offset(raw));
846 /* If we can't read it, we don't need to continue to obsolete it. Continue */
847 continue;
848 }
849 if (retlen != rawlen) {
850 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Short read (%zd not %u) reading header from obsolete node at %08x\n",
851 retlen, rawlen, ref_offset(raw));
852 continue;
853 }
854
855 if (je16_to_cpu(rd->nodetype) != JFFS2_NODETYPE_DIRENT)
856 continue;
857
858 /* If the name CRC doesn't match, skip */
859 if (je32_to_cpu(rd->name_crc) != name_crc)
860 continue;
861
862 /* If the name length doesn't match, or it's another deletion dirent, skip */
863 if (rd->nsize != name_len || !je32_to_cpu(rd->ino))
864 continue;
865
866 /* OK, check the actual name now */
867 if (memcmp(rd->name, fd->name, name_len))
868 continue;
869
870 /* OK. The name really does match. There really is still an older node on
871 the flash which our deletion dirent obsoletes. So we have to write out
872 a new deletion dirent to replace it */
873 up(&c->erase_free_sem);
874
875 D1(printk(KERN_DEBUG "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n",
876 ref_offset(fd->raw), fd->name, ref_offset(raw), je32_to_cpu(rd->ino)));
877 kfree(rd);
878
879 return jffs2_garbage_collect_dirent(c, jeb, f, fd);
880 }
881
882 up(&c->erase_free_sem);
883 kfree(rd);
884 }
885
886 /* No need for it any more. Just mark it obsolete and remove it from the list */
887 while (*fdp) {
888 if ((*fdp) == fd) {
889 found = 1;
890 *fdp = fd->next;
891 break;
892 }
893 fdp = &(*fdp)->next;
894 }
895 if (!found) {
896 printk(KERN_WARNING "Deletion dirent \"%s\" not found in list for ino #%u\n", fd->name, f->inocache->ino);
897 }
898 jffs2_mark_node_obsolete(c, fd->raw);
899 jffs2_free_full_dirent(fd);
900 return 0;
901 }
902
jffs2_garbage_collect_hole(struct jffs2_sb_info * c,struct jffs2_eraseblock * jeb,struct jffs2_inode_info * f,struct jffs2_full_dnode * fn,uint32_t start,uint32_t end)903 static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
904 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
905 uint32_t start, uint32_t end)
906 {
907 struct jffs2_raw_inode ri;
908 struct jffs2_node_frag *frag;
909 struct jffs2_full_dnode *new_fn;
910 uint32_t alloclen, phys_ofs, ilen;
911 int ret;
912
913 D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
914 f->inocache->ino, start, end));
915
916 memset(&ri, 0, sizeof(ri));
917
918 if(fn->frags > 1) {
919 size_t readlen;
920 uint32_t crc;
921 /* It's partially obsoleted by a later write. So we have to
922 write it out again with the _same_ version as before */
923 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (unsigned char *)&ri);
924 if (readlen != sizeof(ri) || ret) {
925 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);
926 goto fill;
927 }
928 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) {
929 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",
930 ref_offset(fn->raw),
931 je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE);
932 return -EIO;
933 }
934 if (je32_to_cpu(ri.totlen) != sizeof(ri)) {
935 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
936 ref_offset(fn->raw),
937 je32_to_cpu(ri.totlen), sizeof(ri));
938 return -EIO;
939 }
940 crc = crc32(0, &ri, sizeof(ri)-8);
941 if (crc != je32_to_cpu(ri.node_crc)) {
942 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
943 ref_offset(fn->raw),
944 je32_to_cpu(ri.node_crc), crc);
945 /* FIXME: We could possibly deal with this by writing new holes for each frag */
946 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
947 start, end, f->inocache->ino);
948 goto fill;
949 }
950 if (ri.compr != JFFS2_COMPR_ZERO) {
951 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw));
952 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
953 start, end, f->inocache->ino);
954 goto fill;
955 }
956 } else {
957 fill:
958 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
959 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
960 ri.totlen = cpu_to_je32(sizeof(ri));
961 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
962
963 ri.ino = cpu_to_je32(f->inocache->ino);
964 ri.version = cpu_to_je32(++f->highest_version);
965 ri.offset = cpu_to_je32(start);
966 ri.dsize = cpu_to_je32(end - start);
967 ri.csize = cpu_to_je32(0);
968 ri.compr = JFFS2_COMPR_ZERO;
969 }
970
971 frag = frag_last(&f->fragtree);
972 if (frag)
973 /* Fetch the inode length from the fragtree rather then
974 * from i_size since i_size may have not been updated yet */
975 ilen = frag->ofs + frag->size;
976 else
977 ilen = JFFS2_F_I_SIZE(f);
978
979 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
980 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
981 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
982 ri.isize = cpu_to_je32(ilen);
983 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
984 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
985 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
986 ri.data_crc = cpu_to_je32(0);
987 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
988
989 ret = jffs2_reserve_space_gc(c, sizeof(ri), &phys_ofs, &alloclen);
990 if (ret) {
991 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
992 sizeof(ri), ret);
993 return ret;
994 }
995 new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, phys_ofs, ALLOC_GC);
996
997 if (IS_ERR(new_fn)) {
998 printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn));
999 return PTR_ERR(new_fn);
1000 }
1001 if (je32_to_cpu(ri.version) == f->highest_version) {
1002 jffs2_add_full_dnode_to_inode(c, f, new_fn);
1003 if (f->metadata) {
1004 jffs2_mark_node_obsolete(c, f->metadata->raw);
1005 jffs2_free_full_dnode(f->metadata);
1006 f->metadata = NULL;
1007 }
1008 return 0;
1009 }
1010
1011 /*
1012 * We should only get here in the case where the node we are
1013 * replacing had more than one frag, so we kept the same version
1014 * number as before. (Except in case of error -- see 'goto fill;'
1015 * above.)
1016 */
1017 D1(if(unlikely(fn->frags <= 1)) {
1018 printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n",
1019 fn->frags, je32_to_cpu(ri.version), f->highest_version,
1020 je32_to_cpu(ri.ino));
1021 });
1022
1023 /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */
1024 mark_ref_normal(new_fn->raw);
1025
1026 for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
1027 frag; frag = frag_next(frag)) {
1028 if (frag->ofs > fn->size + fn->ofs)
1029 break;
1030 if (frag->node == fn) {
1031 frag->node = new_fn;
1032 new_fn->frags++;
1033 fn->frags--;
1034 }
1035 }
1036 if (fn->frags) {
1037 printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n");
1038 BUG();
1039 }
1040 if (!new_fn->frags) {
1041 printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n");
1042 BUG();
1043 }
1044
1045 jffs2_mark_node_obsolete(c, fn->raw);
1046 jffs2_free_full_dnode(fn);
1047
1048 return 0;
1049 }
1050
jffs2_garbage_collect_dnode(struct jffs2_sb_info * c,struct jffs2_eraseblock * jeb,struct jffs2_inode_info * f,struct jffs2_full_dnode * fn,uint32_t start,uint32_t end)1051 static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
1052 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
1053 uint32_t start, uint32_t end)
1054 {
1055 struct jffs2_full_dnode *new_fn;
1056 struct jffs2_raw_inode ri;
1057 uint32_t alloclen, phys_ofs, offset, orig_end, orig_start;
1058 int ret = 0;
1059 unsigned char *comprbuf = NULL, *writebuf;
1060 unsigned long pg;
1061 unsigned char *pg_ptr;
1062
1063 memset(&ri, 0, sizeof(ri));
1064
1065 D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n",
1066 f->inocache->ino, start, end));
1067
1068 orig_end = end;
1069 orig_start = start;
1070
1071 if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
1072 /* Attempt to do some merging. But only expand to cover logically
1073 adjacent frags if the block containing them is already considered
1074 to be dirty. Otherwise we end up with GC just going round in
1075 circles dirtying the nodes it already wrote out, especially
1076 on NAND where we have small eraseblocks and hence a much higher
1077 chance of nodes having to be split to cross boundaries. */
1078
1079 struct jffs2_node_frag *frag;
1080 uint32_t min, max;
1081
1082 min = start & ~(PAGE_CACHE_SIZE-1);
1083 max = min + PAGE_CACHE_SIZE;
1084
1085 frag = jffs2_lookup_node_frag(&f->fragtree, start);
1086
1087 /* BUG_ON(!frag) but that'll happen anyway... */
1088
1089 BUG_ON(frag->ofs != start);
1090
1091 /* First grow down... */
1092 while((frag = frag_prev(frag)) && frag->ofs >= min) {
1093
1094 /* If the previous frag doesn't even reach the beginning, there's
1095 excessive fragmentation. Just merge. */
1096 if (frag->ofs > min) {
1097 D1(printk(KERN_DEBUG "Expanding down to cover partial frag (0x%x-0x%x)\n",
1098 frag->ofs, frag->ofs+frag->size));
1099 start = frag->ofs;
1100 continue;
1101 }
1102 /* OK. This frag holds the first byte of the page. */
1103 if (!frag->node || !frag->node->raw) {
1104 D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n",
1105 frag->ofs, frag->ofs+frag->size));
1106 break;
1107 } else {
1108
1109 /* OK, it's a frag which extends to the beginning of the page. Does it live
1110 in a block which is still considered clean? If so, don't obsolete it.
1111 If not, cover it anyway. */
1112
1113 struct jffs2_raw_node_ref *raw = frag->node->raw;
1114 struct jffs2_eraseblock *jeb;
1115
1116 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1117
1118 if (jeb == c->gcblock) {
1119 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1120 frag->ofs, frag->ofs+frag->size, ref_offset(raw)));
1121 start = frag->ofs;
1122 break;
1123 }
1124 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1125 D1(printk(KERN_DEBUG "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n",
1126 frag->ofs, frag->ofs+frag->size, jeb->offset));
1127 break;
1128 }
1129
1130 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n",
1131 frag->ofs, frag->ofs+frag->size, jeb->offset));
1132 start = frag->ofs;
1133 break;
1134 }
1135 }
1136
1137 /* ... then up */
1138
1139 /* Find last frag which is actually part of the node we're to GC. */
1140 frag = jffs2_lookup_node_frag(&f->fragtree, end-1);
1141
1142 while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
1143
1144 /* If the previous frag doesn't even reach the beginning, there's lots
1145 of fragmentation. Just merge. */
1146 if (frag->ofs+frag->size < max) {
1147 D1(printk(KERN_DEBUG "Expanding up to cover partial frag (0x%x-0x%x)\n",
1148 frag->ofs, frag->ofs+frag->size));
1149 end = frag->ofs + frag->size;
1150 continue;
1151 }
1152
1153 if (!frag->node || !frag->node->raw) {
1154 D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n",
1155 frag->ofs, frag->ofs+frag->size));
1156 break;
1157 } else {
1158
1159 /* OK, it's a frag which extends to the beginning of the page. Does it live
1160 in a block which is still considered clean? If so, don't obsolete it.
1161 If not, cover it anyway. */
1162
1163 struct jffs2_raw_node_ref *raw = frag->node->raw;
1164 struct jffs2_eraseblock *jeb;
1165
1166 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1167
1168 if (jeb == c->gcblock) {
1169 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1170 frag->ofs, frag->ofs+frag->size, ref_offset(raw)));
1171 end = frag->ofs + frag->size;
1172 break;
1173 }
1174 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1175 D1(printk(KERN_DEBUG "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n",
1176 frag->ofs, frag->ofs+frag->size, jeb->offset));
1177 break;
1178 }
1179
1180 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n",
1181 frag->ofs, frag->ofs+frag->size, jeb->offset));
1182 end = frag->ofs + frag->size;
1183 break;
1184 }
1185 }
1186 D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n",
1187 orig_start, orig_end, start, end));
1188
1189 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size));
1190 BUG_ON(end < orig_end);
1191 BUG_ON(start > orig_start);
1192 }
1193
1194 /* First, use readpage() to read the appropriate page into the page cache */
1195 /* Q: What happens if we actually try to GC the _same_ page for which commit_write()
1196 * triggered garbage collection in the first place?
1197 * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the
1198 * page OK. We'll actually write it out again in commit_write, which is a little
1199 * suboptimal, but at least we're correct.
1200 */
1201 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);
1202
1203 if (IS_ERR(pg_ptr)) {
1204 printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(pg_ptr));
1205 return PTR_ERR(pg_ptr);
1206 }
1207
1208 offset = start;
1209 while(offset < orig_end) {
1210 uint32_t datalen;
1211 uint32_t cdatalen;
1212 uint16_t comprtype = JFFS2_COMPR_NONE;
1213
1214 ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen);
1215
1216 if (ret) {
1217 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n",
1218 sizeof(ri)+ JFFS2_MIN_DATA_LEN, ret);
1219 break;
1220 }
1221 cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
1222 datalen = end - offset;
1223
1224 writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1));
1225
1226 comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
1227
1228 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1229 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
1230 ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
1231 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
1232
1233 ri.ino = cpu_to_je32(f->inocache->ino);
1234 ri.version = cpu_to_je32(++f->highest_version);
1235 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1236 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
1237 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
1238 ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
1239 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
1240 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
1241 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1242 ri.offset = cpu_to_je32(offset);
1243 ri.csize = cpu_to_je32(cdatalen);
1244 ri.dsize = cpu_to_je32(datalen);
1245 ri.compr = comprtype & 0xff;
1246 ri.usercompr = (comprtype >> 8) & 0xff;
1247 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1248 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1249
1250 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, phys_ofs, ALLOC_GC);
1251
1252 jffs2_free_comprbuf(comprbuf, writebuf);
1253
1254 if (IS_ERR(new_fn)) {
1255 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1256 ret = PTR_ERR(new_fn);
1257 break;
1258 }
1259 ret = jffs2_add_full_dnode_to_inode(c, f, new_fn);
1260 offset += datalen;
1261 if (f->metadata) {
1262 jffs2_mark_node_obsolete(c, f->metadata->raw);
1263 jffs2_free_full_dnode(f->metadata);
1264 f->metadata = NULL;
1265 }
1266 }
1267
1268 jffs2_gc_release_page(c, pg_ptr, &pg);
1269 return ret;
1270 }
1271
1272