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