root/fs/jffs2/gc.c

DEFINITIONS

1. jffs2_find_gc_block
2. jffs2_garbage_collect_pass
3. jffs2_garbage_collect_live
4. jffs2_garbage_collect_pristine
5. jffs2_garbage_collect_metadata
6. jffs2_garbage_collect_dirent
7. jffs2_garbage_collect_deletion_dirent
8. jffs2_garbage_collect_hole
9. jffs2_garbage_collect_dnode

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