lightnvm: pblk: implement get log report chunk

In preparation of pblk supporting 2.0, implement the get log report
chunk in pblk. Also, define the chunk states as given in the 2.0 spec.

Signed-off-by: Javier González <javier@cnexlabs.com>
Signed-off-by: Matias Bjørling <mb@lightnvm.io>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 158 insertions, 64 deletions

diff --git a/drivers/lightnvm/pblk-init.c b/drivers/lightnvm/pblk-init.c
index 5b381700ef30..27b4974930b4 100644
--- a/drivers/lightnvm/pblk-init.c
+++ b/drivers/lightnvm/pblk-init.c
@@ -451,6 +451,7 @@ static void pblk_line_meta_free(struct pblk_line *line)
 {
         kfree(line->blk_bitmap);
         kfree(line->erase_bitmap);
+        kfree(line->chks);
 }
 
 static void pblk_lines_free(struct pblk *pblk)
@@ -495,55 +496,44 @@ static int pblk_bb_get_tbl(struct nvm_tgt_dev *dev, struct pblk_lun *rlun,
         return 0;
 }
 
-static void *pblk_bb_get_log(struct pblk *pblk)
+static void *pblk_bb_get_meta(struct pblk *pblk)
 {
         struct nvm_tgt_dev *dev = pblk->dev;
         struct nvm_geo *geo = &dev->geo;
-        u8 *log;
+        u8 *meta;
         int i, nr_blks, blk_per_lun;
         int ret;
 
         blk_per_lun = geo->num_chk * geo->pln_mode;
         nr_blks = blk_per_lun * geo->all_luns;
 
-        log = kmalloc(nr_blks, GFP_KERNEL);
-        if (!log)
+        meta = kmalloc(nr_blks, GFP_KERNEL);
+        if (!meta)
                 return ERR_PTR(-ENOMEM);
 
         for (i = 0; i < geo->all_luns; i++) {
                 struct pblk_lun *rlun = &pblk->luns[i];
-                u8 *log_pos = log + i * blk_per_lun;
+                u8 *meta_pos = meta + i * blk_per_lun;
 
-                ret = pblk_bb_get_tbl(dev, rlun, log_pos, blk_per_lun);
+                ret = pblk_bb_get_tbl(dev, rlun, meta_pos, blk_per_lun);
                 if (ret) {
-                        kfree(log);
+                        kfree(meta);
                         return ERR_PTR(-EIO);
                 }
         }
 
-        return log;
+        return meta;
 }
 
-static int pblk_bb_line(struct pblk *pblk, struct pblk_line *line,
-                        u8 *bb_log, int blk_per_line)
+static void *pblk_chunk_get_meta(struct pblk *pblk)
 {
         struct nvm_tgt_dev *dev = pblk->dev;
         struct nvm_geo *geo = &dev->geo;
-        int i, bb_cnt = 0;
-        int blk_per_lun = geo->num_chk * geo->pln_mode;
 
-        for (i = 0; i < blk_per_line; i++) {
-                struct pblk_lun *rlun = &pblk->luns[i];
-                u8 *lun_bb_log = bb_log + i * blk_per_lun;
-
-                if (lun_bb_log[line->id] == NVM_BLK_T_FREE)
-                        continue;
-
-                set_bit(pblk_ppa_to_pos(geo, rlun->bppa), line->blk_bitmap);
-                bb_cnt++;
-        }
-
-        return bb_cnt;
+        if (geo->version == NVM_OCSSD_SPEC_12)
+                return pblk_bb_get_meta(pblk);
+        else
+                return pblk_chunk_get_info(pblk);
 }
 
 static int pblk_luns_init(struct pblk *pblk)
@@ -644,8 +634,131 @@ static void pblk_set_provision(struct pblk *pblk, long nr_free_blks)
         atomic_set(&pblk->rl.free_user_blocks, nr_free_blks);
 }
 
-static int pblk_setup_line_meta(struct pblk *pblk, struct pblk_line *line,
-                                void *chunk_log, long *nr_bad_blks)
+static int pblk_setup_line_meta_12(struct pblk *pblk, struct pblk_line *line,
+                                   void *chunk_meta)
+{
+        struct nvm_tgt_dev *dev = pblk->dev;
+        struct nvm_geo *geo = &dev->geo;
+        struct pblk_line_meta *lm = &pblk->lm;
+        int i, chk_per_lun, nr_bad_chks = 0;
+
+        chk_per_lun = geo->num_chk * geo->pln_mode;
+
+        for (i = 0; i < lm->blk_per_line; i++) {
+                struct pblk_lun *rlun = &pblk->luns[i];
+                struct nvm_chk_meta *chunk;
+                int pos = pblk_ppa_to_pos(geo, rlun->bppa);
+                u8 *lun_bb_meta = chunk_meta + pos * chk_per_lun;
+
+                chunk = &line->chks[pos];
+
+                /*
+                 * In 1.2 spec. chunk state is not persisted by the device. Thus
+                 * some of the values are reset each time pblk is instantiated.
+                 */
+                if (lun_bb_meta[line->id] == NVM_BLK_T_FREE)
+                        chunk->state =  NVM_CHK_ST_FREE;
+                else
+                        chunk->state = NVM_CHK_ST_OFFLINE;
+
+                chunk->type = NVM_CHK_TP_W_SEQ;
+                chunk->wi = 0;
+                chunk->slba = -1;
+                chunk->cnlb = geo->clba;
+                chunk->wp = 0;
+
+                if (!(chunk->state & NVM_CHK_ST_OFFLINE))
+                        continue;
+
+                set_bit(pos, line->blk_bitmap);
+                nr_bad_chks++;
+        }
+
+        return nr_bad_chks;
+}
+
+static int pblk_setup_line_meta_20(struct pblk *pblk, struct pblk_line *line,
+                                   struct nvm_chk_meta *meta)
+{
+        struct nvm_tgt_dev *dev = pblk->dev;
+        struct nvm_geo *geo = &dev->geo;
+        struct pblk_line_meta *lm = &pblk->lm;
+        int i, nr_bad_chks = 0;
+
+        for (i = 0; i < lm->blk_per_line; i++) {
+                struct pblk_lun *rlun = &pblk->luns[i];
+                struct nvm_chk_meta *chunk;
+                struct nvm_chk_meta *chunk_meta;
+                struct ppa_addr ppa;
+                int pos;
+
+                ppa = rlun->bppa;
+                pos = pblk_ppa_to_pos(geo, ppa);
+                chunk = &line->chks[pos];
+
+                ppa.m.chk = line->id;
+                chunk_meta = pblk_chunk_get_off(pblk, meta, ppa);
+
+                chunk->state = chunk_meta->state;
+                chunk->type = chunk_meta->type;
+                chunk->wi = chunk_meta->wi;
+                chunk->slba = chunk_meta->slba;
+                chunk->cnlb = chunk_meta->cnlb;
+                chunk->wp = chunk_meta->wp;
+
+                if (!(chunk->state & NVM_CHK_ST_OFFLINE))
+                        continue;
+
+                if (chunk->type & NVM_CHK_TP_SZ_SPEC) {
+                        WARN_ONCE(1, "pblk: custom-sized chunks unsupported\n");
+                        continue;
+                }
+
+                set_bit(pos, line->blk_bitmap);
+                nr_bad_chks++;
+        }
+
+        return nr_bad_chks;
+}
+
+static long pblk_setup_line_meta(struct pblk *pblk, struct pblk_line *line,
+                                 void *chunk_meta, int line_id)
+{
+        struct nvm_tgt_dev *dev = pblk->dev;
+        struct nvm_geo *geo = &dev->geo;
+        struct pblk_line_mgmt *l_mg = &pblk->l_mg;
+        struct pblk_line_meta *lm = &pblk->lm;
+        long nr_bad_chks, chk_in_line;
+
+        line->pblk = pblk;
+        line->id = line_id;
+        line->type = PBLK_LINETYPE_FREE;
+        line->state = PBLK_LINESTATE_NEW;
+        line->gc_group = PBLK_LINEGC_NONE;
+        line->vsc = &l_mg->vsc_list[line_id];
+        spin_lock_init(&line->lock);
+
+        if (geo->version == NVM_OCSSD_SPEC_12)
+                nr_bad_chks = pblk_setup_line_meta_12(pblk, line, chunk_meta);
+        else
+                nr_bad_chks = pblk_setup_line_meta_20(pblk, line, chunk_meta);
+
+        chk_in_line = lm->blk_per_line - nr_bad_chks;
+        if (nr_bad_chks < 0 || nr_bad_chks > lm->blk_per_line ||
+                                        chk_in_line < lm->min_blk_line) {
+                line->state = PBLK_LINESTATE_BAD;
+                list_add_tail(&line->list, &l_mg->bad_list);
+                return 0;
+        }
+
+        atomic_set(&line->blk_in_line, chk_in_line);
+        list_add_tail(&line->list, &l_mg->free_list);
+        l_mg->nr_free_lines++;
+
+        return chk_in_line;
+}
+
+static int pblk_alloc_line_meta(struct pblk *pblk, struct pblk_line *line)
 {
         struct pblk_line_meta *lm = &pblk->lm;
 
@@ -659,7 +772,13 @@ static int pblk_setup_line_meta(struct pblk *pblk, struct pblk_line *line,
                 return -ENOMEM;
         }
 
-        *nr_bad_blks = pblk_bb_line(pblk, line, chunk_log, lm->blk_per_line);
+        line->chks = kmalloc(lm->blk_per_line * sizeof(struct nvm_chk_meta),
+                                                                GFP_KERNEL);
+        if (!line->chks) {
+                kfree(line->erase_bitmap);
+                kfree(line->blk_bitmap);
+                return -ENOMEM;
+        }
 
         return 0;
 }
@@ -846,10 +965,9 @@ add_emeta_page:
 static int pblk_lines_init(struct pblk *pblk)
 {
         struct pblk_line_mgmt *l_mg = &pblk->l_mg;
-        struct pblk_line_meta *lm = &pblk->lm;
         struct pblk_line *line;
-        void *chunk_log;
-        long nr_bad_blks = 0, nr_free_blks = 0;
+        void *chunk_meta;
+        long nr_free_chks = 0;
         int i, ret;
 
         ret = pblk_line_meta_init(pblk);
@@ -864,11 +982,9 @@ static int pblk_lines_init(struct pblk *pblk)
         if (ret)
                 goto fail_free_meta;
 
-        chunk_log = pblk_bb_get_log(pblk);
-        if (IS_ERR(chunk_log)) {
-                pr_err("pblk: could not get bad block log (%lu)\n",
-                                                        PTR_ERR(chunk_log));
-                ret = PTR_ERR(chunk_log);
+        chunk_meta = pblk_chunk_get_meta(pblk);
+        if (IS_ERR(chunk_meta)) {
+                ret = PTR_ERR(chunk_meta);
                 goto fail_free_luns;
         }
 
@@ -876,52 +992,30 @@ static int pblk_lines_init(struct pblk *pblk)
                                                                 GFP_KERNEL);
         if (!pblk->lines) {
                 ret = -ENOMEM;
-                goto fail_free_chunk_log;
+                goto fail_free_chunk_meta;
         }
 
         for (i = 0; i < l_mg->nr_lines; i++) {
-                int chk_in_line;
-
                 line = &pblk->lines[i];
 
-                line->pblk = pblk;
-                line->id = i;
-                line->type = PBLK_LINETYPE_FREE;
-                line->state = PBLK_LINESTATE_FREE;
-                line->gc_group = PBLK_LINEGC_NONE;
-                line->vsc = &l_mg->vsc_list[i];
-                spin_lock_init(&line->lock);
-
-                ret = pblk_setup_line_meta(pblk, line, chunk_log, &nr_bad_blks);
+                ret = pblk_alloc_line_meta(pblk, line);
                 if (ret)
                         goto fail_free_lines;
 
-                chk_in_line = lm->blk_per_line - nr_bad_blks;
-                if (nr_bad_blks < 0 || nr_bad_blks > lm->blk_per_line ||
-                                        chk_in_line < lm->min_blk_line) {
-                        line->state = PBLK_LINESTATE_BAD;
-                        list_add_tail(&line->list, &l_mg->bad_list);
-                        continue;
-                }
-
-                nr_free_blks += chk_in_line;
-                atomic_set(&line->blk_in_line, chk_in_line);
-
-                l_mg->nr_free_lines++;
-                list_add_tail(&line->list, &l_mg->free_list);
+                nr_free_chks += pblk_setup_line_meta(pblk, line, chunk_meta, i);
         }
 
-        pblk_set_provision(pblk, nr_free_blks);
+        pblk_set_provision(pblk, nr_free_chks);
 
-        kfree(chunk_log);
+        kfree(chunk_meta);
         return 0;
 
 fail_free_lines:
         while (--i >= 0)
                 pblk_line_meta_free(&pblk->lines[i]);
         kfree(pblk->lines);
-fail_free_chunk_log:
-        kfree(chunk_log);
+fail_free_chunk_meta:
+        kfree(chunk_meta);
 fail_free_luns:
         kfree(pblk->luns);
 fail_free_meta: