Root/fs/jffs2/gc.c

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

Archive Download this file



interactive