[PATCH 26/30] ubi: use blk_mq_alloc_disk and blk_cleanup_disk

[Christoph Hellwig <hch@xxxxxx>]

Use blk_mq_alloc_disk and blk_cleanup_disk to simplify the gendisk and
request_queue allocation.

Signed-off-by: Christoph Hellwig <hch@xxxxxx>
---
 drivers/mtd/ubi/block.c | 68 ++++++++++++++++++-----------------------
 1 file changed, 29 insertions(+), 39 deletions(-)

diff --git a/drivers/mtd/ubi/block.c b/drivers/mtd/ubi/block.c
index e1a2ae21dfd3..e003b4b44ffa 100644
--- a/drivers/mtd/ubi/block.c
+++ b/drivers/mtd/ubi/block.c
@@ -394,53 +394,46 @@ int ubiblock_create(struct ubi_volume_info *vi)
        dev->vol_id = vi->vol_id;
        dev->leb_size = vi->usable_leb_size;
 
+       dev->tag_set.ops = &ubiblock_mq_ops;
+       dev->tag_set.queue_depth = 64;
+       dev->tag_set.numa_node = NUMA_NO_NODE;
+       dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
+       dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
+       dev->tag_set.driver_data = dev;
+       dev->tag_set.nr_hw_queues = 1;
+
+       ret = blk_mq_alloc_tag_set(&dev->tag_set);
+       if (ret) {
+               dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed");
+               goto out_free_dev;;
+       }
+
+
        /* Initialize the gendisk of this ubiblock device */
-       gd = alloc_disk(1);
-       if (!gd) {
-               pr_err("UBI: block: alloc_disk failed\n");
-               ret = -ENODEV;
-               goto out_free_dev;
+       gd = blk_mq_alloc_disk(&dev->tag_set, dev);
+       if (IS_ERR(gd)) {
+               ret = PTR_ERR(gd);
+               goto out_free_tags;
        }
 
        gd->fops = &ubiblock_ops;
        gd->major = ubiblock_major;
+       gd->minors = 1;
        gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
        if (gd->first_minor < 0) {
                dev_err(disk_to_dev(gd),
                        "block: dynamic minor allocation failed");
                ret = -ENODEV;
-               goto out_put_disk;
+               goto out_cleanup_disk;
        }
        gd->private_data = dev;
        sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
        set_capacity(gd, disk_capacity);
        dev->gd = gd;
 
-       dev->tag_set.ops = &ubiblock_mq_ops;
-       dev->tag_set.queue_depth = 64;
-       dev->tag_set.numa_node = NUMA_NO_NODE;
-       dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
-       dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
-       dev->tag_set.driver_data = dev;
-       dev->tag_set.nr_hw_queues = 1;
-
-       ret = blk_mq_alloc_tag_set(&dev->tag_set);
-       if (ret) {
-               dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed");
-               goto out_remove_minor;
-       }
-
-       dev->rq = blk_mq_init_queue(&dev->tag_set);
-       if (IS_ERR(dev->rq)) {
-               dev_err(disk_to_dev(gd), "blk_mq_init_queue failed");
-               ret = PTR_ERR(dev->rq);
-               goto out_free_tags;
-       }
+       dev->rq = gd->queue;
        blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT);
 
-       dev->rq->queuedata = dev;
-       dev->gd->queue = dev->rq;
-
        /*
         * Create one workqueue per volume (per registered block device).
         * Rembember workqueues are cheap, they're not threads.
@@ -448,7 +441,7 @@ int ubiblock_create(struct ubi_volume_info *vi)
        dev->wq = alloc_workqueue("%s", 0, 0, gd->disk_name);
        if (!dev->wq) {
                ret = -ENOMEM;
-               goto out_free_queue;
+               goto out_remove_minor;
        }
 
        list_add_tail(&dev->list, &ubiblock_devices);
@@ -460,14 +453,12 @@ int ubiblock_create(struct ubi_volume_info *vi)
        mutex_unlock(&devices_mutex);
        return 0;
 
-out_free_queue:
-       blk_cleanup_queue(dev->rq);
-out_free_tags:
-       blk_mq_free_tag_set(&dev->tag_set);
 out_remove_minor:
        idr_remove(&ubiblock_minor_idr, gd->first_minor);
-out_put_disk:
-       put_disk(dev->gd);
+out_cleanup_disk:
+       blk_cleanup_disk(dev->gd);
+out_free_tags:
+       blk_mq_free_tag_set(&dev->tag_set);
 out_free_dev:
        kfree(dev);
 out_unlock:
@@ -483,11 +474,10 @@ static void ubiblock_cleanup(struct ubiblock *dev)
        /* Flush pending work */
        destroy_workqueue(dev->wq);
        /* Finally destroy the blk queue */
-       blk_cleanup_queue(dev->rq);
-       blk_mq_free_tag_set(&dev->tag_set);
        dev_info(disk_to_dev(dev->gd), "released");
+       blk_cleanup_disk(dev->gd);
+       blk_mq_free_tag_set(&dev->tag_set);
        idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
-       put_disk(dev->gd);
 }
 
 int ubiblock_remove(struct ubi_volume_info *vi)
-- 
2.30.2