/* Cached device - bcache superblock */
 
-static void register_bdev(struct cache_sb *sb, struct page *sb_page,
+static int register_bdev(struct cache_sb *sb, struct page *sb_page,
                                 struct block_device *bdev,
                                 struct cached_dev *dc)
 {
            BDEV_STATE(&dc->sb) == BDEV_STATE_STALE)
                bch_cached_dev_run(dc);
 
-       return;
+       return 0;
 err:
        pr_notice("error %s: %s", dc->backing_dev_name, err);
        bcache_device_stop(&dc->disk);
+       return -EIO;
 }
 
 /* Flash only volumes */
 static ssize_t register_bcache(struct kobject *k, struct kobj_attribute *attr,
                               const char *buffer, size_t size)
 {
-       ssize_t ret = size;
+       ssize_t ret = -EINVAL;
        const char *err = "cannot allocate memory";
        char *path = NULL;
        struct cache_sb *sb = NULL;
                        if (!IS_ERR(bdev))
                                bdput(bdev);
                        if (attr == &ksysfs_register_quiet)
-                               goto out;
+                               goto quiet_out;
                }
                goto err;
        }
                        goto err_close;
 
                mutex_lock(&bch_register_lock);
-               register_bdev(sb, sb_page, bdev, dc);
+               ret = register_bdev(sb, sb_page, bdev, dc);
                mutex_unlock(&bch_register_lock);
+               if (ret < 0)
+                       goto err;
        } else {
                struct cache *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
 
                if (register_cache(sb, sb_page, bdev, ca) != 0)
                        goto err;
        }
+quiet_out:
+       ret = size;
 out:
        if (sb_page)
                put_page(sb_page);
        blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 err:
        pr_info("error %s: %s", path, err);
-       ret = -EINVAL;
        goto out;
 }