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