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