drivers/mtd/ubi/block.c

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