source: rtems/cpukit/libfs/src/jffs2/src/gc.c @ 0282e83

4.11
Last change on this file since 0282e83 was 3c96bee, checked in by Sebastian Huber <sebastian.huber@…>, on Sep 12, 2013 at 1:32:07 PM

JFFS2: Add RTEMS support

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