fs/jffs2/nodemgmt.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@infradead.org>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/mtd/mtd.h>
  14 #include <linux/compiler.h>
  15 #include <linux/sched.h> /* For cond_resched() */
  16 #include "nodelist.h"
  17 #include "debug.h"
  18
  19 /**
  20  *      jffs2_reserve_space - request physical space to write nodes to flash
  21  *      @c: superblock info
  22  *      @minsize: Minimum acceptable size of allocation
  23  *      @len: Returned value of allocation length
  24  *      @prio: Allocation type - ALLOC_{NORMAL,DELETION}
  25  *
  26  *      Requests a block of physical space on the flash. Returns zero for success
  27  *      and puts 'len' into the appropriate place, or returns -ENOSPC or other
  28  *      error if appropriate. Doesn't return len since that's
  29  *
  30  *      If it returns zero, jffs2_reserve_space() also downs the per-filesystem
  31  *      allocation semaphore, to prevent more than one allocation from being
  32  *      active at any time. The semaphore is later released by jffs2_commit_allocation()
  33  *
  34  *      jffs2_reserve_space() may trigger garbage collection in order to make room
  35  *      for the requested allocation.
  36  */
  37
  38 static int jffs2_do_reserve_space(struct jffs2_sb_info *c,  uint32_t minsize,
  39                                   uint32_t *len, uint32_t sumsize);
  40
  41 int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
  42                         uint32_t *len, int prio, uint32_t sumsize)
  43 {
  44         int ret = -EAGAIN;
  45         int blocksneeded = c->resv_blocks_write;
  46         /* align it */
  47         minsize = PAD(minsize);
  48
  49         D1(printk(KERN_DEBUG "jffs2_reserve_space(): Requested 0x%x bytes\n", minsize));
  50         mutex_lock(&c->alloc_sem);
  51
  52         D1(printk(KERN_DEBUG "jffs2_reserve_space(): alloc sem got\n"));
  53
  54         spin_lock(&c->erase_completion_lock);
  55
  56         /* this needs a little more thought (true <tglx> :)) */
  57         while(ret == -EAGAIN) {
  58                 while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
  59                         uint32_t dirty, avail;
  60
  61                         /* calculate real dirty size
  62                          * dirty_size contains blocks on erase_pending_list
  63                          * those blocks are counted in c->nr_erasing_blocks.
  64                          * If one block is actually erased, it is not longer counted as dirty_space
  65                          * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
  66                          * with c->nr_erasing_blocks * c->sector_size again.
  67                          * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
  68                          * This helps us to force gc and pick eventually a clean block to spread the load.
  69                          * We add unchecked_size here, as we hopefully will find some space to use.
  70                          * This will affect the sum only once, as gc first finishes checking
  71                          * of nodes.
  72                          */
  73                         dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
  74                         if (dirty < c->nospc_dirty_size) {
  75                                 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
  76                                         D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on dirty space to GC, but it's a deletion. Allowing...\n"));
  77                                         break;
  78                                 }
  79                                 D1(printk(KERN_DEBUG "dirty size 0x%08x + unchecked_size 0x%08x < nospc_dirty_size 0x%08x, returning -ENOSPC\n",
  80                                           dirty, c->unchecked_size, c->sector_size));
  81
  82                                 spin_unlock(&c->erase_completion_lock);
  83                                 mutex_unlock(&c->alloc_sem);
  84                                 return -ENOSPC;
  85                         }
  86
  87                         /* Calc possibly available space. Possibly available means that we
  88                          * don't know, if unchecked size contains obsoleted nodes, which could give us some
  89                          * more usable space. This will affect the sum only once, as gc first finishes checking
  90                          * of nodes.
  91                          + Return -ENOSPC, if the maximum possibly available space is less or equal than
  92                          * blocksneeded * sector_size.
  93                          * This blocks endless gc looping on a filesystem, which is nearly full, even if
  94                          * the check above passes.
  95                          */
  96                         avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size;
  97                         if ( (avail / c->sector_size) <= blocksneeded) {
  98                                 if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
  99                                         D1(printk(KERN_NOTICE "jffs2_reserve_space(): Low on possibly available space, but it's a deletion. Allowing...\n"));
 100                                         break;
 101                                 }
 102
 103                                 D1(printk(KERN_DEBUG "max. available size 0x%08x  < blocksneeded * sector_size 0x%08x, returning -ENOSPC\n",
 104                                           avail, blocksneeded * c->sector_size));
 105                                 spin_unlock(&c->erase_completion_lock);
 106                                 mutex_unlock(&c->alloc_sem);
 107                                 return -ENOSPC;
 108                         }
 109
 110                         mutex_unlock(&c->alloc_sem);
 111
 112                         D1(printk(KERN_DEBUG "Triggering GC pass. nr_free_blocks %d, nr_erasing_blocks %d, free_size 0x%08x, dirty_size 0x%08x, wasted_size 0x%08x, used_size 0x%08x, erasing_size 0x%08x, bad_size 0x%08x (total 0x%08x of 0x%08x)\n",
 113                                   c->nr_free_blocks, c->nr_erasing_blocks, c->free_size, c->dirty_size, c->wasted_size, c->used_size, c->erasing_size, c->bad_size,
 114                                   c->free_size + c->dirty_size + c->wasted_size + c->used_size + c->erasing_size + c->bad_size, c->flash_size));
 115                         spin_unlock(&c->erase_completion_lock);
 116
 117                         ret = jffs2_garbage_collect_pass(c);
 118
 119                         if (ret == -EAGAIN)
 120                                 jffs2_erase_pending_blocks(c, 1);
 121                         else if (ret)
 122                                 return ret;
 123
 124                         cond_resched();
 125
 126                         if (signal_pending(current))
 127                                 return -EINTR;
 128
 129                         mutex_lock(&c->alloc_sem);
 130                         spin_lock(&c->erase_completion_lock);
 131                 }
 132
 133                 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
 134                 if (ret) {
 135                         D1(printk(KERN_DEBUG "jffs2_reserve_space: ret is %d\n", ret));
 136                 }
 137         }
 138         spin_unlock(&c->erase_completion_lock);
 139         if (!ret)
 140                 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
 141         if (ret)
 142                 mutex_unlock(&c->alloc_sem);
 143         return ret;
 144 }
 145
 146 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
 147                            uint32_t *len, uint32_t sumsize)
 148 {
 149         int ret = -EAGAIN;
 150         minsize = PAD(minsize);
 151
 152         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc(): Requested 0x%x bytes\n", minsize));
 153
 154         spin_lock(&c->erase_completion_lock);
 155         while(ret == -EAGAIN) {
 156                 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
 157                 if (ret) {
 158                         D1(printk(KERN_DEBUG "jffs2_reserve_space_gc: looping, ret is %d\n", ret));
 159                 }
 160         }
 161         spin_unlock(&c->erase_completion_lock);
 162         if (!ret)
 163                 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
 164
 165         return ret;
 166 }
 167
 168
 169 /* Classify nextblock (clean, dirty of verydirty) and force to select an other one */
 170
 171 static void jffs2_close_nextblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
 172 {
 173
 174         if (c->nextblock == NULL) {
 175                 D1(printk(KERN_DEBUG "jffs2_close_nextblock: Erase block at 0x%08x has already been placed in a list\n",
 176                   jeb->offset));
 177                 return;
 178         }
 179         /* Check, if we have a dirty block now, or if it was dirty already */
 180         if (ISDIRTY (jeb->wasted_size + jeb->dirty_size)) {
 181                 c->dirty_size += jeb->wasted_size;
 182                 c->wasted_size -= jeb->wasted_size;
 183                 jeb->dirty_size += jeb->wasted_size;
 184                 jeb->wasted_size = 0;
 185                 if (VERYDIRTY(c, jeb->dirty_size)) {
 186                         D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to very_dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
 187                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 188                         list_add_tail(&jeb->list, &c->very_dirty_list);
 189                 } else {
 190                         D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to dirty_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
 191                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 192                         list_add_tail(&jeb->list, &c->dirty_list);
 193                 }
 194         } else {
 195                 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
 196                   jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 197                 list_add_tail(&jeb->list, &c->clean_list);
 198         }
 199         c->nextblock = NULL;
 200
 201 }
 202
 203 /* Select a new jeb for nextblock */
 204
 205 static int jffs2_find_nextblock(struct jffs2_sb_info *c)
 206 {
 207         struct list_head *next;
 208
 209         /* Take the next block off the 'free' list */
 210
 211         if (list_empty(&c->free_list)) {
 212
 213                 if (!c->nr_erasing_blocks &&
 214                         !list_empty(&c->erasable_list)) {
 215                         struct jffs2_eraseblock *ejeb;
 216
 217                         ejeb = list_entry(c->erasable_list.next, struct jffs2_eraseblock, list);
 218                         list_move_tail(&ejeb->list, &c->erase_pending_list);
 219                         c->nr_erasing_blocks++;
 220                         jffs2_erase_pending_trigger(c);
 221                         D1(printk(KERN_DEBUG "jffs2_find_nextblock: Triggering erase of erasable block at 0x%08x\n",
 222                                   ejeb->offset));
 223                 }
 224
 225                 if (!c->nr_erasing_blocks &&
 226                         !list_empty(&c->erasable_pending_wbuf_list)) {
 227                         D1(printk(KERN_DEBUG "jffs2_find_nextblock: Flushing write buffer\n"));
 228                         /* c->nextblock is NULL, no update to c->nextblock allowed */
 229                         spin_unlock(&c->erase_completion_lock);
 230                         jffs2_flush_wbuf_pad(c);
 231                         spin_lock(&c->erase_completion_lock);
 232                         /* Have another go. It'll be on the erasable_list now */
 233                         return -EAGAIN;
 234                 }
 235
 236                 if (!c->nr_erasing_blocks) {
 237                         /* Ouch. We're in GC, or we wouldn't have got here.
 238                            And there's no space left. At all. */
 239                         printk(KERN_CRIT "Argh. No free space left for GC. nr_erasing_blocks is %d. nr_free_blocks is %d. (erasableempty: %s, erasingempty: %s, erasependingempty: %s)\n",
 240                                    c->nr_erasing_blocks, c->nr_free_blocks, list_empty(&c->erasable_list)?"yes":"no",
 241                                    list_empty(&c->erasing_list)?"yes":"no", list_empty(&c->erase_pending_list)?"yes":"no");
 242                         return -ENOSPC;
 243                 }
 244
 245                 spin_unlock(&c->erase_completion_lock);
 246                 /* Don't wait for it; just erase one right now */
 247                 jffs2_erase_pending_blocks(c, 1);
 248                 spin_lock(&c->erase_completion_lock);
 249
 250                 /* An erase may have failed, decreasing the
 251                    amount of free space available. So we must
 252                    restart from the beginning */
 253                 return -EAGAIN;
 254         }
 255
 256         next = c->free_list.next;
 257         list_del(next);
 258         c->nextblock = list_entry(next, struct jffs2_eraseblock, list);
 259         c->nr_free_blocks--;
 260
 261         jffs2_sum_reset_collected(c->summary); /* reset collected summary */
 262
 263 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
 264         /* adjust write buffer offset, else we get a non contiguous write bug */
 265         if (!(c->wbuf_ofs % c->sector_size) && !c->wbuf_len)
 266                 c->wbuf_ofs = 0xffffffff;
 267 #endif
 268
 269         D1(printk(KERN_DEBUG "jffs2_find_nextblock(): new nextblock = 0x%08x\n", c->nextblock->offset));
 270
 271         return 0;
 272 }
 273
 274 /* Called with alloc sem _and_ erase_completion_lock */
 275 static int jffs2_do_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
 276                                   uint32_t *len, uint32_t sumsize)
 277 {
 278         struct jffs2_eraseblock *jeb = c->nextblock;
 279         uint32_t reserved_size;                         /* for summary information at the end of the jeb */
 280         int ret;
 281
 282  restart:
 283         reserved_size = 0;
 284
 285         if (jffs2_sum_active() && (sumsize != JFFS2_SUMMARY_NOSUM_SIZE)) {
 286                                                         /* NOSUM_SIZE means not to generate summary */
 287
 288                 if (jeb) {
 289                         reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
 290                         dbg_summary("minsize=%d , jeb->free=%d ,"
 291                                                 "summary->size=%d , sumsize=%d\n",
 292                                                 minsize, jeb->free_size,
 293                                                 c->summary->sum_size, sumsize);
 294                 }
 295
 296                 /* Is there enough space for writing out the current node, or we have to
 297                    write out summary information now, close this jeb and select new nextblock? */
 298                 if (jeb && (PAD(minsize) + PAD(c->summary->sum_size + sumsize +
 299                                         JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size)) {
 300
 301                         /* Has summary been disabled for this jeb? */
 302                         if (jffs2_sum_is_disabled(c->summary)) {
 303                                 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
 304                                 goto restart;
 305                         }
 306
 307                         /* Writing out the collected summary information */
 308                         dbg_summary("generating summary for 0x%08x.\n", jeb->offset);
 309                         ret = jffs2_sum_write_sumnode(c);
 310
 311                         if (ret)
 312                                 return ret;
 313
 314                         if (jffs2_sum_is_disabled(c->summary)) {
 315                                 /* jffs2_write_sumnode() couldn't write out the summary information
 316                                    diabling summary for this jeb and free the collected information
 317                                  */
 318                                 sumsize = JFFS2_SUMMARY_NOSUM_SIZE;
 319                                 goto restart;
 320                         }
 321
 322                         jffs2_close_nextblock(c, jeb);
 323                         jeb = NULL;
 324                         /* keep always valid value in reserved_size */
 325                         reserved_size = PAD(sumsize + c->summary->sum_size + JFFS2_SUMMARY_FRAME_SIZE);
 326                 }
 327         } else {
 328                 if (jeb && minsize > jeb->free_size) {
 329                         uint32_t waste;
 330
 331                         /* Skip the end of this block and file it as having some dirty space */
 332                         /* If there's a pending write to it, flush now */
 333
 334                         if (jffs2_wbuf_dirty(c)) {
 335                                 spin_unlock(&c->erase_completion_lock);
 336                                 D1(printk(KERN_DEBUG "jffs2_do_reserve_space: Flushing write buffer\n"));
 337                                 jffs2_flush_wbuf_pad(c);
 338                                 spin_lock(&c->erase_completion_lock);
 339                                 jeb = c->nextblock;
 340                                 goto restart;
 341                         }
 342
 343                         spin_unlock(&c->erase_completion_lock);
 344
 345                         ret = jffs2_prealloc_raw_node_refs(c, jeb, 1);
 346                         if (ret)
 347                                 return ret;
 348                         /* Just lock it again and continue. Nothing much can change because
 349                            we hold c->alloc_sem anyway. In fact, it's not entirely clear why
 350                            we hold c->erase_completion_lock in the majority of this function...
 351                            but that's a question for another (more caffeine-rich) day. */
 352                         spin_lock(&c->erase_completion_lock);
 353
 354                         waste = jeb->free_size;
 355                         jffs2_link_node_ref(c, jeb,
 356                                             (jeb->offset + c->sector_size - waste) | REF_OBSOLETE,
 357                                             waste, NULL);
 358                         /* FIXME: that made it count as dirty. Convert to wasted */
 359                         jeb->dirty_size -= waste;
 360                         c->dirty_size -= waste;
 361                         jeb->wasted_size += waste;
 362                         c->wasted_size += waste;
 363
 364                         jffs2_close_nextblock(c, jeb);
 365                         jeb = NULL;
 366                 }
 367         }
 368
 369         if (!jeb) {
 370
 371                 ret = jffs2_find_nextblock(c);
 372                 if (ret)
 373                         return ret;
 374
 375                 jeb = c->nextblock;
 376
 377                 if (jeb->free_size != c->sector_size - c->cleanmarker_size) {
 378                         printk(KERN_WARNING "Eep. Block 0x%08x taken from free_list had free_size of 0x%08x!!\n", jeb->offset, jeb->free_size);
 379                         goto restart;
 380                 }
 381         }
 382         /* OK, jeb (==c->nextblock) is now pointing at a block which definitely has
 383            enough space */
 384         *len = jeb->free_size - reserved_size;
 385
 386         if (c->cleanmarker_size && jeb->used_size == c->cleanmarker_size &&
 387             !jeb->first_node->next_in_ino) {
 388                 /* Only node in it beforehand was a CLEANMARKER node (we think).
 389                    So mark it obsolete now that there's going to be another node
 390                    in the block. This will reduce used_size to zero but We've
 391                    already set c->nextblock so that jffs2_mark_node_obsolete()
 392                    won't try to refile it to the dirty_list.
 393                 */
 394                 spin_unlock(&c->erase_completion_lock);
 395                 jffs2_mark_node_obsolete(c, jeb->first_node);
 396                 spin_lock(&c->erase_completion_lock);
 397         }
 398
 399         D1(printk(KERN_DEBUG "jffs2_do_reserve_space(): Giving 0x%x bytes at 0x%x\n",
 400                   *len, jeb->offset + (c->sector_size - jeb->free_size)));
 401         return 0;
 402 }
 403
 404 /**
 405  *      jffs2_add_physical_node_ref - add a physical node reference to the list
 406  *      @c: superblock info
 407  *      @new: new node reference to add
 408  *      @len: length of this physical node
 409  *
 410  *      Should only be used to report nodes for which space has been allocated
 411  *      by jffs2_reserve_space.
 412  *
 413  *      Must be called with the alloc_sem held.
 414  */
 415
 416 struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c,
 417                                                        uint32_t ofs, uint32_t len,
 418                                                        struct jffs2_inode_cache *ic)
 419 {
 420         struct jffs2_eraseblock *jeb;
 421         struct jffs2_raw_node_ref *new;
 422
 423         jeb = &c->blocks[ofs / c->sector_size];
 424
 425         D1(printk(KERN_DEBUG "jffs2_add_physical_node_ref(): Node at 0x%x(%d), size 0x%x\n",
 426                   ofs & ~3, ofs & 3, len));
 427 #if 1
 428         /* Allow non-obsolete nodes only to be added at the end of c->nextblock,
 429            if c->nextblock is set. Note that wbuf.c will file obsolete nodes
 430            even after refiling c->nextblock */
 431         if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
 432             && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
 433                 printk(KERN_WARNING "argh. node added in wrong place at 0x%08x(%d)\n", ofs & ~3, ofs & 3);
 434                 if (c->nextblock)
 435                         printk(KERN_WARNING "nextblock 0x%08x", c->nextblock->offset);
 436                 else
 437                         printk(KERN_WARNING "No nextblock");
 438                 printk(", expected at %08x\n", jeb->offset + (c->sector_size - jeb->free_size));
 439                 return ERR_PTR(-EINVAL);
 440         }
 441 #endif
 442         spin_lock(&c->erase_completion_lock);
 443
 444         new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
 445
 446         if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
 447                 /* If it lives on the dirty_list, jffs2_reserve_space will put it there */
 448                 D1(printk(KERN_DEBUG "Adding full erase block at 0x%08x to clean_list (free 0x%08x, dirty 0x%08x, used 0x%08x\n",
 449                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 450                 if (jffs2_wbuf_dirty(c)) {
 451                         /* Flush the last write in the block if it's outstanding */
 452                         spin_unlock(&c->erase_completion_lock);
 453                         jffs2_flush_wbuf_pad(c);
 454                         spin_lock(&c->erase_completion_lock);
 455                 }
 456
 457                 list_add_tail(&jeb->list, &c->clean_list);
 458                 c->nextblock = NULL;
 459         }
 460         jffs2_dbg_acct_sanity_check_nolock(c,jeb);
 461         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 462
 463         spin_unlock(&c->erase_completion_lock);
 464
 465         return new;
 466 }
 467
 468
 469 void jffs2_complete_reservation(struct jffs2_sb_info *c)
 470 {
 471         D1(printk(KERN_DEBUG "jffs2_complete_reservation()\n"));
 472         jffs2_garbage_collect_trigger(c);
 473         mutex_unlock(&c->alloc_sem);
 474 }
 475
 476 static inline int on_list(struct list_head *obj, struct list_head *head)
 477 {
 478         struct list_head *this;
 479
 480         list_for_each(this, head) {
 481                 if (this == obj) {
 482                         D1(printk("%p is on list at %p\n", obj, head));
 483                         return 1;
 484
 485                 }
 486         }
 487         return 0;
 488 }
 489
 490 void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
 491 {
 492         struct jffs2_eraseblock *jeb;
 493         int blocknr;
 494         struct jffs2_unknown_node n;
 495         int ret, addedsize;
 496         size_t retlen;
 497         uint32_t freed_len;
 498
 499         if(unlikely(!ref)) {
 500                 printk(KERN_NOTICE "EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
 501                 return;
 502         }
 503         if (ref_obsolete(ref)) {
 504                 D1(printk(KERN_DEBUG "jffs2_mark_node_obsolete called with already obsolete node at 0x%08x\n", ref_offset(ref)));
 505                 return;
 506         }
 507         blocknr = ref->flash_offset / c->sector_size;
 508         if (blocknr >= c->nr_blocks) {
 509                 printk(KERN_NOTICE "raw node at 0x%08x is off the end of device!\n", ref->flash_offset);
 510                 BUG();
 511         }
 512         jeb = &c->blocks[blocknr];
 513
 514         if (jffs2_can_mark_obsolete(c) && !jffs2_is_readonly(c) &&
 515             !(c->flags & (JFFS2_SB_FLAG_SCANNING | JFFS2_SB_FLAG_BUILDING))) {
 516                 /* Hm. This may confuse static lock analysis. If any of the above
 517                    three conditions is false, we're going to return from this
 518                    function without actually obliterating any nodes or freeing
 519                    any jffs2_raw_node_refs. So we don't need to stop erases from
 520                    happening, or protect against people holding an obsolete
 521                    jffs2_raw_node_ref without the erase_completion_lock. */
 522                 mutex_lock(&c->erase_free_sem);
 523         }
 524
 525         spin_lock(&c->erase_completion_lock);
 526
 527         freed_len = ref_totlen(c, jeb, ref);
 528
 529         if (ref_flags(ref) == REF_UNCHECKED) {
 530                 D1(if (unlikely(jeb->unchecked_size < freed_len)) {
 531                         printk(KERN_NOTICE "raw unchecked node of size 0x%08x freed from erase block %d at 0x%08x, but unchecked_size was already 0x%08x\n",
 532                                freed_len, blocknr, ref->flash_offset, jeb->used_size);
 533                         BUG();
 534                 })
 535                 D1(printk(KERN_DEBUG "Obsoleting previously unchecked node at 0x%08x of len %x: ", ref_offset(ref), freed_len));
 536                 jeb->unchecked_size -= freed_len;
 537                 c->unchecked_size -= freed_len;
 538         } else {
 539                 D1(if (unlikely(jeb->used_size < freed_len)) {
 540                         printk(KERN_NOTICE "raw node of size 0x%08x freed from erase block %d at 0x%08x, but used_size was already 0x%08x\n",
 541                                freed_len, blocknr, ref->flash_offset, jeb->used_size);
 542                         BUG();
 543                 })
 544                 D1(printk(KERN_DEBUG "Obsoleting node at 0x%08x of len %#x: ", ref_offset(ref), freed_len));
 545                 jeb->used_size -= freed_len;
 546                 c->used_size -= freed_len;
 547         }
 548
 549         // Take care, that wasted size is taken into concern
 550         if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
 551                 D1(printk("Dirtying\n"));
 552                 addedsize = freed_len;
 553                 jeb->dirty_size += freed_len;
 554                 c->dirty_size += freed_len;
 555
 556                 /* Convert wasted space to dirty, if not a bad block */
 557                 if (jeb->wasted_size) {
 558                         if (on_list(&jeb->list, &c->bad_used_list)) {
 559                                 D1(printk(KERN_DEBUG "Leaving block at %08x on the bad_used_list\n",
 560                                           jeb->offset));
 561                                 addedsize = 0; /* To fool the refiling code later */
 562                         } else {
 563                                 D1(printk(KERN_DEBUG "Converting %d bytes of wasted space to dirty in block at %08x\n",
 564                                           jeb->wasted_size, jeb->offset));
 565                                 addedsize += jeb->wasted_size;
 566                                 jeb->dirty_size += jeb->wasted_size;
 567                                 c->dirty_size += jeb->wasted_size;
 568                                 c->wasted_size -= jeb->wasted_size;
 569                                 jeb->wasted_size = 0;
 570                         }
 571                 }
 572         } else {
 573                 D1(printk("Wasting\n"));
 574                 addedsize = 0;
 575                 jeb->wasted_size += freed_len;
 576                 c->wasted_size += freed_len;
 577         }
 578         ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
 579
 580         jffs2_dbg_acct_sanity_check_nolock(c, jeb);
 581         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 582
 583         if (c->flags & JFFS2_SB_FLAG_SCANNING) {
 584                 /* Flash scanning is in progress. Don't muck about with the block
 585                    lists because they're not ready yet, and don't actually
 586                    obliterate nodes that look obsolete. If they weren't
 587                    marked obsolete on the flash at the time they _became_
 588                    obsolete, there was probably a reason for that. */
 589                 spin_unlock(&c->erase_completion_lock);
 590                 /* We didn't lock the erase_free_sem */
 591                 return;
 592         }
 593
 594         if (jeb == c->nextblock) {
 595                 D2(printk(KERN_DEBUG "Not moving nextblock 0x%08x to dirty/erase_pending list\n", jeb->offset));
 596         } else if (!jeb->used_size && !jeb->unchecked_size) {
 597                 if (jeb == c->gcblock) {
 598                         D1(printk(KERN_DEBUG "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n", jeb->offset));
 599                         c->gcblock = NULL;
 600                 } else {
 601                         D1(printk(KERN_DEBUG "Eraseblock at 0x%08x completely dirtied. Removing from (dirty?) list...\n", jeb->offset));
 602                         list_del(&jeb->list);
 603                 }
 604                 if (jffs2_wbuf_dirty(c)) {
 605                         D1(printk(KERN_DEBUG "...and adding to erasable_pending_wbuf_list\n"));
 606                         list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list);
 607                 } else {
 608                         if (jiffies & 127) {
 609                                 /* Most of the time, we just erase it immediately. Otherwise we
 610                                    spend ages scanning it on mount, etc. */
 611                                 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
 612                                 list_add_tail(&jeb->list, &c->erase_pending_list);
 613                                 c->nr_erasing_blocks++;
 614                                 jffs2_erase_pending_trigger(c);
 615                         } else {
 616                                 /* Sometimes, however, we leave it elsewhere so it doesn't get
 617                                    immediately reused, and we spread the load a bit. */
 618                                 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
 619                                 list_add_tail(&jeb->list, &c->erasable_list);
 620                         }
 621                 }
 622                 D1(printk(KERN_DEBUG "Done OK\n"));
 623         } else if (jeb == c->gcblock) {
 624                 D2(printk(KERN_DEBUG "Not moving gcblock 0x%08x to dirty_list\n", jeb->offset));
 625         } else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
 626                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is freshly dirtied. Removing from clean list...\n", jeb->offset));
 627                 list_del(&jeb->list);
 628                 D1(printk(KERN_DEBUG "...and adding to dirty_list\n"));
 629                 list_add_tail(&jeb->list, &c->dirty_list);
 630         } else if (VERYDIRTY(c, jeb->dirty_size) &&
 631                    !VERYDIRTY(c, jeb->dirty_size - addedsize)) {
 632                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x is now very dirty. Removing from dirty list...\n", jeb->offset));
 633                 list_del(&jeb->list);
 634                 D1(printk(KERN_DEBUG "...and adding to very_dirty_list\n"));
 635                 list_add_tail(&jeb->list, &c->very_dirty_list);
 636         } else {
 637                 D1(printk(KERN_DEBUG "Eraseblock at 0x%08x not moved anywhere. (free 0x%08x, dirty 0x%08x, used 0x%08x)\n",
 638                           jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size));
 639         }
 640
 641         spin_unlock(&c->erase_completion_lock);
 642
 643         if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
 644                 (c->flags & JFFS2_SB_FLAG_BUILDING)) {
 645                 /* We didn't lock the erase_free_sem */
 646                 return;
 647         }
 648
 649         /* The erase_free_sem is locked, and has been since before we marked the node obsolete
 650            and potentially put its eraseblock onto the erase_pending_list. Thus, we know that
 651            the block hasn't _already_ been erased, and that 'ref' itself hasn't been freed yet
 652            by jffs2_free_jeb_node_refs() in erase.c. Which is nice. */
 653
 654         D1(printk(KERN_DEBUG "obliterating obsoleted node at 0x%08x\n", ref_offset(ref)));
 655         ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
 656         if (ret) {
 657                 printk(KERN_WARNING "Read error reading from obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret);
 658                 goto out_erase_sem;
 659         }
 660         if (retlen != sizeof(n)) {
 661                 printk(KERN_WARNING "Short read from obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
 662                 goto out_erase_sem;
 663         }
 664         if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
 665                 printk(KERN_WARNING "Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n", je32_to_cpu(n.totlen), freed_len);
 666                 goto out_erase_sem;
 667         }
 668         if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
 669                 D1(printk(KERN_DEBUG "Node at 0x%08x was already marked obsolete (nodetype 0x%04x)\n", ref_offset(ref), je16_to_cpu(n.nodetype)));
 670                 goto out_erase_sem;
 671         }
 672         /* XXX FIXME: This is ugly now */
 673         n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
 674         ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
 675         if (ret) {
 676                 printk(KERN_WARNING "Write error in obliterating obsoleted node at 0x%08x: %d\n", ref_offset(ref), ret);
 677                 goto out_erase_sem;
 678         }
 679         if (retlen != sizeof(n)) {
 680                 printk(KERN_WARNING "Short write in obliterating obsoleted node at 0x%08x: %zd\n", ref_offset(ref), retlen);
 681                 goto out_erase_sem;
 682         }
 683
 684         /* Nodes which have been marked obsolete no longer need to be
 685            associated with any inode. Remove them from the per-inode list.
 686
 687            Note we can't do this for NAND at the moment because we need
 688            obsolete dirent nodes to stay on the lists, because of the
 689            horridness in jffs2_garbage_collect_deletion_dirent(). Also
 690            because we delete the inocache, and on NAND we need that to
 691            stay around until all the nodes are actually erased, in order
 692            to stop us from giving the same inode number to another newly
 693            created inode. */
 694         if (ref->next_in_ino) {
 695                 struct jffs2_inode_cache *ic;
 696                 struct jffs2_raw_node_ref **p;
 697
 698                 spin_lock(&c->erase_completion_lock);
 699
 700                 ic = jffs2_raw_ref_to_ic(ref);
 701                 for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
 702                         ;
 703
 704                 *p = ref->next_in_ino;
 705                 ref->next_in_ino = NULL;
 706
 707                 switch (ic->class) {
 708 #ifdef CONFIG_JFFS2_FS_XATTR
 709                         case RAWNODE_CLASS_XATTR_DATUM:
 710                                 jffs2_release_xattr_datum(c, (struct jffs2_xattr_datum *)ic);
 711                                 break;
 712                         case RAWNODE_CLASS_XATTR_REF:
 713                                 jffs2_release_xattr_ref(c, (struct jffs2_xattr_ref *)ic);
 714                                 break;
 715 #endif
 716                         default:
 717                                 if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
 718                                         jffs2_del_ino_cache(c, ic);
 719                                 break;
 720                 }
 721                 spin_unlock(&c->erase_completion_lock);
 722         }
 723
 724  out_erase_sem:
 725         mutex_unlock(&c->erase_free_sem);
 726 }
 727
 728 int jffs2_thread_should_wake(struct jffs2_sb_info *c)
 729 {
 730         int ret = 0;
 731         uint32_t dirty;
 732         int nr_very_dirty = 0;
 733         struct jffs2_eraseblock *jeb;
 734
 735         if (c->unchecked_size) {
 736                 D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): unchecked_size %d, checked_ino #%d\n",
 737                           c->unchecked_size, c->checked_ino));
 738                 return 1;
 739         }
 740
 741         /* dirty_size contains blocks on erase_pending_list
 742          * those blocks are counted in c->nr_erasing_blocks.
 743          * If one block is actually erased, it is not longer counted as dirty_space
 744          * but it is counted in c->nr_erasing_blocks, so we add it and subtract it
 745          * with c->nr_erasing_blocks * c->sector_size again.
 746          * Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
 747          * This helps us to force gc and pick eventually a clean block to spread the load.
 748          */
 749         dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
 750
 751         if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
 752                         (dirty > c->nospc_dirty_size))
 753                 ret = 1;
 754
 755         list_for_each_entry(jeb, &c->very_dirty_list, list) {
 756                 nr_very_dirty++;
 757                 if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
 758                         ret = 1;
 759                         /* In debug mode, actually go through and count them all */
 760                         D1(continue);
 761                         break;
 762                 }
 763         }
 764
 765         D1(printk(KERN_DEBUG "jffs2_thread_should_wake(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n",
 766                   c->nr_free_blocks, c->nr_erasing_blocks, c->dirty_size, nr_very_dirty, ret?"yes":"no"));
 767
 768         return ret;
 769 }