zram: add dynamic device add/remove functionality

We currently don't support on-demand device creation.  The one and only
way to have N zram devices is to specify num_devices module parameter
(default value: 1).  IOW if, for some reason, at some point, user wants
to have N + 1 devies he/she must umount all the existing devices, unload
the module, load the module passing num_devices equals to N + 1.  And do
this again, if needed.

This patch introduces zram control sysfs class, which has two sysfs
attrs:
- hot_add      -- add a new zram device
- hot_remove   -- remove a specific (device_id) zram device

hot_add sysfs attr is read-only and has only automatic device id
assignment mode (as requested by Minchan Kim).  read operation performed
on this attr creates a new zram device and returns back its device_id or
error status.

Usage example:
	# add a new specific zram device
	cat /sys/class/zram-control/hot_add
	2

	# remove a specific zram device
	echo 4 > /sys/class/zram-control/hot_remove

Returning zram_add() error code back to user (-ENOMEM in this case)

	cat /sys/class/zram-control/hot_add
	cat: /sys/class/zram-control/hot_add: Cannot allocate memory

NOTE, there might be users who already depend on the fact that at least
zram0 device gets always created by zram_init(). Preserve this behavior.

[minchan@kernel.org: use zram->claim to avoid lockdep splat]
Signed-off-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Cc: Minchan Kim <minchan@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 97 insertions, 3 deletions

diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 6a3b36d5bad6..830f0eb501fa 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -29,10 +29,14 @@
 #include <linux/vmalloc.h>
 #include <linux/err.h>
 #include <linux/idr.h>
+#include <linux/sysfs.h>
 
 #include "zram_drv.h"
 
 static DEFINE_IDR(zram_index_idr);
+/* idr index must be protected */
+static DEFINE_MUTEX(zram_index_mutex);
+
 static int zram_major;
 static const char *default_compressor = "lzo";
 
@@ -1273,24 +1277,104 @@ out_free_dev:
         return ret;
 }
 
-static void zram_remove(struct zram *zram)
+static int zram_remove(struct zram *zram)
 {
-        pr_info("Removed device: %s\n", zram->disk->disk_name);
+        struct block_device *bdev;
+
+        bdev = bdget_disk(zram->disk, 0);
+        if (!bdev)
+                return -ENOMEM;
+
+        mutex_lock(&bdev->bd_mutex);
+        if (bdev->bd_openers || zram->claim) {
+                mutex_unlock(&bdev->bd_mutex);
+                bdput(bdev);
+                return -EBUSY;
+        }
+
+        zram->claim = true;
+        mutex_unlock(&bdev->bd_mutex);
+
         /*
          * Remove sysfs first, so no one will perform a disksize
-         * store while we destroy the devices
+         * store while we destroy the devices. This also helps during
+         * hot_remove -- zram_reset_device() is the last holder of
+         * ->init_lock, no later/concurrent disksize_store() or any
+         * other sysfs handlers are possible.
          */
         sysfs_remove_group(&disk_to_dev(zram->disk)->kobj,
                         &zram_disk_attr_group);
 
+        /* Make sure all the pending I/O are finished */
+        fsync_bdev(bdev);
         zram_reset_device(zram);
+        bdput(bdev);
+
+        pr_info("Removed device: %s\n", zram->disk->disk_name);
+
         idr_remove(&zram_index_idr, zram->disk->first_minor);
         blk_cleanup_queue(zram->disk->queue);
         del_gendisk(zram->disk);
         put_disk(zram->disk);
         kfree(zram);
+        return 0;
+}
+
+/* zram-control sysfs attributes */
+static ssize_t hot_add_show(struct class *class,
+                        struct class_attribute *attr,
+                        char *buf)
+{
+        int ret;
+
+        mutex_lock(&zram_index_mutex);
+        ret = zram_add();
+        mutex_unlock(&zram_index_mutex);
+
+        if (ret < 0)
+                return ret;
+        return scnprintf(buf, PAGE_SIZE, "%d\n", ret);
+}
+
+static ssize_t hot_remove_store(struct class *class,
+                        struct class_attribute *attr,
+                        const char *buf,
+                        size_t count)
+{
+        struct zram *zram;
+        int ret, dev_id;
+
+        /* dev_id is gendisk->first_minor, which is `int' */
+        ret = kstrtoint(buf, 10, &dev_id);
+        if (ret)
+                return ret;
+        if (dev_id < 0)
+                return -EINVAL;
+
+        mutex_lock(&zram_index_mutex);
+
+        zram = idr_find(&zram_index_idr, dev_id);
+        if (zram)
+                ret = zram_remove(zram);
+        else
+                ret = -ENODEV;
+
+        mutex_unlock(&zram_index_mutex);
+        return ret ? ret : count;
 }
 
+static struct class_attribute zram_control_class_attrs[] = {
+        __ATTR_RO(hot_add),
+        __ATTR_WO(hot_remove),
+        __ATTR_NULL,
+};
+
+static struct class zram_control_class = {
+        .name           = "zram-control",
+        .owner          = THIS_MODULE,
+        .class_attrs    = zram_control_class_attrs,
+};
+
 static int zram_remove_cb(int id, void *ptr, void *data)
 {
         zram_remove(ptr);
@@ -1299,6 +1383,7 @@ static int zram_remove_cb(int id, void *ptr, void *data)
 
 static void destroy_devices(void)
 {
+        class_unregister(&zram_control_class);
         idr_for_each(&zram_index_idr, &zram_remove_cb, NULL);
         idr_destroy(&zram_index_idr);
         unregister_blkdev(zram_major, "zram");
@@ -1308,14 +1393,23 @@ static int __init zram_init(void)
 {
         int ret;
 
+        ret = class_register(&zram_control_class);
+        if (ret) {
+                pr_warn("Unable to register zram-control class\n");
+                return ret;
+        }
+
         zram_major = register_blkdev(0, "zram");
         if (zram_major <= 0) {
                 pr_warn("Unable to get major number\n");
+                class_unregister(&zram_control_class);
                 return -EBUSY;
         }
 
         while (num_devices != 0) {
+                mutex_lock(&zram_index_mutex);
                 ret = zram_add();
+                mutex_unlock(&zram_index_mutex);
                 if (ret < 0)
                         goto out_error;
                 num_devices--;