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/blkdev.h>
39 #include <linux/blk-mq.h>
40 #include <linux/hdreg.h>
41 #include <linux/scatterlist.h>
42 #include <linux/idr.h>
43 #include <asm/div64.h>
45 #include "ubi-media.h"
48 /* Maximum number of supported devices */
49 #define UBIBLOCK_MAX_DEVICES 32
51 /* Maximum length of the 'block=' parameter */
52 #define UBIBLOCK_PARAM_LEN 63
54 /* Maximum number of comma-separated items in the 'block=' parameter */
55 #define UBIBLOCK_PARAM_COUNT 2
57 struct ubiblock_param {
60 char name[UBIBLOCK_PARAM_LEN+1];
67 /* Numbers of elements set in the @ubiblock_param array */
68 static int ubiblock_devs;
70 /* MTD devices specification parameters */
71 static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES];
74 struct ubi_volume_desc *desc;
81 struct request_queue *rq;
83 struct mutex dev_mutex;
84 struct list_head list;
85 struct blk_mq_tag_set tag_set;
88 /* Linked list of all ubiblock instances */
89 static LIST_HEAD(ubiblock_devices);
90 static DEFINE_IDR(ubiblock_minor_idr);
91 /* Protects ubiblock_devices and ubiblock_minor_idr */
92 static DEFINE_MUTEX(devices_mutex);
93 static int ubiblock_major;
95 static int __init ubiblock_set_param(const char *val,
96 const struct kernel_param *kp)
100 struct ubiblock_param *param;
101 char buf[UBIBLOCK_PARAM_LEN];
102 char *pbuf = &buf[0];
103 char *tokens[UBIBLOCK_PARAM_COUNT];
108 len = strnlen(val, UBIBLOCK_PARAM_LEN);
110 pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
114 if (len == UBIBLOCK_PARAM_LEN) {
115 pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n",
116 val, UBIBLOCK_PARAM_LEN);
122 /* Get rid of the final newline */
123 if (buf[len - 1] == '\n')
126 for (i = 0; i < UBIBLOCK_PARAM_COUNT; i++)
127 tokens[i] = strsep(&pbuf, ",");
129 param = &ubiblock_param[ubiblock_devs];
131 /* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */
132 ret = kstrtoint(tokens[0], 10, ¶m->ubi_num);
136 /* Second param can be a number or a name */
137 ret = kstrtoint(tokens[1], 10, ¶m->vol_id);
140 strcpy(param->name, tokens[1]);
144 /* One parameter: must be device path */
145 strcpy(param->name, tokens[0]);
155 static const struct kernel_param_ops ubiblock_param_ops = {
156 .set = ubiblock_set_param,
158 module_param_cb(block, &ubiblock_param_ops, NULL, 0);
159 MODULE_PARM_DESC(block, "Attach block devices to UBI volumes. Parameter format: block=<path|dev,num|dev,name>.\n"
160 "Multiple \"block\" parameters may be specified.\n"
161 "UBI volumes may be specified by their number, name, or path to the device node.\n"
163 "Using the UBI volume path:\n"
164 "ubi.block=/dev/ubi0_0\n"
165 "Using the UBI device, and the volume name:\n"
166 "ubi.block=0,rootfs\n"
167 "Using both UBI device number and UBI volume number:\n"
170 static struct ubiblock *find_dev_nolock(int ubi_num, int vol_id)
172 struct ubiblock *dev;
174 list_for_each_entry(dev, &ubiblock_devices, list)
175 if (dev->ubi_num == ubi_num && dev->vol_id == vol_id)
180 static blk_status_t ubiblock_read(struct request *req)
182 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
183 struct ubiblock *dev = req->q->queuedata;
184 u64 pos = blk_rq_pos(req) << 9;
185 int to_read = blk_rq_bytes(req);
186 int bytes_left = to_read;
187 /* Get LEB:offset address to read from */
188 int offset = do_div(pos, dev->leb_size);
190 struct req_iterator iter;
194 blk_mq_start_request(req);
197 * It is safe to ignore the return value of blk_rq_map_sg() because
198 * the number of sg entries is limited to UBI_MAX_SG_COUNT
199 * and ubi_read_sg() will check that limit.
201 ubi_sgl_init(&pdu->usgl);
202 blk_rq_map_sg(req->q, req, pdu->usgl.sg);
206 * We can only read one LEB at a time. Therefore if the read
207 * length is larger than one LEB size, we split the operation.
209 if (offset + to_read > dev->leb_size)
210 to_read = dev->leb_size - offset;
212 ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read);
216 bytes_left -= to_read;
217 to_read = bytes_left;
222 rq_for_each_segment(bvec, req, iter)
223 flush_dcache_page(bvec.bv_page);
225 blk_mq_end_request(req, errno_to_blk_status(ret));
230 static int ubiblock_open(struct gendisk *disk, blk_mode_t mode)
232 struct ubiblock *dev = disk->private_data;
235 mutex_lock(&dev->dev_mutex);
236 if (dev->refcnt > 0) {
238 * The volume is already open, just increase the reference
245 * We want users to be aware they should only mount us as read-only.
246 * It's just a paranoid check, as write requests will get rejected
249 if (mode & BLK_OPEN_WRITE) {
253 dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);
254 if (IS_ERR(dev->desc)) {
255 dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
256 dev->ubi_num, dev->vol_id);
257 ret = PTR_ERR(dev->desc);
264 mutex_unlock(&dev->dev_mutex);
268 mutex_unlock(&dev->dev_mutex);
272 static void ubiblock_release(struct gendisk *gd)
274 struct ubiblock *dev = gd->private_data;
276 mutex_lock(&dev->dev_mutex);
278 if (dev->refcnt == 0) {
279 ubi_close_volume(dev->desc);
282 mutex_unlock(&dev->dev_mutex);
285 static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo)
287 /* Some tools might require this information */
290 geo->sectors = get_capacity(bdev->bd_disk);
295 static const struct block_device_operations ubiblock_ops = {
296 .owner = THIS_MODULE,
297 .open = ubiblock_open,
298 .release = ubiblock_release,
299 .getgeo = ubiblock_getgeo,
302 static blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
303 const struct blk_mq_queue_data *bd)
305 switch (req_op(bd->rq)) {
307 return ubiblock_read(bd->rq);
309 return BLK_STS_IOERR;
313 static int ubiblock_init_request(struct blk_mq_tag_set *set,
314 struct request *req, unsigned int hctx_idx,
315 unsigned int numa_node)
317 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
319 sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT);
323 static const struct blk_mq_ops ubiblock_mq_ops = {
324 .queue_rq = ubiblock_queue_rq,
325 .init_request = ubiblock_init_request,
328 static int calc_disk_capacity(struct ubi_volume_info *vi, u64 *disk_capacity)
330 u64 size = vi->used_bytes >> 9;
332 if (vi->used_bytes % 512) {
333 if (vi->vol_type == UBI_DYNAMIC_VOLUME)
334 pr_warn("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
335 vi->used_bytes - (size << 9));
337 pr_info("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
338 vi->used_bytes - (size << 9));
341 if ((sector_t)size != size)
344 *disk_capacity = size;
349 int ubiblock_create(struct ubi_volume_info *vi)
351 struct queue_limits lim = {
352 .max_segments = UBI_MAX_SG_COUNT,
354 struct ubiblock *dev;
359 ret = calc_disk_capacity(vi, &disk_capacity);
364 /* Check that the volume isn't already handled */
365 mutex_lock(&devices_mutex);
366 if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
371 dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
377 mutex_init(&dev->dev_mutex);
379 dev->ubi_num = vi->ubi_num;
380 dev->vol_id = vi->vol_id;
381 dev->leb_size = vi->usable_leb_size;
383 dev->tag_set.ops = &ubiblock_mq_ops;
384 dev->tag_set.queue_depth = 64;
385 dev->tag_set.numa_node = NUMA_NO_NODE;
386 dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
387 dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
388 dev->tag_set.driver_data = dev;
389 dev->tag_set.nr_hw_queues = 1;
391 ret = blk_mq_alloc_tag_set(&dev->tag_set);
393 pr_err("ubiblock%d_%d: blk_mq_alloc_tag_set failed\n",
394 dev->ubi_num, dev->vol_id);
399 /* Initialize the gendisk of this ubiblock device */
400 gd = blk_mq_alloc_disk(&dev->tag_set, &lim, dev);
406 gd->fops = &ubiblock_ops;
407 gd->major = ubiblock_major;
409 gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
410 if (gd->first_minor < 0) {
411 pr_err("ubiblock%d_%d: block: dynamic minor allocation failed\n",
412 dev->ubi_num, dev->vol_id);
414 goto out_cleanup_disk;
416 gd->flags |= GENHD_FL_NO_PART;
417 gd->private_data = dev;
418 sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
419 set_capacity(gd, disk_capacity);
424 list_add_tail(&dev->list, &ubiblock_devices);
426 /* Must be the last step: anyone can call file ops from now on */
427 ret = device_add_disk(vi->dev, dev->gd, NULL);
429 goto out_remove_minor;
431 dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
432 dev->ubi_num, dev->vol_id, vi->name);
433 mutex_unlock(&devices_mutex);
437 list_del(&dev->list);
438 idr_remove(&ubiblock_minor_idr, gd->first_minor);
442 blk_mq_free_tag_set(&dev->tag_set);
446 mutex_unlock(&devices_mutex);
451 static void ubiblock_cleanup(struct ubiblock *dev)
453 int id = dev->gd->first_minor;
455 /* Stop new requests to arrive */
456 del_gendisk(dev->gd);
457 /* Finally destroy the blk queue */
458 dev_info(disk_to_dev(dev->gd), "released");
460 blk_mq_free_tag_set(&dev->tag_set);
461 idr_remove(&ubiblock_minor_idr, id);
464 int ubiblock_remove(struct ubi_volume_info *vi)
466 struct ubiblock *dev;
469 mutex_lock(&devices_mutex);
470 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
476 /* Found a device, let's lock it so we can check if it's busy */
477 mutex_lock(&dev->dev_mutex);
478 if (dev->refcnt > 0) {
483 /* Remove from device list */
484 list_del(&dev->list);
485 ubiblock_cleanup(dev);
486 mutex_unlock(&dev->dev_mutex);
487 mutex_unlock(&devices_mutex);
493 mutex_unlock(&dev->dev_mutex);
495 mutex_unlock(&devices_mutex);
499 static int ubiblock_resize(struct ubi_volume_info *vi)
501 struct ubiblock *dev;
506 * Need to lock the device list until we stop using the device,
507 * otherwise the device struct might get released in
508 * 'ubiblock_remove()'.
510 mutex_lock(&devices_mutex);
511 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
513 mutex_unlock(&devices_mutex);
517 ret = calc_disk_capacity(vi, &disk_capacity);
519 mutex_unlock(&devices_mutex);
521 dev_warn(disk_to_dev(dev->gd),
522 "the volume is too big (%d LEBs), cannot resize",
528 mutex_lock(&dev->dev_mutex);
530 if (get_capacity(dev->gd) != disk_capacity) {
531 set_capacity(dev->gd, disk_capacity);
532 dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
535 mutex_unlock(&dev->dev_mutex);
536 mutex_unlock(&devices_mutex);
541 match_volume_desc(struct ubi_volume_info *vi, const char *name, int ubi_num, int vol_id)
543 int err, len, cur_ubi_num, cur_vol_id;
546 /* No ubi num, name must be a vol device path */
547 err = ubi_get_num_by_path(name, &cur_ubi_num, &cur_vol_id);
548 if (err || vi->ubi_num != cur_ubi_num || vi->vol_id != cur_vol_id)
555 /* Got ubi_num, but no vol_id, name must be volume name */
556 if (vi->ubi_num != ubi_num)
559 len = strnlen(name, UBI_VOL_NAME_MAX + 1);
560 if (len < 1 || vi->name_len != len)
563 if (strcmp(name, vi->name))
569 if (vi->ubi_num != ubi_num)
572 if (vi->vol_id != vol_id)
579 ubiblock_create_from_param(struct ubi_volume_info *vi)
582 struct ubiblock_param *p;
585 * Iterate over ubiblock cmdline parameters. If a parameter matches the
586 * newly added volume create the ubiblock device for it.
588 for (i = 0; i < ubiblock_devs; i++) {
589 p = &ubiblock_param[i];
591 if (!match_volume_desc(vi, p->name, p->ubi_num, p->vol_id))
594 ret = ubiblock_create(vi);
597 "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n",
598 vi->name, p->ubi_num, p->vol_id, ret);
604 static int ubiblock_notify(struct notifier_block *nb,
605 unsigned long notification_type, void *ns_ptr)
607 struct ubi_notification *nt = ns_ptr;
609 switch (notification_type) {
610 case UBI_VOLUME_ADDED:
611 ubiblock_create_from_param(&nt->vi);
613 case UBI_VOLUME_REMOVED:
614 ubiblock_remove(&nt->vi);
616 case UBI_VOLUME_RESIZED:
617 ubiblock_resize(&nt->vi);
619 case UBI_VOLUME_UPDATED:
621 * If the volume is static, a content update might mean the
622 * size (i.e. used_bytes) was also changed.
624 if (nt->vi.vol_type == UBI_STATIC_VOLUME)
625 ubiblock_resize(&nt->vi);
633 static struct notifier_block ubiblock_notifier = {
634 .notifier_call = ubiblock_notify,
637 static void ubiblock_remove_all(void)
639 struct ubiblock *next;
640 struct ubiblock *dev;
642 mutex_lock(&devices_mutex);
643 list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
644 /* The module is being forcefully removed */
646 /* Remove from device list */
647 list_del(&dev->list);
648 ubiblock_cleanup(dev);
651 mutex_unlock(&devices_mutex);
654 int __init ubiblock_init(void)
658 ubiblock_major = register_blkdev(0, "ubiblock");
659 if (ubiblock_major < 0)
660 return ubiblock_major;
662 ret = ubi_register_volume_notifier(&ubiblock_notifier, 0);
668 unregister_blkdev(ubiblock_major, "ubiblock");
669 ubiblock_remove_all();
673 void ubiblock_exit(void)
675 ubi_unregister_volume_notifier(&ubiblock_notifier);
676 ubiblock_remove_all();
677 unregister_blkdev(ubiblock_major, "ubiblock");