[linux-2.6-block.git] / drivers / lightnvm / pblk-map.c

/*
 * Copyright (C) 2016 CNEX Labs
 * Initial release: Javier Gonzalez <javier@cnexlabs.com>
 *                  Matias Bjorling <matias@cnexlabs.com>
 *
 * 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.
 *
 * pblk-map.c - pblk's lba-ppa mapping strategy
 *
 */

#include "pblk.h"

static void pblk_map_page_data(struct pblk *pblk, unsigned int sentry,
			       struct ppa_addr *ppa_list,
			       unsigned long *lun_bitmap,
			       struct pblk_sec_meta *meta_list,
			       unsigned int valid_secs)
{
	struct pblk_line *line = pblk_line_get_data(pblk);
	struct line_emeta *emeta = line->emeta;
	struct pblk_w_ctx *w_ctx;
	__le64 *lba_list = pblk_line_emeta_to_lbas(emeta);
	u64 paddr;
	int nr_secs = pblk->min_write_pgs;
	int i;

	paddr = pblk_alloc_page(pblk, line, nr_secs);

	for (i = 0; i < nr_secs; i++, paddr++) {
		/* ppa to be sent to the device */
		ppa_list[i] = addr_to_gen_ppa(pblk, paddr, line->id);

		/* Write context for target bio completion on write buffer. Note
		 * that the write buffer is protected by the sync backpointer,
		 * and a single writer thread have access to each specific entry
		 * at a time. Thus, it is safe to modify the context for the
		 * entry we are setting up for submission without taking any
		 * lock or memory barrier.
		 */
		if (i < valid_secs) {
			kref_get(&line->ref);
			w_ctx = pblk_rb_w_ctx(&pblk->rwb, sentry + i);
			w_ctx->ppa = ppa_list[i];
			meta_list[i].lba = cpu_to_le64(w_ctx->lba);
			lba_list[paddr] = cpu_to_le64(w_ctx->lba);
			le64_add_cpu(&line->emeta->nr_valid_lbas, 1);
		} else {
			meta_list[i].lba = cpu_to_le64(ADDR_EMPTY);
			lba_list[paddr] = cpu_to_le64(ADDR_EMPTY);
			pblk_map_pad_invalidate(pblk, line, paddr);
		}
	}

	if (pblk_line_is_full(line)) {
		line = pblk_line_replace_data(pblk);
		if (!line)
			return;
	}

	pblk_down_rq(pblk, ppa_list, nr_secs, lun_bitmap);
}

void pblk_map_rq(struct pblk *pblk, struct nvm_rq *rqd, unsigned int sentry,
		 unsigned long *lun_bitmap, unsigned int valid_secs,
		 unsigned int off)
{
	struct pblk_sec_meta *meta_list = rqd->meta_list;
	unsigned int map_secs;
	int min = pblk->min_write_pgs;
	int i;

	for (i = off; i < rqd->nr_ppas; i += min) {
		map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
		pblk_map_page_data(pblk, sentry + i, &rqd->ppa_list[i],
					lun_bitmap, &meta_list[i], map_secs);
	}
}

/* only if erase_ppa is set, acquire erase semaphore */
void pblk_map_erase_rq(struct pblk *pblk, struct nvm_rq *rqd,
		       unsigned int sentry, unsigned long *lun_bitmap,
		       unsigned int valid_secs, struct ppa_addr *erase_ppa)
{
	struct nvm_tgt_dev *dev = pblk->dev;
	struct nvm_geo *geo = &dev->geo;
	struct pblk_line *e_line = pblk_line_get_data_next(pblk);
	struct pblk_sec_meta *meta_list = rqd->meta_list;
	unsigned int map_secs;
	int min = pblk->min_write_pgs;
	int i, erase_lun;

	for (i = 0; i < rqd->nr_ppas; i += min) {
		map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
		pblk_map_page_data(pblk, sentry + i, &rqd->ppa_list[i],
					lun_bitmap, &meta_list[i], map_secs);

		erase_lun = rqd->ppa_list[i].g.lun * geo->nr_chnls +
							rqd->ppa_list[i].g.ch;

		if (!test_bit(erase_lun, e_line->erase_bitmap)) {
			if (down_trylock(&pblk->erase_sem))
				continue;

			set_bit(erase_lun, e_line->erase_bitmap);
			atomic_dec(&e_line->left_eblks);
			*erase_ppa = rqd->ppa_list[i];
			erase_ppa->g.blk = e_line->id;

			/* Avoid evaluating e_line->left_eblks */
			return pblk_map_rq(pblk, rqd, sentry, lun_bitmap,
							valid_secs, i + min);
		}
	}

	/* Erase blocks that are bad in this line but might not be in next */
	if (unlikely(ppa_empty(*erase_ppa))) {
		struct pblk_line_meta *lm = &pblk->lm;

		i = find_first_zero_bit(e_line->erase_bitmap, lm->blk_per_line);
		if (i == lm->blk_per_line)
			return;

		set_bit(i, e_line->erase_bitmap);
		atomic_dec(&e_line->left_eblks);
		*erase_ppa = pblk->luns[i].bppa; /* set ch and lun */
		erase_ppa->g.blk = e_line->id;
	}
}
Commit	Line	Data
a4bd217b JG	1	/*
	2	* Copyright (C) 2016 CNEX Labs
	3	* Initial release: Javier Gonzalez <javier@cnexlabs.com>
	4	* Matias Bjorling <matias@cnexlabs.com>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License version
	8	* 2 as published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* pblk-map.c - pblk's lba-ppa mapping strategy
	16	*
	17	*/
	18
	19	#include "pblk.h"
	20
	21	static void pblk_map_page_data(struct pblk *pblk, unsigned int sentry,
	22	struct ppa_addr *ppa_list,
	23	unsigned long *lun_bitmap,
	24	struct pblk_sec_meta *meta_list,
	25	unsigned int valid_secs)
	26	{
	27	struct pblk_line *line = pblk_line_get_data(pblk);
	28	struct line_emeta *emeta = line->emeta;
	29	struct pblk_w_ctx *w_ctx;
	30	__le64 *lba_list = pblk_line_emeta_to_lbas(emeta);
	31	u64 paddr;
	32	int nr_secs = pblk->min_write_pgs;
	33	int i;
	34
	35	paddr = pblk_alloc_page(pblk, line, nr_secs);
	36
	37	for (i = 0; i < nr_secs; i++, paddr++) {
	38	/* ppa to be sent to the device */
	39	ppa_list[i] = addr_to_gen_ppa(pblk, paddr, line->id);
	40
	41	/* Write context for target bio completion on write buffer. Note
	42	* that the write buffer is protected by the sync backpointer,
	43	* and a single writer thread have access to each specific entry
	44	* at a time. Thus, it is safe to modify the context for the
	45	* entry we are setting up for submission without taking any
	46	* lock or memory barrier.
	47	*/
	48	if (i < valid_secs) {
	49	kref_get(&line->ref);
	50	w_ctx = pblk_rb_w_ctx(&pblk->rwb, sentry + i);
	51	w_ctx->ppa = ppa_list[i];
	52	meta_list[i].lba = cpu_to_le64(w_ctx->lba);
	53	lba_list[paddr] = cpu_to_le64(w_ctx->lba);
	54	le64_add_cpu(&line->emeta->nr_valid_lbas, 1);
	55	} else {
	56	meta_list[i].lba = cpu_to_le64(ADDR_EMPTY);
	57	lba_list[paddr] = cpu_to_le64(ADDR_EMPTY);
	58	pblk_map_pad_invalidate(pblk, line, paddr);
	59	}
	60	}
	61
	62	if (pblk_line_is_full(line)) {
	63	line = pblk_line_replace_data(pblk);
	64	if (!line)
65	return;
66	}
67
68	pblk_down_rq(pblk, ppa_list, nr_secs, lun_bitmap);
69	}
70
71	void pblk_map_rq(struct pblk pblk, struct nvm_rq rqd, unsigned int sentry,
72	unsigned long *lun_bitmap, unsigned int valid_secs,
73	unsigned int off)
74	{
75	struct pblk_sec_meta *meta_list = rqd->meta_list;
76	unsigned int map_secs;
77	int min = pblk->min_write_pgs;
78	int i;
79
80	for (i = off; i < rqd->nr_ppas; i += min) {
81	map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
82	pblk_map_page_data(pblk, sentry + i, &rqd->ppa_list[i],
83	lun_bitmap, &meta_list[i], map_secs);
84	}
85	}
86
87	/* only if erase_ppa is set, acquire erase semaphore */
88	void pblk_map_erase_rq(struct pblk pblk, struct nvm_rq rqd,
89	unsigned int sentry, unsigned long *lun_bitmap,
90	unsigned int valid_secs, struct ppa_addr *erase_ppa)
91	{
92	struct nvm_tgt_dev *dev = pblk->dev;
93	struct nvm_geo *geo = &dev->geo;
94	struct pblk_line *e_line = pblk_line_get_data_next(pblk);
95	struct pblk_sec_meta *meta_list = rqd->meta_list;
96	unsigned int map_secs;
97	int min = pblk->min_write_pgs;
98	int i, erase_lun;
99
100	for (i = 0; i < rqd->nr_ppas; i += min) {
101	map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
102	pblk_map_page_data(pblk, sentry + i, &rqd->ppa_list[i],
103	lun_bitmap, &meta_list[i], map_secs);
104
105	erase_lun = rqd->ppa_list[i].g.lun * geo->nr_chnls +
106	rqd->ppa_list[i].g.ch;
107
108	if (!test_bit(erase_lun, e_line->erase_bitmap)) {
109	if (down_trylock(&pblk->erase_sem))
110	continue;
111
112	set_bit(erase_lun, e_line->erase_bitmap);
a44f53fa	113	atomic_dec(&e_line->left_eblks);
a4bd217b JG	114	*erase_ppa = rqd->ppa_list[i];
	115	erase_ppa->g.blk = e_line->id;
	116
	117	/* Avoid evaluating e_line->left_eblks */
	118	return pblk_map_rq(pblk, rqd, sentry, lun_bitmap,
	119	valid_secs, i + min);
	120	}
	121	}
	122
	123	/* Erase blocks that are bad in this line but might not be in next */
	124	if (unlikely(ppa_empty(*erase_ppa))) {
	125	struct pblk_line_meta *lm = &pblk->lm;
	126
	127	i = find_first_zero_bit(e_line->erase_bitmap, lm->blk_per_line);
	128	if (i == lm->blk_per_line)
	129	return;
	130
	131	set_bit(i, e_line->erase_bitmap);
a44f53fa	132	atomic_dec(&e_line->left_eblks);
a4bd217b JG	133	erase_ppa = pblk->luns[i].bppa; / set ch and lun */
	134	erase_ppa->g.blk = e_line->id;
	135	}
	136	}