1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2014 Ezequiel Garcia
4 * Copyright (c) 2011 Free Electrons
6 * Driver parameter handling strongly based on drivers/mtd/ubi/build.c
7 * Copyright (c) International Business Machines Corp., 2006
8 * Copyright (c) Nokia Corporation, 2007
9 * Authors: Artem Bityutskiy, Frank Haverkamp
13 * Read-only block devices on top of UBI volumes
15 * A simple implementation to allow a block device to be layered on top of a
16 * UBI volume. The implementation is provided by creating a static 1-to-1
17 * mapping between the block device and the UBI volume.
19 * The addressed byte is obtained from the addressed block sector, which is
20 * mapped linearly into the corresponding LEB:
22 * LEB number = addressed byte / LEB size
24 * This feature is compiled in the UBI core, and adds a 'block' parameter
25 * to allow early creation of block devices on top of UBI volumes. Runtime
26 * block creation/removal for UBI volumes is provided through two UBI ioctls:
27 * UBI_IOCVOLCRBLK and UBI_IOCVOLRMBLK.
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/err.h>
33 #include <linux/kernel.h>
34 #include <linux/list.h>
35 #include <linux/mutex.h>
36 #include <linux/slab.h>
37 #include <linux/mtd/ubi.h>
38 #include <linux/workqueue.h>
39 #include <linux/blkdev.h>
40 #include <linux/blk-mq.h>
41 #include <linux/hdreg.h>
42 #include <linux/scatterlist.h>
43 #include <linux/idr.h>
44 #include <asm/div64.h>
46 #include "ubi-media.h"
49 /* Maximum number of supported devices */
50 #define UBIBLOCK_MAX_DEVICES 32
52 /* Maximum length of the 'block=' parameter */
53 #define UBIBLOCK_PARAM_LEN 63
55 /* Maximum number of comma-separated items in the 'block=' parameter */
56 #define UBIBLOCK_PARAM_COUNT 2
58 struct ubiblock_param {
61 char name[UBIBLOCK_PARAM_LEN+1];
65 struct work_struct work;
69 /* Numbers of elements set in the @ubiblock_param array */
70 static int ubiblock_devs __initdata;
72 /* MTD devices specification parameters */
73 static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES] __initdata;
76 struct ubi_volume_desc *desc;
83 struct request_queue *rq;
85 struct workqueue_struct *wq;
87 struct mutex dev_mutex;
88 struct list_head list;
89 struct blk_mq_tag_set tag_set;
92 /* Linked list of all ubiblock instances */
93 static LIST_HEAD(ubiblock_devices);
94 static DEFINE_IDR(ubiblock_minor_idr);
95 /* Protects ubiblock_devices and ubiblock_minor_idr */
96 static DEFINE_MUTEX(devices_mutex);
97 static int ubiblock_major;
99 static int __init ubiblock_set_param(const char *val,
100 const struct kernel_param *kp)
104 struct ubiblock_param *param;
105 char buf[UBIBLOCK_PARAM_LEN];
106 char *pbuf = &buf[0];
107 char *tokens[UBIBLOCK_PARAM_COUNT];
112 len = strnlen(val, UBIBLOCK_PARAM_LEN);
114 pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
118 if (len == UBIBLOCK_PARAM_LEN) {
119 pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n",
120 val, UBIBLOCK_PARAM_LEN);
126 /* Get rid of the final newline */
127 if (buf[len - 1] == '\n')
130 for (i = 0; i < UBIBLOCK_PARAM_COUNT; i++)
131 tokens[i] = strsep(&pbuf, ",");
133 param = &ubiblock_param[ubiblock_devs];
135 /* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */
136 ret = kstrtoint(tokens[0], 10, ¶m->ubi_num);
140 /* Second param can be a number or a name */
141 ret = kstrtoint(tokens[1], 10, ¶m->vol_id);
144 strcpy(param->name, tokens[1]);
148 /* One parameter: must be device path */
149 strcpy(param->name, tokens[0]);
159 static const struct kernel_param_ops ubiblock_param_ops = {
160 .set = ubiblock_set_param,
162 module_param_cb(block, &ubiblock_param_ops, NULL, 0);
163 MODULE_PARM_DESC(block, "Attach block devices to UBI volumes. Parameter format: block=<path|dev,num|dev,name>.\n"
164 "Multiple \"block\" parameters may be specified.\n"
165 "UBI volumes may be specified by their number, name, or path to the device node.\n"
167 "Using the UBI volume path:\n"
168 "ubi.block=/dev/ubi0_0\n"
169 "Using the UBI device, and the volume name:\n"
170 "ubi.block=0,rootfs\n"
171 "Using both UBI device number and UBI volume number:\n"
174 static struct ubiblock *find_dev_nolock(int ubi_num, int vol_id)
176 struct ubiblock *dev;
178 list_for_each_entry(dev, &ubiblock_devices, list)
179 if (dev->ubi_num == ubi_num && dev->vol_id == vol_id)
184 static int ubiblock_read(struct ubiblock_pdu *pdu)
186 int ret, leb, offset, bytes_left, to_read;
188 struct request *req = blk_mq_rq_from_pdu(pdu);
189 struct ubiblock *dev = req->q->queuedata;
191 to_read = blk_rq_bytes(req);
192 pos = blk_rq_pos(req) << 9;
194 /* Get LEB:offset address to read from */
195 offset = do_div(pos, dev->leb_size);
197 bytes_left = to_read;
201 * We can only read one LEB at a time. Therefore if the read
202 * length is larger than one LEB size, we split the operation.
204 if (offset + to_read > dev->leb_size)
205 to_read = dev->leb_size - offset;
207 ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read);
211 bytes_left -= to_read;
212 to_read = bytes_left;
219 static int ubiblock_open(struct block_device *bdev, fmode_t mode)
221 struct ubiblock *dev = bdev->bd_disk->private_data;
224 mutex_lock(&dev->dev_mutex);
225 if (dev->refcnt > 0) {
227 * The volume is already open, just increase the reference
234 * We want users to be aware they should only mount us as read-only.
235 * It's just a paranoid check, as write requests will get rejected
238 if (mode & FMODE_WRITE) {
243 dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);
244 if (IS_ERR(dev->desc)) {
245 dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
246 dev->ubi_num, dev->vol_id);
247 ret = PTR_ERR(dev->desc);
254 mutex_unlock(&dev->dev_mutex);
258 mutex_unlock(&dev->dev_mutex);
262 static void ubiblock_release(struct gendisk *gd, fmode_t mode)
264 struct ubiblock *dev = gd->private_data;
266 mutex_lock(&dev->dev_mutex);
268 if (dev->refcnt == 0) {
269 ubi_close_volume(dev->desc);
272 mutex_unlock(&dev->dev_mutex);
275 static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo)
277 /* Some tools might require this information */
280 geo->sectors = get_capacity(bdev->bd_disk);
285 static const struct block_device_operations ubiblock_ops = {
286 .owner = THIS_MODULE,
287 .open = ubiblock_open,
288 .release = ubiblock_release,
289 .getgeo = ubiblock_getgeo,
292 static void ubiblock_do_work(struct work_struct *work)
295 struct ubiblock_pdu *pdu = container_of(work, struct ubiblock_pdu, work);
296 struct request *req = blk_mq_rq_from_pdu(pdu);
298 blk_mq_start_request(req);
301 * It is safe to ignore the return value of blk_rq_map_sg() because
302 * the number of sg entries is limited to UBI_MAX_SG_COUNT
303 * and ubi_read_sg() will check that limit.
305 blk_rq_map_sg(req->q, req, pdu->usgl.sg);
307 ret = ubiblock_read(pdu);
308 rq_flush_dcache_pages(req);
310 blk_mq_end_request(req, errno_to_blk_status(ret));
313 static blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
314 const struct blk_mq_queue_data *bd)
316 struct request *req = bd->rq;
317 struct ubiblock *dev = hctx->queue->queuedata;
318 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
320 switch (req_op(req)) {
322 ubi_sgl_init(&pdu->usgl);
323 queue_work(dev->wq, &pdu->work);
326 return BLK_STS_IOERR;
331 static int ubiblock_init_request(struct blk_mq_tag_set *set,
332 struct request *req, unsigned int hctx_idx,
333 unsigned int numa_node)
335 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
337 sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT);
338 INIT_WORK(&pdu->work, ubiblock_do_work);
343 static const struct blk_mq_ops ubiblock_mq_ops = {
344 .queue_rq = ubiblock_queue_rq,
345 .init_request = ubiblock_init_request,
348 static int calc_disk_capacity(struct ubi_volume_info *vi, u64 *disk_capacity)
350 u64 size = vi->used_bytes >> 9;
352 if (vi->used_bytes % 512) {
353 pr_warn("UBI: block: volume size is not a multiple of 512, "
354 "last %llu bytes are ignored!\n",
355 vi->used_bytes - (size << 9));
358 if ((sector_t)size != size)
361 *disk_capacity = size;
366 int ubiblock_create(struct ubi_volume_info *vi)
368 struct ubiblock *dev;
373 ret = calc_disk_capacity(vi, &disk_capacity);
378 /* Check that the volume isn't already handled */
379 mutex_lock(&devices_mutex);
380 if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
385 dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
391 mutex_init(&dev->dev_mutex);
393 dev->ubi_num = vi->ubi_num;
394 dev->vol_id = vi->vol_id;
395 dev->leb_size = vi->usable_leb_size;
397 /* Initialize the gendisk of this ubiblock device */
400 pr_err("UBI: block: alloc_disk failed\n");
405 gd->fops = &ubiblock_ops;
406 gd->major = ubiblock_major;
407 gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
408 if (gd->first_minor < 0) {
409 dev_err(disk_to_dev(gd),
410 "block: dynamic minor allocation failed");
414 gd->private_data = dev;
415 sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
416 set_capacity(gd, disk_capacity);
419 dev->tag_set.ops = &ubiblock_mq_ops;
420 dev->tag_set.queue_depth = 64;
421 dev->tag_set.numa_node = NUMA_NO_NODE;
422 dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
423 dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
424 dev->tag_set.driver_data = dev;
425 dev->tag_set.nr_hw_queues = 1;
427 ret = blk_mq_alloc_tag_set(&dev->tag_set);
429 dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed");
430 goto out_remove_minor;
433 dev->rq = blk_mq_init_queue(&dev->tag_set);
434 if (IS_ERR(dev->rq)) {
435 dev_err(disk_to_dev(gd), "blk_mq_init_queue failed");
436 ret = PTR_ERR(dev->rq);
439 blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT);
441 dev->rq->queuedata = dev;
442 dev->gd->queue = dev->rq;
445 * Create one workqueue per volume (per registered block device).
446 * Rembember workqueues are cheap, they're not threads.
448 dev->wq = alloc_workqueue("%s", 0, 0, gd->disk_name);
454 list_add_tail(&dev->list, &ubiblock_devices);
456 /* Must be the last step: anyone can call file ops from now on */
458 dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
459 dev->ubi_num, dev->vol_id, vi->name);
460 mutex_unlock(&devices_mutex);
464 blk_cleanup_queue(dev->rq);
466 blk_mq_free_tag_set(&dev->tag_set);
468 idr_remove(&ubiblock_minor_idr, gd->first_minor);
474 mutex_unlock(&devices_mutex);
479 static void ubiblock_cleanup(struct ubiblock *dev)
481 /* Stop new requests to arrive */
482 del_gendisk(dev->gd);
483 /* Flush pending work */
484 destroy_workqueue(dev->wq);
485 /* Finally destroy the blk queue */
486 blk_cleanup_queue(dev->rq);
487 blk_mq_free_tag_set(&dev->tag_set);
488 dev_info(disk_to_dev(dev->gd), "released");
489 idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
493 int ubiblock_remove(struct ubi_volume_info *vi)
495 struct ubiblock *dev;
498 mutex_lock(&devices_mutex);
499 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
505 /* Found a device, let's lock it so we can check if it's busy */
506 mutex_lock(&dev->dev_mutex);
507 if (dev->refcnt > 0) {
512 /* Remove from device list */
513 list_del(&dev->list);
514 ubiblock_cleanup(dev);
515 mutex_unlock(&dev->dev_mutex);
516 mutex_unlock(&devices_mutex);
522 mutex_unlock(&dev->dev_mutex);
524 mutex_unlock(&devices_mutex);
528 static int ubiblock_resize(struct ubi_volume_info *vi)
530 struct ubiblock *dev;
535 * Need to lock the device list until we stop using the device,
536 * otherwise the device struct might get released in
537 * 'ubiblock_remove()'.
539 mutex_lock(&devices_mutex);
540 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
542 mutex_unlock(&devices_mutex);
546 ret = calc_disk_capacity(vi, &disk_capacity);
548 mutex_unlock(&devices_mutex);
550 dev_warn(disk_to_dev(dev->gd),
551 "the volume is too big (%d LEBs), cannot resize",
557 mutex_lock(&dev->dev_mutex);
559 if (get_capacity(dev->gd) != disk_capacity) {
560 set_capacity(dev->gd, disk_capacity);
561 dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
564 mutex_unlock(&dev->dev_mutex);
565 mutex_unlock(&devices_mutex);
569 static int ubiblock_notify(struct notifier_block *nb,
570 unsigned long notification_type, void *ns_ptr)
572 struct ubi_notification *nt = ns_ptr;
574 switch (notification_type) {
575 case UBI_VOLUME_ADDED:
577 * We want to enforce explicit block device creation for
578 * volumes, so when a volume is added we do nothing.
581 case UBI_VOLUME_REMOVED:
582 ubiblock_remove(&nt->vi);
584 case UBI_VOLUME_RESIZED:
585 ubiblock_resize(&nt->vi);
587 case UBI_VOLUME_UPDATED:
589 * If the volume is static, a content update might mean the
590 * size (i.e. used_bytes) was also changed.
592 if (nt->vi.vol_type == UBI_STATIC_VOLUME)
593 ubiblock_resize(&nt->vi);
601 static struct notifier_block ubiblock_notifier = {
602 .notifier_call = ubiblock_notify,
605 static struct ubi_volume_desc * __init
606 open_volume_desc(const char *name, int ubi_num, int vol_id)
609 /* No ubi num, name must be a vol device path */
610 return ubi_open_volume_path(name, UBI_READONLY);
611 else if (vol_id == -1)
612 /* No vol_id, must be vol_name */
613 return ubi_open_volume_nm(ubi_num, name, UBI_READONLY);
615 return ubi_open_volume(ubi_num, vol_id, UBI_READONLY);
618 static void __init ubiblock_create_from_param(void)
621 struct ubiblock_param *p;
622 struct ubi_volume_desc *desc;
623 struct ubi_volume_info vi;
626 * If there is an error creating one of the ubiblocks, continue on to
627 * create the following ubiblocks. This helps in a circumstance where
628 * the kernel command-line specifies multiple block devices and some
629 * may be broken, but we still want the working ones to come up.
631 for (i = 0; i < ubiblock_devs; i++) {
632 p = &ubiblock_param[i];
634 desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);
637 "UBI: block: can't open volume on ubi%d_%d, err=%ld\n",
638 p->ubi_num, p->vol_id, PTR_ERR(desc));
642 ubi_get_volume_info(desc, &vi);
643 ubi_close_volume(desc);
645 ret = ubiblock_create(&vi);
648 "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n",
649 vi.name, p->ubi_num, p->vol_id, ret);
655 static void ubiblock_remove_all(void)
657 struct ubiblock *next;
658 struct ubiblock *dev;
660 mutex_lock(&devices_mutex);
661 list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
662 /* The module is being forcefully removed */
664 /* Remove from device list */
665 list_del(&dev->list);
666 ubiblock_cleanup(dev);
669 mutex_unlock(&devices_mutex);
672 int __init ubiblock_init(void)
676 ubiblock_major = register_blkdev(0, "ubiblock");
677 if (ubiblock_major < 0)
678 return ubiblock_major;
681 * Attach block devices from 'block=' module param.
682 * Even if one block device in the param list fails to come up,
683 * still allow the module to load and leave any others up.
685 ubiblock_create_from_param();
688 * Block devices are only created upon user requests, so we ignore
691 ret = ubi_register_volume_notifier(&ubiblock_notifier, 1);
697 unregister_blkdev(ubiblock_major, "ubiblock");
698 ubiblock_remove_all();
702 void __exit ubiblock_exit(void)
704 ubi_unregister_volume_notifier(&ubiblock_notifier);
705 ubiblock_remove_all();
706 unregister_blkdev(ubiblock_major, "ubiblock");