bcache: remove redundant LIST_HEAD(journal) from run_cache_set()

[platform/kernel/linux-rpi.git] / drivers / md / bcache / super.c

diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index 30ba9ae..2321643 100644 (file)
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -643,10 +643,6 @@ static int ioctl_dev(struct block_device *b, fmode_t mode,
                     unsigned int cmd, unsigned long arg)
 {
        struct bcache_device *d = b->bd_disk->private_data;
-       struct cached_dev *dc = container_of(d, struct cached_dev, disk);
-
-       if (dc->io_disable)
-               return -EIO;
 
        return d->ioctl(d, mode, cmd, arg);
 }
@@ -1152,11 +1148,12 @@ int bch_cached_dev_attach(struct cached_dev *dc, struct cache_set *c,
        }
 
        if (BDEV_STATE(&dc->sb) == BDEV_STATE_DIRTY) {
-               bch_sectors_dirty_init(&dc->disk);
                atomic_set(&dc->has_dirty, 1);
                bch_writeback_queue(dc);
        }
 
+       bch_sectors_dirty_init(&dc->disk);
+
        bch_cached_dev_run(dc);
        bcache_device_link(&dc->disk, c, "bdev");
        atomic_inc(&c->attached_dev_nr);
@@ -1183,18 +1180,16 @@ static void cached_dev_free(struct closure *cl)
 {
        struct cached_dev *dc = container_of(cl, struct cached_dev, disk.cl);
 
-       mutex_lock(&bch_register_lock);
-
        if (test_and_clear_bit(BCACHE_DEV_WB_RUNNING, &dc->disk.flags))
                cancel_writeback_rate_update_dwork(dc);
 
        if (!IS_ERR_OR_NULL(dc->writeback_thread))
                kthread_stop(dc->writeback_thread);
-       if (dc->writeback_write_wq)
-               destroy_workqueue(dc->writeback_write_wq);
        if (!IS_ERR_OR_NULL(dc->status_update_thread))
                kthread_stop(dc->status_update_thread);
 
+       mutex_lock(&bch_register_lock);
+
        if (atomic_read(&dc->running))
                bd_unlink_disk_holder(dc->bdev, dc->disk.disk);
        bcache_device_free(&dc->disk);
@@ -1428,8 +1423,6 @@ int bch_flash_dev_create(struct cache_set *c, uint64_t size)
 
 bool bch_cached_dev_error(struct cached_dev *dc)
 {
-       struct cache_set *c;
-
        if (!dc || test_bit(BCACHE_DEV_CLOSING, &dc->disk.flags))
                return false;
 
@@ -1440,21 +1433,6 @@ bool bch_cached_dev_error(struct cached_dev *dc)
        pr_err("stop %s: too many IO errors on backing device %s\n",
                dc->disk.disk->disk_name, dc->backing_dev_name);
 
-       /*
-        * If the cached device is still attached to a cache set,
-        * even dc->io_disable is true and no more I/O requests
-        * accepted, cache device internal I/O (writeback scan or
-        * garbage collection) may still prevent bcache device from
-        * being stopped. So here CACHE_SET_IO_DISABLE should be
-        * set to c->flags too, to make the internal I/O to cache
-        * device rejected and stopped immediately.
-        * If c is NULL, that means the bcache device is not attached
-        * to any cache set, then no CACHE_SET_IO_DISABLE bit to set.
-        */
-       c = dc->disk.c;
-       if (c && test_and_set_bit(CACHE_SET_IO_DISABLE, &c->flags))
-               pr_info("CACHE_SET_IO_DISABLE already set");
-
        bcache_device_stop(&dc->disk);
        return true;
 }
@@ -1514,6 +1492,7 @@ static void cache_set_free(struct closure *cl)
        bch_btree_cache_free(c);
        bch_journal_free(c);
 
+       mutex_lock(&bch_register_lock);
        for_each_cache(ca, c, i)
                if (ca) {
                        ca->set = NULL;
@@ -1532,7 +1511,6 @@ static void cache_set_free(struct closure *cl)
        mempool_exit(&c->search);
        kfree(c->devices);
 
-       mutex_lock(&bch_register_lock);
        list_del(&c->list);
        mutex_unlock(&bch_register_lock);
 
@@ -1555,7 +1533,7 @@ static void cache_set_flush(struct closure *cl)
        kobject_put(&c->internal);
        kobject_del(&c->kobj);
 
-       if (c->gc_thread)
+       if (!IS_ERR_OR_NULL(c->gc_thread))
                kthread_stop(c->gc_thread);
 
        if (!IS_ERR_OR_NULL(c->root))
@@ -1773,13 +1751,15 @@ err:
        return NULL;
 }
 
-static void run_cache_set(struct cache_set *c)
+static int run_cache_set(struct cache_set *c)
 {
        const char *err = "cannot allocate memory";
        struct cached_dev *dc, *t;
        struct cache *ca;
        struct closure cl;
        unsigned int i;
+       LIST_HEAD(journal);
+       struct journal_replay *l;
 
        closure_init_stack(&cl);
 
@@ -1788,7 +1768,6 @@ static void run_cache_set(struct cache_set *c)
        set_gc_sectors(c);
 
        if (CACHE_SYNC(&c->sb)) {
-               LIST_HEAD(journal);
                struct bkey *k;
                struct jset *j;
 
@@ -1867,7 +1846,9 @@ static void run_cache_set(struct cache_set *c)
                if (j->version < BCACHE_JSET_VERSION_UUID)
                        __uuid_write(c);
 
-               bch_journal_replay(c, &journal);
+               err = "bcache: replay journal failed";
+               if (bch_journal_replay(c, &journal))
+                       goto err;
        } else {
                pr_notice("invalidating existing data");
 
@@ -1935,11 +1916,19 @@ static void run_cache_set(struct cache_set *c)
        flash_devs_run(c);
 
        set_bit(CACHE_SET_RUNNING, &c->flags);
-       return;
+       return 0;
 err:
+       while (!list_empty(&journal)) {
+               l = list_first_entry(&journal, struct journal_replay, list);
+               list_del(&l->list);
+               kfree(l);
+       }
+
        closure_sync(&cl);
        /* XXX: test this, it's broken */
        bch_cache_set_error(c, "%s", err);
+
+       return -EIO;
 }
 
 static bool can_attach_cache(struct cache *ca, struct cache_set *c)
@@ -2003,8 +1992,11 @@ found:
        ca->set->cache[ca->sb.nr_this_dev] = ca;
        c->cache_by_alloc[c->caches_loaded++] = ca;
 
-       if (c->caches_loaded == c->sb.nr_in_set)
-               run_cache_set(c);
+       if (c->caches_loaded == c->sb.nr_in_set) {
+               err = "failed to run cache set";
+               if (run_cache_set(c) < 0)
+                       goto err;
+       }
 
        return NULL;
 err: