[linux-block.git] / drivers / md / dm-ebs-target.c

/*
 * Copyright (C) 2020 Red Hat GmbH
 *
 * This file is released under the GPL.
 *
 * Device-mapper target to emulate smaller logical block
 * size on backing devices exposing (natively) larger ones.
 *
 * E.g. 512 byte sector emulation on 4K native disks.
 */

#include "dm.h"
#include <linux/module.h>
#include <linux/workqueue.h>
#include <linux/dm-bufio.h>

#define DM_MSG_PREFIX "ebs"

static void ebs_dtr(struct dm_target *ti);

/* Emulated block size context. */
struct ebs_c {
	struct dm_dev *dev;		/* Underlying device to emulate block size on. */
	struct dm_bufio_client *bufio;	/* Use dm-bufio for read and read-modify-write processing. */
	struct workqueue_struct *wq;	/* Workqueue for ^ processing of bios. */
	struct work_struct ws;		/* Work item used for ^. */
	struct bio_list bios_in;	/* Worker bios input list. */
	spinlock_t lock;		/* Guard bios input list above. */
	sector_t start;			/* <start> table line argument, see ebs_ctr below. */
	unsigned int e_bs;		/* Emulated block size in sectors exposed to upper layer. */
	unsigned int u_bs;		/* Underlying block size in sectors retrieved from/set on lower layer device. */
	unsigned char block_shift;	/* bitshift sectors -> blocks used in dm-bufio API. */
	bool u_bs_set:1;		/* Flag to indicate underlying block size is set on table line. */
};

static inline sector_t __sector_to_block(struct ebs_c *ec, sector_t sector)
{
	return sector >> ec->block_shift;
}

static inline sector_t __block_mod(sector_t sector, unsigned int bs)
{
	return sector & (bs - 1);
}

/* Return number of blocks for a bio, accounting for misalignment of start and end sectors. */
static inline unsigned int __nr_blocks(struct ebs_c *ec, struct bio *bio)
{
	sector_t end_sector = __block_mod(bio->bi_iter.bi_sector, ec->u_bs) + bio_sectors(bio);

	return __sector_to_block(ec, end_sector) + (__block_mod(end_sector, ec->u_bs) ? 1 : 0);
}

static inline bool __ebs_check_bs(unsigned int bs)
{
	return bs && is_power_of_2(bs);
}

/*
 * READ/WRITE:
 *
 * copy blocks between bufio blocks and bio vector's (partial/overlapping) pages.
 */
static int __ebs_rw_bvec(struct ebs_c *ec, enum req_op op, struct bio_vec *bv,
			 struct bvec_iter *iter)
{
	int r = 0;
	unsigned char *ba, *pa;
	unsigned int cur_len;
	unsigned int bv_len = bv->bv_len;
	unsigned int buf_off = to_bytes(__block_mod(iter->bi_sector, ec->u_bs));
	sector_t block = __sector_to_block(ec, iter->bi_sector);
	struct dm_buffer *b;

	if (unlikely(!bv->bv_page || !bv_len))
		return -EIO;

	pa = bvec_virt(bv);

	/* Handle overlapping page <-> blocks */
	while (bv_len) {
		cur_len = min(dm_bufio_get_block_size(ec->bufio) - buf_off, bv_len);

		/* Avoid reading for writes in case bio vector's page overwrites block completely. */
		if (op == REQ_OP_READ || buf_off || bv_len < dm_bufio_get_block_size(ec->bufio))
			ba = dm_bufio_read(ec->bufio, block, &b);
		else
			ba = dm_bufio_new(ec->bufio, block, &b);

		if (IS_ERR(ba)) {
			/*
			 * Carry on with next buffer, if any, to issue all possible
			 * data but return error.
			 */
			r = PTR_ERR(ba);
		} else {
			/* Copy data to/from bio to buffer if read/new was successful above. */
			ba += buf_off;
			if (op == REQ_OP_READ) {
				memcpy(pa, ba, cur_len);
				flush_dcache_page(bv->bv_page);
			} else {
				flush_dcache_page(bv->bv_page);
				memcpy(ba, pa, cur_len);
				dm_bufio_mark_partial_buffer_dirty(b, buf_off, buf_off + cur_len);
			}

			dm_bufio_release(b);
		}

		pa += cur_len;
		bv_len -= cur_len;
		buf_off = 0;
		block++;
	}

	return r;
}

/* READ/WRITE: iterate bio vector's copying between (partial) pages and bufio blocks. */
static int __ebs_rw_bio(struct ebs_c *ec, enum req_op op, struct bio *bio)
{
	int r = 0, rr;
	struct bio_vec bv;
	struct bvec_iter iter;

	bio_for_each_bvec(bv, bio, iter) {
		rr = __ebs_rw_bvec(ec, op, &bv, &iter);
		if (rr)
			r = rr;
	}

	return r;
}

/*
 * Discard bio's blocks, i.e. pass discards down.
 *
 * Avoid discarding partial blocks at beginning and end;
 * return 0 in case no blocks can be discarded as a result.
 */
static int __ebs_discard_bio(struct ebs_c *ec, struct bio *bio)
{
	sector_t block, blocks, sector = bio->bi_iter.bi_sector;

	block = __sector_to_block(ec, sector);
	blocks = __nr_blocks(ec, bio);

	/*
	 * Partial first underlying block (__nr_blocks() may have
	 * resulted in one block).
	 */
	if (__block_mod(sector, ec->u_bs)) {
		block++;
		blocks--;
	}

	/* Partial last underlying block if any. */
	if (blocks && __block_mod(bio_end_sector(bio), ec->u_bs))
		blocks--;

	return blocks ? dm_bufio_issue_discard(ec->bufio, block, blocks) : 0;
}

/* Release blocks them from the bufio cache. */
static void __ebs_forget_bio(struct ebs_c *ec, struct bio *bio)
{
	sector_t blocks, sector = bio->bi_iter.bi_sector;

	blocks = __nr_blocks(ec, bio);

	dm_bufio_forget_buffers(ec->bufio, __sector_to_block(ec, sector), blocks);
}

/* Worker function to process incoming bios. */
static void __ebs_process_bios(struct work_struct *ws)
{
	int r;
	bool write = false;
	sector_t block1, block2;
	struct ebs_c *ec = container_of(ws, struct ebs_c, ws);
	struct bio *bio;
	struct bio_list bios;

	bio_list_init(&bios);

	spin_lock_irq(&ec->lock);
	bios = ec->bios_in;
	bio_list_init(&ec->bios_in);
	spin_unlock_irq(&ec->lock);

	/* Prefetch all read and any mis-aligned write buffers */
	bio_list_for_each(bio, &bios) {
		block1 = __sector_to_block(ec, bio->bi_iter.bi_sector);
		if (bio_op(bio) == REQ_OP_READ)
			dm_bufio_prefetch(ec->bufio, block1, __nr_blocks(ec, bio));
		else if (bio_op(bio) == REQ_OP_WRITE && !(bio->bi_opf & REQ_PREFLUSH)) {
			block2 = __sector_to_block(ec, bio_end_sector(bio));
			if (__block_mod(bio->bi_iter.bi_sector, ec->u_bs))
				dm_bufio_prefetch(ec->bufio, block1, 1);
			if (__block_mod(bio_end_sector(bio), ec->u_bs) && block2 != block1)
				dm_bufio_prefetch(ec->bufio, block2, 1);
		}
	}

	bio_list_for_each(bio, &bios) {
		r = -EIO;
		if (bio_op(bio) == REQ_OP_READ)
			r = __ebs_rw_bio(ec, REQ_OP_READ, bio);
		else if (bio_op(bio) == REQ_OP_WRITE) {
			write = true;
			r = __ebs_rw_bio(ec, REQ_OP_WRITE, bio);
		} else if (bio_op(bio) == REQ_OP_DISCARD) {
			__ebs_forget_bio(ec, bio);
			r = __ebs_discard_bio(ec, bio);
		}

		if (r < 0)
			bio->bi_status = errno_to_blk_status(r);
	}

	/*
	 * We write dirty buffers after processing I/O on them
	 * but before we endio thus addressing REQ_FUA/REQ_SYNC.
	 */
	r = write ? dm_bufio_write_dirty_buffers(ec->bufio) : 0;

	while ((bio = bio_list_pop(&bios))) {
		/* Any other request is endioed. */
		if (unlikely(r && bio_op(bio) == REQ_OP_WRITE))
			bio_io_error(bio);
		else
			bio_endio(bio);
	}
}

/*
 * Construct an emulated block size mapping: <dev_path> <offset> <ebs> [<ubs>]
 *
 * <dev_path>: path of the underlying device
 * <offset>: offset in 512 bytes sectors into <dev_path>
 * <ebs>: emulated block size in units of 512 bytes exposed to the upper layer
 * [<ubs>]: underlying block size in units of 512 bytes imposed on the lower layer;
 * 	    optional, if not supplied, retrieve logical block size from underlying device
 */
static int ebs_ctr(struct dm_target *ti, unsigned int argc, char **argv)
{
	int r;
	unsigned short tmp1;
	unsigned long long tmp;
	char dummy;
	struct ebs_c *ec;

	if (argc < 3 || argc > 4) {
		ti->error = "Invalid argument count";
		return -EINVAL;
	}

	ec = ti->private = kzalloc(sizeof(*ec), GFP_KERNEL);
	if (!ec) {
		ti->error = "Cannot allocate ebs context";
		return -ENOMEM;
	}

	r = -EINVAL;
	if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1 ||
	    tmp != (sector_t)tmp ||
	    (sector_t)tmp >= ti->len) {
		ti->error = "Invalid device offset sector";
		goto bad;
	}
	ec->start = tmp;

	if (sscanf(argv[2], "%hu%c", &tmp1, &dummy) != 1 ||
	    !__ebs_check_bs(tmp1) ||
	    to_bytes(tmp1) > PAGE_SIZE) {
		ti->error = "Invalid emulated block size";
		goto bad;
	}
	ec->e_bs = tmp1;

	if (argc > 3) {
		if (sscanf(argv[3], "%hu%c", &tmp1, &dummy) != 1 || !__ebs_check_bs(tmp1)) {
			ti->error = "Invalid underlying block size";
			goto bad;
		}
		ec->u_bs = tmp1;
		ec->u_bs_set = true;
	} else
		ec->u_bs_set = false;

	r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ec->dev);
	if (r) {
		ti->error = "Device lookup failed";
		ec->dev = NULL;
		goto bad;
	}

	r = -EINVAL;
	if (!ec->u_bs_set) {
		ec->u_bs = to_sector(bdev_logical_block_size(ec->dev->bdev));
		if (!__ebs_check_bs(ec->u_bs)) {
			ti->error = "Invalid retrieved underlying block size";
			goto bad;
		}
	}

	if (!ec->u_bs_set && ec->e_bs == ec->u_bs)
		DMINFO("Emulation superfluous: emulated equal to underlying block size");

	if (__block_mod(ec->start, ec->u_bs)) {
		ti->error = "Device offset must be multiple of underlying block size";
		goto bad;
	}

	ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1,
					   0, NULL, NULL, 0);
	if (IS_ERR(ec->bufio)) {
		ti->error = "Cannot create dm bufio client";
		r = PTR_ERR(ec->bufio);
		ec->bufio = NULL;
		goto bad;
	}

	ec->wq = alloc_ordered_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM);
	if (!ec->wq) {
		ti->error = "Cannot create dm-" DM_MSG_PREFIX " workqueue";
		r = -ENOMEM;
		goto bad;
	}

	ec->block_shift = __ffs(ec->u_bs);
	INIT_WORK(&ec->ws, &__ebs_process_bios);
	bio_list_init(&ec->bios_in);
	spin_lock_init(&ec->lock);

	ti->num_flush_bios = 1;
	ti->num_discard_bios = 1;
	ti->num_secure_erase_bios = 0;
	ti->num_write_zeroes_bios = 0;
	return 0;
bad:
	ebs_dtr(ti);
	return r;
}

static void ebs_dtr(struct dm_target *ti)
{
	struct ebs_c *ec = ti->private;

	if (ec->wq)
		destroy_workqueue(ec->wq);
	if (ec->bufio)
		dm_bufio_client_destroy(ec->bufio);
	if (ec->dev)
		dm_put_device(ti, ec->dev);
	kfree(ec);
}

static int ebs_map(struct dm_target *ti, struct bio *bio)
{
	struct ebs_c *ec = ti->private;

	bio_set_dev(bio, ec->dev->bdev);
	bio->bi_iter.bi_sector = ec->start + dm_target_offset(ti, bio->bi_iter.bi_sector);

	if (unlikely(bio_op(bio) == REQ_OP_FLUSH))
		return DM_MAPIO_REMAPPED;
	/*
	 * Only queue for bufio processing in case of partial or overlapping buffers
	 * -or-
	 * emulation with ebs == ubs aiming for tests of dm-bufio overhead.
	 */
	if (likely(__block_mod(bio->bi_iter.bi_sector, ec->u_bs) ||
		   __block_mod(bio_end_sector(bio), ec->u_bs) ||
		   ec->e_bs == ec->u_bs)) {
		spin_lock_irq(&ec->lock);
		bio_list_add(&ec->bios_in, bio);
		spin_unlock_irq(&ec->lock);

		queue_work(ec->wq, &ec->ws);

		return DM_MAPIO_SUBMITTED;
	}

	/* Forget any buffer content relative to this direct backing device I/O. */
	__ebs_forget_bio(ec, bio);

	return DM_MAPIO_REMAPPED;
}

static void ebs_status(struct dm_target *ti, status_type_t type,
		       unsigned status_flags, char *result, unsigned maxlen)
{
	struct ebs_c *ec = ti->private;

	switch (type) {
	case STATUSTYPE_INFO:
		*result = '\0';
		break;
	case STATUSTYPE_TABLE:
		snprintf(result, maxlen, ec->u_bs_set ? "%s %llu %u %u" : "%s %llu %u",
			 ec->dev->name, (unsigned long long) ec->start, ec->e_bs, ec->u_bs);
		break;
	case STATUSTYPE_IMA:
		*result = '\0';
		break;
	}
}

static int ebs_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
{
	struct ebs_c *ec = ti->private;
	struct dm_dev *dev = ec->dev;

	/*
	 * Only pass ioctls through if the device sizes match exactly.
	 */
	*bdev = dev->bdev;
	return !!(ec->start || ti->len != bdev_nr_sectors(dev->bdev));
}

static void ebs_io_hints(struct dm_target *ti, struct queue_limits *limits)
{
	struct ebs_c *ec = ti->private;

	limits->logical_block_size = to_bytes(ec->e_bs);
	limits->physical_block_size = to_bytes(ec->u_bs);
	limits->alignment_offset = limits->physical_block_size;
	blk_limits_io_min(limits, limits->logical_block_size);
}

static int ebs_iterate_devices(struct dm_target *ti,
				  iterate_devices_callout_fn fn, void *data)
{
	struct ebs_c *ec = ti->private;

	return fn(ti, ec->dev, ec->start, ti->len, data);
}

static struct target_type ebs_target = {
	.name		 = "ebs",
	.version	 = {1, 0, 1},
	.features	 = DM_TARGET_PASSES_INTEGRITY,
	.module		 = THIS_MODULE,
	.ctr		 = ebs_ctr,
	.dtr		 = ebs_dtr,
	.map		 = ebs_map,
	.status		 = ebs_status,
	.io_hints	 = ebs_io_hints,
	.prepare_ioctl	 = ebs_prepare_ioctl,
	.iterate_devices = ebs_iterate_devices,
};

static int __init dm_ebs_init(void)
{
	int r = dm_register_target(&ebs_target);

	if (r < 0)
		DMERR("register failed %d", r);

	return r;
}

static void dm_ebs_exit(void)
{
	dm_unregister_target(&ebs_target);
}

module_init(dm_ebs_init);
module_exit(dm_ebs_exit);

MODULE_AUTHOR("Heinz Mauelshagen <dm-devel@redhat.com>");
MODULE_DESCRIPTION(DM_NAME " emulated block size target");
MODULE_LICENSE("GPL");
Commit	Line	Data
d3c7b35c HM	1	/*
	2	* Copyright (C) 2020 Red Hat GmbH
	3	*
	4	* This file is released under the GPL.
	5	*
	6	* Device-mapper target to emulate smaller logical block
	7	* size on backing devices exposing (natively) larger ones.
	8	*
	9	* E.g. 512 byte sector emulation on 4K native disks.
	10	*/
	11
	12	#include "dm.h"
	13	#include <linux/module.h>
	14	#include <linux/workqueue.h>
	15	#include <linux/dm-bufio.h>
	16
	17	#define DM_MSG_PREFIX "ebs"
	18
	19	static void ebs_dtr(struct dm_target *ti);
	20
	21	/* Emulated block size context. */
	22	struct ebs_c {
	23	struct dm_dev dev; / Underlying device to emulate block size on. */
	24	struct dm_bufio_client bufio; / Use dm-bufio for read and read-modify-write processing. */
	25	struct workqueue_struct wq; / Workqueue for ^ processing of bios. */
	26	struct work_struct ws; /* Work item used for ^. */
	27	struct bio_list bios_in; /* Worker bios input list. */
	28	spinlock_t lock; /* Guard bios input list above. */
	29	sector_t start; /* <start> table line argument, see ebs_ctr below. */
	30	unsigned int e_bs; /* Emulated block size in sectors exposed to upper layer. */
1c72e023	31	unsigned int u_bs; /* Underlying block size in sectors retrieved from/set on lower layer device. */
d3c7b35c HM	32	unsigned char block_shift; /* bitshift sectors -> blocks used in dm-bufio API. */
	33	bool u_bs_set:1; /* Flag to indicate underlying block size is set on table line. */
	34	};
	35
	36	static inline sector_t __sector_to_block(struct ebs_c *ec, sector_t sector)
	37	{
	38	return sector >> ec->block_shift;
	39	}
	40
	41	static inline sector_t __block_mod(sector_t sector, unsigned int bs)
	42	{
	43	return sector & (bs - 1);
	44	}
	45
1c72e023	46	/* Return number of blocks for a bio, accounting for misalignment of start and end sectors. */
d3c7b35c HM	47	static inline unsigned int __nr_blocks(struct ebs_c ec, struct bio bio)
	48	{
	49	sector_t end_sector = __block_mod(bio->bi_iter.bi_sector, ec->u_bs) + bio_sectors(bio);
	50
	51	return __sector_to_block(ec, end_sector) + (__block_mod(end_sector, ec->u_bs) ? 1 : 0);
	52	}
	53
	54	static inline bool __ebs_check_bs(unsigned int bs)
	55	{
	56	return bs && is_power_of_2(bs);
	57	}
	58
	59	/*
	60	* READ/WRITE:
	61	*
	62	* copy blocks between bufio blocks and bio vector's (partial/overlapping) pages.
	63	*/
67a7b9a5 BVA	64	static int __ebs_rw_bvec(struct ebs_c ec, enum req_op op, struct bio_vec bv,
67a7b9a5 BVA	65	struct bvec_iter *iter)
d3c7b35c HM	66	{
	67	int r = 0;
	68	unsigned char ba, pa;
	69	unsigned int cur_len;
	70	unsigned int bv_len = bv->bv_len;
	71	unsigned int buf_off = to_bytes(__block_mod(iter->bi_sector, ec->u_bs));
	72	sector_t block = __sector_to_block(ec, iter->bi_sector);
	73	struct dm_buffer *b;
	74
	75	if (unlikely(!bv->bv_page \|\| !bv_len))
	76	return -EIO;
	77
3a8ba33b	78	pa = bvec_virt(bv);
d3c7b35c HM	79
	80	/* Handle overlapping page <-> blocks */
	81	while (bv_len) {
	82	cur_len = min(dm_bufio_get_block_size(ec->bufio) - buf_off, bv_len);
	83
	84	/* Avoid reading for writes in case bio vector's page overwrites block completely. */
67a7b9a5	85	if (op == REQ_OP_READ \|\| buf_off \|\| bv_len < dm_bufio_get_block_size(ec->bufio))
d3c7b35c HM	86	ba = dm_bufio_read(ec->bufio, block, &b);
	87	else
	88	ba = dm_bufio_new(ec->bufio, block, &b);
	89
52252ade	90	if (IS_ERR(ba)) {
d3c7b35c HM	91	/*
	92	* Carry on with next buffer, if any, to issue all possible
	93	* data but return error.
	94	*/
	95	r = PTR_ERR(ba);
	96	} else {
	97	/* Copy data to/from bio to buffer if read/new was successful above. */
	98	ba += buf_off;
67a7b9a5	99	if (op == REQ_OP_READ) {
d3c7b35c HM	100	memcpy(pa, ba, cur_len);
	101	flush_dcache_page(bv->bv_page);
	102	} else {
	103	flush_dcache_page(bv->bv_page);
	104	memcpy(ba, pa, cur_len);
	105	dm_bufio_mark_partial_buffer_dirty(b, buf_off, buf_off + cur_len);
	106	}
	107
	108	dm_bufio_release(b);
	109	}
	110
	111	pa += cur_len;
	112	bv_len -= cur_len;
	113	buf_off = 0;
	114	block++;
	115	}
	116
	117	return r;
	118	}
	119
	120	/* READ/WRITE: iterate bio vector's copying between (partial) pages and bufio blocks. */
67a7b9a5	121	static int __ebs_rw_bio(struct ebs_c ec, enum req_op op, struct bio bio)
d3c7b35c HM	122	{
	123	int r = 0, rr;
	124	struct bio_vec bv;
	125	struct bvec_iter iter;
	126
	127	bio_for_each_bvec(bv, bio, iter) {
67a7b9a5	128	rr = __ebs_rw_bvec(ec, op, &bv, &iter);
d3c7b35c HM	129	if (rr)
	130	r = rr;
	131	}
	132
	133	return r;
	134	}
	135
a5089a95 HM	136	/*
	137	* Discard bio's blocks, i.e. pass discards down.
	138	*
	139	* Avoid discarding partial blocks at beginning and end;
	140	* return 0 in case no blocks can be discarded as a result.
	141	*/
	142	static int __ebs_discard_bio(struct ebs_c ec, struct bio bio)
	143	{
	144	sector_t block, blocks, sector = bio->bi_iter.bi_sector;
	145
	146	block = __sector_to_block(ec, sector);
	147	blocks = __nr_blocks(ec, bio);
	148
	149	/*
	150	* Partial first underlying block (__nr_blocks() may have
	151	* resulted in one block).
	152	*/
	153	if (__block_mod(sector, ec->u_bs)) {
	154	block++;
	155	blocks--;
	156	}
	157
	158	/* Partial last underlying block if any. */
	159	if (blocks && __block_mod(bio_end_sector(bio), ec->u_bs))
	160	blocks--;
	161
	162	return blocks ? dm_bufio_issue_discard(ec->bufio, block, blocks) : 0;
	163	}
	164
	165	/* Release blocks them from the bufio cache. */
	166	static void __ebs_forget_bio(struct ebs_c ec, struct bio bio)
d3c7b35c HM	167	{
	168	sector_t blocks, sector = bio->bi_iter.bi_sector;
	169
	170	blocks = __nr_blocks(ec, bio);
334b4fc1 MP	171
334b4fc1 MP	172	dm_bufio_forget_buffers(ec->bufio, __sector_to_block(ec, sector), blocks);
d3c7b35c HM	173	}
d3c7b35c HM	174
1c72e023	175	/* Worker function to process incoming bios. */
d3c7b35c HM	176	static void __ebs_process_bios(struct work_struct *ws)
	177	{
	178	int r;
	179	bool write = false;
	180	sector_t block1, block2;
	181	struct ebs_c *ec = container_of(ws, struct ebs_c, ws);
	182	struct bio *bio;
	183	struct bio_list bios;
	184
	185	bio_list_init(&bios);
	186
	187	spin_lock_irq(&ec->lock);
	188	bios = ec->bios_in;
	189	bio_list_init(&ec->bios_in);
	190	spin_unlock_irq(&ec->lock);
	191
	192	/* Prefetch all read and any mis-aligned write buffers */
	193	bio_list_for_each(bio, &bios) {
	194	block1 = __sector_to_block(ec, bio->bi_iter.bi_sector);
	195	if (bio_op(bio) == REQ_OP_READ)
	196	dm_bufio_prefetch(ec->bufio, block1, __nr_blocks(ec, bio));
	197	else if (bio_op(bio) == REQ_OP_WRITE && !(bio->bi_opf & REQ_PREFLUSH)) {
	198	block2 = __sector_to_block(ec, bio_end_sector(bio));
	199	if (__block_mod(bio->bi_iter.bi_sector, ec->u_bs))
	200	dm_bufio_prefetch(ec->bufio, block1, 1);
	201	if (__block_mod(bio_end_sector(bio), ec->u_bs) && block2 != block1)
	202	dm_bufio_prefetch(ec->bufio, block2, 1);
	203	}
	204	}
	205
	206	bio_list_for_each(bio, &bios) {
	207	r = -EIO;
	208	if (bio_op(bio) == REQ_OP_READ)
67a7b9a5	209	r = __ebs_rw_bio(ec, REQ_OP_READ, bio);
d3c7b35c HM	210	else if (bio_op(bio) == REQ_OP_WRITE) {
d3c7b35c HM	211	write = true;
67a7b9a5	212	r = __ebs_rw_bio(ec, REQ_OP_WRITE, bio);
d3c7b35c	213	} else if (bio_op(bio) == REQ_OP_DISCARD) {
a5089a95 HM	214	__ebs_forget_bio(ec, bio);
a5089a95 HM	215	r = __ebs_discard_bio(ec, bio);
d3c7b35c HM	216	}
	217
	218	if (r < 0)
	219	bio->bi_status = errno_to_blk_status(r);
	220	}
	221
	222	/*
	223	* We write dirty buffers after processing I/O on them
	224	* but before we endio thus addressing REQ_FUA/REQ_SYNC.
	225	*/
	226	r = write ? dm_bufio_write_dirty_buffers(ec->bufio) : 0;
	227
	228	while ((bio = bio_list_pop(&bios))) {
	229	/* Any other request is endioed. */
	230	if (unlikely(r && bio_op(bio) == REQ_OP_WRITE))
	231	bio_io_error(bio);
	232	else
	233	bio_endio(bio);
	234	}
	235	}
	236
	237	/*
	238	* Construct an emulated block size mapping: <dev_path> <offset> <ebs> [<ubs>]
	239	*
	240	* <dev_path>: path of the underlying device
	241	* <offset>: offset in 512 bytes sectors into <dev_path>
	242	* <ebs>: emulated block size in units of 512 bytes exposed to the upper layer
	243	* [<ubs>]: underlying block size in units of 512 bytes imposed on the lower layer;
	244	* optional, if not supplied, retrieve logical block size from underlying device
	245	*/
	246	static int ebs_ctr(struct dm_target ti, unsigned int argc, char *argv)
	247	{
	248	int r;
	249	unsigned short tmp1;
	250	unsigned long long tmp;
	251	char dummy;
	252	struct ebs_c *ec;
	253
	254	if (argc < 3 \|\| argc > 4) {
	255	ti->error = "Invalid argument count";
	256	return -EINVAL;
	257	}
	258
	259	ec = ti->private = kzalloc(sizeof(*ec), GFP_KERNEL);
	260	if (!ec) {
	261	ti->error = "Cannot allocate ebs context";
	262	return -ENOMEM;
	263	}
	264
	265	r = -EINVAL;
	266	if (sscanf(argv[1], "%llu%c", &tmp, &dummy) != 1 \|\|
	267	tmp != (sector_t)tmp \|\|
	268	(sector_t)tmp >= ti->len) {
	269	ti->error = "Invalid device offset sector";
	270	goto bad;
	271	}
	272	ec->start = tmp;
	273
	274	if (sscanf(argv[2], "%hu%c", &tmp1, &dummy) != 1 \|\|
	275	!__ebs_check_bs(tmp1) \|\|
	276	to_bytes(tmp1) > PAGE_SIZE) {
	277	ti->error = "Invalid emulated block size";
	278	goto bad;
	279	}
280	ec->e_bs = tmp1;
281
282	if (argc > 3) {
283	if (sscanf(argv[3], "%hu%c", &tmp1, &dummy) != 1 \|\| !__ebs_check_bs(tmp1)) {
284	ti->error = "Invalid underlying block size";
285	goto bad;
286	}
287	ec->u_bs = tmp1;
288	ec->u_bs_set = true;
289	} else
290	ec->u_bs_set = false;
291
292	r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &ec->dev);
293	if (r) {
294	ti->error = "Device lookup failed";
295	ec->dev = NULL;
296	goto bad;
297	}
298
299	r = -EINVAL;
300	if (!ec->u_bs_set) {
301	ec->u_bs = to_sector(bdev_logical_block_size(ec->dev->bdev));
302	if (!__ebs_check_bs(ec->u_bs)) {
303	ti->error = "Invalid retrieved underlying block size";
304	goto bad;
305	}
306	}
307
308	if (!ec->u_bs_set && ec->e_bs == ec->u_bs)
309	DMINFO("Emulation superfluous: emulated equal to underlying block size");
310
311	if (__block_mod(ec->start, ec->u_bs)) {
312	ti->error = "Device offset must be multiple of underlying block size";
313	goto bad;
314	}
315
0fcb100d NH	316	ec->bufio = dm_bufio_client_create(ec->dev->bdev, to_bytes(ec->u_bs), 1,
0fcb100d NH	317	0, NULL, NULL, 0);
d3c7b35c HM	318	if (IS_ERR(ec->bufio)) {
	319	ti->error = "Cannot create dm bufio client";
	320	r = PTR_ERR(ec->bufio);
	321	ec->bufio = NULL;
	322	goto bad;
	323	}
	324
	325	ec->wq = alloc_ordered_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM);
	326	if (!ec->wq) {
	327	ti->error = "Cannot create dm-" DM_MSG_PREFIX " workqueue";
	328	r = -ENOMEM;
	329	goto bad;
	330	}
	331
	332	ec->block_shift = __ffs(ec->u_bs);
	333	INIT_WORK(&ec->ws, &__ebs_process_bios);
	334	bio_list_init(&ec->bios_in);
	335	spin_lock_init(&ec->lock);
	336
	337	ti->num_flush_bios = 1;
	338	ti->num_discard_bios = 1;
	339	ti->num_secure_erase_bios = 0;
d3c7b35c HM	340	ti->num_write_zeroes_bios = 0;
	341	return 0;
	342	bad:
	343	ebs_dtr(ti);
	344	return r;
	345	}
	346
	347	static void ebs_dtr(struct dm_target *ti)
	348	{
	349	struct ebs_c *ec = ti->private;
	350
	351	if (ec->wq)
	352	destroy_workqueue(ec->wq);
	353	if (ec->bufio)
	354	dm_bufio_client_destroy(ec->bufio);
	355	if (ec->dev)
	356	dm_put_device(ti, ec->dev);
	357	kfree(ec);
	358	}
	359
	360	static int ebs_map(struct dm_target ti, struct bio bio)
	361	{
	362	struct ebs_c *ec = ti->private;
	363
	364	bio_set_dev(bio, ec->dev->bdev);
	365	bio->bi_iter.bi_sector = ec->start + dm_target_offset(ti, bio->bi_iter.bi_sector);
	366
4cb6f226	367	if (unlikely(bio_op(bio) == REQ_OP_FLUSH))
d3c7b35c HM	368	return DM_MAPIO_REMAPPED;
	369	/*
	370	* Only queue for bufio processing in case of partial or overlapping buffers
	371	* -or-
	372	* emulation with ebs == ubs aiming for tests of dm-bufio overhead.
	373	*/
	374	if (likely(__block_mod(bio->bi_iter.bi_sector, ec->u_bs) \|\|
	375	__block_mod(bio_end_sector(bio), ec->u_bs) \|\|
	376	ec->e_bs == ec->u_bs)) {
	377	spin_lock_irq(&ec->lock);
	378	bio_list_add(&ec->bios_in, bio);
	379	spin_unlock_irq(&ec->lock);
	380
	381	queue_work(ec->wq, &ec->ws);
	382
	383	return DM_MAPIO_SUBMITTED;
	384	}
	385
	386	/* Forget any buffer content relative to this direct backing device I/O. */
	387	__ebs_forget_bio(ec, bio);
	388
	389	return DM_MAPIO_REMAPPED;
	390	}
	391
	392	static void ebs_status(struct dm_target *ti, status_type_t type,
	393	unsigned status_flags, char *result, unsigned maxlen)
	394	{
	395	struct ebs_c *ec = ti->private;
	396
	397	switch (type) {
	398	case STATUSTYPE_INFO:
	399	*result = '\0';
	400	break;
	401	case STATUSTYPE_TABLE:
	402	snprintf(result, maxlen, ec->u_bs_set ? "%s %llu %u %u" : "%s %llu %u",
	403	ec->dev->name, (unsigned long long) ec->start, ec->e_bs, ec->u_bs);
	404	break;
8ec45662 TS	405	case STATUSTYPE_IMA:
	406	*result = '\0';
	407	break;
d3c7b35c HM	408	}
	409	}
	410
	411	static int ebs_prepare_ioctl(struct dm_target ti, struct block_device *bdev)
	412	{
	413	struct ebs_c *ec = ti->private;
	414	struct dm_dev *dev = ec->dev;
	415
	416	/*
	417	* Only pass ioctls through if the device sizes match exactly.
	418	*/
	419	*bdev = dev->bdev;
6dcbb52c	420	return !!(ec->start \|\| ti->len != bdev_nr_sectors(dev->bdev));
d3c7b35c HM	421	}
	422
	423	static void ebs_io_hints(struct dm_target ti, struct queue_limits limits)
	424	{
	425	struct ebs_c *ec = ti->private;
	426
	427	limits->logical_block_size = to_bytes(ec->e_bs);
	428	limits->physical_block_size = to_bytes(ec->u_bs);
	429	limits->alignment_offset = limits->physical_block_size;
	430	blk_limits_io_min(limits, limits->logical_block_size);
	431	}
	432
	433	static int ebs_iterate_devices(struct dm_target *ti,
	434	iterate_devices_callout_fn fn, void *data)
	435	{
	436	struct ebs_c *ec = ti->private;
	437
	438	return fn(ti, ec->dev, ec->start, ti->len, data);
	439	}
	440
	441	static struct target_type ebs_target = {
	442	.name = "ebs",
a5089a95	443	.version = {1, 0, 1},
d3c7b35c HM	444	.features = DM_TARGET_PASSES_INTEGRITY,
	445	.module = THIS_MODULE,
	446	.ctr = ebs_ctr,
	447	.dtr = ebs_dtr,
	448	.map = ebs_map,
	449	.status = ebs_status,
	450	.io_hints = ebs_io_hints,
	451	.prepare_ioctl = ebs_prepare_ioctl,
	452	.iterate_devices = ebs_iterate_devices,
	453	};
	454
	455	static int __init dm_ebs_init(void)
	456	{
	457	int r = dm_register_target(&ebs_target);
	458
	459	if (r < 0)
	460	DMERR("register failed %d", r);
	461
	462	return r;
	463	}
	464
	465	static void dm_ebs_exit(void)
	466	{
	467	dm_unregister_target(&ebs_target);
	468	}
	469
	470	module_init(dm_ebs_init);
	471	module_exit(dm_ebs_exit);
	472
	473	MODULE_AUTHOR("Heinz Mauelshagen <dm-devel@redhat.com>");
	474	MODULE_DESCRIPTION(DM_NAME " emulated block size target");
	475	MODULE_LICENSE("GPL");