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