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
 21static 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 pblk_emeta *emeta;
 29	struct pblk_w_ctx *w_ctx;
 30	__le64 *lba_list;
 31	u64 paddr;
 32	int nr_secs = pblk->min_write_pgs;
 33	int i;
 34
 35	if (pblk_line_is_full(line)) {
 36		struct pblk_line *prev_line = line;
 37
 38		line = pblk_line_replace_data(pblk);
 39		pblk_line_close_meta(pblk, prev_line);
 40	}
 41
 42	emeta = line->emeta;
 43	lba_list = emeta_to_lbas(pblk, emeta->buf);
 44
 45	paddr = pblk_alloc_page(pblk, line, nr_secs);
 46
 47	for (i = 0; i < nr_secs; i++, paddr++) {
 48		__le64 addr_empty = cpu_to_le64(ADDR_EMPTY);
 49
 50		/* ppa to be sent to the device */
 51		ppa_list[i] = addr_to_gen_ppa(pblk, paddr, line->id);
 52
 53		/* Write context for target bio completion on write buffer. Note
 54		 * that the write buffer is protected by the sync backpointer,
 55		 * and a single writer thread have access to each specific entry
 56		 * at a time. Thus, it is safe to modify the context for the
 57		 * entry we are setting up for submission without taking any
 58		 * lock or memory barrier.
 59		 */
 60		if (i < valid_secs) {
 61			kref_get(&line->ref);
 62			w_ctx = pblk_rb_w_ctx(&pblk->rwb, sentry + i);
 63			w_ctx->ppa = ppa_list[i];
 64			meta_list[i].lba = cpu_to_le64(w_ctx->lba);
 65			lba_list[paddr] = cpu_to_le64(w_ctx->lba);
 66			if (lba_list[paddr] != addr_empty)
 67				line->nr_valid_lbas++;
 68			else
 69				atomic64_inc(&pblk->pad_wa);
 70		} else {
 71			lba_list[paddr] = meta_list[i].lba = addr_empty;
 72			__pblk_map_invalidate(pblk, line, paddr);
 73		}
 74	}
 75
 76	pblk_down_rq(pblk, ppa_list, nr_secs, lun_bitmap);
 77}
 78
 79void pblk_map_rq(struct pblk *pblk, struct nvm_rq *rqd, unsigned int sentry,
 80		 unsigned long *lun_bitmap, unsigned int valid_secs,
 81		 unsigned int off)
 82{
 83	struct pblk_sec_meta *meta_list = rqd->meta_list;
 84	unsigned int map_secs;
 85	int min = pblk->min_write_pgs;
 86	int i;
 87
 88	for (i = off; i < rqd->nr_ppas; i += min) {
 89		map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
 90		pblk_map_page_data(pblk, sentry + i, &rqd->ppa_list[i],
 91					lun_bitmap, &meta_list[i], map_secs);
 92	}
 93}
 94
 95/* only if erase_ppa is set, acquire erase semaphore */
 96void pblk_map_erase_rq(struct pblk *pblk, struct nvm_rq *rqd,
 97		       unsigned int sentry, unsigned long *lun_bitmap,
 98		       unsigned int valid_secs, struct ppa_addr *erase_ppa)
 99{
100	struct nvm_tgt_dev *dev = pblk->dev;
101	struct nvm_geo *geo = &dev->geo;
102	struct pblk_line_meta *lm = &pblk->lm;
103	struct pblk_sec_meta *meta_list = rqd->meta_list;
104	struct pblk_line *e_line, *d_line;
105	unsigned int map_secs;
106	int min = pblk->min_write_pgs;
107	int i, erase_lun;
108
109	for (i = 0; i < rqd->nr_ppas; i += min) {
110		map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
111		pblk_map_page_data(pblk, sentry + i, &rqd->ppa_list[i],
112					lun_bitmap, &meta_list[i], map_secs);
113
114		erase_lun = pblk_ppa_to_pos(geo, rqd->ppa_list[i]);
115
116		/* line can change after page map. We might also be writing the
117		 * last line.
118		 */
119		e_line = pblk_line_get_erase(pblk);
120		if (!e_line)
121			return pblk_map_rq(pblk, rqd, sentry, lun_bitmap,
122							valid_secs, i + min);
123
124		spin_lock(&e_line->lock);
125		if (!test_bit(erase_lun, e_line->erase_bitmap)) {
126			set_bit(erase_lun, e_line->erase_bitmap);
127			atomic_dec(&e_line->left_eblks);
128
129			*erase_ppa = rqd->ppa_list[i];
130			erase_ppa->a.blk = e_line->id;
131
132			spin_unlock(&e_line->lock);
133
134			/* Avoid evaluating e_line->left_eblks */
135			return pblk_map_rq(pblk, rqd, sentry, lun_bitmap,
136							valid_secs, i + min);
137		}
138		spin_unlock(&e_line->lock);
139	}
140
141	d_line = pblk_line_get_data(pblk);
142
143	/* line can change after page map. We might also be writing the
144	 * last line.
145	 */
146	e_line = pblk_line_get_erase(pblk);
147	if (!e_line)
148		return;
149
150	/* Erase blocks that are bad in this line but might not be in next */
151	if (unlikely(pblk_ppa_empty(*erase_ppa)) &&
152			bitmap_weight(d_line->blk_bitmap, lm->blk_per_line)) {
153		int bit = -1;
154
155retry:
156		bit = find_next_bit(d_line->blk_bitmap,
157						lm->blk_per_line, bit + 1);
158		if (bit >= lm->blk_per_line)
159			return;
160
161		spin_lock(&e_line->lock);
162		if (test_bit(bit, e_line->erase_bitmap)) {
163			spin_unlock(&e_line->lock);
164			goto retry;
165		}
166		spin_unlock(&e_line->lock);
167
168		set_bit(bit, e_line->erase_bitmap);
169		atomic_dec(&e_line->left_eblks);
170		*erase_ppa = pblk->luns[bit].bppa; /* set ch and lun */
171		erase_ppa->a.blk = e_line->id;
172	}
173}