Merge tag 'for-linus-20160324' of git://git.infradead.org/linux-mtd

Pull MTD updates from Brian Norris:
 "NAND:
   - Add sunxi_nand randomizer support
   - begin refactoring NAND ecclayout structs
   - fix pxa3xx_nand dmaengine usage
   - brcmnand: fix support for v7.1 controller
   - add Qualcomm NAND controller driver

  SPI NOR:
   - add new ls1021a, ls2080a support to Freescale QuadSPI
   - add new flash ID entries
   - support bottom-block protection for Winbond flash
   - support Status Register Write Protect
   - remove broken QPI support for Micron SPI flash

  JFFS2:
   - improve post-mount CRC scan efficiency

  General:
   - refactor bcm63xxpart parser, to later extend for NAND
   - add writebuf size parameter to mtdram

  Other minor code quality improvements"

* tag 'for-linus-20160324' of git://git.infradead.org/linux-mtd: (72 commits)
  mtd: nand: remove kerneldoc for removed function parameter
  mtd: nand: Qualcomm NAND controller driver
  dt/bindings: qcom_nandc: Add DT bindings
  mtd: nand: don't select chip in nand_chip's block_bad op
  mtd: spi-nor: support lock/unlock for a few Winbond chips
  mtd: spi-nor: add TB (Top/Bottom) protect support
  mtd: spi-nor: add SPI_NOR_HAS_LOCK flag
  mtd: spi-nor: use BIT() for flash_info flags
  mtd: spi-nor: disallow further writes to SR if WP# is low
  mtd: spi-nor: make lock/unlock bounds checks more obvious and robust
  mtd: spi-nor: silently drop lock/unlock for already locked/unlocked region
  mtd: spi-nor: wait for SR_WIP to clear on initial unlock
  mtd: nand: simplify nand_bch_init() usage
  mtd: mtdswap: remove useless if (!mtd->ecclayout) test
  mtd: create an mtd_oobavail() helper and make use of it
  mtd: kill the ecclayout->oobavail field
  mtd: nand: check status before reporting timeout
  mtd: bcm63xxpart: give width specifier an 'int', not 'size_t'
  mtd: mtdram: Add parameter for setting writebuf size
  mtd: nand: pxa3xx_nand: kill unused field 'drcmr_cmd'
  ...

1 files changed, 42 insertions, 22 deletions

diff --git a/fs/jffs2/gc.c b/fs/jffs2/gc.c
index 95d5880a63ee..7e553f286775 100644
--- a/fs/jffs2/gc.c
+++ b/fs/jffs2/gc.c
@@ -134,37 +134,59 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
         if (mutex_lock_interruptible(&c->alloc_sem))
                 return -EINTR;
 
+
         for (;;) {
+                /* We can't start doing GC until we've finished checking
+                   the node CRCs etc. */
+                int bucket, want_ino;
+
                 spin_lock(&c->erase_completion_lock);
                 if (!c->unchecked_size)
                         break;
-
-                /* We can't start doing GC yet. We haven't finished checking
-                   the node CRCs etc. Do it now. */
-
-                /* checked_ino is protected by the alloc_sem */
-                if (c->checked_ino > c->highest_ino && xattr) {
-                        pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
-                                c->unchecked_size);
-                        jffs2_dbg_dump_block_lists_nolock(c);
-                        spin_unlock(&c->erase_completion_lock);
-                        mutex_unlock(&c->alloc_sem);
-                        return -ENOSPC;
-                }
-
                 spin_unlock(&c->erase_completion_lock);
 
                 if (!xattr)
                         xattr = jffs2_verify_xattr(c);
 
                 spin_lock(&c->inocache_lock);
+                /* Instead of doing the inodes in numeric order, doing a lookup
+                 * in the hash for each possible number, just walk the hash
+                 * buckets of *existing* inodes. This means that we process
+                 * them out-of-order, but it can be a lot faster if there's
+                 * a sparse inode# space. Which there often is. */
+                want_ino = c->check_ino;
+                for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
+                        for (ic = c->inocache_list[bucket]; ic; ic = ic->next) {
+                                if (ic->ino < want_ino)
+                                        continue;
+
+                                if (ic->state != INO_STATE_CHECKEDABSENT &&
+                                    ic->state != INO_STATE_PRESENT)
+                                        goto got_next; /* with inocache_lock held */
+
+                                jffs2_dbg(1, "Skipping ino #%u already checked\n",
+                                          ic->ino);
+                        }
+                        want_ino = 0;
+                }
 
-                ic = jffs2_get_ino_cache(c, c->checked_ino++);
+                /* Point c->check_ino past the end of the last bucket. */
+                c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) &
+                                ~c->inocache_hashsize) - 1;
 
-                if (!ic) {
-                        spin_unlock(&c->inocache_lock);
-                        continue;
-                }
+                spin_unlock(&c->inocache_lock);
+
+                pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
+                        c->unchecked_size);
+                jffs2_dbg_dump_block_lists_nolock(c);
+                mutex_unlock(&c->alloc_sem);
+                return -ENOSPC;
+
+        got_next:
+                /* For next time round the loop, we want c->checked_ino to indicate
+                 * the *next* one we want to check. And since we're walking the
+                 * buckets rather than doing it sequentially, it's: */
+                c->check_ino = ic->ino + c->inocache_hashsize;
 
                 if (!ic->pino_nlink) {
                         jffs2_dbg(1, "Skipping check of ino #%d with nlink/pino zero\n",
@@ -176,8 +198,6 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
                 switch(ic->state) {
                 case INO_STATE_CHECKEDABSENT:
                 case INO_STATE_PRESENT:
-                        jffs2_dbg(1, "Skipping ino #%u already checked\n",
-                                  ic->ino);
                         spin_unlock(&c->inocache_lock);
                         continue;
 
@@ -196,7 +216,7 @@ int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
                                   ic->ino);
                         /* We need to come back again for the _same_ inode. We've
                          made no progress in this case, but that should be OK */
-                        c->checked_ino--;
+                        c->check_ino = ic->ino;
 
                         mutex_unlock(&c->alloc_sem);
                         sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);