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 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 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 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 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 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 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 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 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 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 349 int ubiblock_create(struct ubi_volume_info *vi) 350 { 351 struct queue_limits lim = { 352 .max_segments = UBI_MAX_SG_COUNT, 353 }; 354 struct ubiblock *dev; 355 struct gendisk *gd; 356 u64 disk_capacity; 357 int ret; 358 359 ret = calc_disk_capacity(vi, &disk_capacity); 360 if (ret) { 361 return ret; 362 } 363 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)) { 367 ret = -EEXIST; 368 goto out_unlock; 369 } 370 371 dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL); 372 if (!dev) { 373 ret = -ENOMEM; 374 goto out_unlock; 375 } 376 377 mutex_init(&dev->dev_mutex); 378 379 dev->ubi_num = vi->ubi_num; 380 dev->vol_id = vi->vol_id; 381 dev->leb_size = vi->usable_leb_size; 382 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; 390 391 ret = blk_mq_alloc_tag_set(&dev->tag_set); 392 if (ret) { 393 dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed"); 394 goto out_free_dev; 395 } 396 397 398 /* Initialize the gendisk of this ubiblock device */ 399 gd = blk_mq_alloc_disk(&dev->tag_set, &lim, dev); 400 if (IS_ERR(gd)) { 401 ret = PTR_ERR(gd); 402 goto out_free_tags; 403 } 404 405 gd->fops = &ubiblock_ops; 406 gd->major = ubiblock_major; 407 gd->minors = 1; 408 gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL); 409 if (gd->first_minor < 0) { 410 dev_err(disk_to_dev(gd), 411 "block: dynamic minor allocation failed"); 412 ret = -ENODEV; 413 goto out_cleanup_disk; 414 } 415 gd->flags |= GENHD_FL_NO_PART; 416 gd->private_data = dev; 417 sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id); 418 set_capacity(gd, disk_capacity); 419 dev->gd = gd; 420 421 dev->rq = gd->queue; 422 423 list_add_tail(&dev->list, &ubiblock_devices); 424 425 /* Must be the last step: anyone can call file ops from now on */ 426 ret = device_add_disk(vi->dev, dev->gd, NULL); 427 if (ret) 428 goto out_remove_minor; 429 430 dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)", 431 dev->ubi_num, dev->vol_id, vi->name); 432 mutex_unlock(&devices_mutex); 433 return 0; 434 435 out_remove_minor: 436 list_del(&dev->list); 437 idr_remove(&ubiblock_minor_idr, gd->first_minor); 438 out_cleanup_disk: 439 put_disk(gd); 440 out_free_tags: 441 blk_mq_free_tag_set(&dev->tag_set); 442 out_free_dev: 443 kfree(dev); 444 out_unlock: 445 mutex_unlock(&devices_mutex); 446 447 return ret; 448 } 449 450 static void ubiblock_cleanup(struct ubiblock *dev) 451 { 452 int id = dev->gd->first_minor; 453 454 /* Stop new requests to arrive */ 455 del_gendisk(dev->gd); 456 /* Finally destroy the blk queue */ 457 dev_info(disk_to_dev(dev->gd), "released"); 458 put_disk(dev->gd); 459 blk_mq_free_tag_set(&dev->tag_set); 460 idr_remove(&ubiblock_minor_idr, id); 461 } 462 463 int ubiblock_remove(struct ubi_volume_info *vi) 464 { 465 struct ubiblock *dev; 466 int ret; 467 468 mutex_lock(&devices_mutex); 469 dev = find_dev_nolock(vi->ubi_num, vi->vol_id); 470 if (!dev) { 471 ret = -ENODEV; 472 goto out_unlock; 473 } 474 475 /* Found a device, let's lock it so we can check if it's busy */ 476 mutex_lock(&dev->dev_mutex); 477 if (dev->refcnt > 0) { 478 ret = -EBUSY; 479 goto out_unlock_dev; 480 } 481 482 /* Remove from device list */ 483 list_del(&dev->list); 484 ubiblock_cleanup(dev); 485 mutex_unlock(&dev->dev_mutex); 486 mutex_unlock(&devices_mutex); 487 488 kfree(dev); 489 return 0; 490 491 out_unlock_dev: 492 mutex_unlock(&dev->dev_mutex); 493 out_unlock: 494 mutex_unlock(&devices_mutex); 495 return ret; 496 } 497 498 static int ubiblock_resize(struct ubi_volume_info *vi) 499 { 500 struct ubiblock *dev; 501 u64 disk_capacity; 502 int ret; 503 504 /* 505 * Need to lock the device list until we stop using the device, 506 * otherwise the device struct might get released in 507 * 'ubiblock_remove()'. 508 */ 509 mutex_lock(&devices_mutex); 510 dev = find_dev_nolock(vi->ubi_num, vi->vol_id); 511 if (!dev) { 512 mutex_unlock(&devices_mutex); 513 return -ENODEV; 514 } 515 516 ret = calc_disk_capacity(vi, &disk_capacity); 517 if (ret) { 518 mutex_unlock(&devices_mutex); 519 if (ret == -EFBIG) { 520 dev_warn(disk_to_dev(dev->gd), 521 "the volume is too big (%d LEBs), cannot resize", 522 vi->size); 523 } 524 return ret; 525 } 526 527 mutex_lock(&dev->dev_mutex); 528 529 if (get_capacity(dev->gd) != disk_capacity) { 530 set_capacity(dev->gd, disk_capacity); 531 dev_info(disk_to_dev(dev->gd), "resized to %lld bytes", 532 vi->used_bytes); 533 } 534 mutex_unlock(&dev->dev_mutex); 535 mutex_unlock(&devices_mutex); 536 return 0; 537 } 538 539 static int ubiblock_notify(struct notifier_block *nb, 540 unsigned long notification_type, void *ns_ptr) 541 { 542 struct ubi_notification *nt = ns_ptr; 543 544 switch (notification_type) { 545 case UBI_VOLUME_ADDED: 546 /* 547 * We want to enforce explicit block device creation for 548 * volumes, so when a volume is added we do nothing. 549 */ 550 break; 551 case UBI_VOLUME_REMOVED: 552 ubiblock_remove(&nt->vi); 553 break; 554 case UBI_VOLUME_RESIZED: 555 ubiblock_resize(&nt->vi); 556 break; 557 case UBI_VOLUME_UPDATED: 558 /* 559 * If the volume is static, a content update might mean the 560 * size (i.e. used_bytes) was also changed. 561 */ 562 if (nt->vi.vol_type == UBI_STATIC_VOLUME) 563 ubiblock_resize(&nt->vi); 564 break; 565 default: 566 break; 567 } 568 return NOTIFY_OK; 569 } 570 571 static struct notifier_block ubiblock_notifier = { 572 .notifier_call = ubiblock_notify, 573 }; 574 575 static struct ubi_volume_desc * __init 576 open_volume_desc(const char *name, int ubi_num, int vol_id) 577 { 578 if (ubi_num == -1) 579 /* No ubi num, name must be a vol device path */ 580 return ubi_open_volume_path(name, UBI_READONLY); 581 else if (vol_id == -1) 582 /* No vol_id, must be vol_name */ 583 return ubi_open_volume_nm(ubi_num, name, UBI_READONLY); 584 else 585 return ubi_open_volume(ubi_num, vol_id, UBI_READONLY); 586 } 587 588 static void __init ubiblock_create_from_param(void) 589 { 590 int i, ret = 0; 591 struct ubiblock_param *p; 592 struct ubi_volume_desc *desc; 593 struct ubi_volume_info vi; 594 595 /* 596 * If there is an error creating one of the ubiblocks, continue on to 597 * create the following ubiblocks. This helps in a circumstance where 598 * the kernel command-line specifies multiple block devices and some 599 * may be broken, but we still want the working ones to come up. 600 */ 601 for (i = 0; i < ubiblock_devs; i++) { 602 p = &ubiblock_param[i]; 603 604 desc = open_volume_desc(p->name, p->ubi_num, p->vol_id); 605 if (IS_ERR(desc)) { 606 pr_err( 607 "UBI: block: can't open volume on ubi%d_%d, err=%ld\n", 608 p->ubi_num, p->vol_id, PTR_ERR(desc)); 609 continue; 610 } 611 612 ubi_get_volume_info(desc, &vi); 613 ubi_close_volume(desc); 614 615 ret = ubiblock_create(&vi); 616 if (ret) { 617 pr_err( 618 "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n", 619 vi.name, p->ubi_num, p->vol_id, ret); 620 continue; 621 } 622 } 623 } 624 625 static void ubiblock_remove_all(void) 626 { 627 struct ubiblock *next; 628 struct ubiblock *dev; 629 630 mutex_lock(&devices_mutex); 631 list_for_each_entry_safe(dev, next, &ubiblock_devices, list) { 632 /* The module is being forcefully removed */ 633 WARN_ON(dev->desc); 634 /* Remove from device list */ 635 list_del(&dev->list); 636 ubiblock_cleanup(dev); 637 kfree(dev); 638 } 639 mutex_unlock(&devices_mutex); 640 } 641 642 int __init ubiblock_init(void) 643 { 644 int ret; 645 646 ubiblock_major = register_blkdev(0, "ubiblock"); 647 if (ubiblock_major < 0) 648 return ubiblock_major; 649 650 /* 651 * Attach block devices from 'block=' module param. 652 * Even if one block device in the param list fails to come up, 653 * still allow the module to load and leave any others up. 654 */ 655 ubiblock_create_from_param(); 656 657 /* 658 * Block devices are only created upon user requests, so we ignore 659 * existing volumes. 660 */ 661 ret = ubi_register_volume_notifier(&ubiblock_notifier, 1); 662 if (ret) 663 goto err_unreg; 664 return 0; 665 666 err_unreg: 667 unregister_blkdev(ubiblock_major, "ubiblock"); 668 ubiblock_remove_all(); 669 return ret; 670 } 671 672 void __exit ubiblock_exit(void) 673 { 674 ubi_unregister_volume_notifier(&ubiblock_notifier); 675 ubiblock_remove_all(); 676 unregister_blkdev(ubiblock_major, "ubiblock"); 677 } 678