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