[mirror_ubuntu-zesty-kernel.git] / drivers / lightnvm / gennvm.c

/*
 * Copyright (C) 2015 Matias Bjorling <m@bjorling.me>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
 * USA.
 *
 * Implementation of a general nvm manager for Open-Channel SSDs.
 */

#include "gennvm.h"

static struct nvm_target *gen_find_target(struct gen_dev *gn, const char *name)
{
	struct nvm_target *tgt;

	list_for_each_entry(tgt, &gn->targets, list)
		if (!strcmp(name, tgt->disk->disk_name))
			return tgt;

	return NULL;
}

static const struct block_device_operations gen_fops = {
	.owner		= THIS_MODULE,
};

static int gen_reserve_luns(struct nvm_dev *dev, struct nvm_target *t,
			    int lun_begin, int lun_end)
{
	int i;

	for (i = lun_begin; i <= lun_end; i++) {
		if (test_and_set_bit(i, dev->lun_map)) {
			pr_err("nvm: lun %d already allocated\n", i);
			goto err;
		}
	}

	return 0;

err:
	while (--i > lun_begin)
		clear_bit(i, dev->lun_map);

	return -EBUSY;
}

static void gen_release_luns_err(struct nvm_dev *dev, int lun_begin,
				 int lun_end)
{
	int i;

	for (i = lun_begin; i <= lun_end; i++)
		WARN_ON(!test_and_clear_bit(i, dev->lun_map));
}

static void gen_remove_tgt_dev(struct nvm_tgt_dev *tgt_dev)
{
	struct nvm_dev *dev = tgt_dev->parent;
	struct gen_dev_map *dev_map = tgt_dev->map;
	int i, j;

	for (i = 0; i < dev_map->nr_chnls; i++) {
		struct gen_ch_map *ch_map = &dev_map->chnls[i];
		int *lun_offs = ch_map->lun_offs;
		int ch = i + ch_map->ch_off;

		for (j = 0; j < ch_map->nr_luns; j++) {
			int lun = j + lun_offs[j];
			int lunid = (ch * dev->geo.luns_per_chnl) + lun;

			WARN_ON(!test_and_clear_bit(lunid, dev->lun_map));
		}

		kfree(ch_map->lun_offs);
	}

	kfree(dev_map->chnls);
	kfree(dev_map);
	kfree(tgt_dev->luns);
	kfree(tgt_dev);
}

static struct nvm_tgt_dev *gen_create_tgt_dev(struct nvm_dev *dev,
					      int lun_begin, int lun_end)
{
	struct nvm_tgt_dev *tgt_dev = NULL;
	struct gen_dev_map *dev_rmap = dev->rmap;
	struct gen_dev_map *dev_map;
	struct ppa_addr *luns;
	int nr_luns = lun_end - lun_begin + 1;
	int luns_left = nr_luns;
	int nr_chnls = nr_luns / dev->geo.luns_per_chnl;
	int nr_chnls_mod = nr_luns % dev->geo.luns_per_chnl;
	int bch = lun_begin / dev->geo.luns_per_chnl;
	int blun = lun_begin % dev->geo.luns_per_chnl;
	int lunid = 0;
	int lun_balanced = 1;
	int prev_nr_luns;
	int i, j;

	nr_chnls = nr_luns / dev->geo.luns_per_chnl;
	nr_chnls = (nr_chnls_mod == 0) ? nr_chnls : nr_chnls + 1;

	dev_map = kmalloc(sizeof(struct gen_dev_map), GFP_KERNEL);
	if (!dev_map)
		goto err_dev;

	dev_map->chnls = kcalloc(nr_chnls, sizeof(struct gen_ch_map),
								GFP_KERNEL);
	if (!dev_map->chnls)
		goto err_chnls;

	luns = kcalloc(nr_luns, sizeof(struct ppa_addr), GFP_KERNEL);
	if (!luns)
		goto err_luns;

	prev_nr_luns = (luns_left > dev->geo.luns_per_chnl) ?
					dev->geo.luns_per_chnl : luns_left;
	for (i = 0; i < nr_chnls; i++) {
		struct gen_ch_map *ch_rmap = &dev_rmap->chnls[i + bch];
		int *lun_roffs = ch_rmap->lun_offs;
		struct gen_ch_map *ch_map = &dev_map->chnls[i];
		int *lun_offs;
		int luns_in_chnl = (luns_left > dev->geo.luns_per_chnl) ?
					dev->geo.luns_per_chnl : luns_left;

		if (lun_balanced && prev_nr_luns != luns_in_chnl)
			lun_balanced = 0;

		ch_map->ch_off = ch_rmap->ch_off = bch;
		ch_map->nr_luns = luns_in_chnl;

		lun_offs = kcalloc(luns_in_chnl, sizeof(int), GFP_KERNEL);
		if (!lun_offs)
			goto err_ch;

		for (j = 0; j < luns_in_chnl; j++) {
			luns[lunid].ppa = 0;
			luns[lunid].g.ch = i;
			luns[lunid++].g.lun = j;

			lun_offs[j] = blun;
			lun_roffs[j + blun] = blun;
		}

		ch_map->lun_offs = lun_offs;

		/* when starting a new channel, lun offset is reset */
		blun = 0;
		luns_left -= luns_in_chnl;
	}

	dev_map->nr_chnls = nr_chnls;

	tgt_dev = kmalloc(sizeof(struct nvm_tgt_dev), GFP_KERNEL);
	if (!tgt_dev)
		goto err_ch;

	memcpy(&tgt_dev->geo, &dev->geo, sizeof(struct nvm_geo));
	/* Target device only owns a portion of the physical device */
	tgt_dev->geo.nr_chnls = nr_chnls;
	tgt_dev->geo.nr_luns = nr_luns;
	tgt_dev->geo.luns_per_chnl = (lun_balanced) ? prev_nr_luns : -1;
	tgt_dev->total_secs = nr_luns * tgt_dev->geo.sec_per_lun;
	tgt_dev->q = dev->q;
	tgt_dev->map = dev_map;
	tgt_dev->luns = luns;
	memcpy(&tgt_dev->identity, &dev->identity, sizeof(struct nvm_id));

	tgt_dev->parent = dev;

	return tgt_dev;
err_ch:
	while (--i > 0)
		kfree(dev_map->chnls[i].lun_offs);
	kfree(luns);
err_luns:
	kfree(dev_map->chnls);
err_chnls:
	kfree(dev_map);
err_dev:
	return tgt_dev;
}

static int gen_create_tgt(struct nvm_dev *dev, struct nvm_ioctl_create *create)
{
	struct gen_dev *gn = dev->mp;
	struct nvm_ioctl_create_simple *s = &create->conf.s;
	struct request_queue *tqueue;
	struct gendisk *tdisk;
	struct nvm_tgt_type *tt;
	struct nvm_target *t;
	struct nvm_tgt_dev *tgt_dev;
	void *targetdata;

	tt = nvm_find_target_type(create->tgttype, 1);
	if (!tt) {
		pr_err("nvm: target type %s not found\n", create->tgttype);
		return -EINVAL;
	}

	mutex_lock(&gn->lock);
	t = gen_find_target(gn, create->tgtname);
	if (t) {
		pr_err("nvm: target name already exists.\n");
		mutex_unlock(&gn->lock);
		return -EINVAL;
	}
	mutex_unlock(&gn->lock);

	t = kmalloc(sizeof(struct nvm_target), GFP_KERNEL);
	if (!t)
		return -ENOMEM;

	if (gen_reserve_luns(dev, t, s->lun_begin, s->lun_end))
		goto err_t;

	tgt_dev = gen_create_tgt_dev(dev, s->lun_begin, s->lun_end);
	if (!tgt_dev) {
		pr_err("nvm: could not create target device\n");
		goto err_reserve;
	}

	tqueue = blk_alloc_queue_node(GFP_KERNEL, dev->q->node);
	if (!tqueue)
		goto err_dev;
	blk_queue_make_request(tqueue, tt->make_rq);

	tdisk = alloc_disk(0);
	if (!tdisk)
		goto err_queue;

	sprintf(tdisk->disk_name, "%s", create->tgtname);
	tdisk->flags = GENHD_FL_EXT_DEVT;
	tdisk->major = 0;
	tdisk->first_minor = 0;
	tdisk->fops = &gen_fops;
	tdisk->queue = tqueue;

	targetdata = tt->init(tgt_dev, tdisk);
	if (IS_ERR(targetdata))
		goto err_init;

	tdisk->private_data = targetdata;
	tqueue->queuedata = targetdata;

	blk_queue_max_hw_sectors(tqueue, 8 * dev->ops->max_phys_sect);

	set_capacity(tdisk, tt->capacity(targetdata));
	add_disk(tdisk);

	t->type = tt;
	t->disk = tdisk;
	t->dev = tgt_dev;

	mutex_lock(&gn->lock);
	list_add_tail(&t->list, &gn->targets);
	mutex_unlock(&gn->lock);

	return 0;
err_init:
	put_disk(tdisk);
err_queue:
	blk_cleanup_queue(tqueue);
err_dev:
	kfree(tgt_dev);
err_reserve:
	gen_release_luns_err(dev, s->lun_begin, s->lun_end);
err_t:
	kfree(t);
	return -ENOMEM;
}

static void __gen_remove_target(struct nvm_target *t)
{
	struct nvm_tgt_type *tt = t->type;
	struct gendisk *tdisk = t->disk;
	struct request_queue *q = tdisk->queue;

	del_gendisk(tdisk);
	blk_cleanup_queue(q);

	if (tt->exit)
		tt->exit(tdisk->private_data);

	gen_remove_tgt_dev(t->dev);
	put_disk(tdisk);

	list_del(&t->list);
	kfree(t);
}

/**
 * gen_remove_tgt - Removes a target from the media manager
 * @dev:	device
 * @remove:	ioctl structure with target name to remove.
 *
 * Returns:
 * 0: on success
 * 1: on not found
 * <0: on error
 */
static int gen_remove_tgt(struct nvm_dev *dev, struct nvm_ioctl_remove *remove)
{
	struct gen_dev *gn = dev->mp;
	struct nvm_target *t;

	if (!gn)
		return 1;

	mutex_lock(&gn->lock);
	t = gen_find_target(gn, remove->tgtname);
	if (!t) {
		mutex_unlock(&gn->lock);
		return 1;
	}
	__gen_remove_target(t);
	mutex_unlock(&gn->lock);

	return 0;
}

static int gen_get_area(struct nvm_dev *dev, sector_t *lba, sector_t len)
{
	struct nvm_geo *geo = &dev->geo;
	struct gen_dev *gn = dev->mp;
	struct gen_area *area, *prev, *next;
	sector_t begin = 0;
	sector_t max_sectors = (geo->sec_size * dev->total_secs) >> 9;

	if (len > max_sectors)
		return -EINVAL;

	area = kmalloc(sizeof(struct gen_area), GFP_KERNEL);
	if (!area)
		return -ENOMEM;

	prev = NULL;

	spin_lock(&dev->lock);
	list_for_each_entry(next, &gn->area_list, list) {
		if (begin + len > next->begin) {
			begin = next->end;
			prev = next;
			continue;
		}
		break;
	}

	if ((begin + len) > max_sectors) {
		spin_unlock(&dev->lock);
		kfree(area);
		return -EINVAL;
	}

	area->begin = *lba = begin;
	area->end = begin + len;

	if (prev) /* insert into sorted order */
		list_add(&area->list, &prev->list);
	else
		list_add(&area->list, &gn->area_list);
	spin_unlock(&dev->lock);

	return 0;
}

static void gen_put_area(struct nvm_dev *dev, sector_t begin)
{
	struct gen_dev *gn = dev->mp;
	struct gen_area *area;

	spin_lock(&dev->lock);
	list_for_each_entry(area, &gn->area_list, list) {
		if (area->begin != begin)
			continue;

		list_del(&area->list);
		spin_unlock(&dev->lock);
		kfree(area);
		return;
	}
	spin_unlock(&dev->lock);
}

static void gen_free(struct nvm_dev *dev)
{
	kfree(dev->mp);
	kfree(dev->rmap);
	dev->mp = NULL;
}

static int gen_register(struct nvm_dev *dev)
{
	struct gen_dev *gn;
	struct gen_dev_map *dev_rmap;
	int i, j;

	if (!try_module_get(THIS_MODULE))
		return -ENODEV;

	gn = kzalloc(sizeof(struct gen_dev), GFP_KERNEL);
	if (!gn)
		goto err_gn;

	dev_rmap = kmalloc(sizeof(struct gen_dev_map), GFP_KERNEL);
	if (!dev_rmap)
		goto err_rmap;

	dev_rmap->chnls = kcalloc(dev->geo.nr_chnls, sizeof(struct gen_ch_map),
								GFP_KERNEL);
	if (!dev_rmap->chnls)
		goto err_chnls;

	for (i = 0; i < dev->geo.nr_chnls; i++) {
		struct gen_ch_map *ch_rmap;
		int *lun_roffs;
		int luns_in_chnl = dev->geo.luns_per_chnl;

		ch_rmap = &dev_rmap->chnls[i];

		ch_rmap->ch_off = -1;
		ch_rmap->nr_luns = luns_in_chnl;

		lun_roffs = kcalloc(luns_in_chnl, sizeof(int), GFP_KERNEL);
		if (!lun_roffs)
			goto err_ch;

		for (j = 0; j < luns_in_chnl; j++)
			lun_roffs[j] = -1;

		ch_rmap->lun_offs = lun_roffs;
	}

	gn->dev = dev;
	gn->nr_luns = dev->geo.nr_luns;
	INIT_LIST_HEAD(&gn->area_list);
	mutex_init(&gn->lock);
	INIT_LIST_HEAD(&gn->targets);
	dev->mp = gn;
	dev->rmap = dev_rmap;

	return 1;
err_ch:
	while (--i >= 0)
		kfree(dev_rmap->chnls[i].lun_offs);
err_chnls:
	kfree(dev_rmap);
err_rmap:
	gen_free(dev);
err_gn:
	module_put(THIS_MODULE);
	return -ENOMEM;
}

static void gen_unregister(struct nvm_dev *dev)
{
	struct gen_dev *gn = dev->mp;
	struct nvm_target *t, *tmp;

	mutex_lock(&gn->lock);
	list_for_each_entry_safe(t, tmp, &gn->targets, list) {
		if (t->dev->parent != dev)
			continue;
		__gen_remove_target(t);
	}
	mutex_unlock(&gn->lock);

	gen_free(dev);
	module_put(THIS_MODULE);
}

static int gen_map_to_dev(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *p)
{
	struct gen_dev_map *dev_map = tgt_dev->map;
	struct gen_ch_map *ch_map = &dev_map->chnls[p->g.ch];
	int lun_off = ch_map->lun_offs[p->g.lun];
	struct nvm_dev *dev = tgt_dev->parent;
	struct gen_dev_map *dev_rmap = dev->rmap;
	struct gen_ch_map *ch_rmap;
	int lun_roff;

	p->g.ch += ch_map->ch_off;
	p->g.lun += lun_off;

	ch_rmap = &dev_rmap->chnls[p->g.ch];
	lun_roff = ch_rmap->lun_offs[p->g.lun];

	if (unlikely(ch_rmap->ch_off < 0 || lun_roff < 0)) {
		pr_err("nvm: corrupted device partition table\n");
		return -EINVAL;
	}

	return 0;
}

static int gen_map_to_tgt(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *p)
{
	struct nvm_dev *dev = tgt_dev->parent;
	struct gen_dev_map *dev_rmap = dev->rmap;
	struct gen_ch_map *ch_rmap = &dev_rmap->chnls[p->g.ch];
	int lun_roff = ch_rmap->lun_offs[p->g.lun];

	p->g.ch -= ch_rmap->ch_off;
	p->g.lun -= lun_roff;

	return 0;
}

static int gen_trans_rq(struct nvm_tgt_dev *tgt_dev, struct nvm_rq *rqd,
			int flag)
{
	gen_trans_fn *f;
	int i;
	int ret = 0;

	f = (flag == TRANS_TGT_TO_DEV) ? gen_map_to_dev : gen_map_to_tgt;

	if (rqd->nr_ppas == 1)
		return f(tgt_dev, &rqd->ppa_addr);

	for (i = 0; i < rqd->nr_ppas; i++) {
		ret = f(tgt_dev, &rqd->ppa_list[i]);
		if (ret)
			goto out;
	}

out:
	return ret;
}

static void gen_end_io(struct nvm_rq *rqd)
{
	struct nvm_tgt_dev *tgt_dev = rqd->dev;
	struct nvm_tgt_instance *ins = rqd->ins;

	/* Convert address space */
	if (tgt_dev)
		gen_trans_rq(tgt_dev, rqd, TRANS_DEV_TO_TGT);

	ins->tt->end_io(rqd);
}

static int gen_submit_io(struct nvm_tgt_dev *tgt_dev, struct nvm_rq *rqd)
{
	struct nvm_dev *dev = tgt_dev->parent;

	if (!dev->ops->submit_io)
		return -ENODEV;

	/* Convert address space */
	gen_trans_rq(tgt_dev, rqd, TRANS_TGT_TO_DEV);
	nvm_generic_to_addr_mode(dev, rqd);

	rqd->dev = tgt_dev;
	rqd->end_io = gen_end_io;
	return dev->ops->submit_io(dev, rqd);
}

static int gen_erase_blk(struct nvm_tgt_dev *tgt_dev, struct ppa_addr *p,
			 int flags)
{
	/* Convert address space */
	gen_map_to_dev(tgt_dev, p);

	return nvm_erase_ppa(tgt_dev->parent, p, 1, flags);
}

static struct ppa_addr gen_trans_ppa(struct nvm_tgt_dev *tgt_dev,
				     struct ppa_addr p, int direction)
{
	gen_trans_fn *f;
	struct ppa_addr ppa = p;

	f = (direction == TRANS_TGT_TO_DEV) ? gen_map_to_dev : gen_map_to_tgt;
	f(tgt_dev, &ppa);

	return ppa;
}

static void gen_part_to_tgt(struct nvm_dev *dev, sector_t *entries,
			       int len)
{
	struct nvm_geo *geo = &dev->geo;
	struct gen_dev_map *dev_rmap = dev->rmap;
	u64 i;

	for (i = 0; i < len; i++) {
		struct gen_ch_map *ch_rmap;
		int *lun_roffs;
		struct ppa_addr gaddr;
		u64 pba = le64_to_cpu(entries[i]);
		int off;
		u64 diff;

		if (!pba)
			continue;

		gaddr = linear_to_generic_addr(geo, pba);
		ch_rmap = &dev_rmap->chnls[gaddr.g.ch];
		lun_roffs = ch_rmap->lun_offs;

		off = gaddr.g.ch * geo->luns_per_chnl + gaddr.g.lun;

		diff = ((ch_rmap->ch_off * geo->luns_per_chnl) +
				(lun_roffs[gaddr.g.lun])) * geo->sec_per_lun;

		entries[i] -= cpu_to_le64(diff);
	}
}

static struct nvmm_type gen = {
	.name			= "gennvm",
	.version		= {0, 1, 0},

	.register_mgr		= gen_register,
	.unregister_mgr		= gen_unregister,

	.create_tgt		= gen_create_tgt,
	.remove_tgt		= gen_remove_tgt,

	.submit_io		= gen_submit_io,
	.erase_blk		= gen_erase_blk,

	.get_area		= gen_get_area,
	.put_area		= gen_put_area,

	.trans_ppa		= gen_trans_ppa,
	.part_to_tgt		= gen_part_to_tgt,
};

static int __init gen_module_init(void)
{
	return nvm_register_mgr(&gen);
}

static void gen_module_exit(void)
{
	nvm_unregister_mgr(&gen);
}

module_init(gen_module_init);
module_exit(gen_module_exit);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("General media manager for Open-Channel SSDs");
Commit	Line	Data
48add0f5 MB	1	/*
	2	* Copyright (C) 2015 Matias Bjorling <m@bjorling.me>
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License version
	6	* 2 as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; see the file COPYING. If not, write to
	15	* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
	16	* USA.
	17	*
5e60edb7	18	* Implementation of a general nvm manager for Open-Channel SSDs.
48add0f5 MB	19	*/
	20
	21	#include "gennvm.h"
	22
b76eb20b MB	23	static struct nvm_target gen_find_target(struct gen_dev gn, const char *name)
	24	{
	25	struct nvm_target *tgt;
	26
	27	list_for_each_entry(tgt, &gn->targets, list)
	28	if (!strcmp(name, tgt->disk->disk_name))
	29	return tgt;
	30
	31	return NULL;
	32	}
	33
	34	static const struct block_device_operations gen_fops = {
	35	.owner = THIS_MODULE,
	36	};
	37
8176117b JG	38	static int gen_reserve_luns(struct nvm_dev dev, struct nvm_target t,
	39	int lun_begin, int lun_end)
	40	{
8176117b JG	41	int i;
	42
	43	for (i = lun_begin; i <= lun_end; i++) {
	44	if (test_and_set_bit(i, dev->lun_map)) {
	45	pr_err("nvm: lun %d already allocated\n", i);
	46	goto err;
	47	}
8176117b JG	48	}
	49
	50	return 0;
	51
	52	err:
8e53624d	53	while (--i > lun_begin)
8176117b	54	clear_bit(i, dev->lun_map);
8176117b JG	55
	56	return -EBUSY;
	57	}
	58
8e53624d JG	59	static void gen_release_luns_err(struct nvm_dev *dev, int lun_begin,
8e53624d JG	60	int lun_end)
8176117b	61	{
8e53624d	62	int i;
8176117b	63
8e53624d JG	64	for (i = lun_begin; i <= lun_end; i++)
8e53624d JG	65	WARN_ON(!test_and_clear_bit(i, dev->lun_map));
8176117b JG	66	}
8176117b JG	67
8e79b5cb JG	68	static void gen_remove_tgt_dev(struct nvm_tgt_dev *tgt_dev)
8e79b5cb JG	69	{
8e53624d JG	70	struct nvm_dev *dev = tgt_dev->parent;
	71	struct gen_dev_map *dev_map = tgt_dev->map;
	72	int i, j;
	73
	74	for (i = 0; i < dev_map->nr_chnls; i++) {
	75	struct gen_ch_map *ch_map = &dev_map->chnls[i];
	76	int *lun_offs = ch_map->lun_offs;
	77	int ch = i + ch_map->ch_off;
	78
	79	for (j = 0; j < ch_map->nr_luns; j++) {
	80	int lun = j + lun_offs[j];
	81	int lunid = (ch * dev->geo.luns_per_chnl) + lun;
	82
	83	WARN_ON(!test_and_clear_bit(lunid, dev->lun_map));
	84	}
	85
	86	kfree(ch_map->lun_offs);
	87	}
	88
	89	kfree(dev_map->chnls);
	90	kfree(dev_map);
	91	kfree(tgt_dev->luns);
8e79b5cb JG	92	kfree(tgt_dev);
	93	}
	94
	95	static struct nvm_tgt_dev gen_create_tgt_dev(struct nvm_dev dev,
	96	int lun_begin, int lun_end)
	97	{
	98	struct nvm_tgt_dev *tgt_dev = NULL;
8e53624d JG	99	struct gen_dev_map *dev_rmap = dev->rmap;
	100	struct gen_dev_map *dev_map;
	101	struct ppa_addr *luns;
8e79b5cb	102	int nr_luns = lun_end - lun_begin + 1;
8e53624d JG	103	int luns_left = nr_luns;
	104	int nr_chnls = nr_luns / dev->geo.luns_per_chnl;
	105	int nr_chnls_mod = nr_luns % dev->geo.luns_per_chnl;
	106	int bch = lun_begin / dev->geo.luns_per_chnl;
	107	int blun = lun_begin % dev->geo.luns_per_chnl;
	108	int lunid = 0;
	109	int lun_balanced = 1;
	110	int prev_nr_luns;
	111	int i, j;
	112
	113	nr_chnls = nr_luns / dev->geo.luns_per_chnl;
	114	nr_chnls = (nr_chnls_mod == 0) ? nr_chnls : nr_chnls + 1;
	115
	116	dev_map = kmalloc(sizeof(struct gen_dev_map), GFP_KERNEL);
	117	if (!dev_map)
	118	goto err_dev;
	119
	120	dev_map->chnls = kcalloc(nr_chnls, sizeof(struct gen_ch_map),
	121	GFP_KERNEL);
	122	if (!dev_map->chnls)
	123	goto err_chnls;
	124
	125	luns = kcalloc(nr_luns, sizeof(struct ppa_addr), GFP_KERNEL);
	126	if (!luns)
	127	goto err_luns;
	128
	129	prev_nr_luns = (luns_left > dev->geo.luns_per_chnl) ?
	130	dev->geo.luns_per_chnl : luns_left;
	131	for (i = 0; i < nr_chnls; i++) {
	132	struct gen_ch_map *ch_rmap = &dev_rmap->chnls[i + bch];
	133	int *lun_roffs = ch_rmap->lun_offs;
	134	struct gen_ch_map *ch_map = &dev_map->chnls[i];
	135	int *lun_offs;
	136	int luns_in_chnl = (luns_left > dev->geo.luns_per_chnl) ?
	137	dev->geo.luns_per_chnl : luns_left;
	138
	139	if (lun_balanced && prev_nr_luns != luns_in_chnl)
	140	lun_balanced = 0;
	141
	142	ch_map->ch_off = ch_rmap->ch_off = bch;
	143	ch_map->nr_luns = luns_in_chnl;
	144
	145	lun_offs = kcalloc(luns_in_chnl, sizeof(int), GFP_KERNEL);
	146	if (!lun_offs)
	147	goto err_ch;
	148
	149	for (j = 0; j < luns_in_chnl; j++) {
	150	luns[lunid].ppa = 0;
	151	luns[lunid].g.ch = i;
	152	luns[lunid++].g.lun = j;
	153
	154	lun_offs[j] = blun;
	155	lun_roffs[j + blun] = blun;
	156	}
	157
	158	ch_map->lun_offs = lun_offs;
	159
	160	/* when starting a new channel, lun offset is reset */
	161	blun = 0;
	162	luns_left -= luns_in_chnl;
	163	}
	164
	165	dev_map->nr_chnls = nr_chnls;
8e79b5cb JG	166
	167	tgt_dev = kmalloc(sizeof(struct nvm_tgt_dev), GFP_KERNEL);
	168	if (!tgt_dev)
8e53624d	169	goto err_ch;
8e79b5cb JG	170
8e79b5cb JG	171	memcpy(&tgt_dev->geo, &dev->geo, sizeof(struct nvm_geo));
8e53624d JG	172	/* Target device only owns a portion of the physical device */
8e53624d JG	173	tgt_dev->geo.nr_chnls = nr_chnls;
8e79b5cb	174	tgt_dev->geo.nr_luns = nr_luns;
8e53624d	175	tgt_dev->geo.luns_per_chnl = (lun_balanced) ? prev_nr_luns : -1;
8e79b5cb JG	176	tgt_dev->total_secs = nr_luns * tgt_dev->geo.sec_per_lun;
8e79b5cb JG	177	tgt_dev->q = dev->q;
8e53624d JG	178	tgt_dev->map = dev_map;
8e53624d JG	179	tgt_dev->luns = luns;
8e79b5cb JG	180	memcpy(&tgt_dev->identity, &dev->identity, sizeof(struct nvm_id));
	181
	182	tgt_dev->parent = dev;
	183
8e53624d JG	184	return tgt_dev;
	185	err_ch:
	186	while (--i > 0)
	187	kfree(dev_map->chnls[i].lun_offs);
	188	kfree(luns);
	189	err_luns:
	190	kfree(dev_map->chnls);
	191	err_chnls:
	192	kfree(dev_map);
	193	err_dev:
8e79b5cb JG	194	return tgt_dev;
	195	}
	196
b76eb20b MB	197	static int gen_create_tgt(struct nvm_dev dev, struct nvm_ioctl_create create)
	198	{
	199	struct gen_dev *gn = dev->mp;
	200	struct nvm_ioctl_create_simple *s = &create->conf.s;
	201	struct request_queue *tqueue;
	202	struct gendisk *tdisk;
	203	struct nvm_tgt_type *tt;
	204	struct nvm_target *t;
8e79b5cb	205	struct nvm_tgt_dev *tgt_dev;
b76eb20b MB	206	void *targetdata;
	207
	208	tt = nvm_find_target_type(create->tgttype, 1);
	209	if (!tt) {
	210	pr_err("nvm: target type %s not found\n", create->tgttype);
	211	return -EINVAL;
	212	}
	213
	214	mutex_lock(&gn->lock);
	215	t = gen_find_target(gn, create->tgtname);
	216	if (t) {
	217	pr_err("nvm: target name already exists.\n");
	218	mutex_unlock(&gn->lock);
	219	return -EINVAL;
	220	}
	221	mutex_unlock(&gn->lock);
	222
	223	t = kmalloc(sizeof(struct nvm_target), GFP_KERNEL);
	224	if (!t)
	225	return -ENOMEM;
	226
8176117b JG	227	if (gen_reserve_luns(dev, t, s->lun_begin, s->lun_end))
	228	goto err_t;
	229
8e79b5cb	230	tgt_dev = gen_create_tgt_dev(dev, s->lun_begin, s->lun_end);
8e53624d JG	231	if (!tgt_dev) {
8e53624d JG	232	pr_err("nvm: could not create target device\n");
8e79b5cb	233	goto err_reserve;
8e53624d	234	}
8e79b5cb	235
b76eb20b MB	236	tqueue = blk_alloc_queue_node(GFP_KERNEL, dev->q->node);
b76eb20b MB	237	if (!tqueue)
8e79b5cb	238	goto err_dev;
b76eb20b MB	239	blk_queue_make_request(tqueue, tt->make_rq);
	240
	241	tdisk = alloc_disk(0);
	242	if (!tdisk)
	243	goto err_queue;
	244
	245	sprintf(tdisk->disk_name, "%s", create->tgtname);
	246	tdisk->flags = GENHD_FL_EXT_DEVT;
	247	tdisk->major = 0;
	248	tdisk->first_minor = 0;
	249	tdisk->fops = &gen_fops;
	250	tdisk->queue = tqueue;
	251
8e53624d	252	targetdata = tt->init(tgt_dev, tdisk);
b76eb20b MB	253	if (IS_ERR(targetdata))
	254	goto err_init;
	255
	256	tdisk->private_data = targetdata;
	257	tqueue->queuedata = targetdata;
	258
	259	blk_queue_max_hw_sectors(tqueue, 8 * dev->ops->max_phys_sect);
	260
	261	set_capacity(tdisk, tt->capacity(targetdata));
	262	add_disk(tdisk);
	263
	264	t->type = tt;
	265	t->disk = tdisk;
8e79b5cb	266	t->dev = tgt_dev;
b76eb20b MB	267
	268	mutex_lock(&gn->lock);
	269	list_add_tail(&t->list, &gn->targets);
	270	mutex_unlock(&gn->lock);
	271
	272	return 0;
	273	err_init:
	274	put_disk(tdisk);
	275	err_queue:
	276	blk_cleanup_queue(tqueue);
8e79b5cb JG	277	err_dev:
8e79b5cb JG	278	kfree(tgt_dev);
8176117b	279	err_reserve:
8e53624d	280	gen_release_luns_err(dev, s->lun_begin, s->lun_end);
b76eb20b MB	281	err_t:
	282	kfree(t);
	283	return -ENOMEM;
	284	}
	285
	286	static void __gen_remove_target(struct nvm_target *t)
	287	{
	288	struct nvm_tgt_type *tt = t->type;
	289	struct gendisk *tdisk = t->disk;
	290	struct request_queue *q = tdisk->queue;
	291
	292	del_gendisk(tdisk);
	293	blk_cleanup_queue(q);
	294
	295	if (tt->exit)
	296	tt->exit(tdisk->private_data);
	297
8e79b5cb	298	gen_remove_tgt_dev(t->dev);
b76eb20b MB	299	put_disk(tdisk);
	300
	301	list_del(&t->list);
	302	kfree(t);
	303	}
	304
	305	/**
	306	* gen_remove_tgt - Removes a target from the media manager
	307	* @dev: device
	308	* @remove: ioctl structure with target name to remove.
	309	*
	310	* Returns:
	311	* 0: on success
	312	* 1: on not found
	313	* <0: on error
	314	*/
	315	static int gen_remove_tgt(struct nvm_dev dev, struct nvm_ioctl_remove remove)
	316	{
	317	struct gen_dev *gn = dev->mp;
	318	struct nvm_target *t;
	319
	320	if (!gn)
	321	return 1;
	322
	323	mutex_lock(&gn->lock);
	324	t = gen_find_target(gn, remove->tgtname);
	325	if (!t) {
	326	mutex_unlock(&gn->lock);
	327	return 1;
	328	}
	329	__gen_remove_target(t);
	330	mutex_unlock(&gn->lock);
	331
	332	return 0;
	333	}
	334
5e60edb7	335	static int gen_get_area(struct nvm_dev dev, sector_t lba, sector_t len)
4c9dacb8	336	{
8e79b5cb	337	struct nvm_geo *geo = &dev->geo;
5e60edb7 MB	338	struct gen_dev *gn = dev->mp;
5e60edb7 MB	339	struct gen_area area, prev, *next;
4c9dacb8	340	sector_t begin = 0;
8e79b5cb	341	sector_t max_sectors = (geo->sec_size * dev->total_secs) >> 9;
4c9dacb8 WT	342
	343	if (len > max_sectors)
	344	return -EINVAL;
	345
5e60edb7	346	area = kmalloc(sizeof(struct gen_area), GFP_KERNEL);
4c9dacb8 WT	347	if (!area)
	348	return -ENOMEM;
	349
	350	prev = NULL;
	351
	352	spin_lock(&dev->lock);
	353	list_for_each_entry(next, &gn->area_list, list) {
	354	if (begin + len > next->begin) {
	355	begin = next->end;
	356	prev = next;
	357	continue;
	358	}
	359	break;
	360	}
	361
	362	if ((begin + len) > max_sectors) {
	363	spin_unlock(&dev->lock);
	364	kfree(area);
	365	return -EINVAL;
	366	}
	367
	368	area->begin = *lba = begin;
	369	area->end = begin + len;
	370
	371	if (prev) /* insert into sorted order */
	372	list_add(&area->list, &prev->list);
	373	else
	374	list_add(&area->list, &gn->area_list);
	375	spin_unlock(&dev->lock);
	376
	377	return 0;
	378	}
	379
5e60edb7	380	static void gen_put_area(struct nvm_dev *dev, sector_t begin)
4c9dacb8	381	{
5e60edb7 MB	382	struct gen_dev *gn = dev->mp;
5e60edb7 MB	383	struct gen_area *area;
4c9dacb8 WT	384
	385	spin_lock(&dev->lock);
	386	list_for_each_entry(area, &gn->area_list, list) {
	387	if (area->begin != begin)
	388	continue;
	389
	390	list_del(&area->list);
	391	spin_unlock(&dev->lock);
	392	kfree(area);
	393	return;
	394	}
	395	spin_unlock(&dev->lock);
	396	}
	397
5e60edb7	398	static void gen_free(struct nvm_dev *dev)
8261bd48	399	{
8261bd48	400	kfree(dev->mp);
8e53624d	401	kfree(dev->rmap);
8261bd48 WT	402	dev->mp = NULL;
	403	}
	404
5e60edb7	405	static int gen_register(struct nvm_dev *dev)
48add0f5	406	{
5e60edb7	407	struct gen_dev *gn;
8e53624d JG	408	struct gen_dev_map *dev_rmap;
8e53624d JG	409	int i, j;
48add0f5	410
008b7443 MB	411	if (!try_module_get(THIS_MODULE))
	412	return -ENODEV;
	413
5e60edb7	414	gn = kzalloc(sizeof(struct gen_dev), GFP_KERNEL);
48add0f5	415	if (!gn)
8e53624d JG	416	goto err_gn;
	417
	418	dev_rmap = kmalloc(sizeof(struct gen_dev_map), GFP_KERNEL);
	419	if (!dev_rmap)
	420	goto err_rmap;
	421
	422	dev_rmap->chnls = kcalloc(dev->geo.nr_chnls, sizeof(struct gen_ch_map),
	423	GFP_KERNEL);
	424	if (!dev_rmap->chnls)
	425	goto err_chnls;
	426
	427	for (i = 0; i < dev->geo.nr_chnls; i++) {
	428	struct gen_ch_map *ch_rmap;
	429	int *lun_roffs;
	430	int luns_in_chnl = dev->geo.luns_per_chnl;
	431
	432	ch_rmap = &dev_rmap->chnls[i];
	433
	434	ch_rmap->ch_off = -1;
	435	ch_rmap->nr_luns = luns_in_chnl;
	436
	437	lun_roffs = kcalloc(luns_in_chnl, sizeof(int), GFP_KERNEL);
	438	if (!lun_roffs)
	439	goto err_ch;
	440
	441	for (j = 0; j < luns_in_chnl; j++)
	442	lun_roffs[j] = -1;
	443
	444	ch_rmap->lun_offs = lun_roffs;
	445	}
48add0f5	446
11450469	447	gn->dev = dev;
8e79b5cb	448	gn->nr_luns = dev->geo.nr_luns;
4c9dacb8	449	INIT_LIST_HEAD(&gn->area_list);
b76eb20b MB	450	mutex_init(&gn->lock);
b76eb20b MB	451	INIT_LIST_HEAD(&gn->targets);
48add0f5	452	dev->mp = gn;
8e53624d	453	dev->rmap = dev_rmap;
48add0f5	454
48add0f5	455	return 1;
8e53624d JG	456	err_ch:
	457	while (--i >= 0)
	458	kfree(dev_rmap->chnls[i].lun_offs);
	459	err_chnls:
	460	kfree(dev_rmap);
	461	err_rmap:
5e60edb7	462	gen_free(dev);
8e53624d	463	err_gn:
008b7443	464	module_put(THIS_MODULE);
8e53624d	465	return -ENOMEM;
48add0f5 MB	466	}
48add0f5 MB	467
5e60edb7	468	static void gen_unregister(struct nvm_dev *dev)
48add0f5	469	{
b76eb20b MB	470	struct gen_dev *gn = dev->mp;
	471	struct nvm_target t, tmp;
	472
	473	mutex_lock(&gn->lock);
	474	list_for_each_entry_safe(t, tmp, &gn->targets, list) {
8e79b5cb	475	if (t->dev->parent != dev)
b76eb20b MB	476	continue;
	477	__gen_remove_target(t);
	478	}
	479	mutex_unlock(&gn->lock);
	480
5e60edb7	481	gen_free(dev);
008b7443	482	module_put(THIS_MODULE);
48add0f5 MB	483	}
48add0f5 MB	484
8e53624d JG	485	static int gen_map_to_dev(struct nvm_tgt_dev tgt_dev, struct ppa_addr p)
	486	{
	487	struct gen_dev_map *dev_map = tgt_dev->map;
	488	struct gen_ch_map *ch_map = &dev_map->chnls[p->g.ch];
	489	int lun_off = ch_map->lun_offs[p->g.lun];
	490	struct nvm_dev *dev = tgt_dev->parent;
	491	struct gen_dev_map *dev_rmap = dev->rmap;
	492	struct gen_ch_map *ch_rmap;
	493	int lun_roff;
	494
	495	p->g.ch += ch_map->ch_off;
	496	p->g.lun += lun_off;
	497
	498	ch_rmap = &dev_rmap->chnls[p->g.ch];
	499	lun_roff = ch_rmap->lun_offs[p->g.lun];
	500
	501	if (unlikely(ch_rmap->ch_off < 0 \|\| lun_roff < 0)) {
	502	pr_err("nvm: corrupted device partition table\n");
	503	return -EINVAL;
	504	}
	505
	506	return 0;
	507	}
	508
	509	static int gen_map_to_tgt(struct nvm_tgt_dev tgt_dev, struct ppa_addr p)
	510	{
	511	struct nvm_dev *dev = tgt_dev->parent;
	512	struct gen_dev_map *dev_rmap = dev->rmap;
	513	struct gen_ch_map *ch_rmap = &dev_rmap->chnls[p->g.ch];
	514	int lun_roff = ch_rmap->lun_offs[p->g.lun];
	515
	516	p->g.ch -= ch_rmap->ch_off;
	517	p->g.lun -= lun_roff;
	518
	519	return 0;
	520	}
	521
	522	static int gen_trans_rq(struct nvm_tgt_dev tgt_dev, struct nvm_rq rqd,
	523	int flag)
	524	{
	525	gen_trans_fn *f;
	526	int i;
	527	int ret = 0;
	528
	529	f = (flag == TRANS_TGT_TO_DEV) ? gen_map_to_dev : gen_map_to_tgt;
	530
	531	if (rqd->nr_ppas == 1)
	532	return f(tgt_dev, &rqd->ppa_addr);
	533
	534	for (i = 0; i < rqd->nr_ppas; i++) {
	535	ret = f(tgt_dev, &rqd->ppa_list[i]);
	536	if (ret)
	537	goto out;
	538	}
	539
	540	out:
	541	return ret;
	542	}
	543
5e60edb7	544	static void gen_end_io(struct nvm_rq *rqd)
48add0f5	545	{
8e53624d	546	struct nvm_tgt_dev *tgt_dev = rqd->dev;
48add0f5	547	struct nvm_tgt_instance *ins = rqd->ins;
48add0f5	548
8e53624d JG	549	/* Convert address space */
	550	if (tgt_dev)
	551	gen_trans_rq(tgt_dev, rqd, TRANS_DEV_TO_TGT);
	552
72d256ec	553	ins->tt->end_io(rqd);
91276162	554	}
48add0f5	555
8e53624d	556	static int gen_submit_io(struct nvm_tgt_dev tgt_dev, struct nvm_rq rqd)
91276162	557	{
8e53624d JG	558	struct nvm_dev *dev = tgt_dev->parent;
8e53624d JG	559
91276162 MB	560	if (!dev->ops->submit_io)
	561	return -ENODEV;
	562
	563	/* Convert address space */
8e53624d	564	gen_trans_rq(tgt_dev, rqd, TRANS_TGT_TO_DEV);
91276162 MB	565	nvm_generic_to_addr_mode(dev, rqd);
91276162 MB	566
8e53624d	567	rqd->dev = tgt_dev;
5e60edb7	568	rqd->end_io = gen_end_io;
91276162	569	return dev->ops->submit_io(dev, rqd);
48add0f5 MB	570	}
48add0f5 MB	571
8e53624d JG	572	static int gen_erase_blk(struct nvm_tgt_dev tgt_dev, struct ppa_addr p,
8e53624d JG	573	int flags)
48add0f5	574	{
8e53624d JG	575	/* Convert address space */
	576	gen_map_to_dev(tgt_dev, p);
	577
	578	return nvm_erase_ppa(tgt_dev->parent, p, 1, flags);
	579	}
	580
333ba053 JG	581	static struct ppa_addr gen_trans_ppa(struct nvm_tgt_dev *tgt_dev,
	582	struct ppa_addr p, int direction)
	583	{
	584	gen_trans_fn *f;
	585	struct ppa_addr ppa = p;
	586
	587	f = (direction == TRANS_TGT_TO_DEV) ? gen_map_to_dev : gen_map_to_tgt;
	588	f(tgt_dev, &ppa);
	589
	590	return ppa;
	591	}
	592
8e53624d JG	593	static void gen_part_to_tgt(struct nvm_dev dev, sector_t entries,
	594	int len)
	595	{
	596	struct nvm_geo *geo = &dev->geo;
	597	struct gen_dev_map *dev_rmap = dev->rmap;
	598	u64 i;
	599
	600	for (i = 0; i < len; i++) {
	601	struct gen_ch_map *ch_rmap;
	602	int *lun_roffs;
	603	struct ppa_addr gaddr;
	604	u64 pba = le64_to_cpu(entries[i]);
	605	int off;
	606	u64 diff;
	607
	608	if (!pba)
	609	continue;
	610
	611	gaddr = linear_to_generic_addr(geo, pba);
	612	ch_rmap = &dev_rmap->chnls[gaddr.g.ch];
	613	lun_roffs = ch_rmap->lun_offs;
	614
	615	off = gaddr.g.ch * geo->luns_per_chnl + gaddr.g.lun;
	616
	617	diff = ((ch_rmap->ch_off * geo->luns_per_chnl) +
	618	(lun_roffs[gaddr.g.lun])) * geo->sec_per_lun;
	619
	620	entries[i] -= cpu_to_le64(diff);
	621	}
48add0f5 MB	622	}
48add0f5 MB	623
5e60edb7	624	static struct nvmm_type gen = {
ff0e498b JG	625	.name = "gennvm",
	626	.version = {0, 1, 0},
	627
5e60edb7 MB	628	.register_mgr = gen_register,
5e60edb7 MB	629	.unregister_mgr = gen_unregister,
48add0f5	630
b76eb20b MB	631	.create_tgt = gen_create_tgt,
	632	.remove_tgt = gen_remove_tgt,
	633
5e60edb7 MB	634	.submit_io = gen_submit_io,
5e60edb7 MB	635	.erase_blk = gen_erase_blk,
48add0f5	636
5e60edb7 MB	637	.get_area = gen_get_area,
5e60edb7 MB	638	.put_area = gen_put_area,
4c9dacb8	639
333ba053	640	.trans_ppa = gen_trans_ppa,
8e53624d	641	.part_to_tgt = gen_part_to_tgt,
48add0f5 MB	642	};
48add0f5 MB	643
5e60edb7	644	static int __init gen_module_init(void)
48add0f5	645	{
5e60edb7	646	return nvm_register_mgr(&gen);
48add0f5 MB	647	}
48add0f5 MB	648
5e60edb7	649	static void gen_module_exit(void)
48add0f5	650	{
5e60edb7	651	nvm_unregister_mgr(&gen);
48add0f5 MB	652	}
48add0f5 MB	653
5e60edb7 MB	654	module_init(gen_module_init);
5e60edb7 MB	655	module_exit(gen_module_exit);
48add0f5	656	MODULE_LICENSE("GPL v2");
5e60edb7	657	MODULE_DESCRIPTION("General media manager for Open-Channel SSDs");