drivers/mtd/ubi/block.c

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