2 * Copyright (c) 2014 Ezequiel Garcia
3 * Copyright (c) 2011 Free Electrons
5 * Driver parameter handling strongly based on drivers/mtd/ubi/build.c
6 * Copyright (c) International Business Machines Corp., 2006
7 * Copyright (c) Nokia Corporation, 2007
8 * Authors: Artem Bityutskiy, Frank Haverkamp
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation, version 2.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
21 * Read-only block devices on top of UBI volumes
23 * A simple implementation to allow a block device to be layered on top of a
24 * UBI volume. The implementation is provided by creating a static 1-to-1
25 * mapping between the block device and the UBI volume.
27 * The addressed byte is obtained from the addressed block sector, which is
28 * mapped linearly into the corresponding LEB:
30 * LEB number = addressed byte / LEB size
32 * This feature is compiled in the UBI core, and adds a 'block' parameter
33 * to allow early creation of block devices on top of UBI volumes. Runtime
34 * block creation/removal for UBI volumes is provided through two UBI ioctls:
35 * UBI_IOCVOLCRBLK and UBI_IOCVOLRMBLK.
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/err.h>
41 #include <linux/kernel.h>
42 #include <linux/list.h>
43 #include <linux/mutex.h>
44 #include <linux/slab.h>
45 #include <linux/mtd/ubi.h>
46 #include <linux/workqueue.h>
47 #include <linux/blkdev.h>
48 #include <linux/blk-mq.h>
49 #include <linux/hdreg.h>
50 #include <linux/scatterlist.h>
51 #include <linux/idr.h>
52 #include <asm/div64.h>
54 #include "ubi-media.h"
57 /* Maximum number of supported devices */
58 #define UBIBLOCK_MAX_DEVICES 32
60 /* Maximum length of the 'block=' parameter */
61 #define UBIBLOCK_PARAM_LEN 63
63 /* Maximum number of comma-separated items in the 'block=' parameter */
64 #define UBIBLOCK_PARAM_COUNT 2
66 struct ubiblock_param
{
69 char name
[UBIBLOCK_PARAM_LEN
+1];
73 struct work_struct work
;
77 /* Numbers of elements set in the @ubiblock_param array */
78 static int ubiblock_devs __initdata
;
80 /* MTD devices specification parameters */
81 static struct ubiblock_param ubiblock_param
[UBIBLOCK_MAX_DEVICES
] __initdata
;
84 struct ubi_volume_desc
*desc
;
91 struct request_queue
*rq
;
93 struct workqueue_struct
*wq
;
95 struct mutex dev_mutex
;
96 struct list_head list
;
97 struct blk_mq_tag_set tag_set
;
100 /* Linked list of all ubiblock instances */
101 static LIST_HEAD(ubiblock_devices
);
102 static DEFINE_MUTEX(devices_mutex
);
103 static int ubiblock_major
;
105 static int __init
ubiblock_set_param(const char *val
,
106 const struct kernel_param
*kp
)
110 struct ubiblock_param
*param
;
111 char buf
[UBIBLOCK_PARAM_LEN
];
112 char *pbuf
= &buf
[0];
113 char *tokens
[UBIBLOCK_PARAM_COUNT
];
118 len
= strnlen(val
, UBIBLOCK_PARAM_LEN
);
120 pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
124 if (len
== UBIBLOCK_PARAM_LEN
) {
125 pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n",
126 val
, UBIBLOCK_PARAM_LEN
);
132 /* Get rid of the final newline */
133 if (buf
[len
- 1] == '\n')
136 for (i
= 0; i
< UBIBLOCK_PARAM_COUNT
; i
++)
137 tokens
[i
] = strsep(&pbuf
, ",");
139 param
= &ubiblock_param
[ubiblock_devs
];
141 /* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */
142 ret
= kstrtoint(tokens
[0], 10, ¶m
->ubi_num
);
146 /* Second param can be a number or a name */
147 ret
= kstrtoint(tokens
[1], 10, ¶m
->vol_id
);
150 strcpy(param
->name
, tokens
[1]);
154 /* One parameter: must be device path */
155 strcpy(param
->name
, tokens
[0]);
165 static const struct kernel_param_ops ubiblock_param_ops
= {
166 .set
= ubiblock_set_param
,
168 module_param_cb(block
, &ubiblock_param_ops
, NULL
, 0);
169 MODULE_PARM_DESC(block
, "Attach block devices to UBI volumes. Parameter format: block=<path|dev,num|dev,name>.\n"
170 "Multiple \"block\" parameters may be specified.\n"
171 "UBI volumes may be specified by their number, name, or path to the device node.\n"
173 "Using the UBI volume path:\n"
174 "ubi.block=/dev/ubi0_0\n"
175 "Using the UBI device, and the volume name:\n"
176 "ubi.block=0,rootfs\n"
177 "Using both UBI device number and UBI volume number:\n"
180 static struct ubiblock
*find_dev_nolock(int ubi_num
, int vol_id
)
182 struct ubiblock
*dev
;
184 list_for_each_entry(dev
, &ubiblock_devices
, list
)
185 if (dev
->ubi_num
== ubi_num
&& dev
->vol_id
== vol_id
)
190 static int ubiblock_read(struct ubiblock_pdu
*pdu
)
192 int ret
, leb
, offset
, bytes_left
, to_read
;
194 struct request
*req
= blk_mq_rq_from_pdu(pdu
);
195 struct ubiblock
*dev
= req
->q
->queuedata
;
197 to_read
= blk_rq_bytes(req
);
198 pos
= blk_rq_pos(req
) << 9;
200 /* Get LEB:offset address to read from */
201 offset
= do_div(pos
, dev
->leb_size
);
203 bytes_left
= to_read
;
207 * We can only read one LEB at a time. Therefore if the read
208 * length is larger than one LEB size, we split the operation.
210 if (offset
+ to_read
> dev
->leb_size
)
211 to_read
= dev
->leb_size
- offset
;
213 ret
= ubi_read_sg(dev
->desc
, leb
, &pdu
->usgl
, offset
, to_read
);
217 bytes_left
-= to_read
;
218 to_read
= bytes_left
;
225 static int ubiblock_open(struct block_device
*bdev
, fmode_t mode
)
227 struct ubiblock
*dev
= bdev
->bd_disk
->private_data
;
230 mutex_lock(&dev
->dev_mutex
);
231 if (dev
->refcnt
> 0) {
233 * The volume is already open, just increase the reference
240 * We want users to be aware they should only mount us as read-only.
241 * It's just a paranoid check, as write requests will get rejected
244 if (mode
& FMODE_WRITE
) {
249 dev
->desc
= ubi_open_volume(dev
->ubi_num
, dev
->vol_id
, UBI_READONLY
);
250 if (IS_ERR(dev
->desc
)) {
251 dev_err(disk_to_dev(dev
->gd
), "failed to open ubi volume %d_%d",
252 dev
->ubi_num
, dev
->vol_id
);
253 ret
= PTR_ERR(dev
->desc
);
260 mutex_unlock(&dev
->dev_mutex
);
264 mutex_unlock(&dev
->dev_mutex
);
268 static void ubiblock_release(struct gendisk
*gd
, fmode_t mode
)
270 struct ubiblock
*dev
= gd
->private_data
;
272 mutex_lock(&dev
->dev_mutex
);
274 if (dev
->refcnt
== 0) {
275 ubi_close_volume(dev
->desc
);
278 mutex_unlock(&dev
->dev_mutex
);
281 static int ubiblock_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
283 /* Some tools might require this information */
286 geo
->sectors
= get_capacity(bdev
->bd_disk
);
291 static const struct block_device_operations ubiblock_ops
= {
292 .owner
= THIS_MODULE
,
293 .open
= ubiblock_open
,
294 .release
= ubiblock_release
,
295 .getgeo
= ubiblock_getgeo
,
298 static void ubiblock_do_work(struct work_struct
*work
)
301 struct ubiblock_pdu
*pdu
= container_of(work
, struct ubiblock_pdu
, work
);
302 struct request
*req
= blk_mq_rq_from_pdu(pdu
);
304 blk_mq_start_request(req
);
307 * It is safe to ignore the return value of blk_rq_map_sg() because
308 * the number of sg entries is limited to UBI_MAX_SG_COUNT
309 * and ubi_read_sg() will check that limit.
311 blk_rq_map_sg(req
->q
, req
, pdu
->usgl
.sg
);
313 ret
= ubiblock_read(pdu
);
314 rq_flush_dcache_pages(req
);
316 blk_mq_end_request(req
, errno_to_blk_status(ret
));
319 static blk_status_t
ubiblock_queue_rq(struct blk_mq_hw_ctx
*hctx
,
320 const struct blk_mq_queue_data
*bd
)
322 struct request
*req
= bd
->rq
;
323 struct ubiblock
*dev
= hctx
->queue
->queuedata
;
324 struct ubiblock_pdu
*pdu
= blk_mq_rq_to_pdu(req
);
326 switch (req_op(req
)) {
328 ubi_sgl_init(&pdu
->usgl
);
329 queue_work(dev
->wq
, &pdu
->work
);
332 return BLK_STS_IOERR
;
337 static int ubiblock_init_request(struct blk_mq_tag_set
*set
,
338 struct request
*req
, unsigned int hctx_idx
,
339 unsigned int numa_node
)
341 struct ubiblock_pdu
*pdu
= blk_mq_rq_to_pdu(req
);
343 sg_init_table(pdu
->usgl
.sg
, UBI_MAX_SG_COUNT
);
344 INIT_WORK(&pdu
->work
, ubiblock_do_work
);
349 static const struct blk_mq_ops ubiblock_mq_ops
= {
350 .queue_rq
= ubiblock_queue_rq
,
351 .init_request
= ubiblock_init_request
,
354 static DEFINE_IDR(ubiblock_minor_idr
);
356 int ubiblock_create(struct ubi_volume_info
*vi
)
358 struct ubiblock
*dev
;
360 u64 disk_capacity
= vi
->used_bytes
>> 9;
363 if ((sector_t
)disk_capacity
!= disk_capacity
)
365 /* Check that the volume isn't already handled */
366 mutex_lock(&devices_mutex
);
367 if (find_dev_nolock(vi
->ubi_num
, vi
->vol_id
)) {
368 mutex_unlock(&devices_mutex
);
371 mutex_unlock(&devices_mutex
);
373 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 /* Initialize the gendisk of this ubiblock device */
386 pr_err("UBI: block: alloc_disk failed\n");
391 gd
->fops
= &ubiblock_ops
;
392 gd
->major
= ubiblock_major
;
393 gd
->first_minor
= idr_alloc(&ubiblock_minor_idr
, dev
, 0, 0, GFP_KERNEL
);
394 if (gd
->first_minor
< 0) {
395 dev_err(disk_to_dev(gd
),
396 "block: dynamic minor allocation failed");
400 gd
->private_data
= dev
;
401 sprintf(gd
->disk_name
, "ubiblock%d_%d", dev
->ubi_num
, dev
->vol_id
);
402 set_capacity(gd
, disk_capacity
);
405 dev
->tag_set
.ops
= &ubiblock_mq_ops
;
406 dev
->tag_set
.queue_depth
= 64;
407 dev
->tag_set
.numa_node
= NUMA_NO_NODE
;
408 dev
->tag_set
.flags
= BLK_MQ_F_SHOULD_MERGE
;
409 dev
->tag_set
.cmd_size
= sizeof(struct ubiblock_pdu
);
410 dev
->tag_set
.driver_data
= dev
;
411 dev
->tag_set
.nr_hw_queues
= 1;
413 ret
= blk_mq_alloc_tag_set(&dev
->tag_set
);
415 dev_err(disk_to_dev(dev
->gd
), "blk_mq_alloc_tag_set failed");
416 goto out_remove_minor
;
419 dev
->rq
= blk_mq_init_queue(&dev
->tag_set
);
420 if (IS_ERR(dev
->rq
)) {
421 dev_err(disk_to_dev(gd
), "blk_mq_init_queue failed");
422 ret
= PTR_ERR(dev
->rq
);
425 blk_queue_max_segments(dev
->rq
, UBI_MAX_SG_COUNT
);
427 dev
->rq
->queuedata
= dev
;
428 dev
->gd
->queue
= dev
->rq
;
431 * Create one workqueue per volume (per registered block device).
432 * Rembember workqueues are cheap, they're not threads.
434 dev
->wq
= alloc_workqueue("%s", 0, 0, gd
->disk_name
);
440 mutex_lock(&devices_mutex
);
441 list_add_tail(&dev
->list
, &ubiblock_devices
);
442 mutex_unlock(&devices_mutex
);
444 /* Must be the last step: anyone can call file ops from now on */
446 dev_info(disk_to_dev(dev
->gd
), "created from ubi%d:%d(%s)",
447 dev
->ubi_num
, dev
->vol_id
, vi
->name
);
451 blk_cleanup_queue(dev
->rq
);
453 blk_mq_free_tag_set(&dev
->tag_set
);
455 idr_remove(&ubiblock_minor_idr
, gd
->first_minor
);
464 static void ubiblock_cleanup(struct ubiblock
*dev
)
466 /* Stop new requests to arrive */
467 del_gendisk(dev
->gd
);
468 /* Flush pending work */
469 destroy_workqueue(dev
->wq
);
470 /* Finally destroy the blk queue */
471 blk_cleanup_queue(dev
->rq
);
472 blk_mq_free_tag_set(&dev
->tag_set
);
473 dev_info(disk_to_dev(dev
->gd
), "released");
474 idr_remove(&ubiblock_minor_idr
, dev
->gd
->first_minor
);
478 int ubiblock_remove(struct ubi_volume_info
*vi
)
480 struct ubiblock
*dev
;
482 mutex_lock(&devices_mutex
);
483 dev
= find_dev_nolock(vi
->ubi_num
, vi
->vol_id
);
485 mutex_unlock(&devices_mutex
);
489 /* Found a device, let's lock it so we can check if it's busy */
490 mutex_lock(&dev
->dev_mutex
);
491 if (dev
->refcnt
> 0) {
492 mutex_unlock(&dev
->dev_mutex
);
493 mutex_unlock(&devices_mutex
);
497 /* Remove from device list */
498 list_del(&dev
->list
);
499 mutex_unlock(&devices_mutex
);
501 ubiblock_cleanup(dev
);
502 mutex_unlock(&dev
->dev_mutex
);
507 static int ubiblock_resize(struct ubi_volume_info
*vi
)
509 struct ubiblock
*dev
;
510 u64 disk_capacity
= vi
->used_bytes
>> 9;
513 * Need to lock the device list until we stop using the device,
514 * otherwise the device struct might get released in
515 * 'ubiblock_remove()'.
517 mutex_lock(&devices_mutex
);
518 dev
= find_dev_nolock(vi
->ubi_num
, vi
->vol_id
);
520 mutex_unlock(&devices_mutex
);
523 if ((sector_t
)disk_capacity
!= disk_capacity
) {
524 mutex_unlock(&devices_mutex
);
525 dev_warn(disk_to_dev(dev
->gd
), "the volume is too big (%d LEBs), cannot resize",
530 mutex_lock(&dev
->dev_mutex
);
532 if (get_capacity(dev
->gd
) != disk_capacity
) {
533 set_capacity(dev
->gd
, disk_capacity
);
534 dev_info(disk_to_dev(dev
->gd
), "resized to %lld bytes",
537 mutex_unlock(&dev
->dev_mutex
);
538 mutex_unlock(&devices_mutex
);
542 static int ubiblock_notify(struct notifier_block
*nb
,
543 unsigned long notification_type
, void *ns_ptr
)
545 struct ubi_notification
*nt
= ns_ptr
;
547 switch (notification_type
) {
548 case UBI_VOLUME_ADDED
:
550 * We want to enforce explicit block device creation for
551 * volumes, so when a volume is added we do nothing.
554 case UBI_VOLUME_REMOVED
:
555 ubiblock_remove(&nt
->vi
);
557 case UBI_VOLUME_RESIZED
:
558 ubiblock_resize(&nt
->vi
);
560 case UBI_VOLUME_UPDATED
:
562 * If the volume is static, a content update might mean the
563 * size (i.e. used_bytes) was also changed.
565 if (nt
->vi
.vol_type
== UBI_STATIC_VOLUME
)
566 ubiblock_resize(&nt
->vi
);
574 static struct notifier_block ubiblock_notifier
= {
575 .notifier_call
= ubiblock_notify
,
578 static struct ubi_volume_desc
* __init
579 open_volume_desc(const char *name
, int ubi_num
, int vol_id
)
582 /* No ubi num, name must be a vol device path */
583 return ubi_open_volume_path(name
, UBI_READONLY
);
584 else if (vol_id
== -1)
585 /* No vol_id, must be vol_name */
586 return ubi_open_volume_nm(ubi_num
, name
, UBI_READONLY
);
588 return ubi_open_volume(ubi_num
, vol_id
, UBI_READONLY
);
591 static void __init
ubiblock_create_from_param(void)
594 struct ubiblock_param
*p
;
595 struct ubi_volume_desc
*desc
;
596 struct ubi_volume_info vi
;
599 * If there is an error creating one of the ubiblocks, continue on to
600 * create the following ubiblocks. This helps in a circumstance where
601 * the kernel command-line specifies multiple block devices and some
602 * may be broken, but we still want the working ones to come up.
604 for (i
= 0; i
< ubiblock_devs
; i
++) {
605 p
= &ubiblock_param
[i
];
607 desc
= open_volume_desc(p
->name
, p
->ubi_num
, p
->vol_id
);
610 "UBI: block: can't open volume on ubi%d_%d, err=%ld\n",
611 p
->ubi_num
, p
->vol_id
, PTR_ERR(desc
));
615 ubi_get_volume_info(desc
, &vi
);
616 ubi_close_volume(desc
);
618 ret
= ubiblock_create(&vi
);
621 "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n",
622 vi
.name
, p
->ubi_num
, p
->vol_id
, ret
);
628 static void ubiblock_remove_all(void)
630 struct ubiblock
*next
;
631 struct ubiblock
*dev
;
633 list_for_each_entry_safe(dev
, next
, &ubiblock_devices
, list
) {
634 /* The module is being forcefully removed */
636 /* Remove from device list */
637 list_del(&dev
->list
);
638 ubiblock_cleanup(dev
);
643 int __init
ubiblock_init(void)
647 ubiblock_major
= register_blkdev(0, "ubiblock");
648 if (ubiblock_major
< 0)
649 return ubiblock_major
;
652 * Attach block devices from 'block=' module param.
653 * Even if one block device in the param list fails to come up,
654 * still allow the module to load and leave any others up.
656 ubiblock_create_from_param();
659 * Block devices are only created upon user requests, so we ignore
662 ret
= ubi_register_volume_notifier(&ubiblock_notifier
, 1);
668 unregister_blkdev(ubiblock_major
, "ubiblock");
669 ubiblock_remove_all();
673 void __exit
ubiblock_exit(void)
675 ubi_unregister_volume_notifier(&ubiblock_notifier
);
676 ubiblock_remove_all();
677 unregister_blkdev(ubiblock_major
, "ubiblock");