Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2014 Ezequiel Garcia
4 * Copyright (c) 2011 Free Electrons
5 *
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
10 */
11
12/*
13 * Read-only block devices on top of UBI volumes
14 *
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.
18 *
19 * The addressed byte is obtained from the addressed block sector, which is
20 * mapped linearly into the corresponding LEB:
21 *
22 * LEB number = addressed byte / LEB size
23 *
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.
28 */
29
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>
45
46#include "ubi-media.h"
47#include "ubi.h"
48
49/* Maximum number of supported devices */
50#define UBIBLOCK_MAX_DEVICES 32
51
52/* Maximum length of the 'block=' parameter */
53#define UBIBLOCK_PARAM_LEN 63
54
55/* Maximum number of comma-separated items in the 'block=' parameter */
56#define UBIBLOCK_PARAM_COUNT 2
57
58struct ubiblock_param {
59 int ubi_num;
60 int vol_id;
61 char name[UBIBLOCK_PARAM_LEN+1];
62};
63
64struct ubiblock_pdu {
65 struct work_struct work;
66 struct ubi_sgl usgl;
67};
68
69/* Numbers of elements set in the @ubiblock_param array */
70static int ubiblock_devs __initdata;
71
72/* MTD devices specification parameters */
73static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES] __initdata;
74
75struct ubiblock {
76 struct ubi_volume_desc *desc;
77 int ubi_num;
78 int vol_id;
79 int refcnt;
80 int leb_size;
81
82 struct gendisk *gd;
83 struct request_queue *rq;
84
85 struct workqueue_struct *wq;
86
87 struct mutex dev_mutex;
88 struct list_head list;
89 struct blk_mq_tag_set tag_set;
90};
91
92/* Linked list of all ubiblock instances */
93static LIST_HEAD(ubiblock_devices);
94static DEFINE_IDR(ubiblock_minor_idr);
95/* Protects ubiblock_devices and ubiblock_minor_idr */
96static DEFINE_MUTEX(devices_mutex);
97static int ubiblock_major;
98
99static int __init ubiblock_set_param(const char *val,
100 const struct kernel_param *kp)
101{
102 int i, ret;
103 size_t len;
104 struct ubiblock_param *param;
105 char buf[UBIBLOCK_PARAM_LEN];
106 char *pbuf = &buf[0];
107 char *tokens[UBIBLOCK_PARAM_COUNT];
108
109 if (!val)
110 return -EINVAL;
111
112 len = strnlen(val, UBIBLOCK_PARAM_LEN);
113 if (len == 0) {
114 pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
115 return 0;
116 }
117
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);
121 return -EINVAL;
122 }
123
124 strcpy(buf, val);
125
126 /* Get rid of the final newline */
127 if (buf[len - 1] == '\n')
128 buf[len - 1] = '\0';
129
130 for (i = 0; i < UBIBLOCK_PARAM_COUNT; i++)
131 tokens[i] = strsep(&pbuf, ",");
132
133 param = &ubiblock_param[ubiblock_devs];
134 if (tokens[1]) {
135 /* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */
136 ret = kstrtoint(tokens[0], 10, ¶m->ubi_num);
137 if (ret < 0)
138 return -EINVAL;
139
140 /* Second param can be a number or a name */
141 ret = kstrtoint(tokens[1], 10, ¶m->vol_id);
142 if (ret < 0) {
143 param->vol_id = -1;
144 strcpy(param->name, tokens[1]);
145 }
146
147 } else {
148 /* One parameter: must be device path */
149 strcpy(param->name, tokens[0]);
150 param->ubi_num = -1;
151 param->vol_id = -1;
152 }
153
154 ubiblock_devs++;
155
156 return 0;
157}
158
159static const struct kernel_param_ops ubiblock_param_ops = {
160 .set = ubiblock_set_param,
161};
162module_param_cb(block, &ubiblock_param_ops, NULL, 0);
163MODULE_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"
166 "Examples\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"
172 "ubi.block=0,0\n");
173
174static struct ubiblock *find_dev_nolock(int ubi_num, int vol_id)
175{
176 struct ubiblock *dev;
177
178 list_for_each_entry(dev, &ubiblock_devices, list)
179 if (dev->ubi_num == ubi_num && dev->vol_id == vol_id)
180 return dev;
181 return NULL;
182}
183
184static int ubiblock_read(struct ubiblock_pdu *pdu)
185{
186 int ret, leb, offset, bytes_left, to_read;
187 u64 pos;
188 struct request *req = blk_mq_rq_from_pdu(pdu);
189 struct ubiblock *dev = req->q->queuedata;
190
191 to_read = blk_rq_bytes(req);
192 pos = blk_rq_pos(req) << 9;
193
194 /* Get LEB:offset address to read from */
195 offset = do_div(pos, dev->leb_size);
196 leb = pos;
197 bytes_left = to_read;
198
199 while (bytes_left) {
200 /*
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.
203 */
204 if (offset + to_read > dev->leb_size)
205 to_read = dev->leb_size - offset;
206
207 ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read);
208 if (ret < 0)
209 return ret;
210
211 bytes_left -= to_read;
212 to_read = bytes_left;
213 leb += 1;
214 offset = 0;
215 }
216 return 0;
217}
218
219static int ubiblock_open(struct block_device *bdev, fmode_t mode)
220{
221 struct ubiblock *dev = bdev->bd_disk->private_data;
222 int ret;
223
224 mutex_lock(&dev->dev_mutex);
225 if (dev->refcnt > 0) {
226 /*
227 * The volume is already open, just increase the reference
228 * counter.
229 */
230 goto out_done;
231 }
232
233 /*
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
236 * in any case.
237 */
238 if (mode & FMODE_WRITE) {
239 ret = -EROFS;
240 goto out_unlock;
241 }
242
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);
248 dev->desc = NULL;
249 goto out_unlock;
250 }
251
252out_done:
253 dev->refcnt++;
254 mutex_unlock(&dev->dev_mutex);
255 return 0;
256
257out_unlock:
258 mutex_unlock(&dev->dev_mutex);
259 return ret;
260}
261
262static void ubiblock_release(struct gendisk *gd, fmode_t mode)
263{
264 struct ubiblock *dev = gd->private_data;
265
266 mutex_lock(&dev->dev_mutex);
267 dev->refcnt--;
268 if (dev->refcnt == 0) {
269 ubi_close_volume(dev->desc);
270 dev->desc = NULL;
271 }
272 mutex_unlock(&dev->dev_mutex);
273}
274
275static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo)
276{
277 /* Some tools might require this information */
278 geo->heads = 1;
279 geo->cylinders = 1;
280 geo->sectors = get_capacity(bdev->bd_disk);
281 geo->start = 0;
282 return 0;
283}
284
285static const struct block_device_operations ubiblock_ops = {
286 .owner = THIS_MODULE,
287 .open = ubiblock_open,
288 .release = ubiblock_release,
289 .getgeo = ubiblock_getgeo,
290};
291
292static void ubiblock_do_work(struct work_struct *work)
293{
294 int ret;
295 struct ubiblock_pdu *pdu = container_of(work, struct ubiblock_pdu, work);
296 struct request *req = blk_mq_rq_from_pdu(pdu);
297 struct req_iterator iter;
298 struct bio_vec bvec;
299
300 blk_mq_start_request(req);
301
302 /*
303 * It is safe to ignore the return value of blk_rq_map_sg() because
304 * the number of sg entries is limited to UBI_MAX_SG_COUNT
305 * and ubi_read_sg() will check that limit.
306 */
307 blk_rq_map_sg(req->q, req, pdu->usgl.sg);
308
309 ret = ubiblock_read(pdu);
310
311 rq_for_each_segment(bvec, req, iter)
312 flush_dcache_page(bvec.bv_page);
313
314 blk_mq_end_request(req, errno_to_blk_status(ret));
315}
316
317static blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
318 const struct blk_mq_queue_data *bd)
319{
320 struct request *req = bd->rq;
321 struct ubiblock *dev = hctx->queue->queuedata;
322 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
323
324 switch (req_op(req)) {
325 case REQ_OP_READ:
326 ubi_sgl_init(&pdu->usgl);
327 queue_work(dev->wq, &pdu->work);
328 return BLK_STS_OK;
329 default:
330 return BLK_STS_IOERR;
331 }
332
333}
334
335static int ubiblock_init_request(struct blk_mq_tag_set *set,
336 struct request *req, unsigned int hctx_idx,
337 unsigned int numa_node)
338{
339 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
340
341 sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT);
342 INIT_WORK(&pdu->work, ubiblock_do_work);
343
344 return 0;
345}
346
347static const struct blk_mq_ops ubiblock_mq_ops = {
348 .queue_rq = ubiblock_queue_rq,
349 .init_request = ubiblock_init_request,
350};
351
352static int calc_disk_capacity(struct ubi_volume_info *vi, u64 *disk_capacity)
353{
354 u64 size = vi->used_bytes >> 9;
355
356 if (vi->used_bytes % 512) {
357 pr_warn("UBI: block: volume size is not a multiple of 512, "
358 "last %llu bytes are ignored!\n",
359 vi->used_bytes - (size << 9));
360 }
361
362 if ((sector_t)size != size)
363 return -EFBIG;
364
365 *disk_capacity = size;
366
367 return 0;
368}
369
370int ubiblock_create(struct ubi_volume_info *vi)
371{
372 struct ubiblock *dev;
373 struct gendisk *gd;
374 u64 disk_capacity;
375 int ret;
376
377 ret = calc_disk_capacity(vi, &disk_capacity);
378 if (ret) {
379 return ret;
380 }
381
382 /* Check that the volume isn't already handled */
383 mutex_lock(&devices_mutex);
384 if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
385 ret = -EEXIST;
386 goto out_unlock;
387 }
388
389 dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
390 if (!dev) {
391 ret = -ENOMEM;
392 goto out_unlock;
393 }
394
395 mutex_init(&dev->dev_mutex);
396
397 dev->ubi_num = vi->ubi_num;
398 dev->vol_id = vi->vol_id;
399 dev->leb_size = vi->usable_leb_size;
400
401 dev->tag_set.ops = &ubiblock_mq_ops;
402 dev->tag_set.queue_depth = 64;
403 dev->tag_set.numa_node = NUMA_NO_NODE;
404 dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
405 dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
406 dev->tag_set.driver_data = dev;
407 dev->tag_set.nr_hw_queues = 1;
408
409 ret = blk_mq_alloc_tag_set(&dev->tag_set);
410 if (ret) {
411 dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed");
412 goto out_free_dev;
413 }
414
415
416 /* Initialize the gendisk of this ubiblock device */
417 gd = blk_mq_alloc_disk(&dev->tag_set, dev);
418 if (IS_ERR(gd)) {
419 ret = PTR_ERR(gd);
420 goto out_free_tags;
421 }
422
423 gd->fops = &ubiblock_ops;
424 gd->major = ubiblock_major;
425 gd->minors = 1;
426 gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
427 if (gd->first_minor < 0) {
428 dev_err(disk_to_dev(gd),
429 "block: dynamic minor allocation failed");
430 ret = -ENODEV;
431 goto out_cleanup_disk;
432 }
433 gd->flags |= GENHD_FL_NO_PART;
434 gd->private_data = dev;
435 sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
436 set_capacity(gd, disk_capacity);
437 dev->gd = gd;
438
439 dev->rq = gd->queue;
440 blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT);
441
442 /*
443 * Create one workqueue per volume (per registered block device).
444 * Remember workqueues are cheap, they're not threads.
445 */
446 dev->wq = alloc_workqueue("%s", 0, 0, gd->disk_name);
447 if (!dev->wq) {
448 ret = -ENOMEM;
449 goto out_remove_minor;
450 }
451
452 list_add_tail(&dev->list, &ubiblock_devices);
453
454 /* Must be the last step: anyone can call file ops from now on */
455 ret = add_disk(dev->gd);
456 if (ret)
457 goto out_destroy_wq;
458
459 dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
460 dev->ubi_num, dev->vol_id, vi->name);
461 mutex_unlock(&devices_mutex);
462 return 0;
463
464out_destroy_wq:
465 list_del(&dev->list);
466 destroy_workqueue(dev->wq);
467out_remove_minor:
468 idr_remove(&ubiblock_minor_idr, gd->first_minor);
469out_cleanup_disk:
470 put_disk(dev->gd);
471out_free_tags:
472 blk_mq_free_tag_set(&dev->tag_set);
473out_free_dev:
474 kfree(dev);
475out_unlock:
476 mutex_unlock(&devices_mutex);
477
478 return ret;
479}
480
481static void ubiblock_cleanup(struct ubiblock *dev)
482{
483 /* Stop new requests to arrive */
484 del_gendisk(dev->gd);
485 /* Flush pending work */
486 destroy_workqueue(dev->wq);
487 /* Finally destroy the blk queue */
488 dev_info(disk_to_dev(dev->gd), "released");
489 put_disk(dev->gd);
490 blk_mq_free_tag_set(&dev->tag_set);
491 idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
492}
493
494int ubiblock_remove(struct ubi_volume_info *vi)
495{
496 struct ubiblock *dev;
497 int ret;
498
499 mutex_lock(&devices_mutex);
500 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
501 if (!dev) {
502 ret = -ENODEV;
503 goto out_unlock;
504 }
505
506 /* Found a device, let's lock it so we can check if it's busy */
507 mutex_lock(&dev->dev_mutex);
508 if (dev->refcnt > 0) {
509 ret = -EBUSY;
510 goto out_unlock_dev;
511 }
512
513 /* Remove from device list */
514 list_del(&dev->list);
515 ubiblock_cleanup(dev);
516 mutex_unlock(&dev->dev_mutex);
517 mutex_unlock(&devices_mutex);
518
519 kfree(dev);
520 return 0;
521
522out_unlock_dev:
523 mutex_unlock(&dev->dev_mutex);
524out_unlock:
525 mutex_unlock(&devices_mutex);
526 return ret;
527}
528
529static int ubiblock_resize(struct ubi_volume_info *vi)
530{
531 struct ubiblock *dev;
532 u64 disk_capacity;
533 int ret;
534
535 /*
536 * Need to lock the device list until we stop using the device,
537 * otherwise the device struct might get released in
538 * 'ubiblock_remove()'.
539 */
540 mutex_lock(&devices_mutex);
541 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
542 if (!dev) {
543 mutex_unlock(&devices_mutex);
544 return -ENODEV;
545 }
546
547 ret = calc_disk_capacity(vi, &disk_capacity);
548 if (ret) {
549 mutex_unlock(&devices_mutex);
550 if (ret == -EFBIG) {
551 dev_warn(disk_to_dev(dev->gd),
552 "the volume is too big (%d LEBs), cannot resize",
553 vi->size);
554 }
555 return ret;
556 }
557
558 mutex_lock(&dev->dev_mutex);
559
560 if (get_capacity(dev->gd) != disk_capacity) {
561 set_capacity(dev->gd, disk_capacity);
562 dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
563 vi->used_bytes);
564 }
565 mutex_unlock(&dev->dev_mutex);
566 mutex_unlock(&devices_mutex);
567 return 0;
568}
569
570static int ubiblock_notify(struct notifier_block *nb,
571 unsigned long notification_type, void *ns_ptr)
572{
573 struct ubi_notification *nt = ns_ptr;
574
575 switch (notification_type) {
576 case UBI_VOLUME_ADDED:
577 /*
578 * We want to enforce explicit block device creation for
579 * volumes, so when a volume is added we do nothing.
580 */
581 break;
582 case UBI_VOLUME_REMOVED:
583 ubiblock_remove(&nt->vi);
584 break;
585 case UBI_VOLUME_RESIZED:
586 ubiblock_resize(&nt->vi);
587 break;
588 case UBI_VOLUME_UPDATED:
589 /*
590 * If the volume is static, a content update might mean the
591 * size (i.e. used_bytes) was also changed.
592 */
593 if (nt->vi.vol_type == UBI_STATIC_VOLUME)
594 ubiblock_resize(&nt->vi);
595 break;
596 default:
597 break;
598 }
599 return NOTIFY_OK;
600}
601
602static struct notifier_block ubiblock_notifier = {
603 .notifier_call = ubiblock_notify,
604};
605
606static struct ubi_volume_desc * __init
607open_volume_desc(const char *name, int ubi_num, int vol_id)
608{
609 if (ubi_num == -1)
610 /* No ubi num, name must be a vol device path */
611 return ubi_open_volume_path(name, UBI_READONLY);
612 else if (vol_id == -1)
613 /* No vol_id, must be vol_name */
614 return ubi_open_volume_nm(ubi_num, name, UBI_READONLY);
615 else
616 return ubi_open_volume(ubi_num, vol_id, UBI_READONLY);
617}
618
619static void __init ubiblock_create_from_param(void)
620{
621 int i, ret = 0;
622 struct ubiblock_param *p;
623 struct ubi_volume_desc *desc;
624 struct ubi_volume_info vi;
625
626 /*
627 * If there is an error creating one of the ubiblocks, continue on to
628 * create the following ubiblocks. This helps in a circumstance where
629 * the kernel command-line specifies multiple block devices and some
630 * may be broken, but we still want the working ones to come up.
631 */
632 for (i = 0; i < ubiblock_devs; i++) {
633 p = &ubiblock_param[i];
634
635 desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);
636 if (IS_ERR(desc)) {
637 pr_err(
638 "UBI: block: can't open volume on ubi%d_%d, err=%ld\n",
639 p->ubi_num, p->vol_id, PTR_ERR(desc));
640 continue;
641 }
642
643 ubi_get_volume_info(desc, &vi);
644 ubi_close_volume(desc);
645
646 ret = ubiblock_create(&vi);
647 if (ret) {
648 pr_err(
649 "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n",
650 vi.name, p->ubi_num, p->vol_id, ret);
651 continue;
652 }
653 }
654}
655
656static void ubiblock_remove_all(void)
657{
658 struct ubiblock *next;
659 struct ubiblock *dev;
660
661 mutex_lock(&devices_mutex);
662 list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
663 /* The module is being forcefully removed */
664 WARN_ON(dev->desc);
665 /* Remove from device list */
666 list_del(&dev->list);
667 ubiblock_cleanup(dev);
668 kfree(dev);
669 }
670 mutex_unlock(&devices_mutex);
671}
672
673int __init ubiblock_init(void)
674{
675 int ret;
676
677 ubiblock_major = register_blkdev(0, "ubiblock");
678 if (ubiblock_major < 0)
679 return ubiblock_major;
680
681 /*
682 * Attach block devices from 'block=' module param.
683 * Even if one block device in the param list fails to come up,
684 * still allow the module to load and leave any others up.
685 */
686 ubiblock_create_from_param();
687
688 /*
689 * Block devices are only created upon user requests, so we ignore
690 * existing volumes.
691 */
692 ret = ubi_register_volume_notifier(&ubiblock_notifier, 1);
693 if (ret)
694 goto err_unreg;
695 return 0;
696
697err_unreg:
698 unregister_blkdev(ubiblock_major, "ubiblock");
699 ubiblock_remove_all();
700 return ret;
701}
702
703void __exit ubiblock_exit(void)
704{
705 ubi_unregister_volume_notifier(&ubiblock_notifier);
706 ubiblock_remove_all();
707 unregister_blkdev(ubiblock_major, "ubiblock");
708}