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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 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
 */

/*
 * 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/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 ubi_sgl usgl;
};

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

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

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 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_IDR(ubiblock_minor_idr);
/* Protects ubiblock_devices and ubiblock_minor_idr */
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 blk_status_t ubiblock_read(struct request *req)
{
	struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
	struct ubiblock *dev = req->q->queuedata;
	u64 pos = blk_rq_pos(req) << 9;
	int to_read = blk_rq_bytes(req);
	int bytes_left = to_read;
	/* Get LEB:offset address to read from */
	int offset = do_div(pos, dev->leb_size);
	int leb = pos;
	struct req_iterator iter;
	struct bio_vec bvec;
	int ret;

	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.
	 */
	ubi_sgl_init(&pdu->usgl);
	blk_rq_map_sg(req->q, req, pdu->usgl.sg);

	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)
			break;

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

	rq_for_each_segment(bvec, req, iter)
		flush_dcache_page(bvec.bv_page);

	blk_mq_end_request(req, errno_to_blk_status(ret));

	return BLK_STS_OK;
}

static int ubiblock_open(struct gendisk *disk, blk_mode_t mode)
{
	struct ubiblock *dev = 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 & BLK_OPEN_WRITE) {
		ret = -EROFS;
		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)
{
	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 blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
			     const struct blk_mq_queue_data *bd)
{
	switch (req_op(bd->rq)) {
	case REQ_OP_READ:
		return ubiblock_read(bd->rq);
	default:
		return BLK_STS_IOERR;
	}
}

static int ubiblock_init_request(struct blk_mq_tag_set *set,
		struct request *req, unsigned int hctx_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);
	return 0;
}

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

static int calc_disk_capacity(struct ubi_volume_info *vi, u64 *disk_capacity)
{
	u64 size = vi->used_bytes >> 9;

	if (vi->used_bytes % 512) {
		if (vi->vol_type == UBI_DYNAMIC_VOLUME)
			pr_warn("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
				vi->used_bytes - (size << 9));
		else
			pr_info("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
				vi->used_bytes - (size << 9));
	}

	if ((sector_t)size != size)
		return -EFBIG;

	*disk_capacity = size;

	return 0;
}

int ubiblock_create(struct ubi_volume_info *vi)
{
	struct queue_limits lim = {
		.max_segments		= UBI_MAX_SG_COUNT,
	};
	struct ubiblock *dev;
	struct gendisk *gd;
	u64 disk_capacity;
	int ret;

	ret = calc_disk_capacity(vi, &disk_capacity);
	if (ret) {
		return ret;
	}

	/* Check that the volume isn't already handled */
	mutex_lock(&devices_mutex);
	if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
		ret = -EEXIST;
		goto out_unlock;
	}

	dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
	if (!dev) {
		ret = -ENOMEM;
		goto out_unlock;
	}

	mutex_init(&dev->dev_mutex);

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

	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 | BLK_MQ_F_BLOCKING;
	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) {
		pr_err("ubiblock%d_%d: blk_mq_alloc_tag_set failed\n",
			dev->ubi_num, dev->vol_id);
		goto out_free_dev;
	}


	/* Initialize the gendisk of this ubiblock device */
	gd = blk_mq_alloc_disk(&dev->tag_set, &lim, dev);
	if (IS_ERR(gd)) {
		ret = PTR_ERR(gd);
		goto out_free_tags;
	}

	gd->fops = &ubiblock_ops;
	gd->major = ubiblock_major;
	gd->minors = 1;
	gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
	if (gd->first_minor < 0) {
		pr_err("ubiblock%d_%d: block: dynamic minor allocation failed\n",
			dev->ubi_num, dev->vol_id);
		ret = -ENODEV;
		goto out_cleanup_disk;
	}
	gd->flags |= GENHD_FL_NO_PART;
	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->rq = gd->queue;

	list_add_tail(&dev->list, &ubiblock_devices);

	/* Must be the last step: anyone can call file ops from now on */
	ret = device_add_disk(vi->dev, dev->gd, NULL);
	if (ret)
		goto out_remove_minor;

	dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
		 dev->ubi_num, dev->vol_id, vi->name);
	mutex_unlock(&devices_mutex);
	return 0;

out_remove_minor:
	list_del(&dev->list);
	idr_remove(&ubiblock_minor_idr, gd->first_minor);
out_cleanup_disk:
	put_disk(gd);
out_free_tags:
	blk_mq_free_tag_set(&dev->tag_set);
out_free_dev:
	kfree(dev);
out_unlock:
	mutex_unlock(&devices_mutex);

	return ret;
}

static void ubiblock_cleanup(struct ubiblock *dev)
{
	int id = dev->gd->first_minor;

	/* Stop new requests to arrive */
	del_gendisk(dev->gd);
	/* Finally destroy the blk queue */
	dev_info(disk_to_dev(dev->gd), "released");
	put_disk(dev->gd);
	blk_mq_free_tag_set(&dev->tag_set);
	idr_remove(&ubiblock_minor_idr, id);
}

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

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

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

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

	kfree(dev);
	return 0;

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

static int ubiblock_resize(struct ubi_volume_info *vi)
{
	struct ubiblock *dev;
	u64 disk_capacity;
	int ret;

	/*
	 * 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;
	}

	ret = calc_disk_capacity(vi, &disk_capacity);
	if (ret) {
		mutex_unlock(&devices_mutex);
		if (ret == -EFBIG) {
			dev_warn(disk_to_dev(dev->gd),
				 "the volume is too big (%d LEBs), cannot resize",
				 vi->size);
		}
		return ret;
	}

	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 bool
match_volume_desc(struct ubi_volume_info *vi, const char *name, int ubi_num, int vol_id)
{
	int err, len, cur_ubi_num, cur_vol_id;

	if (ubi_num == -1) {
		/* No ubi num, name must be a vol device path */
		err = ubi_get_num_by_path(name, &cur_ubi_num, &cur_vol_id);
		if (err || vi->ubi_num != cur_ubi_num || vi->vol_id != cur_vol_id)
			return false;

		return true;
	}

	if (vol_id == -1) {
		/* Got ubi_num, but no vol_id, name must be volume name */
		if (vi->ubi_num != ubi_num)
			return false;

		len = strnlen(name, UBI_VOL_NAME_MAX + 1);
		if (len < 1 || vi->name_len != len)
			return false;

		if (strcmp(name, vi->name))
			return false;

		return true;
	}

	if (vi->ubi_num != ubi_num)
		return false;

	if (vi->vol_id != vol_id)
		return false;

	return true;
}

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

	/*
	 * Iterate over ubiblock cmdline parameters. If a parameter matches the
	 * newly added volume create the ubiblock device for it.
	 */
	for (i = 0; i < ubiblock_devs; i++) {
		p = &ubiblock_param[i];

		if (!match_volume_desc(vi, p->name, p->ubi_num, p->vol_id))
			continue;

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

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:
		ubiblock_create_from_param(&nt->vi);
		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 void ubiblock_remove_all(void)
{
	struct ubiblock *next;
	struct ubiblock *dev;

	mutex_lock(&devices_mutex);
	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);
	}
	mutex_unlock(&devices_mutex);
}

int __init ubiblock_init(void)
{
	int ret;

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

	ret = ubi_register_volume_notifier(&ubiblock_notifier, 0);
	if (ret)
		goto err_unreg;
	return 0;

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

void ubiblock_exit(void)
{
	ubi_unregister_volume_notifier(&ubiblock_notifier);
	ubiblock_remove_all();
	unregister_blkdev(ubiblock_major, "ubiblock");
}
Commit	Line	Data
	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;
	69
	70	/* MTD devices specification parameters */
	71	static struct ubiblock_param ubiblock_param[UBIBLOCK_MAX_DEVICES];
	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 gendisk *disk, blk_mode_t mode)
	231	{
	232	struct ubiblock *dev = 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 & BLK_OPEN_WRITE) {
	250	ret = -EROFS;
	251	goto out_unlock;
	252	}
	253	dev->desc = ubi_open_volume(dev->ubi_num, dev->vol_id, UBI_READONLY);
	254	if (IS_ERR(dev->desc)) {
	255	dev_err(disk_to_dev(dev->gd), "failed to open ubi volume %d_%d",
	256	dev->ubi_num, dev->vol_id);
	257	ret = PTR_ERR(dev->desc);
	258	dev->desc = NULL;
	259	goto out_unlock;
	260	}
	261
	262	out_done:
	263	dev->refcnt++;
	264	mutex_unlock(&dev->dev_mutex);
	265	return 0;
	266
	267	out_unlock:
	268	mutex_unlock(&dev->dev_mutex);
	269	return ret;
	270	}
	271
	272	static void ubiblock_release(struct gendisk *gd)
	273	{
	274	struct ubiblock *dev = gd->private_data;
	275
	276	mutex_lock(&dev->dev_mutex);
	277	dev->refcnt--;
	278	if (dev->refcnt == 0) {
	279	ubi_close_volume(dev->desc);
	280	dev->desc = NULL;
	281	}
	282	mutex_unlock(&dev->dev_mutex);
	283	}
	284
	285	static int ubiblock_getgeo(struct block_device bdev, struct hd_geometry geo)
	286	{
	287	/* Some tools might require this information */
	288	geo->heads = 1;
	289	geo->cylinders = 1;
	290	geo->sectors = get_capacity(bdev->bd_disk);
	291	geo->start = 0;
	292	return 0;
	293	}
	294
	295	static const struct block_device_operations ubiblock_ops = {
	296	.owner = THIS_MODULE,
	297	.open = ubiblock_open,
	298	.release = ubiblock_release,
	299	.getgeo = ubiblock_getgeo,
	300	};
	301
	302	static blk_status_t ubiblock_queue_rq(struct blk_mq_hw_ctx *hctx,
	303	const struct blk_mq_queue_data *bd)
	304	{
	305	switch (req_op(bd->rq)) {
	306	case REQ_OP_READ:
	307	return ubiblock_read(bd->rq);
	308	default:
	309	return BLK_STS_IOERR;
	310	}
	311	}
	312
	313	static int ubiblock_init_request(struct blk_mq_tag_set *set,
	314	struct request *req, unsigned int hctx_idx,
	315	unsigned int numa_node)
	316	{
	317	struct ubiblock_pdu *pdu = blk_mq_rq_to_pdu(req);
	318
	319	sg_init_table(pdu->usgl.sg, UBI_MAX_SG_COUNT);
	320	return 0;
	321	}
	322
	323	static const struct blk_mq_ops ubiblock_mq_ops = {
	324	.queue_rq = ubiblock_queue_rq,
	325	.init_request = ubiblock_init_request,
	326	};
	327
	328	static int calc_disk_capacity(struct ubi_volume_info vi, u64 disk_capacity)
	329	{
	330	u64 size = vi->used_bytes >> 9;
	331
	332	if (vi->used_bytes % 512) {
	333	if (vi->vol_type == UBI_DYNAMIC_VOLUME)
	334	pr_warn("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
	335	vi->used_bytes - (size << 9));
	336	else
	337	pr_info("UBI: block: volume size is not a multiple of 512, last %llu bytes are ignored!\n",
	338	vi->used_bytes - (size << 9));
	339	}
	340
	341	if ((sector_t)size != size)
	342	return -EFBIG;
	343
	344	*disk_capacity = size;
	345
	346	return 0;
	347	}
	348
	349	int ubiblock_create(struct ubi_volume_info *vi)
	350	{
	351	struct queue_limits lim = {
	352	.max_segments = UBI_MAX_SG_COUNT,
	353	};
	354	struct ubiblock *dev;
	355	struct gendisk *gd;
	356	u64 disk_capacity;
	357	int ret;
	358
	359	ret = calc_disk_capacity(vi, &disk_capacity);
	360	if (ret) {
	361	return ret;
	362	}
	363
	364	/* Check that the volume isn't already handled */
	365	mutex_lock(&devices_mutex);
	366	if (find_dev_nolock(vi->ubi_num, vi->vol_id)) {
	367	ret = -EEXIST;
	368	goto out_unlock;
	369	}
	370
	371	dev = kzalloc(sizeof(struct ubiblock), GFP_KERNEL);
	372	if (!dev) {
	373	ret = -ENOMEM;
	374	goto out_unlock;
	375	}
	376
	377	mutex_init(&dev->dev_mutex);
	378
	379	dev->ubi_num = vi->ubi_num;
	380	dev->vol_id = vi->vol_id;
	381	dev->leb_size = vi->usable_leb_size;
	382
	383	dev->tag_set.ops = &ubiblock_mq_ops;
	384	dev->tag_set.queue_depth = 64;
	385	dev->tag_set.numa_node = NUMA_NO_NODE;
	386	dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE \| BLK_MQ_F_BLOCKING;
	387	dev->tag_set.cmd_size = sizeof(struct ubiblock_pdu);
	388	dev->tag_set.driver_data = dev;
	389	dev->tag_set.nr_hw_queues = 1;
	390
	391	ret = blk_mq_alloc_tag_set(&dev->tag_set);
	392	if (ret) {
	393	pr_err("ubiblock%d_%d: blk_mq_alloc_tag_set failed\n",
	394	dev->ubi_num, dev->vol_id);
	395	goto out_free_dev;
	396	}
	397
	398
	399	/* Initialize the gendisk of this ubiblock device */
	400	gd = blk_mq_alloc_disk(&dev->tag_set, &lim, dev);
	401	if (IS_ERR(gd)) {
	402	ret = PTR_ERR(gd);
	403	goto out_free_tags;
	404	}
	405
	406	gd->fops = &ubiblock_ops;
	407	gd->major = ubiblock_major;
	408	gd->minors = 1;
	409	gd->first_minor = idr_alloc(&ubiblock_minor_idr, dev, 0, 0, GFP_KERNEL);
	410	if (gd->first_minor < 0) {
	411	pr_err("ubiblock%d_%d: block: dynamic minor allocation failed\n",
	412	dev->ubi_num, dev->vol_id);
	413	ret = -ENODEV;
	414	goto out_cleanup_disk;
	415	}
	416	gd->flags \|= GENHD_FL_NO_PART;
	417	gd->private_data = dev;
	418	sprintf(gd->disk_name, "ubiblock%d_%d", dev->ubi_num, dev->vol_id);
	419	set_capacity(gd, disk_capacity);
	420	dev->gd = gd;
	421
	422	dev->rq = gd->queue;
	423
	424	list_add_tail(&dev->list, &ubiblock_devices);
	425
	426	/* Must be the last step: anyone can call file ops from now on */
	427	ret = device_add_disk(vi->dev, dev->gd, NULL);
	428	if (ret)
	429	goto out_remove_minor;
	430
	431	dev_info(disk_to_dev(dev->gd), "created from ubi%d:%d(%s)",
	432	dev->ubi_num, dev->vol_id, vi->name);
	433	mutex_unlock(&devices_mutex);
	434	return 0;
	435
	436	out_remove_minor:
	437	list_del(&dev->list);
	438	idr_remove(&ubiblock_minor_idr, gd->first_minor);
	439	out_cleanup_disk:
	440	put_disk(gd);
	441	out_free_tags:
	442	blk_mq_free_tag_set(&dev->tag_set);
	443	out_free_dev:
	444	kfree(dev);
	445	out_unlock:
	446	mutex_unlock(&devices_mutex);
	447
	448	return ret;
	449	}
	450
	451	static void ubiblock_cleanup(struct ubiblock *dev)
	452	{
	453	int id = dev->gd->first_minor;
	454
	455	/* Stop new requests to arrive */
	456	del_gendisk(dev->gd);
	457	/* Finally destroy the blk queue */
	458	dev_info(disk_to_dev(dev->gd), "released");
	459	put_disk(dev->gd);
	460	blk_mq_free_tag_set(&dev->tag_set);
	461	idr_remove(&ubiblock_minor_idr, id);
	462	}
	463
	464	int ubiblock_remove(struct ubi_volume_info *vi)
	465	{
	466	struct ubiblock *dev;
	467	int ret;
	468
	469	mutex_lock(&devices_mutex);
	470	dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
	471	if (!dev) {
	472	ret = -ENODEV;
	473	goto out_unlock;
	474	}
	475
	476	/* Found a device, let's lock it so we can check if it's busy */
	477	mutex_lock(&dev->dev_mutex);
	478	if (dev->refcnt > 0) {
	479	ret = -EBUSY;
	480	goto out_unlock_dev;
	481	}
	482
	483	/* Remove from device list */
	484	list_del(&dev->list);
	485	ubiblock_cleanup(dev);
	486	mutex_unlock(&dev->dev_mutex);
	487	mutex_unlock(&devices_mutex);
	488
	489	kfree(dev);
	490	return 0;
	491
	492	out_unlock_dev:
	493	mutex_unlock(&dev->dev_mutex);
	494	out_unlock:
	495	mutex_unlock(&devices_mutex);
	496	return ret;
	497	}
	498
	499	static int ubiblock_resize(struct ubi_volume_info *vi)
	500	{
	501	struct ubiblock *dev;
	502	u64 disk_capacity;
	503	int ret;
	504
	505	/*
	506	* Need to lock the device list until we stop using the device,
	507	* otherwise the device struct might get released in
	508	* 'ubiblock_remove()'.
	509	*/
	510	mutex_lock(&devices_mutex);
	511	dev = find_dev_nolock(vi->ubi_num, vi->vol_id);
	512	if (!dev) {
	513	mutex_unlock(&devices_mutex);
	514	return -ENODEV;
	515	}
	516
	517	ret = calc_disk_capacity(vi, &disk_capacity);
	518	if (ret) {
	519	mutex_unlock(&devices_mutex);
	520	if (ret == -EFBIG) {
	521	dev_warn(disk_to_dev(dev->gd),
	522	"the volume is too big (%d LEBs), cannot resize",
	523	vi->size);
	524	}
	525	return ret;
	526	}
	527
	528	mutex_lock(&dev->dev_mutex);
	529
	530	if (get_capacity(dev->gd) != disk_capacity) {
	531	set_capacity(dev->gd, disk_capacity);
	532	dev_info(disk_to_dev(dev->gd), "resized to %lld bytes",
	533	vi->used_bytes);
	534	}
	535	mutex_unlock(&dev->dev_mutex);
	536	mutex_unlock(&devices_mutex);
	537	return 0;
	538	}
	539
	540	static bool
	541	match_volume_desc(struct ubi_volume_info vi, const char name, int ubi_num, int vol_id)
	542	{
	543	int err, len, cur_ubi_num, cur_vol_id;
	544
	545	if (ubi_num == -1) {
	546	/* No ubi num, name must be a vol device path */
	547	err = ubi_get_num_by_path(name, &cur_ubi_num, &cur_vol_id);
	548	if (err \|\| vi->ubi_num != cur_ubi_num \|\| vi->vol_id != cur_vol_id)
	549	return false;
	550
	551	return true;
	552	}
	553
	554	if (vol_id == -1) {
	555	/* Got ubi_num, but no vol_id, name must be volume name */
	556	if (vi->ubi_num != ubi_num)
	557	return false;
	558
	559	len = strnlen(name, UBI_VOL_NAME_MAX + 1);
	560	if (len < 1 \|\| vi->name_len != len)
	561	return false;
	562
	563	if (strcmp(name, vi->name))
	564	return false;
	565
	566	return true;
	567	}
	568
	569	if (vi->ubi_num != ubi_num)
	570	return false;
	571
	572	if (vi->vol_id != vol_id)
	573	return false;
	574
	575	return true;
	576	}
	577
	578	static void
	579	ubiblock_create_from_param(struct ubi_volume_info *vi)
	580	{
	581	int i, ret = 0;
	582	struct ubiblock_param *p;
	583
	584	/*
	585	* Iterate over ubiblock cmdline parameters. If a parameter matches the
	586	* newly added volume create the ubiblock device for it.
	587	*/
	588	for (i = 0; i < ubiblock_devs; i++) {
	589	p = &ubiblock_param[i];
	590
	591	if (!match_volume_desc(vi, p->name, p->ubi_num, p->vol_id))
	592	continue;
	593
	594	ret = ubiblock_create(vi);
	595	if (ret) {
	596	pr_err(
	597	"UBI: block: can't add '%s' volume on ubi%d_%d, err=%d\n",
	598	vi->name, p->ubi_num, p->vol_id, ret);
	599	}
	600	break;
	601	}
	602	}
	603
	604	static int ubiblock_notify(struct notifier_block *nb,
	605	unsigned long notification_type, void *ns_ptr)
	606	{
	607	struct ubi_notification *nt = ns_ptr;
	608
	609	switch (notification_type) {
	610	case UBI_VOLUME_ADDED:
	611	ubiblock_create_from_param(&nt->vi);
	612	break;
	613	case UBI_VOLUME_REMOVED:
	614	ubiblock_remove(&nt->vi);
	615	break;
	616	case UBI_VOLUME_RESIZED:
	617	ubiblock_resize(&nt->vi);
	618	break;
	619	case UBI_VOLUME_UPDATED:
	620	/*
	621	* If the volume is static, a content update might mean the
	622	* size (i.e. used_bytes) was also changed.
	623	*/
	624	if (nt->vi.vol_type == UBI_STATIC_VOLUME)
	625	ubiblock_resize(&nt->vi);
	626	break;
	627	default:
	628	break;
	629	}
	630	return NOTIFY_OK;
	631	}
	632
	633	static struct notifier_block ubiblock_notifier = {
	634	.notifier_call = ubiblock_notify,
	635	};
	636
	637	static void ubiblock_remove_all(void)
	638	{
	639	struct ubiblock *next;
	640	struct ubiblock *dev;
	641
	642	mutex_lock(&devices_mutex);
	643	list_for_each_entry_safe(dev, next, &ubiblock_devices, list) {
	644	/* The module is being forcefully removed */
	645	WARN_ON(dev->desc);
	646	/* Remove from device list */
	647	list_del(&dev->list);
	648	ubiblock_cleanup(dev);
	649	kfree(dev);
	650	}
	651	mutex_unlock(&devices_mutex);
	652	}
	653
	654	int __init ubiblock_init(void)
	655	{
	656	int ret;
	657
	658	ubiblock_major = register_blkdev(0, "ubiblock");
	659	if (ubiblock_major < 0)
	660	return ubiblock_major;
	661
	662	ret = ubi_register_volume_notifier(&ubiblock_notifier, 0);
	663	if (ret)
	664	goto err_unreg;
	665	return 0;
	666
	667	err_unreg:
	668	unregister_blkdev(ubiblock_major, "ubiblock");
	669	ubiblock_remove_all();
	670	return ret;
	671	}
	672
	673	void ubiblock_exit(void)
	674	{
	675	ubi_unregister_volume_notifier(&ubiblock_notifier);
	676	ubiblock_remove_all();
	677	unregister_blkdev(ubiblock_major, "ubiblock");
	678	}