forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
210 lines
5.7 KiB
210 lines
5.7 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (C) 2016 CNEX Labs |
|
* Initial release: Javier Gonzalez <[email protected]> |
|
* Matias Bjorling <[email protected]> |
|
* |
|
* 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 int pblk_map_page_data(struct pblk *pblk, unsigned int sentry, |
|
struct ppa_addr *ppa_list, |
|
unsigned long *lun_bitmap, |
|
void *meta_list, |
|
unsigned int valid_secs) |
|
{ |
|
struct pblk_line *line = pblk_line_get_data(pblk); |
|
struct pblk_emeta *emeta; |
|
struct pblk_w_ctx *w_ctx; |
|
__le64 *lba_list; |
|
u64 paddr; |
|
int nr_secs = pblk->min_write_pgs; |
|
int i; |
|
|
|
if (!line) |
|
return -ENOSPC; |
|
|
|
if (pblk_line_is_full(line)) { |
|
struct pblk_line *prev_line = line; |
|
|
|
/* If we cannot allocate a new line, make sure to store metadata |
|
* on current line and then fail |
|
*/ |
|
line = pblk_line_replace_data(pblk); |
|
pblk_line_close_meta(pblk, prev_line); |
|
|
|
if (!line) { |
|
pblk_pipeline_stop(pblk); |
|
return -ENOSPC; |
|
} |
|
|
|
} |
|
|
|
emeta = line->emeta; |
|
lba_list = emeta_to_lbas(pblk, emeta->buf); |
|
|
|
paddr = pblk_alloc_page(pblk, line, nr_secs); |
|
|
|
for (i = 0; i < nr_secs; i++, paddr++) { |
|
struct pblk_sec_meta *meta = pblk_get_meta(pblk, meta_list, i); |
|
__le64 addr_empty = cpu_to_le64(ADDR_EMPTY); |
|
|
|
/* 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); |
|
atomic_inc(&line->sec_to_update); |
|
w_ctx = pblk_rb_w_ctx(&pblk->rwb, sentry + i); |
|
w_ctx->ppa = ppa_list[i]; |
|
meta->lba = cpu_to_le64(w_ctx->lba); |
|
lba_list[paddr] = cpu_to_le64(w_ctx->lba); |
|
if (lba_list[paddr] != addr_empty) |
|
line->nr_valid_lbas++; |
|
else |
|
atomic64_inc(&pblk->pad_wa); |
|
} else { |
|
lba_list[paddr] = addr_empty; |
|
meta->lba = addr_empty; |
|
__pblk_map_invalidate(pblk, line, paddr); |
|
} |
|
} |
|
|
|
pblk_down_rq(pblk, ppa_list[0], lun_bitmap); |
|
return 0; |
|
} |
|
|
|
int pblk_map_rq(struct pblk *pblk, struct nvm_rq *rqd, unsigned int sentry, |
|
unsigned long *lun_bitmap, unsigned int valid_secs, |
|
unsigned int off) |
|
{ |
|
void *meta_list = pblk_get_meta_for_writes(pblk, rqd); |
|
void *meta_buffer; |
|
struct ppa_addr *ppa_list = nvm_rq_to_ppa_list(rqd); |
|
unsigned int map_secs; |
|
int min = pblk->min_write_pgs; |
|
int i; |
|
int ret; |
|
|
|
for (i = off; i < rqd->nr_ppas; i += min) { |
|
map_secs = (i + min > valid_secs) ? (valid_secs % min) : min; |
|
meta_buffer = pblk_get_meta(pblk, meta_list, i); |
|
|
|
ret = pblk_map_page_data(pblk, sentry + i, &ppa_list[i], |
|
lun_bitmap, meta_buffer, map_secs); |
|
if (ret) |
|
return ret; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
/* only if erase_ppa is set, acquire erase semaphore */ |
|
int 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_meta *lm = &pblk->lm; |
|
void *meta_list = pblk_get_meta_for_writes(pblk, rqd); |
|
void *meta_buffer; |
|
struct ppa_addr *ppa_list = nvm_rq_to_ppa_list(rqd); |
|
struct pblk_line *e_line, *d_line; |
|
unsigned int map_secs; |
|
int min = pblk->min_write_pgs; |
|
int i, erase_lun; |
|
int ret; |
|
|
|
|
|
for (i = 0; i < rqd->nr_ppas; i += min) { |
|
map_secs = (i + min > valid_secs) ? (valid_secs % min) : min; |
|
meta_buffer = pblk_get_meta(pblk, meta_list, i); |
|
|
|
ret = pblk_map_page_data(pblk, sentry + i, &ppa_list[i], |
|
lun_bitmap, meta_buffer, map_secs); |
|
if (ret) |
|
return ret; |
|
|
|
erase_lun = pblk_ppa_to_pos(geo, ppa_list[i]); |
|
|
|
/* line can change after page map. We might also be writing the |
|
* last line. |
|
*/ |
|
e_line = pblk_line_get_erase(pblk); |
|
if (!e_line) |
|
return pblk_map_rq(pblk, rqd, sentry, lun_bitmap, |
|
valid_secs, i + min); |
|
|
|
spin_lock(&e_line->lock); |
|
if (!test_bit(erase_lun, e_line->erase_bitmap)) { |
|
set_bit(erase_lun, e_line->erase_bitmap); |
|
atomic_dec(&e_line->left_eblks); |
|
|
|
*erase_ppa = ppa_list[i]; |
|
erase_ppa->a.blk = e_line->id; |
|
erase_ppa->a.reserved = 0; |
|
|
|
spin_unlock(&e_line->lock); |
|
|
|
/* Avoid evaluating e_line->left_eblks */ |
|
return pblk_map_rq(pblk, rqd, sentry, lun_bitmap, |
|
valid_secs, i + min); |
|
} |
|
spin_unlock(&e_line->lock); |
|
} |
|
|
|
d_line = pblk_line_get_data(pblk); |
|
|
|
/* line can change after page map. We might also be writing the |
|
* last line. |
|
*/ |
|
e_line = pblk_line_get_erase(pblk); |
|
if (!e_line) |
|
return -ENOSPC; |
|
|
|
/* Erase blocks that are bad in this line but might not be in next */ |
|
if (unlikely(pblk_ppa_empty(*erase_ppa)) && |
|
bitmap_weight(d_line->blk_bitmap, lm->blk_per_line)) { |
|
int bit = -1; |
|
|
|
retry: |
|
bit = find_next_bit(d_line->blk_bitmap, |
|
lm->blk_per_line, bit + 1); |
|
if (bit >= lm->blk_per_line) |
|
return 0; |
|
|
|
spin_lock(&e_line->lock); |
|
if (test_bit(bit, e_line->erase_bitmap)) { |
|
spin_unlock(&e_line->lock); |
|
goto retry; |
|
} |
|
spin_unlock(&e_line->lock); |
|
|
|
set_bit(bit, e_line->erase_bitmap); |
|
atomic_dec(&e_line->left_eblks); |
|
*erase_ppa = pblk->luns[bit].bppa; /* set ch and lun */ |
|
erase_ppa->a.blk = e_line->id; |
|
} |
|
|
|
return 0; |
|
}
|
|
|