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 block_device * bdev,fmode_t mode)230 static int ubiblock_open(struct block_device *bdev, fmode_t mode)
231 {
232 struct ubiblock *dev = bdev->bd_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 & FMODE_WRITE) {
250 ret = -EROFS;
251 goto out_unlock;
252 }
253
254 dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);
255 if (IS_ERR(dev->desc)) {
256 dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
257 dev->ubi_num, dev->vol_id);
258 ret = PTR_ERR(dev->desc);
259 dev->desc = NULL;
260 goto out_unlock;
261 }
262
263 out_done:
264 dev->refcnt++;
265 mutex_unlock(&dev->dev_mutex);
266 return 0;
267
268 out_unlock:
269 mutex_unlock(&dev->dev_mutex);
270 return ret;
271 }
272
ubiblock_release(struct gendisk * gd,fmode_t mode)273 static void ubiblock_release(struct gendisk *gd, fmode_t mode)
274 {
275 struct ubiblock *dev = gd->private_data;
276
277 mutex_lock(&dev->dev_mutex);
278 dev->refcnt--;
279 if (dev->refcnt == 0) {
280 ubi_close_volume(dev->desc);
281 dev->desc = NULL;
282 }
283 mutex_unlock(&dev->dev_mutex);
284 }
285
ubiblock_getgeo(struct block_device * bdev,struct hd_geometry * geo)286 static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo)
287 {
288 /* Some tools might require this information */
289 geo->heads = 1;
290 geo->cylinders = 1;
291 geo->sectors = get_capacity(bdev->bd_disk);
292 geo->start = 0;
293 return 0;
294 }
295
296 static const struct block_device_operations ubiblock_ops = {
297 .owner = THIS_MODULE,
298 .open = ubiblock_open,
299 .release = ubiblock_release,
300 .getgeo = ubiblock_getgeo,
301 };
302
ubiblock_queue_rq(struct blk_mq_hw_ctx * hctx,const struct blk_mq_queue_data * bd)303 static blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
304 const struct blk_mq_queue_data *bd)
305 {
306 switch (req_op(bd->rq)) {
307 case REQ_OP_READ:
308 return ubiblock_read(bd->rq);
309 default:
310 return BLK_STS_IOERR;
311 }
312 }
313
ubiblock_init_request(struct blk_mq_tag_set * set,struct request * req,unsigned int hctx_idx,unsigned int numa_node)314 static int ubiblock_init_request(struct blk_mq_tag_set *set,
315 struct request *req, unsigned int hctx_idx,
316 unsigned int numa_node)
317 {
318 struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
319
320 sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT);
321 return 0;
322 }
323
324 static const struct blk_mq_ops ubiblock_mq_ops = {
325 .queue_rq = ubiblock_queue_rq,
326 .init_request = ubiblock_init_request,
327 };
328
calc_disk_capacity(struct ubi_volume_info * vi,u64 * disk_capacity)329 static int calc_disk_capacity(struct ubi_volume_info *vi, u64 *disk_capacity)
330 {
331 u64 size = vi->used_bytes >> 9;
332
333 if (vi->used_bytes % 512) {
334 if (vi->vol_type == UBI_DYNAMIC_VOLUME)
335 pr_warn("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
336 vi->used_bytes - (size << 9));
337 else
338 pr_info("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
339 vi->used_bytes - (size << 9));
340 }
341
342 if ((sector_t)size != size)
343 return -EFBIG;
344
345 *disk_capacity = size;
346
347 return 0;
348 }
349
ubiblock_create(struct ubi_volume_info * vi)350 int ubiblock_create(struct ubi_volume_info *vi)
351 {
352 struct ubiblock *dev;
353 struct gendisk *gd;
354 u64 disk_capacity;
355 int ret;
356
357 ret = calc_disk_capacity(vi, &disk_capacity);
358 if (ret) {
359 return ret;
360 }
361
362 /* Check that the volume isn't already handled */
363 mutex_lock(&devices_mutex);
364 if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
365 ret = -EEXIST;
366 goto out_unlock;
367 }
368
369 dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
370 if (!dev) {
371 ret = -ENOMEM;
372 goto out_unlock;
373 }
374
375 mutex_init(&dev->dev_mutex);
376
377 dev->ubi_num = vi->ubi_num;
378 dev->vol_id = vi->vol_id;
379 dev->leb_size = vi->usable_leb_size;
380
381 dev->tag_set.ops = &ubiblock_mq_ops;
382 dev->tag_set.queue_depth = 64;
383 dev->tag_set.numa_node = NUMA_NO_NODE;
384 dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
385 dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
386 dev->tag_set.driver_data = dev;
387 dev->tag_set.nr_hw_queues = 1;
388
389 ret = blk_mq_alloc_tag_set(&dev->tag_set);
390 if (ret) {
391 dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed");
392 goto out_free_dev;
393 }
394
395
396 /* Initialize the gendisk of this ubiblock device */
397 gd = blk_mq_alloc_disk(&dev->tag_set, dev);
398 if (IS_ERR(gd)) {
399 ret = PTR_ERR(gd);
400 goto out_free_tags;
401 }
402
403 gd->fops = &ubiblock_ops;
404 gd->major = ubiblock_major;
405 gd->minors = 1;
406 gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
407 if (gd->first_minor < 0) {
408 dev_err(disk_to_dev(gd),
409 "block: dynamic minor allocation failed");
410 ret = -ENODEV;
411 goto out_cleanup_disk;
412 }
413 gd->flags |= GENHD_FL_NO_PART;
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);
417 dev->gd = gd;
418
419 dev->rq = gd->queue;
420 blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT);
421
422 list_add_tail(&dev->list, &ubiblock_devices);
423
424 /* Must be the last step: anyone can call file ops from now on */
425 ret = device_add_disk(vi->dev, dev->gd, NULL);
426 if (ret)
427 goto out_remove_minor;
428
429 dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
430 dev->ubi_num, dev->vol_id, vi->name);
431 mutex_unlock(&devices_mutex);
432 return 0;
433
434 out_remove_minor:
435 list_del(&dev->list);
436 idr_remove(&ubiblock_minor_idr, gd->first_minor);
437 out_cleanup_disk:
438 put_disk(dev->gd);
439 out_free_tags:
440 blk_mq_free_tag_set(&dev->tag_set);
441 out_free_dev:
442 kfree(dev);
443 out_unlock:
444 mutex_unlock(&devices_mutex);
445
446 return ret;
447 }
448
ubiblock_cleanup(struct ubiblock * dev)449 static void ubiblock_cleanup(struct ubiblock *dev)
450 {
451 /* Stop new requests to arrive */
452 del_gendisk(dev->gd);
453 /* Finally destroy the blk queue */
454 dev_info(disk_to_dev(dev->gd), "released");
455 put_disk(dev->gd);
456 blk_mq_free_tag_set(&dev->tag_set);
457 idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
458 }
459
ubiblock_remove(struct ubi_volume_info * vi)460 int ubiblock_remove(struct ubi_volume_info *vi)
461 {
462 struct ubiblock *dev;
463 int ret;
464
465 mutex_lock(&devices_mutex);
466 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
467 if (!dev) {
468 ret = -ENODEV;
469 goto out_unlock;
470 }
471
472 /* Found a device, let's lock it so we can check if it's busy */
473 mutex_lock(&dev->dev_mutex);
474 if (dev->refcnt > 0) {
475 ret = -EBUSY;
476 goto out_unlock_dev;
477 }
478
479 /* Remove from device list */
480 list_del(&dev->list);
481 ubiblock_cleanup(dev);
482 mutex_unlock(&dev->dev_mutex);
483 mutex_unlock(&devices_mutex);
484
485 kfree(dev);
486 return 0;
487
488 out_unlock_dev:
489 mutex_unlock(&dev->dev_mutex);
490 out_unlock:
491 mutex_unlock(&devices_mutex);
492 return ret;
493 }
494
ubiblock_resize(struct ubi_volume_info * vi)495 static int ubiblock_resize(struct ubi_volume_info *vi)
496 {
497 struct ubiblock *dev;
498 u64 disk_capacity;
499 int ret;
500
501 /*
502 * Need to lock the device list until we stop using the device,
503 * otherwise the device struct might get released in
504 * 'ubiblock_remove()'.
505 */
506 mutex_lock(&devices_mutex);
507 dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
508 if (!dev) {
509 mutex_unlock(&devices_mutex);
510 return -ENODEV;
511 }
512
513 ret = calc_disk_capacity(vi, &disk_capacity);
514 if (ret) {
515 mutex_unlock(&devices_mutex);
516 if (ret == -EFBIG) {
517 dev_warn(disk_to_dev(dev->gd),
518 "the volume is too big (%d LEBs), cannot resize",
519 vi->size);
520 }
521 return ret;
522 }
523
524 mutex_lock(&dev->dev_mutex);
525
526 if (get_capacity(dev->gd) != disk_capacity) {
527 set_capacity(dev->gd, disk_capacity);
528 dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
529 vi->used_bytes);
530 }
531 mutex_unlock(&dev->dev_mutex);
532 mutex_unlock(&devices_mutex);
533 return 0;
534 }
535
ubiblock_notify(struct notifier_block * nb,unsigned long notification_type,void * ns_ptr)536 static int ubiblock_notify(struct notifier_block *nb,
537 unsigned long notification_type, void *ns_ptr)
538 {
539 struct ubi_notification *nt = ns_ptr;
540
541 switch (notification_type) {
542 case UBI_VOLUME_ADDED:
543 /*
544 * We want to enforce explicit block device creation for
545 * volumes, so when a volume is added we do nothing.
546 */
547 break;
548 case UBI_VOLUME_REMOVED:
549 ubiblock_remove(&nt->vi);
550 break;
551 case UBI_VOLUME_RESIZED:
552 ubiblock_resize(&nt->vi);
553 break;
554 case UBI_VOLUME_UPDATED:
555 /*
556 * If the volume is static, a content update might mean the
557 * size (i.e. used_bytes) was also changed.
558 */
559 if (nt->vi.vol_type == UBI_STATIC_VOLUME)
560 ubiblock_resize(&nt->vi);
561 break;
562 default:
563 break;
564 }
565 return NOTIFY_OK;
566 }
567
568 static struct notifier_block ubiblock_notifier = {
569 .notifier_call = ubiblock_notify,
570 };
571
572 static struct ubi_volume_desc * __init
open_volume_desc(const char * name,int ubi_num,int vol_id)573 open_volume_desc(const char *name, int ubi_num, int vol_id)
574 {
575 if (ubi_num == -1)
576 /* No ubi num, name must be a vol device path */
577 return ubi_open_volume_path(name, UBI_READONLY);
578 else if (vol_id == -1)
579 /* No vol_id, must be vol_name */
580 return ubi_open_volume_nm(ubi_num, name, UBI_READONLY);
581 else
582 return ubi_open_volume(ubi_num, vol_id, UBI_READONLY);
583 }
584
ubiblock_create_from_param(void)585 static void __init ubiblock_create_from_param(void)
586 {
587 int i, ret = 0;
588 struct ubiblock_param *p;
589 struct ubi_volume_desc *desc;
590 struct ubi_volume_info vi;
591
592 /*
593 * If there is an error creating one of the ubiblocks, continue on to
594 * create the following ubiblocks. This helps in a circumstance where
595 * the kernel command-line specifies multiple block devices and some
596 * may be broken, but we still want the working ones to come up.
597 */
598 for (i = 0; i < ubiblock_devs; i++) {
599 p = &ubiblock_param[i];
600
601 desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);
602 if (IS_ERR(desc)) {
603 pr_err(
604 "UBI: block: can't open volume on ubi%d_%d, err=%ld\n",
605 p->ubi_num, p->vol_id, PTR_ERR(desc));
606 continue;
607 }
608
609 ubi_get_volume_info(desc, &vi);
610 ubi_close_volume(desc);
611
612 ret = ubiblock_create(&vi);
613 if (ret) {
614 pr_err(
615 "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n",
616 vi.name, p->ubi_num, p->vol_id, ret);
617 continue;
618 }
619 }
620 }
621
ubiblock_remove_all(void)622 static void ubiblock_remove_all(void)
623 {
624 struct ubiblock *next;
625 struct ubiblock *dev;
626
627 mutex_lock(&devices_mutex);
628 list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
629 /* The module is being forcefully removed */
630 WARN_ON(dev->desc);
631 /* Remove from device list */
632 list_del(&dev->list);
633 ubiblock_cleanup(dev);
634 kfree(dev);
635 }
636 mutex_unlock(&devices_mutex);
637 }
638
ubiblock_init(void)639 int __init ubiblock_init(void)
640 {
641 int ret;
642
643 ubiblock_major = register_blkdev(0, "ubiblock");
644 if (ubiblock_major < 0)
645 return ubiblock_major;
646
647 /*
648 * Attach block devices from 'block=' module param.
649 * Even if one block device in the param list fails to come up,
650 * still allow the module to load and leave any others up.
651 */
652 ubiblock_create_from_param();
653
654 /*
655 * Block devices are only created upon user requests, so we ignore
656 * existing volumes.
657 */
658 ret = ubi_register_volume_notifier(&ubiblock_notifier, 1);
659 if (ret)
660 goto err_unreg;
661 return 0;
662
663 err_unreg:
664 unregister_blkdev(ubiblock_major, "ubiblock");
665 ubiblock_remove_all();
666 return ret;
667 }
668
ubiblock_exit(void)669 void __exit ubiblock_exit(void)
670 {
671 ubi_unregister_volume_notifier(&ubiblock_notifier);
672 ubiblock_remove_all();
673 unregister_blkdev(ubiblock_major, "ubiblock");
674 }
675