lkml.org 
[lkml]   [2019]   [Apr]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[RFC PATCH 1/1] lightnvm: add lzbd - a zoned block device target
Date
From: Hans Holmberg <hans.holmberg@cnexlabs.com>

Introduce a new target: lzbd - LightNVM Zoned Block Device

The new target makes it possible to expose an
Open-Channel 2.0 SSD as one or more zoned block devices.

See Documentation/lightnvm/lzbd.txt for more information.

Experimental in its present state of implementation.

Signed-off-by: Hans Holmberg <hans.holmberg@cnexlabs.com>
---
Documentation/lightnvm/lzbd.txt | 122 +++++++++++
drivers/lightnvm/Kconfig | 11 +
drivers/lightnvm/Makefile | 3 +
drivers/lightnvm/lzbd-io.c | 342 +++++++++++++++++++++++++++++++
drivers/lightnvm/lzbd-target.c | 392 +++++++++++++++++++++++++++++++++++
drivers/lightnvm/lzbd-user.c | 310 ++++++++++++++++++++++++++++
drivers/lightnvm/lzbd-zone.c | 444 ++++++++++++++++++++++++++++++++++++++++
drivers/lightnvm/lzbd.h | 139 +++++++++++++
8 files changed, 1763 insertions(+)
create mode 100644 Documentation/lightnvm/lzbd.txt
create mode 100644 drivers/lightnvm/lzbd-io.c
create mode 100644 drivers/lightnvm/lzbd-target.c
create mode 100644 drivers/lightnvm/lzbd-user.c
create mode 100644 drivers/lightnvm/lzbd-zone.c
create mode 100644 drivers/lightnvm/lzbd.h

diff --git a/Documentation/lightnvm/lzbd.txt b/Documentation/lightnvm/lzbd.txt
new file mode 100644
index 000000000000..8bdbc01a25be
--- /dev/null
+++ b/Documentation/lightnvm/lzbd.txt
@@ -0,0 +1,122 @@
+lzbd: A Zoned Block Device LightNVM Target
+==========================================
+
+The lzbd lightnvm target makes it possible to expose an Open-Channel 2.0 SSD
+as one or more zoned block devices.
+
+Each lightnvm target is assigned a range of parallel units. Parallel units(PUs)
+are not shared among targets avoiding I/O QoS disturbances between targets as
+far as possible.
+
+For more information on lightnvm, see [1]
+For more information on Open-Channel 2.0, see [2].
+For more information on zoned block devices see [3].
+
+lzbd is designed to act as a slim adaptor, making it possible to plug
+OCSSD 2.0 SSDs into the zone block device ecosystem.
+
+lzbd manages zone to chunk mapping, read/write restrictions, wear leveling
+and write errors.
+
+Zone geometry
+-------------
+
+From a user perspective, lzbd targets form a number of sequential-write-required
+(BLK_ZONE_TYPE_SEQWRITE_REQ) zones.
+
+Not all of the target's capacity is exposed to the user.
+Some chunks are reserved for metadata and over-provisioning.
+
+The zones follow the same constraints as described in [3].
+
+All zones are of the same size (SZ).
+
+Simple example:
+
+Sector Zone type
+ _______________________
+0 --> | Sequential write req. |
+ | |
+ |_______________________|
+SZ --> | Sequential write req. |
+ | |
+ |_______________________|
+SZ*2..--> | Sequential write req. |
+ | |
+.......... .........................
+ |_______________________|
+SZ*N-1 --> | Sequential write req. |
+ |_______________________|
+
+
+SZ is configurable, but is restricted to a multiple of
+(chunk size (CLBA) * Number of PUs).
+
+Zone to chunk mapping
+---------------------
+
+Zones are spread across PUs to allow maximum write throughput through striping.
+One or more chunks (CHK) per PU is assigned.
+
+Example:
+
+OCSSD 2.0 Geometry: 4 PUs, 16 chunks per PU.
+Zones: 3
+
+ Zone PU0 PU1 PU2 PU3
+_______ _____ _____ _____ _____
+ |CHK 0|CHK 0|CHK A|CHK 0|
+ 0 |CHK 2|CHK 3|CHK 3|CHK 1|
+_______ |_____|_____|_____|_____|
+ |CHK 3|CHK B|CHK 8|CHK A|
+ 1 |CHK 7|CHK F|CHK 2|CHK 3|
+_______ |_____|_____|_____|_____|
+ |CHK 8|CHK 2|CHK 7|CHK 4|
+ 2 |CHK 1|CHK A|CHK 5|CHK 2|
+_______ |_____|_____|_____|_____|
+
+Chunks are assigned to a zone when it is opened based on the chunk wear index.
+
+Note: The disk's Maximum Open Chunks (MAXOC) limit puts an upper bound on
+maximum simultaneously open zones (unless MAXOC = 0).
+
+Meta data and over-provisioning
+-------------------------------
+
+lzbd needs the following meta data to be persisted:
+
+* a zone-to chunk mapping (Z2C) table, size: 4 bytes * Number of chunks
+* a superblock containing target configuration, guuid, on-disk format version,
+ etc.
+
+Additionally, chunks need to be reserved for handling:
+
+* write errors
+* chunks wearing out and going offline
+* persisting data not aligned with the minimal write constraint
+
+The meta data is stored a separate set of chunks from the user data.
+
+Host memory requirements
+------------------------
+
+The Z2C mapping table needs to be kept in host memory (see above), and:
+
+* in order to achieve maximum throughput and alignment requirements,
+ a small write buffer is needed
+ Size: Optimal Write Size (WS_OPT) * Maximum number of open zones.
+
+* to satisify OCSSD 2.0 read restrictions, a read buffer is needed.
+ Size: Number of PUs * Cache Minimum Write Size Units (MW_CUNITS) *
+ Maximum number of open zones.
+
+If MW_CUNITS = 0, no read buffer is needed and data can be written without
+any host copying/buffering (except for handling WS_OPT alignment).
+
+References
+----------
+
+[1] Lightnvm website: http://lightnvm.io/
+[2] OCSSD 2.0 Specification: http://lightnvm.io/docs/OCSSD-2_0-20180129.pdf
+[3] ZBC / Zoned block device support: https://lwn.net/Articles/703871/
+
diff --git a/drivers/lightnvm/Kconfig b/drivers/lightnvm/Kconfig
index a872cd720967..98882874bda6 100644
--- a/drivers/lightnvm/Kconfig
+++ b/drivers/lightnvm/Kconfig
@@ -16,6 +16,17 @@ menuconfig NVM

if NVM

+config NVM_LZBD
+ tristate "Zoned Block Device Open-Channel SSD target"
+ depends on BLK_DEV_ZONED
+ help
+ Allows an open-channel SSD to be exposed as a zoned block device to the
+ host.
+
+ Highly EXPERIMENTAL for now.
+
+ Only say Y if you want to play with it.
+
config NVM_PBLK
tristate "Physical Block Device Open-Channel SSD target"
help
diff --git a/drivers/lightnvm/Makefile b/drivers/lightnvm/Makefile
index 97d9d7c71550..f9eea8b23b33 100644
--- a/drivers/lightnvm/Makefile
+++ b/drivers/lightnvm/Makefile
@@ -9,3 +9,6 @@ pblk-y := pblk-init.o pblk-core.o pblk-rb.o \
pblk-write.o pblk-cache.o pblk-read.o \
pblk-gc.o pblk-recovery.o pblk-map.o \
pblk-rl.o pblk-sysfs.o
+
+obj-$(CONFIG_NVM_LZBD) += lzbd.o
+lzbd-y := lzbd-target.o lzbd-user.o lzbd-io.o lzbd-zone.o
diff --git a/drivers/lightnvm/lzbd-io.c b/drivers/lightnvm/lzbd-io.c
new file mode 100644
index 000000000000..b210ab33fdd3
--- /dev/null
+++ b/drivers/lightnvm/lzbd-io.c
@@ -0,0 +1,342 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *
+ * Zoned block device lightnvm target
+ * Copyright (C) 2019 CNEX Labs
+ *
+ * Disk I/O
+ */
+
+#include "lzbd.h"
+
+static inline void lzbd_chunk_log(char *message, int err,
+ struct lzbd_chunk *lzbd_chunk)
+{
+
+ /* TODO: create trace points in stead */
+ pr_err("lzbd: %s: err: %d grp: %d pu: %d chk: %d slba: %llu state: %d wp: %llu\n",
+ message,
+ err,
+ lzbd_chunk->ppa.m.grp,
+ lzbd_chunk->ppa.m.pu,
+ lzbd_chunk->ppa.m.chk,
+ lzbd_chunk->meta->slba,
+ lzbd_chunk->meta->state,
+ lzbd_chunk->meta->wp);
+}
+
+int lzbd_reset_chunk(struct lzbd *lzbd, struct lzbd_chunk *chunk)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_rq rqd = {NULL};
+ int ret;
+
+ if ((chunk->meta->state & (NVM_CHK_ST_FREE | NVM_CHK_ST_OFFLINE))) {
+ pr_err("lzbd: reset of chunk in illegal state: %d\n",
+ chunk->meta->state);
+ return -EINVAL;
+ }
+
+ rqd.opcode = NVM_OP_ERASE;
+ rqd.ppa_addr = chunk->ppa;
+ rqd.nr_ppas = 1;
+ rqd.is_seq = 1;
+
+ ret = nvm_submit_io_sync(dev, &rqd);
+
+ /* For now, set the chunk offline if the request fails
+ * TODO: Pass a buffer in the request so we get a full
+ * meta update from the device
+ */
+
+ if (!ret) {
+ if (rqd.error) {
+ if ((rqd.error & 0xfff) == 0x2c0) {
+ lzbd_chunk_log("chunk went offline", 0, chunk);
+ chunk->meta->state = NVM_CHK_ST_OFFLINE;
+ } else {
+ if ((rqd.error & 0xfff) == 0x2c1) {
+ lzbd_chunk_log("invalid reset",
+ -EINVAL, chunk);
+ } else {
+ lzbd_chunk_log("unknown error",
+ -EINVAL, chunk);
+ }
+ return -EINVAL;
+ }
+ } else {
+ chunk->meta->state = NVM_CHK_ST_FREE;
+ chunk->meta->wp = 0;
+ }
+ }
+
+ return ret;
+}
+
+/* Prepare a write request to a chunk. If the function call succeeds
+ * the call must be paired with a lzbd_free_wr_rq
+ */
+static int lzbd_init_wr_rq(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *bio, struct nvm_rq *rq)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct ppa_addr ppa;
+ struct ppa_addr *ppa_list;
+ int metadata_sz = geo->sos * NVM_MAX_VLBA;
+ int nr_ppas = geo->ws_opt;
+ int i;
+
+ memset(rq, 0, sizeof(struct nvm_rq));
+
+ rq->bio = bio;
+ rq->opcode = NVM_OP_PWRITE;
+ rq->nr_ppas = nr_ppas;
+ rq->is_seq = 1;
+ rq->private = &chunk->wr_ctx;
+
+ /* Do we respect the write size restrictions? */
+ if (nr_ppas > geo->ws_opt || (nr_ppas % geo->ws_min)) {
+ pr_err("lzbd: write size violation size: %d\n", nr_ppas);
+ return -EINVAL;
+ }
+
+ /* Is the chunk in the right state? */
+ if (!(chunk->meta->state & (NVM_CHK_ST_FREE | NVM_CHK_ST_OPEN))) {
+ pr_err("lzbd: write to chunk in wrong state: %d\n",
+ chunk->meta->state);
+ return -EINVAL;
+ }
+
+ /* Do we have room for the write? */
+ if ((chunk->meta->wp + nr_ppas) > geo->clba) {
+ pr_err("lzbd: cant fit write into chunk size %d\n", nr_ppas);
+ return -EINVAL;
+ }
+
+ rq->meta_list = nvm_dev_dma_alloc(dev->parent, GFP_KERNEL,
+ &rq->dma_meta_list);
+ if (!rq->meta_list)
+ return -ENOMEM;
+
+ /* We don't care about metadata. yet. */
+ memset(rq->meta_list, 42, metadata_sz);
+
+ if (nr_ppas > 1) {
+ rq->ppa_list = rq->meta_list + metadata_sz;
+ rq->dma_ppa_list = rq->dma_meta_list + metadata_sz;
+ }
+
+ //pr_err("lzbd: writing %d sectors\n", nr_ppas);
+
+ ppa.ppa = chunk->ppa.ppa;
+
+ mutex_lock(&chunk->wr_ctx.wr_lock);
+
+ ppa.m.sec = chunk->meta->wp;
+
+ ppa_list = nvm_rq_to_ppa_list(rq);
+ for (i = 0; i < nr_ppas; i++) {
+ ppa_list[i].ppa = ppa.ppa;
+ ppa.m.sec++;
+ }
+
+ return 0;
+}
+
+static void lzbd_free_wr_rq(struct lzbd *lzbd, struct nvm_rq *rq)
+{
+ struct lzbd_wr_ctx *wr_ctx = rq->private;
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct lzbd_chunk *chunk;
+
+ chunk = container_of(wr_ctx, struct lzbd_chunk, wr_ctx);
+
+ mutex_unlock(&chunk->wr_ctx.wr_lock);
+ nvm_dev_dma_free(dev->parent, rq->meta_list, rq->dma_meta_list);
+}
+
+static inline void lzbd_wr_rq_post(struct nvm_rq *rq)
+{
+ struct lzbd_wr_ctx *wr_ctx = rq->private;
+ struct lzbd *lzbd = wr_ctx->lzbd;
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct lzbd_chunk *chunk;
+
+ chunk = container_of(wr_ctx, struct lzbd_chunk, wr_ctx);
+
+ if (!rq->error) {
+ if (chunk->meta->wp == 0)
+ chunk->meta->state = NVM_CHK_ST_OPEN;
+
+ chunk->meta->wp += rq->nr_ppas;
+ if (chunk->meta->wp == geo->clba)
+ chunk->meta->state = NVM_CHK_ST_CLOSED;
+ }
+}
+
+int lzbd_write_to_chunk_sync(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *bio)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_rq rq;
+ int ret;
+
+ ret = lzbd_init_wr_rq(lzbd, chunk, bio, &rq);
+ if (ret)
+ return ret;
+
+ ret = nvm_submit_io_sync(dev, &rq);
+ if (ret) {
+ ret = rq.error;
+ pr_err("lzbd: sync write request submit failed: %d\n", ret);
+ } else {
+ lzbd_wr_rq_post(&rq);
+ }
+
+ lzbd_free_wr_rq(lzbd, &rq);
+
+ return ret;
+}
+
+static void lzbd_read_endio(struct nvm_rq *rq)
+{
+ struct lzbd_rd_ctx *rd_ctx = container_of(rq, struct lzbd_rd_ctx, rqd);
+ struct lzbd *lzbd = rd_ctx->lzbd;
+ struct lzbd_user_read *read = rd_ctx->read;
+ struct nvm_tgt_dev *dev = lzbd->dev;
+
+ if (unlikely(rq->error))
+ read->error = true;
+
+ if (rq->meta_list)
+ nvm_dev_dma_free(dev->parent, rq->meta_list, rq->dma_meta_list);
+
+ kref_put(&read->ref, lzbd_user_read_put);
+ kfree(rd_ctx);
+}
+
+static int lzbd_read_from_chunk_async(struct lzbd *lzbd,
+ struct lzbd_chunk *chunk,
+ struct bio *bio,
+ struct lzbd_user_read *user_read,
+ int start)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct lzbd_rd_ctx *rd_ctx;
+ struct nvm_rq *rq;
+ struct ppa_addr ppa;
+ struct ppa_addr *ppa_list;
+ int metadata_sz = geo->sos * NVM_MAX_VLBA;
+ int nr_ppas = lzbd_get_bio_len(bio);
+ int ret;
+ int i;
+
+ /* Do we respect the read size restrictions? */
+ if (nr_ppas >= NVM_MAX_VLBA) {
+ pr_err("lzbd: read size violation size: %d\n", nr_ppas);
+ return -EINVAL;
+ }
+
+ /* Is the chunk in the right state? */
+ if (!(chunk->meta->state & (NVM_CHK_ST_OPEN | NVM_CHK_ST_CLOSED))) {
+ pr_err("lzbd: read from chunk in wrong state: %d\n",
+ chunk->meta->state);
+ return -EINVAL;
+ }
+
+ /*Are we reading within bounds? */
+ if ((start + nr_ppas) > geo->clba) {
+ pr_err("lzbd: read past the chunk size %d start: %d\n",
+ nr_ppas, start);
+ return -EINVAL;
+ }
+
+ rd_ctx = kzalloc(sizeof(struct lzbd_rd_ctx), GFP_KERNEL);
+ if (!rd_ctx)
+ return -ENOMEM;
+
+ rd_ctx->read = user_read;
+ rd_ctx->lzbd = lzbd;
+
+ rq = &rd_ctx->rqd;
+ rq->bio = bio;
+ rq->opcode = NVM_OP_PREAD;
+ rq->nr_ppas = nr_ppas;
+ rq->end_io = lzbd_read_endio;
+ rq->private = lzbd;
+ rq->meta_list = nvm_dev_dma_alloc(dev->parent, GFP_KERNEL,
+ &rq->dma_meta_list);
+ if (!rq->meta_list) {
+ kfree(rd_ctx);
+ return -ENOMEM;
+ }
+
+ if (nr_ppas > 1) {
+ rq->ppa_list = rq->meta_list + metadata_sz;
+ rq->dma_ppa_list = rq->dma_meta_list + metadata_sz;
+ }
+
+ ppa.ppa = chunk->ppa.ppa;
+ ppa.m.sec = start;
+
+ ppa_list = nvm_rq_to_ppa_list(rq);
+ for (i = 0; i < nr_ppas; i++) {
+ ppa_list[i].ppa = ppa.ppa;
+ ppa.m.sec++;
+ }
+
+ ret = nvm_submit_io(dev, rq);
+
+ if (ret) {
+ pr_err("lzbd: read request submit failed: %d\n", ret);
+ nvm_dev_dma_free(dev->parent, rq->meta_list, rq->dma_meta_list);
+ kfree(rd_ctx);
+ }
+
+ return ret;
+}
+
+int lzbd_write_to_chunk_user(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *user_bio)
+{
+ struct bio *write_bio;
+ int ret = 0;
+
+ write_bio = bio_clone_fast(user_bio, GFP_KERNEL, &lzbd_bio_set);
+ if (!write_bio)
+ return -ENOMEM;
+
+ ret = lzbd_write_to_chunk_sync(lzbd, chunk, write_bio);
+ if (ret) {
+ ret = -EIO;
+ bio_io_error(user_bio);
+ } else {
+ ret = 0;
+ bio_endio(user_bio);
+ }
+
+ return ret;
+}
+
+int lzbd_read_from_chunk_user(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *bio, struct lzbd_user_read *user_read,
+ int start)
+{
+ struct bio *read_bio;
+ int ret = 0;
+
+ read_bio = bio_clone_fast(bio, GFP_KERNEL, &lzbd_bio_set);
+ if (!read_bio) {
+ pr_err("lzbd: bio clone failed!\n");
+ return -ENOMEM;
+ }
+
+ ret = lzbd_read_from_chunk_async(lzbd, chunk,
+ read_bio, user_read, start);
+
+ return ret;
+}
+
diff --git a/drivers/lightnvm/lzbd-target.c b/drivers/lightnvm/lzbd-target.c
new file mode 100644
index 000000000000..04dd22873eeb
--- /dev/null
+++ b/drivers/lightnvm/lzbd-target.c
@@ -0,0 +1,392 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *
+ * Zoned block device lightnvm target
+ * Copyright (C) 2019 CNEX Labs
+ *
+ * Target handling: module boilerplate, init and remove
+ */
+
+#include <linux/module.h>
+
+#include "lzbd.h"
+
+struct bio_set lzbd_bio_set;
+
+static sector_t lzbd_capacity(void *private)
+{
+ struct lzbd *lzbd = private;
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+
+ return dl->capacity;
+}
+
+static void lzbd_free_chunks(struct lzbd *lzbd)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct lzbd_chunks *chunks = &lzbd->chunks;
+ int parallel_units = geo->all_luns;
+ int i;
+
+ for (i = 0; i < parallel_units; i++) {
+ struct lzbd_pu *pu = &chunks->pus[i];
+ struct list_head *pos, *n;
+ struct lzbd_chunk *chunk;
+
+ mutex_destroy(&pu->lock);
+
+ list_for_each_safe(pos, n, &pu->chk_list) {
+ chunk = list_entry(pos, struct lzbd_chunk, list);
+
+ list_del(pos);
+ mutex_destroy(&chunk->wr_ctx.wr_lock);
+ kfree(chunk);
+ }
+ }
+
+ kfree(chunks->pus);
+ vfree(chunks->meta);
+}
+
+/* Add chunk to chunklist in falling wi order */
+void lzbd_add_chunk(struct lzbd_chunk *chunk,
+ struct list_head *head)
+{
+ struct lzbd_chunk *c = NULL;
+
+ list_for_each_entry(c, head, list) {
+ if (chunk->meta->wi < c->meta->wi)
+ break;
+ }
+
+ list_add_tail(&chunk->list, &c->list);
+}
+
+
+static int lzbd_init_chunks(struct lzbd *lzbd)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct nvm_chk_meta *meta;
+ struct lzbd_chunks *chunks = &lzbd->chunks;
+ int parallel_units = geo->all_luns;
+ struct ppa_addr ppa;
+ int ret;
+ int chk;
+ int i;
+
+ chunks->pus = kcalloc(parallel_units, sizeof(struct lzbd_pu),
+ GFP_KERNEL);
+ if (!chunks->pus)
+ return -ENOMEM;
+
+ meta = vzalloc(geo->all_chunks * sizeof(*meta));
+ if (!meta) {
+ kfree(chunks->pus);
+ return -ENOMEM;
+ }
+
+ chunks->meta = meta;
+
+ for (i = 0; i < parallel_units; i++) {
+ struct lzbd_pu *lzbd_pu = &chunks->pus[i];
+
+ INIT_LIST_HEAD(&lzbd_pu->chk_list);
+ mutex_init(&lzbd_pu->lock);
+ }
+
+ ppa.ppa = 0; /* get all chunks */
+ ret = nvm_get_chunk_meta(dev, ppa, geo->all_chunks, meta);
+ if (ret) {
+ lzbd_free_chunks(lzbd);
+ return -EIO;
+ }
+
+ for (chk = 0; chk < geo->num_chk; chk++) {
+ for (i = 0; i < parallel_units; i++) {
+ struct lzbd_pu *lzbd_pu = &chunks->pus[i];
+ struct nvm_chk_meta *chk_meta;
+ int grp = i / geo->num_lun;
+ int pu = i % geo->num_lun;
+ int offset = 0;
+
+ offset += grp * geo->num_lun * geo->num_chk;
+ offset += pu * geo->num_chk;
+ offset += chk;
+
+ chk_meta = &meta[offset];
+
+ if (!(chk_meta->state & NVM_CHK_ST_OFFLINE)) {
+ struct lzbd_chunk *chunk;
+
+ chunk = kzalloc(sizeof(*chunk), GFP_KERNEL);
+ if (!chunk) {
+ lzbd_free_chunks(lzbd);
+ return -ENOMEM;
+ }
+
+ INIT_LIST_HEAD(&chunk->list);
+ chunk->meta = chk_meta;
+ chunk->ppa.m.grp = grp;
+ chunk->ppa.m.pu = pu;
+ chunk->ppa.m.chk = chk;
+ chunk->pu = i;
+
+ lzbd_add_chunk(chunk, &lzbd_pu->chk_list);
+
+ mutex_init(&chunk->wr_ctx.wr_lock);
+ chunk->wr_ctx.lzbd = lzbd;
+ } else {
+ lzbd_pu->offline_chks++;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static struct lzbd_zone *lzbd_init_zones(struct lzbd *lzbd)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ int i;
+ struct lzbd_zone *zones;
+ u64 zone_offset = 0;
+
+ zones = kmalloc_array(dl->zones, sizeof(*zones), GFP_KERNEL);
+ if (!zones)
+ return NULL;
+
+ /* Sequential zones */
+ for (i = 0; i < dl->zones; i++, zone_offset += dl->zone_size) {
+ struct lzbd_zone *zone = &zones[i];
+ struct blk_zone *bz = &zone->blk_zone;
+
+ bz->start = zone_offset;
+ bz->len = dl->zone_size;
+ bz->wp = zone_offset + dl->zone_size;
+ bz->type = BLK_ZONE_TYPE_SEQWRITE_REQ;
+ bz->cond = BLK_ZONE_COND_FULL;
+
+ bz->non_seq = 0;
+ bz->reset = 1;
+
+ /* zero-out reserved bytes to be forward-compatible */
+ memset(bz->reserved, 0, sizeof(bz->reserved));
+
+ zones[i].chunks = NULL;
+ mutex_init(&zone->lock);
+
+ zone->wr_align.buffer = NULL;
+ mutex_init(&zone->wr_align.lock);
+ }
+
+ return zones;
+}
+
+
+static void lzbd_config_disk_queue(struct lzbd *lzbd)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct gendisk *disk = lzbd->disk;
+ struct nvm_geo *geo = &dev->geo;
+ struct request_queue *bqueue = dev->q;
+ struct request_queue *dqueue = disk->queue;
+
+ blk_queue_logical_block_size(dqueue, queue_physical_block_size(bqueue));
+ blk_queue_max_hw_sectors(dqueue, queue_max_hw_sectors(bqueue));
+
+ blk_queue_write_cache(dqueue, true, false);
+
+ dqueue->limits.discard_granularity = geo->clba * geo->csecs;
+ dqueue->limits.discard_alignment = 0;
+ blk_queue_max_discard_sectors(dqueue, UINT_MAX >> 9);
+ blk_queue_flag_set(QUEUE_FLAG_DISCARD, dqueue);
+
+ dqueue->limits.zoned = BLK_ZONED_HM;
+ dqueue->nr_zones = dl->zones;
+ dqueue->limits.chunk_sectors = dl->zone_size;
+}
+
+
+static int lzbd_dev_is_supported(struct nvm_tgt_dev *dev)
+{
+ struct nvm_geo *geo = &dev->geo;
+
+ if (geo->major_ver_id != 2) {
+ pr_err("lzbd only supports Open Channel 2.x devices\n");
+ return 0;
+ }
+
+ if (geo->csecs != LZBD_SECTOR_SIZE) {
+ pr_err("lzbd: unsupported block size %d", geo->csecs);
+ return 0;
+ }
+
+ /* We will need to check(some of) these parameters later on,
+ * but for now, just print them. TODO: check cunit, maxoc
+ */
+ pr_info("lzbd: ws_min:%d ws_opt:%d cunits:%d maxoc:%d maxocpu:%d\n",
+ geo->ws_min, geo->ws_opt, geo->mw_cunits,
+ geo->maxoc, geo->maxocpu);
+
+ return 1;
+}
+
+
+static const struct block_device_operations lzbd_fops = {
+ .report_zones = lzbd_report_zones,
+ .owner = THIS_MODULE,
+};
+
+static void lzbd_dump_geo(struct nvm_tgt_dev *dev)
+{
+ struct nvm_geo *geo = &dev->geo;
+
+ pr_info("lzbd: target geo: num_grp: %d num_pu: %d num_chk: %d ws_opt: %d\n",
+ geo->num_ch, geo->all_luns, geo->num_chk, geo->ws_opt);
+}
+
+static void lzbd_create_layout(struct lzbd *lzbd)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ int user_chunks;
+
+ /* Default to 20% over-provisioning if not specified
+ * (better safe than sorry)
+ */
+ if (geo->op == NVM_TARGET_DEFAULT_OP)
+ dl->op = 20;
+ else
+ dl->op = geo->op;
+
+ dl->meta_chunks = 4;
+ dl->zone_chunks = geo->all_luns;
+ dl->zone_size = (geo->clba * dl->zone_chunks) << 3;
+
+ user_chunks = geo->all_chunks * (100 - dl->op);
+ sector_div(user_chunks, 100);
+
+ dl->zones = user_chunks / dl->zone_chunks;
+ dl->capacity = dl->zones * dl->zone_size;
+}
+
+static void lzbd_dump_layout(struct lzbd *lzbd)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+
+ pr_info("lzbd: layout: op: %d zones: %d per zone chks: %d secs: %llu\n",
+ dl->op, dl->zones, dl->zone_chunks,
+ (unsigned long long)dl->zone_size);
+}
+
+static void *lzbd_init(struct nvm_tgt_dev *dev, struct gendisk *tdisk,
+ int flags)
+{
+ struct lzbd *lzbd;
+
+ lzbd_dump_geo(dev);
+
+ if (!lzbd_dev_is_supported(dev))
+ return ERR_PTR(-EINVAL);
+
+
+ if (!(flags & NVM_TARGET_FACTORY)) {
+ pr_err("lzbd: metadata not persisted, only factory init supported\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ lzbd = kzalloc(sizeof(struct lzbd), GFP_KERNEL);
+ if (!lzbd)
+ return ERR_PTR(-ENOMEM);
+
+ lzbd->dev = dev;
+ lzbd->disk = tdisk;
+
+ lzbd_create_layout(lzbd);
+ lzbd_dump_layout(lzbd);
+
+ lzbd->zones = lzbd_init_zones(lzbd);
+
+ if (!lzbd->zones)
+ goto err_free_lzbd;
+
+ if (lzbd_init_chunks(lzbd))
+ goto err_free_zones;
+ lzbd_config_disk_queue(lzbd);
+
+ /* Override the fops to enable zone reporting support */
+ lzbd->disk->fops = &lzbd_fops;
+
+ return lzbd;
+
+err_free_zones:
+ kfree(lzbd->zones);
+err_free_lzbd:
+ kfree(lzbd);
+
+ return ERR_PTR(-ENOMEM);
+}
+
+static void lzbd_exit(void *private, bool graceful)
+{
+ struct lzbd *lzbd = private;
+
+ lzbd_free_chunks(lzbd);
+ kfree(lzbd->zones);
+ kfree(lzbd);
+}
+
+
+static int lzbd_sysfs_init(struct gendisk *tdisk)
+{
+ /* Crickets */
+ return 0;
+}
+
+static void lzbd_sysfs_exit(struct gendisk *tdisk)
+{
+ /* Tumbleweed */
+}
+
+static struct nvm_tgt_type tt_lzbd = {
+ .name = "lzbd",
+ .version = {0, 0, 1},
+
+ .init = lzbd_init,
+ .exit = lzbd_exit,
+
+ .capacity = lzbd_capacity,
+ .make_rq = lzbd_make_rq,
+
+ .sysfs_init = lzbd_sysfs_init,
+ .sysfs_exit = lzbd_sysfs_exit,
+
+ .owner = THIS_MODULE,
+};
+
+static int __init lzbd_module_init(void)
+{
+ int ret;
+
+ ret = bioset_init(&lzbd_bio_set, BIO_POOL_SIZE, 0, 0);
+ if (ret)
+ return ret;
+
+ return nvm_register_tgt_type(&tt_lzbd);
+}
+
+static void lzbd_module_exit(void)
+{
+ bioset_exit(&lzbd_bio_set);
+ nvm_unregister_tgt_type(&tt_lzbd);
+}
+
+module_init(lzbd_module_init);
+module_exit(lzbd_module_exit);
+MODULE_AUTHOR("Hans Holmberg <hans.holmberg@cnexlabs.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Zoned Block-Device for Open-Channel SSDs");
diff --git a/drivers/lightnvm/lzbd-user.c b/drivers/lightnvm/lzbd-user.c
new file mode 100644
index 000000000000..e38ec763941e
--- /dev/null
+++ b/drivers/lightnvm/lzbd-user.c
@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *
+ * Zoned block device lightnvm target
+ * Copyright (C) 2019 CNEX Labs
+ *
+ * User interfacing code: read/write/reset requests
+ */
+
+#include "lzbd.h"
+
+static void lzbd_fail_bio(struct bio *bio, char *op)
+{
+ pr_err("lzbd: failing %s. start lba: %lu length: %lu\n", op,
+ lzbd_get_bio_lba(bio), lzbd_get_bio_len(bio));
+
+ bio_io_error(bio);
+}
+
+static struct lzbd_zone *lzbd_get_zone(struct lzbd *lzbd, sector_t sector)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct lzbd_zone *zone;
+ struct blk_zone *bz;
+
+ sector_div(sector, dl->zone_size);
+
+ if (sector >= dl->zones)
+ return NULL;
+
+ zone = &lzbd->zones[sector];
+ bz = &zone->blk_zone;
+
+ return zone;
+}
+
+static int lzbd_write_rq(struct lzbd *lzbd, struct lzbd_zone *zone,
+ struct bio *bio)
+{
+ sector_t sector = bio->bi_iter.bi_sector;
+ sector_t nr_secs = lzbd_get_bio_len(bio);
+ struct blk_zone *bz;
+ int left;
+
+ mutex_lock(&zone->lock);
+
+ bz = &zone->blk_zone;
+
+ if (bz->cond == BLK_ZONE_COND_OFFLINE) {
+ mutex_unlock(&zone->lock);
+ return -EIO;
+ }
+
+ if (bz->cond == BLK_ZONE_COND_EMPTY)
+ bz->cond = BLK_ZONE_COND_IMP_OPEN;
+
+ if (sector != bz->wp) {
+ if (sector == bz->start) {
+ if (lzbd_zone_reset(lzbd, zone)) {
+ pr_err("lzbd: zone reset failed");
+ bz->cond = BLK_ZONE_COND_OFFLINE;
+ mutex_unlock(&zone->lock);
+ return -EIO;
+ }
+ bz->cond = BLK_ZONE_COND_IMP_OPEN;
+ bz->wp = bz->start;
+ } else {
+ pr_err("lzbd: write pointer error");
+ mutex_unlock(&zone->lock);
+ return -EIO;
+ }
+ }
+
+ left = lzbd_zone_write(lzbd, zone, bio);
+
+ bz->wp += (nr_secs - left) << 3;
+ if (bz->wp == (bz->start + bz->len)) {
+ lzbd_zone_free_wr_buffer(zone);
+ bz->cond = BLK_ZONE_COND_FULL;
+ }
+
+ mutex_unlock(&zone->lock);
+
+ if (left > 0) {
+ pr_err("lzbd: write did not complete");
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static int lzbd_read_rq(struct lzbd *lzbd, struct lzbd_zone *zone,
+ struct bio *bio)
+{
+ struct blk_zone *bz;
+ sector_t read_end, data_end;
+ sector_t data_start = bio->bi_iter.bi_sector;
+ int ret;
+
+ if (!zone) {
+ lzbd_fail_bio(bio, "lzbd: no zone mapped to read sector");
+ return -EIO;
+ }
+
+ bz = &zone->blk_zone;
+
+ if (!zone->chunks || bz->cond == BLK_ZONE_COND_OFFLINE) {
+ /* No valid data in this zone */
+ zero_fill_bio(bio);
+ bio_endio(bio);
+ return 0;
+ }
+
+ if (data_start >= bz->wp) {
+ zero_fill_bio(bio);
+ bio_endio(bio);
+ return 0;
+ }
+
+ read_end = bio_end_sector(bio);
+ data_end = min_t(sector_t, bz->wp, read_end);
+
+ if (read_end > data_end) {
+ sector_t split_sz = data_end - data_start;
+ struct bio *split;
+
+ if (data_end <= data_start) {
+ lzbd_fail_bio(bio, "internal error(read)");
+ return -EIO;
+ }
+
+ split = bio_split(bio, split_sz,
+ GFP_KERNEL, &lzbd_bio_set);
+
+ ret = lzbd_zone_read(lzbd, zone, split);
+ if (ret) {
+ lzbd_fail_bio(bio, "split read");
+ return -EIO;
+ }
+
+ zero_fill_bio(bio);
+ bio_endio(bio);
+
+ } else {
+ lzbd_zone_read(lzbd, zone, bio);
+ }
+
+ return 0;
+}
+
+static void lzbd_zone_reset_rq(struct lzbd *lzbd, struct request_queue *q,
+ struct bio *bio)
+{
+ sector_t sector = bio->bi_iter.bi_sector;
+ struct lzbd_zone *zone;
+
+ zone = lzbd_get_zone(lzbd, sector);
+
+ if (zone) {
+ struct blk_zone *bz = &zone->blk_zone;
+ int ret;
+
+ mutex_lock(&zone->lock);
+
+ ret = lzbd_zone_reset(lzbd, zone);
+ if (ret) {
+ bz->cond = BLK_ZONE_COND_OFFLINE;
+ lzbd_fail_bio(bio, "zone reset");
+ mutex_unlock(&zone->lock);
+ return;
+ }
+
+ bz->cond = BLK_ZONE_COND_EMPTY;
+ bz->wp = bz->start;
+
+ mutex_unlock(&zone->lock);
+
+ bio_endio(bio);
+ } else {
+ bio_io_error(bio);
+ }
+}
+
+static void lzbd_discard_rq(struct lzbd *lzbd, struct request_queue *q,
+ struct bio *bio)
+{
+ /* TODO: Implement discard */
+ bio_endio(bio);
+}
+
+static struct bio *lzbd_zplit(struct lzbd *lzbd, struct bio *bio,
+ struct lzbd_zone **first_zone)
+{
+ sector_t bio_start = bio->bi_iter.bi_sector;
+ sector_t bio_end, zone_end;
+ struct lzbd_zone *zone;
+ struct blk_zone *bz;
+ struct bio *zone_bio;
+
+ zone = lzbd_get_zone(lzbd, bio_start);
+ if (!zone)
+ return NULL;
+
+ bio_end = bio_end_sector(bio);
+ bz = &zone->blk_zone;
+ zone_end = bz->start + bz->len;
+
+ if (bio_end > zone_end) {
+ zone_bio = bio_split(bio, zone_end - bio_start,
+ GFP_KERNEL, &lzbd_bio_set);
+ } else {
+ zone_bio = bio;
+ }
+
+ *first_zone = zone;
+ return zone_bio;
+}
+
+blk_qc_t lzbd_make_rq(struct request_queue *q, struct bio *bio)
+{
+ struct lzbd *lzbd = q->queuedata;
+
+ if (bio->bi_opf & REQ_PREFLUSH) {
+ /* TODO: Implement syncs */
+ pr_err("lzbd: ignoring sync!\n");
+ }
+
+ if (bio_op(bio) == REQ_OP_READ || bio_op(bio) == REQ_OP_WRITE) {
+ struct bio *zplit;
+ struct lzbd_zone *zone;
+
+ if (!lzbd_get_bio_len(bio)) {
+ bio_endio(bio);
+ return BLK_QC_T_NONE;
+ }
+
+ do {
+ zplit = lzbd_zplit(lzbd, bio, &zone);
+ if (!zplit || !zone) {
+ lzbd_fail_bio(bio, "zone split");
+ return BLK_QC_T_NONE;
+ }
+
+ if (op_is_write(bio_op(bio))) {
+ if (lzbd_write_rq(lzbd, zone, zplit)) {
+ lzbd_fail_bio(zplit, "write");
+ if (zplit != bio)
+ lzbd_fail_bio(bio,
+ "write");
+
+ return BLK_QC_T_NONE;
+ }
+ } else {
+ if (lzbd_read_rq(lzbd, zone, zplit)) {
+ lzbd_fail_bio(zplit, "read");
+ if (zplit != bio)
+ lzbd_fail_bio(bio,
+ "read");
+ return BLK_QC_T_NONE;
+ }
+ }
+ } while (bio != zplit);
+
+ return BLK_QC_T_NONE;
+ }
+
+ switch (bio_op(bio)) {
+ case REQ_OP_DISCARD:
+ lzbd_discard_rq(lzbd, q, bio);
+ break;
+ case REQ_OP_ZONE_RESET:
+ lzbd_zone_reset_rq(lzbd, q, bio);
+ break;
+ default:
+ pr_err("lzbd: unsupported operation: %d", bio_op(bio));
+ bio_io_error(bio);
+ break;
+ }
+
+ return BLK_QC_T_NONE;
+}
+
+int lzbd_report_zones(struct gendisk *disk, sector_t sector,
+ struct blk_zone *zones, unsigned int *nr_zones,
+ gfp_t gfp_mask)
+{
+ struct lzbd *lzbd = disk->private_data;
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ unsigned int max_zones = *nr_zones;
+ unsigned int reported = 0;
+ struct lzbd_zone *zone;
+
+ sector_div(sector, dl->zone_size);
+
+ while ((zone = lzbd_get_zone(lzbd, sector))) {
+ struct blk_zone *bz = &zone->blk_zone;
+
+ if (reported >= max_zones)
+ break;
+
+ memcpy(&zones[reported], bz, sizeof(*bz));
+
+ sector = sector + dl->zone_size;
+ reported++;
+ }
+
+ *nr_zones = reported;
+
+ return 0;
+}
diff --git a/drivers/lightnvm/lzbd-zone.c b/drivers/lightnvm/lzbd-zone.c
new file mode 100644
index 000000000000..813f7b006ef1
--- /dev/null
+++ b/drivers/lightnvm/lzbd-zone.c
@@ -0,0 +1,444 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *
+ * Zoned block device lightnvm target
+ * Copyright (C) 2019 CNEX Labs
+ *
+ * Internal zone handling
+ */
+
+#include "lzbd.h"
+
+static struct lzbd_chunk *lzbd_get_chunk(struct lzbd *lzbd, int pref_pu)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ int parallel_units = geo->all_luns;
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct lzbd_chunks *chunks = &lzbd->chunks;
+ int i = pref_pu;
+ int retries = dl->zone_chunks - 1;
+
+ do {
+ struct lzbd_pu *pu = &chunks->pus[i];
+ struct list_head *chk_list = &pu->chk_list;
+
+ mutex_lock(&pu->lock);
+
+ if (!list_empty(&pu->chk_list)) {
+ struct lzbd_chunk *chunk;
+
+ chunk = list_first_entry(chk_list,
+ struct lzbd_chunk, list);
+ list_del(&chunk->list);
+ mutex_unlock(&pu->lock);
+ return chunk;
+ }
+ mutex_unlock(&pu->lock);
+
+ if (++i == parallel_units)
+ i = 0;
+
+ } while (retries--);
+
+ return NULL;
+}
+
+void lzbd_zone_free_wr_buffer(struct lzbd_zone *zone)
+{
+ kfree(zone->wr_align.buffer);
+ zone->wr_align.buffer = NULL;
+ zone->wr_align.secs = 0;
+}
+
+static void lzbd_zone_deallocate(struct lzbd *lzbd, struct lzbd_zone *zone)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct lzbd_chunks *chunks = &lzbd->chunks;
+ int i;
+
+ if (!zone->chunks)
+ return;
+
+ for (i = 0; i < dl->zone_chunks; i++) {
+ struct lzbd_chunk *chunk = zone->chunks[i];
+
+ if (chunk) {
+ struct lzbd_pu *pu = &chunks->pus[chunk->pu];
+
+ mutex_lock(&pu->lock);
+
+ /* TODO: implement proper wear leveling
+ * The wear indices do not get updated right now
+ * so just add the chunk at the bottom of the list
+ */
+ list_add_tail(&chunk->list, &pu->chk_list);
+ mutex_unlock(&pu->lock);
+ }
+ }
+
+ lzbd_zone_free_wr_buffer(zone);
+ kfree(zone->chunks);
+ zone->chunks = NULL;
+}
+
+int lzbd_zone_allocate(struct lzbd *lzbd, struct lzbd_zone *zone)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ int to_allocate = dl->zone_chunks;
+ int i;
+
+ zone->chunks = kmalloc_array(to_allocate,
+ sizeof(struct lzbd_chunk *),
+ GFP_KERNEL | __GFP_ZERO);
+
+ if (!zone->chunks)
+ return -ENOMEM;
+
+ zone->wr_align.secs = 0;
+
+ zone->wr_align.buffer = kzalloc(geo->ws_opt << LZBD_SECTOR_BITS,
+ GFP_KERNEL);
+ if (!zone->wr_align.buffer) {
+ kfree(zone->chunks);
+ return -ENOMEM;
+ }
+
+ for (i = 0; i < to_allocate; i++) {
+ struct lzbd_chunk *chunk = lzbd_get_chunk(lzbd, i);
+
+ if (!chunk) {
+ pr_err("failed to allocate zone!\n");
+ lzbd_zone_deallocate(lzbd, zone);
+ return -ENOSPC;
+ }
+
+ zone->chunks[i] = chunk;
+ }
+
+ return 0;
+}
+
+static int lzbd_zone_reset_chunks(struct lzbd *lzbd, struct lzbd_zone *zone)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ int i = 0;
+
+ /* TODO: Do parallel resetting and handle reset failures */
+ for (i = 0; i < dl->zone_chunks; i++) {
+ struct lzbd_chunk *chunk = zone->chunks[i];
+ int state = chunk->meta->state;
+ int ret;
+
+ if (state & (NVM_CHK_ST_CLOSED | NVM_CHK_ST_OPEN)) {
+ ret = lzbd_reset_chunk(lzbd, chunk);
+ if (ret) {
+ pr_err("lzbd: reset failed!\n");
+ return -EIO; /* Fail for now if reset fails */
+ }
+ }
+ }
+
+ return 0;
+}
+
+int lzbd_zone_reset(struct lzbd *lzbd, struct lzbd_zone *zone)
+{
+ int ret;
+
+ lzbd_zone_deallocate(lzbd, zone);
+ ret = lzbd_zone_allocate(lzbd, zone);
+ if (ret)
+ return ret;
+
+ ret = lzbd_zone_reset_chunks(lzbd, zone);
+
+ zone->wi = 0;
+ atomic_set(&zone->s_wp, 0);
+
+ return ret;
+}
+
+
+static void lzbd_add_to_align_buf(struct lzbd_wr_align *wr_align,
+ struct bio *bio, int secs)
+{
+ char *buffer = wr_align->buffer;
+
+ buffer += (wr_align->secs * LZBD_SECTOR_SIZE);
+
+ mutex_lock(&wr_align->lock);
+ while (secs--) {
+ char *data = bio_data(bio);
+
+ memcpy(buffer, data, LZBD_SECTOR_SIZE);
+ buffer += LZBD_SECTOR_SIZE;
+ wr_align->secs++;
+ bio_advance(bio, LZBD_SECTOR_SIZE);
+
+ }
+
+ mutex_unlock(&wr_align->lock);
+}
+
+static void lzbd_read_from_align_buf(struct lzbd_wr_align *wr_align,
+ struct bio *bio, int start, int secs)
+{
+ char *buffer = wr_align->buffer;
+
+ buffer += (start * LZBD_SECTOR_SIZE);
+
+ mutex_lock(&wr_align->lock);
+ while (secs--) {
+ char *data = bio_data(bio);
+
+ memcpy(data, buffer, LZBD_SECTOR_SIZE);
+ buffer += LZBD_SECTOR_SIZE;
+
+ bio_advance(bio, LZBD_SECTOR_SIZE);
+ }
+
+ mutex_unlock(&wr_align->lock);
+}
+
+int lzbd_zone_write(struct lzbd *lzbd, struct lzbd_zone *zone, struct bio *bio)
+{
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct lzbd_wr_align *wr_align = &zone->wr_align;
+ int sectors_left = lzbd_get_bio_len(bio);
+ int ret;
+
+ /* Unaligned write? */
+ if (wr_align->secs) {
+ int secs;
+
+ secs = min_t(int, geo->ws_opt - wr_align->secs, sectors_left);
+ lzbd_add_to_align_buf(wr_align, bio, secs);
+ sectors_left -= secs;
+
+ /* Time to flush the alignment buffer ? */
+ if (wr_align->secs == geo->ws_opt) {
+ struct bio *bio;
+
+ bio = bio_map_kern(dev->q, wr_align->buffer,
+ geo->ws_opt * LZBD_SECTOR_SIZE,
+ GFP_KERNEL);
+ if (!bio) {
+ pr_err("lzbd: failed to map align bio\n");
+ return -EIO;
+ }
+
+ ret = lzbd_write_to_chunk_user(lzbd,
+ zone->chunks[zone->wi], bio);
+
+ if (ret) {
+ pr_err("lzbd: alignment write failed\n");
+ return sectors_left;
+ }
+
+ wr_align->secs = 0;
+ zone->wi = (zone->wi + 1) % dl->zone_chunks;
+ atomic_add(geo->ws_opt, &zone->s_wp);
+ }
+ }
+
+ if (sectors_left == 0) {
+ bio_endio(bio);
+ return 0;
+ }
+
+ while (sectors_left > geo->ws_opt) {
+ struct bio *split;
+
+ split = bio_split(bio, geo->ws_opt << 3,
+ GFP_KERNEL, &lzbd_bio_set);
+
+ if (split == NULL) {
+ pr_err("lzbd: split failed!\n");
+ return sectors_left;
+ }
+
+ ret = lzbd_write_to_chunk_user(lzbd,
+ zone->chunks[zone->wi], split);
+
+ if (ret)
+ return sectors_left;
+
+ zone->wi = (zone->wi + 1) % dl->zone_chunks;
+ atomic_add(geo->ws_opt, &zone->s_wp);
+
+ sectors_left -= geo->ws_opt;
+ }
+
+ if (sectors_left == geo->ws_opt) {
+ ret = lzbd_write_to_chunk_user(lzbd,
+ zone->chunks[zone->wi], bio);
+ if (ret) {
+ pr_err("lzbd: last aligned write failed\n");
+ return sectors_left;
+ }
+
+ zone->wi = (zone->wi + 1) % dl->zone_chunks;
+ atomic_add(geo->ws_opt, &zone->s_wp);
+ sectors_left -= geo->ws_opt;
+ } else {
+ wr_align->secs = 0;
+ lzbd_add_to_align_buf(wr_align, bio, sectors_left);
+ bio_endio(bio);
+ sectors_left = 0;
+ }
+
+ return sectors_left;
+}
+
+void lzbd_user_read_put(struct kref *ref)
+{
+ struct lzbd_user_read *read;
+
+ read = container_of(ref, struct lzbd_user_read, ref);
+
+ if (unlikely(read->error))
+ bio_io_error(read->user_bio);
+ else
+ bio_endio(read->user_bio);
+
+ kfree(read);
+}
+
+
+static struct lzbd_user_read *lzbd_init_user_read(struct bio *bio)
+{
+ struct lzbd_user_read *rd;
+
+ rd = kmalloc(sizeof(struct lzbd_user_read), GFP_KERNEL);
+ if (!rd)
+ return NULL;
+
+ rd->user_bio = bio;
+ kref_init(&rd->ref);
+ rd->error = false;
+
+ return rd;
+}
+
+
+int lzbd_zone_read(struct lzbd *lzbd, struct lzbd_zone *zone, struct bio *bio)
+{
+ struct lzbd_disk_layout *dl = &lzbd->disk_layout;
+ struct nvm_tgt_dev *dev = lzbd->dev;
+ struct nvm_geo *geo = &dev->geo;
+ struct blk_zone *bz = &zone->blk_zone;
+ struct lzbd_chunk *read_chunk;
+ sector_t lba = lzbd_get_bio_lba(bio);
+ int to_read = lzbd_get_bio_len(bio);
+ struct lzbd_user_read *read;
+ int readsize;
+ int zsi, zso, csi, co;
+ int pu;
+ int ret;
+
+ read = lzbd_init_user_read(bio);
+ if (!read) {
+ pr_err("lzbd: failed to init read\n");
+ bio_io_error(bio);
+ return -EIO;
+ }
+
+ if (!zone->chunks) {
+ /* No data has been written to this zone */
+ zero_fill_bio(bio);
+ bio_endio(bio);
+ kfree(read);
+ return 0;
+ }
+
+ lba -= bz->start >> 3;
+
+ /* TODO: use sector_div instead */
+
+ /* Zone stripe index and offset */
+ zsi = lba / geo->ws_opt; /* zone stripe index */
+ zso = lba % geo->ws_opt; /* zone stripe offset */
+
+ pu = zsi % dl->zone_chunks;
+ read_chunk = zone->chunks[pu];
+
+ /* Chunk stripe index and chunk offset */
+ csi = lba / (dl->zone_chunks * geo->ws_opt);
+ co = csi * geo->ws_opt + zso;
+
+ readsize = min_t(int, geo->ws_opt - zso, to_read);
+
+ while (to_read > 0) {
+ struct bio *rbio = bio;
+ int s_wp = atomic_read(&zone->s_wp);
+
+ if (lba >= s_wp) {
+ /* Grab the write lock to prevent races
+ * with writes
+ */
+ mutex_lock(&zone->lock);
+ if (lba >= atomic_read(&zone->s_wp)) {
+ lzbd_read_from_align_buf(&zone->wr_align, bio,
+ zso, to_read);
+ mutex_unlock(&zone->lock);
+ ret = 0;
+ goto done;
+ }
+ mutex_unlock(&zone->lock);
+ }
+
+ if ((zso + to_read) > geo->ws_opt) {
+
+ rbio = bio_split(bio, readsize << 3, GFP_KERNEL,
+ &lzbd_bio_set);
+
+ if (!rbio) {
+ read->error = true;
+ ret = -EIO;
+ goto done;
+ }
+
+ }
+
+ if (lba + to_read >= s_wp)
+ readsize = s_wp - lba;
+
+ kref_get(&read->ref);
+ ret = lzbd_read_from_chunk_user(lzbd, zone->chunks[pu],
+ rbio, read, co);
+ if (ret) {
+ pr_err("lzbd: user disk read failed!\n");
+ read->error = true;
+ kref_put(&read->ref, lzbd_user_read_put);
+ ret = -EIO;
+ goto done;
+ }
+
+ lba += readsize;
+
+ if (zso) {
+ co -= zso;
+ zso = 0;
+ }
+
+ if (++pu == dl->zone_chunks) {
+ pu = 0;
+ co += geo->ws_opt;
+ }
+
+ to_read -= readsize;
+ readsize = min_t(int, geo->ws_opt, to_read);
+ read_chunk = zone->chunks[pu];
+ }
+
+ ret = 0;
+done:
+ kref_put(&read->ref, lzbd_user_read_put);
+ return ret;
+}
+
diff --git a/drivers/lightnvm/lzbd.h b/drivers/lightnvm/lzbd.h
new file mode 100644
index 000000000000..97cca99a49bf
--- /dev/null
+++ b/drivers/lightnvm/lzbd.h
@@ -0,0 +1,139 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ *
+ * Zoned block device lightnvm target
+ * Copyright (C) 2019 CNEX Labs
+ *
+ */
+
+#include <linux/blkdev.h>
+#include <linux/blk-mq.h>
+#include <linux/bio.h>
+#include <linux/lightnvm.h>
+
+#define LZBD_SECTOR_BITS (12) /* 4096 */
+#define LZBD_SECTOR_SIZE (4096UL)
+
+/* sector unit to lzbd sector shift*/
+#define LZBD_SECTOR_SHIFT (3)
+
+extern struct bio_set lzbd_bio_set;
+
+
+/* Get length, in lzbd sectors, of bio */
+static inline sector_t lzbd_get_bio_len(struct bio *bio)
+{
+ return bio->bi_iter.bi_size >> LZBD_SECTOR_BITS;
+}
+
+/* Get bio start lba in lzbd sectors */
+static inline sector_t lzbd_get_bio_lba(struct bio *bio)
+{
+ return bio->bi_iter.bi_sector >> LZBD_SECTOR_SHIFT;
+}
+
+struct lzbd_wr_ctx {
+ struct lzbd *lzbd;
+ struct mutex wr_lock; /* Max one outstanding write */
+
+ void *private;
+ /* bio completion list goes here, along with lock*/
+};
+
+struct lzbd_user_read {
+ struct bio *user_bio;
+ struct kref ref;
+ bool error;
+};
+
+struct lzbd_rd_ctx {
+ struct lzbd *lzbd;
+ struct lzbd_user_read *read;
+ struct nvm_rq rqd;
+};
+
+struct lzbd_chunk {
+ struct nvm_chk_meta *meta; /* Metadata for the chunk */
+ struct ppa_addr ppa; /* Start ppa */
+ int pu; /* Parallel unit */
+
+ struct lzbd_wr_ctx wr_ctx;
+ struct list_head list; /* A chunk is offline or
+ * part of a PU free list or
+ * part of a zone chunk list or
+ * part of a metadata list
+ */
+
+ /* a cuinits buffer should go here */
+};
+
+struct lzbd_pu {
+ struct list_head chk_list; /* One list per parallel unit */
+ struct mutex lock; /* Protecting list */
+ int offline_chks;
+};
+
+struct lzbd_chunks {
+ struct lzbd_pu *pus; /* Chunks organized per parallel unit*/
+ struct nvm_chk_meta *meta; /* Metadata for all chunks */
+};
+
+struct lzbd_wr_align {
+ void *buffer; /* Buffer data */
+ int secs; /* Number of 4k secs in buffer */
+ struct mutex lock;
+};
+
+struct lzbd_zone {
+ struct blk_zone blk_zone;
+ struct lzbd_chunk **chunks;
+
+ int wi; /* Write chunk index */
+ atomic_t s_wp; /* Sync write pointer */
+
+ struct lzbd_wr_align wr_align; /* Write alignment buffer */
+
+ struct mutex lock; /* Write lock */
+};
+
+struct lzbd_disk_layout {
+ int op; /* Over provision ratio */
+ int meta_chunks; /* Metadata chunks */
+
+ int zones; /* Number of zones */
+ int zone_chunks; /* Zone per chunk */
+ sector_t zone_size; /* Number of 512b sectors per zone */
+
+ sector_t capacity; /* Disk capacity in 512b sectors */
+};
+
+struct lzbd {
+ struct nvm_tgt_dev *dev;
+ struct gendisk *disk;
+
+ struct lzbd_zone *zones;
+
+ struct lzbd_chunks chunks;
+ struct lzbd_disk_layout disk_layout;
+};
+
+blk_qc_t lzbd_make_rq(struct request_queue *q, struct bio *bio);
+
+int lzbd_report_zones(struct gendisk *disk, sector_t sector,
+ struct blk_zone *zones, unsigned int *nr_zones,
+ gfp_t gfp_mask);
+
+int lzbd_reset_chunk(struct lzbd *lzbd, struct lzbd_chunk *chunk);
+int lzbd_write_to_chunk_sync(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *bio);
+int lzbd_write_to_chunk_user(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *user_bio);
+int lzbd_read_from_chunk_user(struct lzbd *lzbd, struct lzbd_chunk *chunk,
+ struct bio *bio, struct lzbd_user_read *user_read,
+ int start);
+int lzbd_zone_reset(struct lzbd *lzbd, struct lzbd_zone *zone);
+int lzbd_zone_write(struct lzbd *lzbd, struct lzbd_zone *zone, struct bio *bio);
+int lzbd_zone_read(struct lzbd *lzbd, struct lzbd_zone *zone, struct bio *bio);
+void lzbd_zone_free_wr_buffer(struct lzbd_zone *zone);
+void lzbd_user_read_put(struct kref *ref);
+
--
2.7.4
\
 
 \ /
  Last update: 2019-04-18 14:03    [W:0.081 / U:1.980 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site