blob: 7086cd6345038cbc9015dacb4b23dcaf7f4f081f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +010010 * $Id: gc.c,v 1.148 2005/04/09 10:47:00 dedekind Exp $
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
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. */
Artem B. Bityuckiya42163d2005-03-20 17:45:29 +000053again:
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 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;
Artem B. Bityuckiya42163d2005-03-20 17:45:29 +000083 } 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"));
Artem B. Bityuckiy3cceb9f2005-03-20 21:43:26 +000086 spin_unlock(&c->erase_completion_lock);
Artem B. Bityuckiya42163d2005-03-20 17:45:29 +000087 jffs2_flush_wbuf_pad(c);
Artem B. Bityuckiy3cceb9f2005-03-20 21:43:26 +000088 spin_lock(&c->erase_completion_lock);
Artem B. Bityuckiya42163d2005-03-20 17:45:29 +000089 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 } 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 D2(jffs2_dump_block_lists(c));
115 return ret;
116}
117
118/* jffs2_garbage_collect_pass
119 * Make a single attempt to progress GC. Move one node, and possibly
120 * start erasing one eraseblock.
121 */
122int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
123{
124 struct jffs2_inode_info *f;
125 struct jffs2_inode_cache *ic;
126 struct jffs2_eraseblock *jeb;
127 struct jffs2_raw_node_ref *raw;
128 int ret = 0, inum, nlink;
129
130 if (down_interruptible(&c->alloc_sem))
131 return -EINTR;
132
133 for (;;) {
134 spin_lock(&c->erase_completion_lock);
135 if (!c->unchecked_size)
136 break;
137
138 /* We can't start doing GC yet. We haven't finished checking
139 the node CRCs etc. Do it now. */
140
141 /* checked_ino is protected by the alloc_sem */
142 if (c->checked_ino > c->highest_ino) {
143 printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
144 c->unchecked_size);
145 D2(jffs2_dump_block_lists(c));
146 spin_unlock(&c->erase_completion_lock);
147 BUG();
148 }
149
150 spin_unlock(&c->erase_completion_lock);
151
152 spin_lock(&c->inocache_lock);
153
154 ic = jffs2_get_ino_cache(c, c->checked_ino++);
155
156 if (!ic) {
157 spin_unlock(&c->inocache_lock);
158 continue;
159 }
160
161 if (!ic->nlink) {
162 D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink zero\n",
163 ic->ino));
164 spin_unlock(&c->inocache_lock);
165 continue;
166 }
167 switch(ic->state) {
168 case INO_STATE_CHECKEDABSENT:
169 case INO_STATE_PRESENT:
170 D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino));
171 spin_unlock(&c->inocache_lock);
172 continue;
173
174 case INO_STATE_GC:
175 case INO_STATE_CHECKING:
176 printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state);
177 spin_unlock(&c->inocache_lock);
178 BUG();
179
180 case INO_STATE_READING:
181 /* We need to wait for it to finish, lest we move on
182 and trigger the BUG() above while we haven't yet
183 finished checking all its nodes */
184 D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino));
185 up(&c->alloc_sem);
186 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
187 return 0;
188
189 default:
190 BUG();
191
192 case INO_STATE_UNCHECKED:
193 ;
194 }
195 ic->state = INO_STATE_CHECKING;
196 spin_unlock(&c->inocache_lock);
197
198 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino));
199
200 ret = jffs2_do_crccheck_inode(c, ic);
201 if (ret)
202 printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino);
203
204 jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
205 up(&c->alloc_sem);
206 return ret;
207 }
208
209 /* First, work out which block we're garbage-collecting */
210 jeb = c->gcblock;
211
212 if (!jeb)
213 jeb = jffs2_find_gc_block(c);
214
215 if (!jeb) {
216 D1 (printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n"));
217 spin_unlock(&c->erase_completion_lock);
218 up(&c->alloc_sem);
219 return -EIO;
220 }
221
222 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));
223 D1(if (c->nextblock)
224 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));
225
226 if (!jeb->used_size) {
227 up(&c->alloc_sem);
228 goto eraseit;
229 }
230
231 raw = jeb->gc_node;
232
233 while(ref_obsolete(raw)) {
234 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw)));
235 raw = raw->next_phys;
236 if (unlikely(!raw)) {
237 printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n");
238 printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
239 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size);
240 jeb->gc_node = raw;
241 spin_unlock(&c->erase_completion_lock);
242 up(&c->alloc_sem);
243 BUG();
244 }
245 }
246 jeb->gc_node = raw;
247
248 D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw)));
249
250 if (!raw->next_in_ino) {
251 /* Inode-less node. Clean marker, snapshot or something like that */
252 /* FIXME: If it's something that needs to be copied, including something
253 we don't grok that has JFFS2_NODETYPE_RWCOMPAT_COPY, we should do so */
254 spin_unlock(&c->erase_completion_lock);
255 jffs2_mark_node_obsolete(c, raw);
256 up(&c->alloc_sem);
257 goto eraseit_lock;
258 }
259
260 ic = jffs2_raw_ref_to_ic(raw);
261
262 /* We need to hold the inocache. Either the erase_completion_lock or
263 the inocache_lock are sufficient; we trade down since the inocache_lock
264 causes less contention. */
265 spin_lock(&c->inocache_lock);
266
267 spin_unlock(&c->erase_completion_lock);
268
269 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));
270
271 /* Three possibilities:
272 1. Inode is already in-core. We must iget it and do proper
273 updating to its fragtree, etc.
274 2. Inode is not in-core, node is REF_PRISTINE. We lock the
275 inocache to prevent a read_inode(), copy the node intact.
276 3. Inode is not in-core, node is not pristine. We must iget()
277 and take the slow path.
278 */
279
280 switch(ic->state) {
281 case INO_STATE_CHECKEDABSENT:
282 /* It's been checked, but it's not currently in-core.
283 We can just copy any pristine nodes, but have
284 to prevent anyone else from doing read_inode() while
285 we're at it, so we set the state accordingly */
286 if (ref_flags(raw) == REF_PRISTINE)
287 ic->state = INO_STATE_GC;
288 else {
289 D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n",
290 ic->ino));
291 }
292 break;
293
294 case INO_STATE_PRESENT:
295 /* It's in-core. GC must iget() it. */
296 break;
297
298 case INO_STATE_UNCHECKED:
299 case INO_STATE_CHECKING:
300 case INO_STATE_GC:
301 /* Should never happen. We should have finished checking
302 by the time we actually start doing any GC, and since
303 we're holding the alloc_sem, no other garbage collection
304 can happen.
305 */
306 printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
307 ic->ino, ic->state);
308 up(&c->alloc_sem);
309 spin_unlock(&c->inocache_lock);
310 BUG();
311
312 case INO_STATE_READING:
313 /* Someone's currently trying to read it. We must wait for
314 them to finish and then go through the full iget() route
315 to do the GC. However, sometimes read_inode() needs to get
316 the alloc_sem() (for marking nodes invalid) so we must
317 drop the alloc_sem before sleeping. */
318
319 up(&c->alloc_sem);
320 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n",
321 ic->ino, ic->state));
322 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
323 /* And because we dropped the alloc_sem we must start again from the
324 beginning. Ponder chance of livelock here -- we're returning success
325 without actually making any progress.
326
327 Q: What are the chances that the inode is back in INO_STATE_READING
328 again by the time we next enter this function? And that this happens
329 enough times to cause a real delay?
330
331 A: Small enough that I don't care :)
332 */
333 return 0;
334 }
335
336 /* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the
337 node intact, and we don't have to muck about with the fragtree etc.
338 because we know it's not in-core. If it _was_ in-core, we go through
339 all the iget() crap anyway */
340
341 if (ic->state == INO_STATE_GC) {
342 spin_unlock(&c->inocache_lock);
343
344 ret = jffs2_garbage_collect_pristine(c, ic, raw);
345
346 spin_lock(&c->inocache_lock);
347 ic->state = INO_STATE_CHECKEDABSENT;
348 wake_up(&c->inocache_wq);
349
350 if (ret != -EBADFD) {
351 spin_unlock(&c->inocache_lock);
352 goto release_sem;
353 }
354
355 /* Fall through if it wanted us to, with inocache_lock held */
356 }
357
358 /* Prevent the fairly unlikely race where the gcblock is
359 entirely obsoleted by the final close of a file which had
360 the only valid nodes in the block, followed by erasure,
361 followed by freeing of the ic because the erased block(s)
362 held _all_ the nodes of that inode.... never been seen but
363 it's vaguely possible. */
364
365 inum = ic->ino;
366 nlink = ic->nlink;
367 spin_unlock(&c->inocache_lock);
368
369 f = jffs2_gc_fetch_inode(c, inum, nlink);
370 if (IS_ERR(f)) {
371 ret = PTR_ERR(f);
372 goto release_sem;
373 }
374 if (!f) {
375 ret = 0;
376 goto release_sem;
377 }
378
379 ret = jffs2_garbage_collect_live(c, jeb, raw, f);
380
381 jffs2_gc_release_inode(c, f);
382
383 release_sem:
384 up(&c->alloc_sem);
385
386 eraseit_lock:
387 /* If we've finished this block, start it erasing */
388 spin_lock(&c->erase_completion_lock);
389
390 eraseit:
391 if (c->gcblock && !c->gcblock->used_size) {
392 D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset));
393 /* We're GC'ing an empty block? */
394 list_add_tail(&c->gcblock->list, &c->erase_pending_list);
395 c->gcblock = NULL;
396 c->nr_erasing_blocks++;
397 jffs2_erase_pending_trigger(c);
398 }
399 spin_unlock(&c->erase_completion_lock);
400
401 return ret;
402}
403
404static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
405 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f)
406{
407 struct jffs2_node_frag *frag;
408 struct jffs2_full_dnode *fn = NULL;
409 struct jffs2_full_dirent *fd;
410 uint32_t start = 0, end = 0, nrfrags = 0;
411 int ret = 0;
412
413 down(&f->sem);
414
415 /* Now we have the lock for this inode. Check that it's still the one at the head
416 of the list. */
417
418 spin_lock(&c->erase_completion_lock);
419
420 if (c->gcblock != jeb) {
421 spin_unlock(&c->erase_completion_lock);
422 D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n"));
423 goto upnout;
424 }
425 if (ref_obsolete(raw)) {
426 spin_unlock(&c->erase_completion_lock);
427 D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n"));
428 /* They'll call again */
429 goto upnout;
430 }
431 spin_unlock(&c->erase_completion_lock);
432
433 /* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */
434 if (f->metadata && f->metadata->raw == raw) {
435 fn = f->metadata;
436 ret = jffs2_garbage_collect_metadata(c, jeb, f, fn);
437 goto upnout;
438 }
439
440 /* FIXME. Read node and do lookup? */
441 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
442 if (frag->node && frag->node->raw == raw) {
443 fn = frag->node;
444 end = frag->ofs + frag->size;
445 if (!nrfrags++)
446 start = frag->ofs;
447 if (nrfrags == frag->node->frags)
448 break; /* We've found them all */
449 }
450 }
451 if (fn) {
452 if (ref_flags(raw) == REF_PRISTINE) {
453 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
454 if (!ret) {
455 /* Urgh. Return it sensibly. */
456 frag->node->raw = f->inocache->nodes;
457 }
458 if (ret != -EBADFD)
459 goto upnout;
460 }
461 /* We found a datanode. Do the GC */
462 if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) {
463 /* It crosses a page boundary. Therefore, it must be a hole. */
464 ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end);
465 } else {
466 /* It could still be a hole. But we GC the page this way anyway */
467 ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end);
468 }
469 goto upnout;
470 }
471
472 /* Wasn't a dnode. Try dirent */
473 for (fd = f->dents; fd; fd=fd->next) {
474 if (fd->raw == raw)
475 break;
476 }
477
478 if (fd && fd->ino) {
479 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
480 } else if (fd) {
481 ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
482 } else {
483 printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n",
484 ref_offset(raw), f->inocache->ino);
485 if (ref_obsolete(raw)) {
486 printk(KERN_WARNING "But it's obsolete so we don't mind too much\n");
487 } else {
488 ret = -EIO;
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,
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, (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, (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 ACCT_SANITY_CHECK(c,jeb);
623 D1(ACCT_PARANOIA_CHECK(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 ACCT_SANITY_CHECK(c,jeb);
631 D1(ACCT_PARANOIA_CHECK(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
667static 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;
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100672 struct jffs2_node_frag *last_frag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 jint16_t dev;
674 char *mdata = NULL, mdatalen = 0;
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100675 uint32_t alloclen, phys_ofs, ilen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 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, 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
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100711 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 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));
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100730 ri.isize = cpu_to_je32(ilen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 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, 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
757static 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(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
795static 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(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. */
Andrew Victor3be36672005-02-09 09:09:05 +0000836 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 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, (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
903static 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;
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100910 uint32_t alloclen, phys_ofs, ilen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 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, (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 }
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100970
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 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));
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +0100982 ri.isize = cpu_to_je32(ilen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 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
1051static 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
Artem B. Bityuckiy8557fd52005-04-09 11:47:03 +01001189 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 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