drivers/lightnvm/pblk-map.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2016 CNEX Labs
   4  * Initial release: Javier Gonzalez <javier@cnexlabs.com>
   5  *                  Matias Bjorling <matias@cnexlabs.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License version
   9  * 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * pblk-map.c - pblk's lba-ppa mapping strategy
  17  *
  18  */
  19
  20 #include "pblk.h"
  21
  22 static int pblk_map_page_data(struct pblk *pblk, unsigned int sentry,
  23                               struct ppa_addr *ppa_list,
  24                               unsigned long *lun_bitmap,
  25                               void *meta_list,
  26                               unsigned int valid_secs)
  27 {
  28         struct pblk_line *line = pblk_line_get_data(pblk);
  29         struct pblk_emeta *emeta;
  30         struct pblk_w_ctx *w_ctx;
  31         __le64 *lba_list;
  32         u64 paddr;
  33         int nr_secs = pblk->min_write_pgs;
  34         int i;
  35
  36         if (!line)
  37                 return -ENOSPC;
  38
  39         if (pblk_line_is_full(line)) {
  40                 struct pblk_line *prev_line = line;
  41
  42                 /* If we cannot allocate a new line, make sure to store metadata
  43                  * on current line and then fail
  44                  */
  45                 line = pblk_line_replace_data(pblk);
  46                 pblk_line_close_meta(pblk, prev_line);
  47
  48                 if (!line) {
  49                         pblk_pipeline_stop(pblk);
  50                         return -ENOSPC;
  51                 }
  52
  53         }
  54
  55         emeta = line->emeta;
  56         lba_list = emeta_to_lbas(pblk, emeta->buf);
  57
  58         paddr = pblk_alloc_page(pblk, line, nr_secs);
  59
  60         for (i = 0; i < nr_secs; i++, paddr++) {
  61                 struct pblk_sec_meta *meta = pblk_get_meta(pblk, meta_list, i);
  62                 __le64 addr_empty = cpu_to_le64(ADDR_EMPTY);
  63
  64                 /* ppa to be sent to the device */
  65                 ppa_list[i] = addr_to_gen_ppa(pblk, paddr, line->id);
  66
  67                 /* Write context for target bio completion on write buffer. Note
  68                  * that the write buffer is protected by the sync backpointer,
  69                  * and a single writer thread have access to each specific entry
  70                  * at a time. Thus, it is safe to modify the context for the
  71                  * entry we are setting up for submission without taking any
  72                  * lock or memory barrier.
  73                  */
  74                 if (i < valid_secs) {
  75                         kref_get(&line->ref);
  76                         w_ctx = pblk_rb_w_ctx(&pblk->rwb, sentry + i);
  77                         w_ctx->ppa = ppa_list[i];
  78                         meta->lba = cpu_to_le64(w_ctx->lba);
  79                         lba_list[paddr] = cpu_to_le64(w_ctx->lba);
  80                         if (lba_list[paddr] != addr_empty)
  81                                 line->nr_valid_lbas++;
  82                         else
  83                                 atomic64_inc(&pblk->pad_wa);
  84                 } else {
  85                         lba_list[paddr] = addr_empty;
  86                         meta->lba = addr_empty;
  87                         __pblk_map_invalidate(pblk, line, paddr);
  88                 }
  89         }
  90
  91         pblk_down_rq(pblk, ppa_list[0], lun_bitmap);
  92         return 0;
  93 }
  94
  95 int pblk_map_rq(struct pblk *pblk, struct nvm_rq *rqd, unsigned int sentry,
  96                  unsigned long *lun_bitmap, unsigned int valid_secs,
  97                  unsigned int off)
  98 {
  99         void *meta_list = pblk_get_meta_for_writes(pblk, rqd);
 100         void *meta_buffer;
 101         struct ppa_addr *ppa_list = nvm_rq_to_ppa_list(rqd);
 102         unsigned int map_secs;
 103         int min = pblk->min_write_pgs;
 104         int i;
 105         int ret;
 106
 107         for (i = off; i < rqd->nr_ppas; i += min) {
 108                 map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
 109                 meta_buffer = pblk_get_meta(pblk, meta_list, i);
 110
 111                 ret = pblk_map_page_data(pblk, sentry + i, &ppa_list[i],
 112                                         lun_bitmap, meta_buffer, map_secs);
 113                 if (ret)
 114                         return ret;
 115         }
 116
 117         return 0;
 118 }
 119
 120 /* only if erase_ppa is set, acquire erase semaphore */
 121 int pblk_map_erase_rq(struct pblk *pblk, struct nvm_rq *rqd,
 122                        unsigned int sentry, unsigned long *lun_bitmap,
 123                        unsigned int valid_secs, struct ppa_addr *erase_ppa)
 124 {
 125         struct nvm_tgt_dev *dev = pblk->dev;
 126         struct nvm_geo *geo = &dev->geo;
 127         struct pblk_line_meta *lm = &pblk->lm;
 128         void *meta_list = pblk_get_meta_for_writes(pblk, rqd);
 129         void *meta_buffer;
 130         struct ppa_addr *ppa_list = nvm_rq_to_ppa_list(rqd);
 131         struct pblk_line *e_line, *d_line;
 132         unsigned int map_secs;
 133         int min = pblk->min_write_pgs;
 134         int i, erase_lun;
 135         int ret;
 136
 137
 138         for (i = 0; i < rqd->nr_ppas; i += min) {
 139                 map_secs = (i + min > valid_secs) ? (valid_secs % min) : min;
 140                 meta_buffer = pblk_get_meta(pblk, meta_list, i);
 141
 142                 ret = pblk_map_page_data(pblk, sentry + i, &ppa_list[i],
 143                                         lun_bitmap, meta_buffer, map_secs);
 144                 if (ret)
 145                         return ret;
 146
 147                 erase_lun = pblk_ppa_to_pos(geo, ppa_list[i]);
 148
 149                 /* line can change after page map. We might also be writing the
 150                  * last line.
 151                  */
 152                 e_line = pblk_line_get_erase(pblk);
 153                 if (!e_line)
 154                         return pblk_map_rq(pblk, rqd, sentry, lun_bitmap,
 155                                                         valid_secs, i + min);
 156
 157                 spin_lock(&e_line->lock);
 158                 if (!test_bit(erase_lun, e_line->erase_bitmap)) {
 159                         set_bit(erase_lun, e_line->erase_bitmap);
 160                         atomic_dec(&e_line->left_eblks);
 161
 162                         *erase_ppa = ppa_list[i];
 163                         erase_ppa->a.blk = e_line->id;
 164
 165                         spin_unlock(&e_line->lock);
 166
 167                         /* Avoid evaluating e_line->left_eblks */
 168                         return pblk_map_rq(pblk, rqd, sentry, lun_bitmap,
 169                                                         valid_secs, i + min);
 170                 }
 171                 spin_unlock(&e_line->lock);
 172         }
 173
 174         d_line = pblk_line_get_data(pblk);
 175
 176         /* line can change after page map. We might also be writing the
 177          * last line.
 178          */
 179         e_line = pblk_line_get_erase(pblk);
 180         if (!e_line)
 181                 return -ENOSPC;
 182
 183         /* Erase blocks that are bad in this line but might not be in next */
 184         if (unlikely(pblk_ppa_empty(*erase_ppa)) &&
 185                         bitmap_weight(d_line->blk_bitmap, lm->blk_per_line)) {
 186                 int bit = -1;
 187
 188 retry:
 189                 bit = find_next_bit(d_line->blk_bitmap,
 190                                                 lm->blk_per_line, bit + 1);
 191                 if (bit >= lm->blk_per_line)
 192                         return 0;
 193
 194                 spin_lock(&e_line->lock);
 195                 if (test_bit(bit, e_line->erase_bitmap)) {
 196                         spin_unlock(&e_line->lock);
 197                         goto retry;
 198                 }
 199                 spin_unlock(&e_line->lock);
 200
 201                 set_bit(bit, e_line->erase_bitmap);
 202                 atomic_dec(&e_line->left_eblks);
 203                 *erase_ppa = pblk->luns[bit].bppa; /* set ch and lun */
 204                 erase_ppa->a.blk = e_line->id;
 205         }
 206
 207         return 0;
 208 }