[deliverable/linux.git] / drivers / mtd / ubi / block.c

/*
 * Copyright (c) 2014 Ezequiel Garcia
 * Copyright (c) 2011 Free Electrons
 *
 * Driver parameter handling strongly based on drivers/mtd/ubi/build.c
 *   Copyright (c) International Business Machines Corp., 2006
 *   Copyright (c) Nokia Corporation, 2007
 *   Authors: Artem Bityutskiy, Frank Haverkamp
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
 * the GNU General Public License for more details.
 */

/*
 * Read-only block devices on top of UBI volumes
 *
 * A simple implementation to allow a block device to be layered on top of a
 * UBI volume. The implementation is provided by creating a static 1-to-1
 * mapping between the block device and the UBI volume.
 *
 * The addressed byte is obtained from the addressed block sector, which is
 * mapped linearly into the corresponding LEB:
 *
 *   LEB number = addressed byte / LEB size
 *
 * This feature is compiled in the UBI core, and adds a 'block' parameter
 * to allow early creation of block devices on top of UBI volumes. Runtime
 * block creation/removal for UBI volumes is provided through two UBI ioctls:
 * UBI_IOCVOLCRBLK and UBI_IOCVOLRMBLK.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/mtd/ubi.h>
#include <linux/workqueue.h>
#include <linux/blkdev.h>
#include <linux/blk-mq.h>
#include <linux/hdreg.h>
#include <linux/scatterlist.h>
#include <linux/idr.h>
#include <asm/div64.h>

#include "ubi-media.h"
#include "ubi.h"

/* Maximum number of supported devices */
#define UBIBLOCK_MAX_DEVICES 32

/* Maximum length of the 'block=' parameter */
#define UBIBLOCK_PARAM_LEN 63

/* Maximum number of comma-separated items in the 'block=' parameter */
#define UBIBLOCK_PARAM_COUNT 2

struct ubiblock_param {
	int ubi_num;
	int vol_id;
	char name[UBIBLOCK_PARAM_LEN+1];
};

struct ubiblock_pdu {
	struct work_struct work;
	struct ubi_sgl usgl;
};

/* Numbers of elements set in the @ubiblock_param array */
static int ubiblock_devs __initdata;

/* MTD devices specification parameters */
static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES] __initdata;

struct ubiblock {
	struct ubi_volume_desc *desc;
	int ubi_num;
	int vol_id;
	int refcnt;
	int leb_size;

	struct gendisk *gd;
	struct request_queue *rq;

	struct workqueue_struct *wq;

	struct mutex dev_mutex;
	struct list_head list;
	struct blk_mq_tag_set tag_set;
};

/* Linked list of all ubiblock instances */
static LIST_HEAD(ubiblock_devices);
static DEFINE_MUTEX(devices_mutex);
static int ubiblock_major;

static int __init ubiblock_set_param(const char *val,
				     const struct kernel_param *kp)
{
	int i, ret;
	size_t len;
	struct ubiblock_param *param;
	char buf[UBIBLOCK_PARAM_LEN];
	char *pbuf = &buf[0];
	char *tokens[UBIBLOCK_PARAM_COUNT];

	if (!val)
		return -EINVAL;

	len = strnlen(val, UBIBLOCK_PARAM_LEN);
	if (len == 0) {
		pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
		return 0;
	}

	if (len == UBIBLOCK_PARAM_LEN) {
		pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n",
		       val, UBIBLOCK_PARAM_LEN);
		return -EINVAL;
	}

	strcpy(buf, val);

	/* Get rid of the final newline */
	if (buf[len - 1] == '\n')
		buf[len - 1] = '\0';

	for (i = 0; i < UBIBLOCK_PARAM_COUNT; i++)
		tokens[i] = strsep(&pbuf, ",");

	param = &ubiblock_param[ubiblock_devs];
	if (tokens[1]) {
		/* Two parameters: can be 'ubi, vol_id' or 'ubi, vol_name' */
		ret = kstrtoint(tokens[0], 10, &param->ubi_num);
		if (ret < 0)
			return -EINVAL;

		/* Second param can be a number or a name */
		ret = kstrtoint(tokens[1], 10, &param->vol_id);
		if (ret < 0) {
			param->vol_id = -1;
			strcpy(param->name, tokens[1]);
		}

	} else {
		/* One parameter: must be device path */
		strcpy(param->name, tokens[0]);
		param->ubi_num = -1;
		param->vol_id = -1;
	}

	ubiblock_devs++;

	return 0;
}

static const struct kernel_param_ops ubiblock_param_ops = {
	.set    = ubiblock_set_param,
};
module_param_cb(block, &ubiblock_param_ops, NULL, 0);
MODULE_PARM_DESC(block, "Attach block devices to UBI volumes. Parameter format: block=<path|dev,num|dev,name>.\n"
			"Multiple \"block\" parameters may be specified.\n"
			"UBI volumes may be specified by their number, name, or path to the device node.\n"
			"Examples\n"
			"Using the UBI volume path:\n"
			"ubi.block=/dev/ubi0_0\n"
			"Using the UBI device, and the volume name:\n"
			"ubi.block=0,rootfs\n"
			"Using both UBI device number and UBI volume number:\n"
			"ubi.block=0,0\n");

static struct ubiblock *find_dev_nolock(int ubi_num, int vol_id)
{
	struct ubiblock *dev;

	list_for_each_entry(dev, &ubiblock_devices, list)
		if (dev->ubi_num == ubi_num && dev->vol_id == vol_id)
			return dev;
	return NULL;
}

static int ubiblock_read(struct ubiblock_pdu *pdu)
{
	int ret, leb, offset, bytes_left, to_read;
	u64 pos;
	struct request *req = blk_mq_rq_from_pdu(pdu);
	struct ubiblock *dev = req->q->queuedata;

	to_read = blk_rq_bytes(req);
	pos = blk_rq_pos(req) << 9;

	/* Get LEB:offset address to read from */
	offset = do_div(pos, dev->leb_size);
	leb = pos;
	bytes_left = to_read;

	while (bytes_left) {
		/*
		 * We can only read one LEB at a time. Therefore if the read
		 * length is larger than one LEB size, we split the operation.
		 */
		if (offset + to_read > dev->leb_size)
			to_read = dev->leb_size - offset;

		ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read);
		if (ret < 0)
			return ret;

		bytes_left -= to_read;
		to_read = bytes_left;
		leb += 1;
		offset = 0;
	}
	return 0;
}

static int ubiblock_open(struct block_device *bdev, fmode_t mode)
{
	struct ubiblock *dev = bdev->bd_disk->private_data;
	int ret;

	mutex_lock(&dev->dev_mutex);
	if (dev->refcnt > 0) {
		/*
		 * The volume is already open, just increase the reference
		 * counter.
		 */
		goto out_done;
	}

	/*
	 * We want users to be aware they should only mount us as read-only.
	 * It's just a paranoid check, as write requests will get rejected
	 * in any case.
	 */
	if (mode & FMODE_WRITE) {
		ret = -EPERM;
		goto out_unlock;
	}

	dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);
	if (IS_ERR(dev->desc)) {
		dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
			dev->ubi_num, dev->vol_id);
		ret = PTR_ERR(dev->desc);
		dev->desc = NULL;
		goto out_unlock;
	}

out_done:
	dev->refcnt++;
	mutex_unlock(&dev->dev_mutex);
	return 0;

out_unlock:
	mutex_unlock(&dev->dev_mutex);
	return ret;
}

static void ubiblock_release(struct gendisk *gd, fmode_t mode)
{
	struct ubiblock *dev = gd->private_data;

	mutex_lock(&dev->dev_mutex);
	dev->refcnt--;
	if (dev->refcnt == 0) {
		ubi_close_volume(dev->desc);
		dev->desc = NULL;
	}
	mutex_unlock(&dev->dev_mutex);
}

static int ubiblock_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	/* Some tools might require this information */
	geo->heads = 1;
	geo->cylinders = 1;
	geo->sectors = get_capacity(bdev->bd_disk);
	geo->start = 0;
	return 0;
}

static const struct block_device_operations ubiblock_ops = {
	.owner = THIS_MODULE,
	.open = ubiblock_open,
	.release = ubiblock_release,
	.getgeo	= ubiblock_getgeo,
};

static void ubiblock_do_work(struct work_struct *work)
{
	int ret;
	struct ubiblock_pdu *pdu = container_of(work, struct ubiblock_pdu, work);
	struct request *req = blk_mq_rq_from_pdu(pdu);

	blk_mq_start_request(req);

	/*
	 * It is safe to ignore the return value of blk_rq_map_sg() because
	 * the number of sg entries is limited to UBI_MAX_SG_COUNT
	 * and ubi_read_sg() will check that limit.
	 */
	blk_rq_map_sg(req->q, req, pdu->usgl.sg);

	ret = ubiblock_read(pdu);
	rq_flush_dcache_pages(req);

	blk_mq_end_request(req, ret);
}

static int ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
			     const struct blk_mq_queue_data *bd)
{
	struct request *req = bd->rq;
	struct ubiblock *dev = hctx->queue->queuedata;
	struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);

	if (req->cmd_type != REQ_TYPE_FS)
		return BLK_MQ_RQ_QUEUE_ERROR;

	if (rq_data_dir(req) != READ)
		return BLK_MQ_RQ_QUEUE_ERROR; /* Write not implemented */

	ubi_sgl_init(&pdu->usgl);
	queue_work(dev->wq, &pdu->work);

	return BLK_MQ_RQ_QUEUE_OK;
}

static int ubiblock_init_request(void *data, struct request *req,
				 unsigned int hctx_idx,
				 unsigned int request_idx,
				 unsigned int numa_node)
{
	struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);

	sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT);
	INIT_WORK(&pdu->work, ubiblock_do_work);

	return 0;
}

static struct blk_mq_ops ubiblock_mq_ops = {
	.queue_rq       = ubiblock_queue_rq,
	.init_request	= ubiblock_init_request,
	.map_queue      = blk_mq_map_queue,
};

static DEFINE_IDR(ubiblock_minor_idr);

int ubiblock_create(struct ubi_volume_info *vi)
{
	struct ubiblock *dev;
	struct gendisk *gd;
	u64 disk_capacity = vi->used_bytes >> 9;
	int ret;

	if ((sector_t)disk_capacity != disk_capacity)
		return -EFBIG;
	/* Check that the volume isn't already handled */
	mutex_lock(&devices_mutex);
	if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
		mutex_unlock(&devices_mutex);
		return -EEXIST;
	}
	mutex_unlock(&devices_mutex);

	dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	mutex_init(&dev->dev_mutex);

	dev->ubi_num = vi->ubi_num;
	dev->vol_id = vi->vol_id;
	dev->leb_size = vi->usable_leb_size;

	/* Initialize the gendisk of this ubiblock device */
	gd = alloc_disk(1);
	if (!gd) {
		pr_err("UBI: block: alloc_disk failed");
		ret = -ENODEV;
		goto out_free_dev;
	}

	gd->fops = &ubiblock_ops;
	gd->major = ubiblock_major;
	gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
	if (gd->first_minor < 0) {
		dev_err(disk_to_dev(gd),
			"block: dynamic minor allocation failed");
		ret = -ENODEV;
		goto out_put_disk;
	}
	gd->private_data = dev;
	sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
	set_capacity(gd, disk_capacity);
	dev->gd = gd;

	dev->tag_set.ops = &ubiblock_mq_ops;
	dev->tag_set.queue_depth = 64;
	dev->tag_set.numa_node = NUMA_NO_NODE;
	dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
	dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
	dev->tag_set.driver_data = dev;
	dev->tag_set.nr_hw_queues = 1;

	ret = blk_mq_alloc_tag_set(&dev->tag_set);
	if (ret) {
		dev_err(disk_to_dev(dev->gd), "blk_mq_alloc_tag_set failed");
		goto out_remove_minor;
	}

	dev->rq = blk_mq_init_queue(&dev->tag_set);
	if (IS_ERR(dev->rq)) {
		dev_err(disk_to_dev(gd), "blk_mq_init_queue failed");
		ret = PTR_ERR(dev->rq);
		goto out_free_tags;
	}
	blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT);

	dev->rq->queuedata = dev;
	dev->gd->queue = dev->rq;

	/*
	 * Create one workqueue per volume (per registered block device).
	 * Rembember workqueues are cheap, they're not threads.
	 */
	dev->wq = alloc_workqueue("%s", 0, 0, gd->disk_name);
	if (!dev->wq) {
		ret = -ENOMEM;
		goto out_free_queue;
	}

	mutex_lock(&devices_mutex);
	list_add_tail(&dev->list, &ubiblock_devices);
	mutex_unlock(&devices_mutex);

	/* Must be the last step: anyone can call file ops from now on */
	add_disk(dev->gd);
	dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
		 dev->ubi_num, dev->vol_id, vi->name);
	return 0;

out_free_queue:
	blk_cleanup_queue(dev->rq);
out_free_tags:
	blk_mq_free_tag_set(&dev->tag_set);
out_remove_minor:
	idr_remove(&ubiblock_minor_idr, gd->first_minor);
out_put_disk:
	put_disk(dev->gd);
out_free_dev:
	kfree(dev);

	return ret;
}

static void ubiblock_cleanup(struct ubiblock *dev)
{
	/* Stop new requests to arrive */
	del_gendisk(dev->gd);
	/* Flush pending work */
	destroy_workqueue(dev->wq);
	/* Finally destroy the blk queue */
	blk_cleanup_queue(dev->rq);
	blk_mq_free_tag_set(&dev->tag_set);
	dev_info(disk_to_dev(dev->gd), "released");
	idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
	put_disk(dev->gd);
}

int ubiblock_remove(struct ubi_volume_info *vi)
{
	struct ubiblock *dev;

	mutex_lock(&devices_mutex);
	dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
	if (!dev) {
		mutex_unlock(&devices_mutex);
		return -ENODEV;
	}

	/* Found a device, let's lock it so we can check if it's busy */
	mutex_lock(&dev->dev_mutex);
	if (dev->refcnt > 0) {
		mutex_unlock(&dev->dev_mutex);
		mutex_unlock(&devices_mutex);
		return -EBUSY;
	}

	/* Remove from device list */
	list_del(&dev->list);
	mutex_unlock(&devices_mutex);

	ubiblock_cleanup(dev);
	mutex_unlock(&dev->dev_mutex);
	kfree(dev);
	return 0;
}

static int ubiblock_resize(struct ubi_volume_info *vi)
{
	struct ubiblock *dev;
	u64 disk_capacity = vi->used_bytes >> 9;

	/*
	 * Need to lock the device list until we stop using the device,
	 * otherwise the device struct might get released in
	 * 'ubiblock_remove()'.
	 */
	mutex_lock(&devices_mutex);
	dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
	if (!dev) {
		mutex_unlock(&devices_mutex);
		return -ENODEV;
	}
	if ((sector_t)disk_capacity != disk_capacity) {
		mutex_unlock(&devices_mutex);
		dev_warn(disk_to_dev(dev->gd), "the volume is too big (%d LEBs), cannot resize",
			 vi->size);
		return -EFBIG;
	}

	mutex_lock(&dev->dev_mutex);

	if (get_capacity(dev->gd) != disk_capacity) {
		set_capacity(dev->gd, disk_capacity);
		dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
			 vi->used_bytes);
	}
	mutex_unlock(&dev->dev_mutex);
	mutex_unlock(&devices_mutex);
	return 0;
}

static int ubiblock_notify(struct notifier_block *nb,
			 unsigned long notification_type, void *ns_ptr)
{
	struct ubi_notification *nt = ns_ptr;

	switch (notification_type) {
	case UBI_VOLUME_ADDED:
		/*
		 * We want to enforce explicit block device creation for
		 * volumes, so when a volume is added we do nothing.
		 */
		break;
	case UBI_VOLUME_REMOVED:
		ubiblock_remove(&nt->vi);
		break;
	case UBI_VOLUME_RESIZED:
		ubiblock_resize(&nt->vi);
		break;
	case UBI_VOLUME_UPDATED:
		/*
		 * If the volume is static, a content update might mean the
		 * size (i.e. used_bytes) was also changed.
		 */
		if (nt->vi.vol_type == UBI_STATIC_VOLUME)
			ubiblock_resize(&nt->vi);
		break;
	default:
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block ubiblock_notifier = {
	.notifier_call = ubiblock_notify,
};

static struct ubi_volume_desc * __init
open_volume_desc(const char *name, int ubi_num, int vol_id)
{
	if (ubi_num == -1)
		/* No ubi num, name must be a vol device path */
		return ubi_open_volume_path(name, UBI_READONLY);
	else if (vol_id == -1)
		/* No vol_id, must be vol_name */
		return ubi_open_volume_nm(ubi_num, name, UBI_READONLY);
	else
		return ubi_open_volume(ubi_num, vol_id, UBI_READONLY);
}

static void __init ubiblock_create_from_param(void)
{
	int i, ret = 0;
	struct ubiblock_param *p;
	struct ubi_volume_desc *desc;
	struct ubi_volume_info vi;

	/*
	 * If there is an error creating one of the ubiblocks, continue on to
	 * create the following ubiblocks. This helps in a circumstance where
	 * the kernel command-line specifies multiple block devices and some
	 * may be broken, but we still want the working ones to come up.
	 */
	for (i = 0; i < ubiblock_devs; i++) {
		p = &ubiblock_param[i];

		desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);
		if (IS_ERR(desc)) {
			pr_err(
			       "UBI: block: can't open volume on ubi%d_%d, err=%ld",
			       p->ubi_num, p->vol_id, PTR_ERR(desc));
			continue;
		}

		ubi_get_volume_info(desc, &vi);
		ubi_close_volume(desc);

		ret = ubiblock_create(&vi);
		if (ret) {
			pr_err(
			       "UBI: block: can't add '%s' volume on ubi%d_%d, err=%d",
			       vi.name, p->ubi_num, p->vol_id, ret);
			continue;
		}
	}
}

static void ubiblock_remove_all(void)
{
	struct ubiblock *next;
	struct ubiblock *dev;

	list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
		/* The module is being forcefully removed */
		WARN_ON(dev->desc);
		/* Remove from device list */
		list_del(&dev->list);
		ubiblock_cleanup(dev);
		kfree(dev);
	}
}

int __init ubiblock_init(void)
{
	int ret;

	ubiblock_major = register_blkdev(0, "ubiblock");
	if (ubiblock_major < 0)
		return ubiblock_major;

	/*
	 * Attach block devices from 'block=' module param.
	 * Even if one block device in the param list fails to come up,
	 * still allow the module to load and leave any others up.
	 */
	ubiblock_create_from_param();

	/*
	 * Block devices are only created upon user requests, so we ignore
	 * existing volumes.
	 */
	ret = ubi_register_volume_notifier(&ubiblock_notifier, 1);
	if (ret)
		goto err_unreg;
	return 0;

err_unreg:
	unregister_blkdev(ubiblock_major, "ubiblock");
	ubiblock_remove_all();
	return ret;
}

void __exit ubiblock_exit(void)
{
	ubi_unregister_volume_notifier(&ubiblock_notifier);
	ubiblock_remove_all();
	unregister_blkdev(ubiblock_major, "ubiblock");
}
Commit	Line	Data
9d54c8a3 EG	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	*
4d283ee2 AB	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:
8af87188	35	* UBI_IOCVOLCRBLK and UBI_IOCVOLRMBLK.
9d54c8a3 EG	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>
9d54c8a3 EG	45	#include <linux/mtd/ubi.h>
	46	#include <linux/workqueue.h>
	47	#include <linux/blkdev.h>
ff1f48ee	48	#include <linux/blk-mq.h>
9d54c8a3	49	#include <linux/hdreg.h>
ff1f48ee	50	#include <linux/scatterlist.h>
2bf50d42	51	#include <linux/idr.h>
9d54c8a3 EG	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
ff1f48ee RW	72	struct ubiblock_pdu {
	73	struct work_struct work;
	74	struct ubi_sgl usgl;
	75	};
	76
9d54c8a3 EG	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;
9d54c8a3 EG	94
9d54c8a3 EG	95	struct mutex dev_mutex;
9d54c8a3	96	struct list_head list;
ff1f48ee	97	struct blk_mq_tag_set tag_set;
9d54c8a3 EG	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) {
32608703	120	pr_warn("UBI: block: empty 'block=' parameter - ignored\n");
9d54c8a3 EG	121	return 0;
	122	}
	123
	124	if (len == UBIBLOCK_PARAM_LEN) {
32608703 TB	125	pr_err("UBI: block: parameter \"%s\" is too long, max. is %d\n",
32608703 TB	126	val, UBIBLOCK_PARAM_LEN);
9d54c8a3 EG	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
9c27847d	165	static const struct kernel_param_ops ubiblock_param_ops = {
9d54c8a3 EG	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
ff1f48ee	190	static int ubiblock_read(struct ubiblock_pdu *pdu)
9d54c8a3	191	{
ff1f48ee RW	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;
9d54c8a3	196
ff1f48ee RW	197	to_read = blk_rq_bytes(req);
ff1f48ee RW	198	pos = blk_rq_pos(req) << 9;
9d54c8a3 EG	199
	200	/* Get LEB:offset address to read from */
	201	offset = do_div(pos, dev->leb_size);
	202	leb = pos;
ff1f48ee	203	bytes_left = to_read;
9d54c8a3 EG	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
ff1f48ee RW	213	ret = ubi_read_sg(dev->desc, leb, &pdu->usgl, offset, to_read);
ff1f48ee RW	214	if (ret < 0)
9d54c8a3 EG	215	return ret;
9d54c8a3 EG	216
9d54c8a3 EG	217	bytes_left -= to_read;
	218	to_read = bytes_left;
	219	leb += 1;
	220	offset = 0;
	221	}
	222	return 0;
	223	}
	224
9d54c8a3 EG	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)) {
32608703 TB	251	dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
32608703 TB	252	dev->ubi_num, dev->vol_id);
9d54c8a3 EG	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
ff1f48ee RW	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);
832b52a1 RW	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	*/
ff1f48ee RW	311	blk_rq_map_sg(req->q, req, pdu->usgl.sg);
	312
	313	ret = ubiblock_read(pdu);
98fb1ffd KC	314	rq_flush_dcache_pages(req);
98fb1ffd KC	315
ff1f48ee RW	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	.map_queue = blk_mq_map_queue,
	355	};
	356
2bf50d42 DE	357	static DEFINE_IDR(ubiblock_minor_idr);
2bf50d42 DE	358
4d283ee2	359	int ubiblock_create(struct ubi_volume_info *vi)
9d54c8a3 EG	360	{
	361	struct ubiblock *dev;
	362	struct gendisk *gd;
978d6496	363	u64 disk_capacity = vi->used_bytes >> 9;
9d54c8a3 EG	364	int ret;
9d54c8a3 EG	365
4df38926 RW	366	if ((sector_t)disk_capacity != disk_capacity)
4df38926 RW	367	return -EFBIG;
9d54c8a3 EG	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	mutex_unlock(&devices_mutex);
	372	return -EEXIST;
	373	}
	374	mutex_unlock(&devices_mutex);
	375
	376	dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
	377	if (!dev)
	378	return -ENOMEM;
	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) {
32608703	389	pr_err("UBI: block: alloc_disk failed");
9d54c8a3 EG	390	ret = -ENODEV;
	391	goto out_free_dev;
	392	}
	393
	394	gd->fops = &ubiblock_ops;
	395	gd->major = ubiblock_major;
2bf50d42 DE	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	}
9d54c8a3 EG	403	gd->private_data = dev;
9d54c8a3 EG	404	sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
9d54c8a3 EG	405	set_capacity(gd, disk_capacity);
	406	dev->gd = gd;
	407
ff1f48ee RW	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");
2bf50d42	419	goto out_remove_minor;
ff1f48ee RW	420	}
	421
	422	dev->rq = blk_mq_init_queue(&dev->tag_set);
8168b9bb	423	if (IS_ERR(dev->rq)) {
ff1f48ee	424	dev_err(disk_to_dev(gd), "blk_mq_init_queue failed");
8168b9bb	425	ret = PTR_ERR(dev->rq);
ff1f48ee	426	goto out_free_tags;
9d54c8a3	427	}
ff1f48ee	428	blk_queue_max_segments(dev->rq, UBI_MAX_SG_COUNT);
9d54c8a3 EG	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	*/
bebfef15	437	dev->wq = alloc_workqueue("%s", 0, 0, gd->disk_name);
151d6b21 HS	438	if (!dev->wq) {
151d6b21 HS	439	ret = -ENOMEM;
9d54c8a3	440	goto out_free_queue;
151d6b21	441	}
9d54c8a3 EG	442
	443	mutex_lock(&devices_mutex);
	444	list_add_tail(&dev->list, &ubiblock_devices);
	445	mutex_unlock(&devices_mutex);
	446
	447	/* Must be the last step: anyone can call file ops from now on */
	448	add_disk(dev->gd);
32608703 TB	449	dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
32608703 TB	450	dev->ubi_num, dev->vol_id, vi->name);
9d54c8a3 EG	451	return 0;
	452
	453	out_free_queue:
	454	blk_cleanup_queue(dev->rq);
ff1f48ee RW	455	out_free_tags:
ff1f48ee RW	456	blk_mq_free_tag_set(&dev->tag_set);
2bf50d42 DE	457	out_remove_minor:
2bf50d42 DE	458	idr_remove(&ubiblock_minor_idr, gd->first_minor);
9d54c8a3 EG	459	out_put_disk:
	460	put_disk(dev->gd);
	461	out_free_dev:
	462	kfree(dev);
	463
	464	return ret;
	465	}
	466
	467	static void ubiblock_cleanup(struct ubiblock *dev)
	468	{
ff1f48ee	469	/* Stop new requests to arrive */
9d54c8a3	470	del_gendisk(dev->gd);
ff1f48ee RW	471	/* Flush pending work */
	472	destroy_workqueue(dev->wq);
	473	/* Finally destroy the blk queue */
9d54c8a3	474	blk_cleanup_queue(dev->rq);
ff1f48ee	475	blk_mq_free_tag_set(&dev->tag_set);
32608703	476	dev_info(disk_to_dev(dev->gd), "released");
2bf50d42	477	idr_remove(&ubiblock_minor_idr, dev->gd->first_minor);
9d54c8a3 EG	478	put_disk(dev->gd);
	479	}
	480
4d283ee2	481	int ubiblock_remove(struct ubi_volume_info *vi)
9d54c8a3 EG	482	{
	483	struct ubiblock *dev;
	484
	485	mutex_lock(&devices_mutex);
	486	dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
	487	if (!dev) {
	488	mutex_unlock(&devices_mutex);
	489	return -ENODEV;
	490	}
	491
	492	/* Found a device, let's lock it so we can check if it's busy */
	493	mutex_lock(&dev->dev_mutex);
	494	if (dev->refcnt > 0) {
	495	mutex_unlock(&dev->dev_mutex);
	496	mutex_unlock(&devices_mutex);
	497	return -EBUSY;
	498	}
	499
	500	/* Remove from device list */
	501	list_del(&dev->list);
	502	mutex_unlock(&devices_mutex);
	503
9d54c8a3 EG	504	ubiblock_cleanup(dev);
	505	mutex_unlock(&dev->dev_mutex);
	506	kfree(dev);
	507	return 0;
	508	}
	509
495f2bf6	510	static int ubiblock_resize(struct ubi_volume_info *vi)
9d54c8a3 EG	511	{
9d54c8a3 EG	512	struct ubiblock *dev;
978d6496	513	u64 disk_capacity = vi->used_bytes >> 9;
9d54c8a3 EG	514
	515	/*
	516	* Need to lock the device list until we stop using the device,
4d283ee2 AB	517	* otherwise the device struct might get released in
4d283ee2 AB	518	* 'ubiblock_remove()'.
9d54c8a3 EG	519	*/
	520	mutex_lock(&devices_mutex);
	521	dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
	522	if (!dev) {
	523	mutex_unlock(&devices_mutex);
495f2bf6	524	return -ENODEV;
9d54c8a3	525	}
3df77072 CIK	526	if ((sector_t)disk_capacity != disk_capacity) {
3df77072 CIK	527	mutex_unlock(&devices_mutex);
32608703 TB	528	dev_warn(disk_to_dev(dev->gd), "the volume is too big (%d LEBs), cannot resize",
32608703 TB	529	vi->size);
3df77072 CIK	530	return -EFBIG;
3df77072 CIK	531	}
9d54c8a3 EG	532
9d54c8a3 EG	533	mutex_lock(&dev->dev_mutex);
06d9c290 EG	534
	535	if (get_capacity(dev->gd) != disk_capacity) {
	536	set_capacity(dev->gd, disk_capacity);
32608703 TB	537	dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
32608703 TB	538	vi->used_bytes);
06d9c290	539	}
9d54c8a3 EG	540	mutex_unlock(&dev->dev_mutex);
9d54c8a3 EG	541	mutex_unlock(&devices_mutex);
495f2bf6	542	return 0;
9d54c8a3 EG	543	}
	544
	545	static int ubiblock_notify(struct notifier_block *nb,
	546	unsigned long notification_type, void *ns_ptr)
	547	{
	548	struct ubi_notification *nt = ns_ptr;
	549
	550	switch (notification_type) {
	551	case UBI_VOLUME_ADDED:
	552	/*
4d283ee2	553	* We want to enforce explicit block device creation for
9d54c8a3 EG	554	* volumes, so when a volume is added we do nothing.
	555	*/
	556	break;
	557	case UBI_VOLUME_REMOVED:
4d283ee2	558	ubiblock_remove(&nt->vi);
9d54c8a3 EG	559	break;
	560	case UBI_VOLUME_RESIZED:
	561	ubiblock_resize(&nt->vi);
	562	break;
06d9c290 EG	563	case UBI_VOLUME_UPDATED:
	564	/*
	565	* If the volume is static, a content update might mean the
	566	* size (i.e. used_bytes) was also changed.
	567	*/
	568	if (nt->vi.vol_type == UBI_STATIC_VOLUME)
	569	ubiblock_resize(&nt->vi);
	570	break;
9d54c8a3 EG	571	default:
	572	break;
	573	}
	574	return NOTIFY_OK;
	575	}
	576
	577	static struct notifier_block ubiblock_notifier = {
	578	.notifier_call = ubiblock_notify,
	579	};
	580
	581	static struct ubi_volume_desc * __init
	582	open_volume_desc(const char *name, int ubi_num, int vol_id)
	583	{
	584	if (ubi_num == -1)
	585	/* No ubi num, name must be a vol device path */
	586	return ubi_open_volume_path(name, UBI_READONLY);
	587	else if (vol_id == -1)
	588	/* No vol_id, must be vol_name */
	589	return ubi_open_volume_nm(ubi_num, name, UBI_READONLY);
	590	else
	591	return ubi_open_volume(ubi_num, vol_id, UBI_READONLY);
	592	}
	593
1440061b	594	static void __init ubiblock_create_from_param(void)
9d54c8a3	595	{
1440061b	596	int i, ret = 0;
9d54c8a3 EG	597	struct ubiblock_param *p;
	598	struct ubi_volume_desc *desc;
	599	struct ubi_volume_info vi;
	600
1440061b DE	601	/*
	602	* If there is an error creating one of the ubiblocks, continue on to
	603	* create the following ubiblocks. This helps in a circumstance where
	604	* the kernel command-line specifies multiple block devices and some
	605	* may be broken, but we still want the working ones to come up.
	606	*/
9d54c8a3 EG	607	for (i = 0; i < ubiblock_devs; i++) {
	608	p = &ubiblock_param[i];
	609
	610	desc = open_volume_desc(p->name, p->ubi_num, p->vol_id);
	611	if (IS_ERR(desc)) {
1440061b DE	612	pr_err(
	613	"UBI: block: can't open volume on ubi%d_%d, err=%ld",
	614	p->ubi_num, p->vol_id, PTR_ERR(desc));
	615	continue;
9d54c8a3 EG	616	}
	617
	618	ubi_get_volume_info(desc, &vi);
	619	ubi_close_volume(desc);
	620
4d283ee2	621	ret = ubiblock_create(&vi);
9d54c8a3	622	if (ret) {
1440061b DE	623	pr_err(
	624	"UBI: block: can't add '%s' volume on ubi%d_%d, err=%d",
	625	vi.name, p->ubi_num, p->vol_id, ret);
	626	continue;
9d54c8a3 EG	627	}
9d54c8a3 EG	628	}
9d54c8a3 EG	629	}
9d54c8a3 EG	630
4d283ee2	631	static void ubiblock_remove_all(void)
9d54c8a3 EG	632	{
	633	struct ubiblock *next;
	634	struct ubiblock *dev;
	635
	636	list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
9d54c8a3 EG	637	/* The module is being forcefully removed */
	638	WARN_ON(dev->desc);
	639	/* Remove from device list */
	640	list_del(&dev->list);
	641	ubiblock_cleanup(dev);
	642	kfree(dev);
	643	}
	644	}
	645
	646	int __init ubiblock_init(void)
	647	{
	648	int ret;
	649
	650	ubiblock_major = register_blkdev(0, "ubiblock");
	651	if (ubiblock_major < 0)
	652	return ubiblock_major;
	653
1440061b DE	654	/*
	655	* Attach block devices from 'block=' module param.
	656	* Even if one block device in the param list fails to come up,
	657	* still allow the module to load and leave any others up.
	658	*/
	659	ubiblock_create_from_param();
9d54c8a3 EG	660
9d54c8a3 EG	661	/*
4d283ee2 AB	662	* Block devices are only created upon user requests, so we ignore
4d283ee2 AB	663	* existing volumes.
9d54c8a3 EG	664	*/
	665	ret = ubi_register_volume_notifier(&ubiblock_notifier, 1);
	666	if (ret)
	667	goto err_unreg;
	668	return 0;
	669
	670	err_unreg:
	671	unregister_blkdev(ubiblock_major, "ubiblock");
4d283ee2	672	ubiblock_remove_all();
9d54c8a3 EG	673	return ret;
	674	}
	675
	676	void __exit ubiblock_exit(void)
	677	{
	678	ubi_unregister_volume_notifier(&ubiblock_notifier);
4d283ee2	679	ubiblock_remove_all();
9d54c8a3 EG	680	unregister_blkdev(ubiblock_major, "ubiblock");
9d54c8a3 EG	681	}