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