From 3b1affa5c3211579fe5161d85bff0f36dff2cf6d Mon Sep 17 00:00:00 2001
From: sunshihao <sunshihao@huawei.com>
Date: Mon, 1 Mar 2021 10:59:02 +0800
Subject: [PATCH 09/12] spdk: add nvme support for HSAK

Signed-off-by: sunshihao <sunshihao@huawei.com>
---
 include/spdk/bdev.h               |   5 +-
 include/spdk/bdev_module.h        |   4 +-
 include/spdk/nvme.h               |  51 +--------
 include/spdk/thread.h             |   2 +
 lib/bdev/bdev.c                   |  13 ++-
 lib/bdev/bdev_self.c              |  36 +++----
 lib/env_dpdk/env.mk               |   2 +-
 lib/env_dpdk/init.c               |   2 +-
 lib/event/reactor.c               |  11 +-
 lib/nvme/nvme.c                   |  35 +++----
 lib/nvme/nvme_ctrlr.c             |  20 +++-
 lib/nvme/nvme_ctrlr_cmd.c         |  19 ++--
 lib/nvme/nvme_ctrlr_self.c        |   3 +
 lib/nvme/nvme_internal.h          |   3 +-
 lib/nvme/nvme_ns_cmd.c            |   1 -
 lib/nvme/nvme_pcie.c              |   2 -
 lib/nvme/nvme_pcie_common.c       |  10 +-
 lib/nvme/nvme_qpair.c             |  12 +--
 lib/thread/thread.c               |   6 ++
 mk/spdk.common.mk                 |   2 +-
 module/bdev/nvme/bdev_nvme.c      |   9 +-
 module/bdev/nvme/bdev_nvme_self.c | 167 ++++++++++++------------------
 module/bdev/nvme/bdev_nvme_self.h |   2 +-
 scripts/setup_self.sh             |  11 +-
 24 files changed, 196 insertions(+), 232 deletions(-)

diff --git a/include/spdk/bdev.h b/include/spdk/bdev.h
index 55b91f9..aae319e 100644
--- a/include/spdk/bdev.h
+++ b/include/spdk/bdev.h
@@ -1642,12 +1642,13 @@ int spdk_bdev_unmap(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
  * negated errno on failure, in which case the callback will not be called.
  */
 int spdk_bdev_unmap_multiblocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
-				void *unmap_d, uint16_t unmap_count,
+				void *unmap_d, uint32_t unmap_count,
 				spdk_bdev_io_completion_cb cb, void *cb_arg);
 
 void *spdk_bdev_get_channel_group(struct spdk_io_channel *io_ch);
 void *spdk_bdev_io_get_pool(size_t nbytes);
-bool spdk_bdev_have_io_in_channel(struct spdk_io_channel *bdevIoCh);
+bool spdk_bdev_have_io_in_channel(struct spdk_io_channel *io_ch);
+int spdk_bdev_get_channel_state(struct spdk_io_channel *io_ch);
 #endif
 
 /**
diff --git a/include/spdk/bdev_module.h b/include/spdk/bdev_module.h
index 7cb0da3..ff7e219 100644
--- a/include/spdk/bdev_module.h
+++ b/include/spdk/bdev_module.h
@@ -412,8 +412,10 @@ enum reqLocation_E {
 };
 
 void spdk_bdev_nvme_remove_cb(void *cb_ctx, void *ctrlr);
-void spdk_bdev_fail_ctrlr(const char *traddr);
+void spdk_bdev_fail_ctrlr(void *cb_ctx, void *ctrlr);
+struct spdk_nvme_ctrlr *spdk_nvme_bdev_ctrlr_get(char *trid);
 void *nvme_channel_get_group(void *io_ch);
+int nvme_channel_get_state(void *io_ch);
 #endif
 
 /** bdev I/O completion status */
diff --git a/include/spdk/nvme.h b/include/spdk/nvme.h
index ad5da75..6c20c29 100644
--- a/include/spdk/nvme.h
+++ b/include/spdk/nvme.h
@@ -4302,7 +4302,7 @@ bool spdk_nvme_ctrlr_is_format_supported(struct spdk_nvme_ctrlr *ctrlr);
 bool spdk_nvme_ctrlr_is_format_all_ns(struct spdk_nvme_ctrlr *ctrlr);
 bool spdk_nvme_ctrlr_is_directive_supported(struct spdk_nvme_ctrlr *ctrlr);
 bool spdk_nvme_ctrlr_is_streams_supported(struct spdk_nvme_ctrlr *ctrlr);
-int32_t spdk_nvme_ctrlr_identify_directives(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
+int32_t spdk_nvme_ctrlr_identify_directives(struct spdk_nvme_ctrlr *ctrlr, uint16_t nsid,
 		void *payload);
 int32_t spdk_nvme_ctrlr_enable_streams(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid);
 int32_t spdk_nvme_ctrlr_ret_streams_param(struct spdk_nvme_ctrlr *ctrlr, void *payload);
@@ -4330,58 +4330,13 @@ int spdk_bdev_nvme_create_self(struct spdk_nvme_transport_id *trid, const char *
 			       const char **names, size_t *count, const char *hostnqn);
 
 int spdk_nvme_detach_ublock(struct spdk_nvme_ctrlr *ctrlr);
-void spdk_nvme_ctrlr_update_unvmcap(struct spdk_nvme_ctrlr *ctrlr);
-
-#define SPDK_NVME_UEVENT_SUBSYSTEM_UIO 1
-#define SPDK_NVME_UEVENT_SUBSYSTEM_NVME 2
-
-enum spdk_nvme_uevent_action {
-	SPDK_NVME_UEVENT_ADD = 0,
-	SPDK_NVME_UEVENT_REMOVE = 1,
-};
-
-struct spdk_uevent {
-	/* remove or add */
-	enum spdk_nvme_uevent_action action;
-	int subsystem;
-	/* pci address of device */
-	char traddr[SPDK_NVMF_TRADDR_MAX_LEN + 1];
-};
-
-int nvme_uevent_connect(void);
-int nvme_get_uevent(int fd, struct spdk_uevent *uevent);
-int nvme_get_uevent_block(int fd, struct spdk_uevent *uevent);
 int32_t spdk_rebind_driver(char *pci_addr, char *driver_name);
+void spdk_nvme_ctrlr_update_unvmcap(struct spdk_nvme_ctrlr *ctrlr);
+void spdk_nvme_ctrlr_fail_hotplug(struct spdk_nvme_ctrlr *ctrlr);
 bool spdk_nvme_ns_pi_md_start(struct spdk_nvme_ns *ns);
 bool spdk_nvme_ns_is_dataset_mng_supported(struct spdk_nvme_ns *ns);
 uint16_t spdk_nvme_get_qpair_id(struct spdk_nvme_qpair *qpair);
 
-/**
- * \brief Submits a write I/O to the specified NVMe namespace.
- *
- * \param ns NVMe namespace to submit the write I/O
- * \param qpair I/O queue pair to submit the request
- * \param lba starting LBA to write the data
- * \param lba_count length (in sectors) for the write operation
- * \param streamId The stream id for write I/O
- * \param cb_fn callback function to invoke when the I/O is completed
- * \param cb_arg argument to pass to the callback function
- * \param io_flags set flags, defined in nvme_spec.h, for this I/O
- * \param reset_sgl_fn callback function to reset scattered payload
- * \param next_sge_fn callback function to iterate each scattered
- * payload memory segment
- *
- * \return 0 if successfully submitted, ENOMEM if an nvme_request
- *	     structure cannot be allocated for the I/O request
- *
- * The command is submitted to a qpair allocated by spdk_nvme_ctrlr_alloc_io_qpair().
- * The user must ensure that only one thread submits I/O on a given qpair at any given time.
- */
-int spdk_nvme_ns_cmd_writev_stream(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair,
-				   uint64_t lba, uint32_t lba_count, uint16_t streamId,
-				   spdk_nvme_cmd_cb cb_fn, void *cb_arg, uint32_t io_flags,
-				   spdk_nvme_req_reset_sgl_cb reset_sgl_fn,
-				   spdk_nvme_req_next_sge_cb next_sge_fn);
 #endif
 
 /*
diff --git a/include/spdk/thread.h b/include/spdk/thread.h
index 5f239a5..68ddf21 100644
--- a/include/spdk/thread.h
+++ b/include/spdk/thread.h
@@ -57,6 +57,8 @@ void spdk_reactors_use(bool useOrNot);
 bool spdk_get_reactor_type(void);
 
 void spdk_set_thread_exited(struct spdk_thread *thread);
+
+uint32_t spdk_get_channel_ref(void *io_ch);
 #endif
 
 /**
diff --git a/lib/bdev/bdev.c b/lib/bdev/bdev.c
index 88a33e4..8a43fbd 100644
--- a/lib/bdev/bdev.c
+++ b/lib/bdev/bdev.c
@@ -4532,10 +4532,12 @@ bdev_channel_destroy(void *io_device, void *ctx_buf)
 	spdk_trace_record(TRACE_BDEV_IOCH_DESTROY, 0, 0, 0, ch->bdev->name,
 			  spdk_thread_get_id(spdk_io_channel_get_thread(ch->channel)));
 
+#ifndef SPDK_CONFIG_APP_RW
 	/* This channel is going away, so add its statistics into the bdev so that they don't get lost. */
 	spdk_spin_lock(&ch->bdev->internal.spinlock);
 	spdk_bdev_add_io_stat(ch->bdev->internal.stat, ch->stat);
 	spdk_spin_unlock(&ch->bdev->internal.spinlock);
+#endif
 
 	bdev_abort_all_queued_io(&ch->queued_resets, ch);
 
@@ -7938,7 +7940,6 @@ static int
 bdev_start_qos(struct spdk_bdev *bdev)
 {
 	struct set_qos_limit_ctx *ctx;
-
 	/* Enable QoS */
 	if (bdev->internal.qos && bdev->internal.qos->thread == NULL) {
 		ctx = calloc(1, sizeof(*ctx));
@@ -10422,6 +10423,16 @@ spdk_bdev_get_channel_group(struct spdk_io_channel *io_ch)
 	return nvme_channel_get_group(nvme_io_ch);
 }
 
+int
+spdk_bdev_get_channel_state(struct spdk_io_channel *io_ch)
+{
+	struct spdk_bdev_channel *ch = spdk_io_channel_get_ctx(io_ch);
+	struct spdk_io_channel *under_io_ch = ch->channel;
+	void *nvme_io_ch = spdk_io_channel_get_ctx(under_io_ch);
+
+	return nvme_channel_get_state(nvme_io_ch);
+}
+
 bool
 spdk_bdev_have_io_in_channel(struct spdk_io_channel *io_ch)
 {
diff --git a/lib/bdev/bdev_self.c b/lib/bdev/bdev_self.c
index 7050c30..c5b92a3 100644
--- a/lib/bdev/bdev_self.c
+++ b/lib/bdev/bdev_self.c
@@ -30,10 +30,8 @@ struct libstorage_bdev_io_stat *g_io_stat_map;
 int32_t g_libstorage_iostat = 0;
 int32_t g_polltime_threshold = 0;
 
-void
-spdk_bdev_init_iostat(struct spdk_bdev_channel *ch, struct spdk_bdev *bdev,
-		      struct spdk_io_channel *io_ch,
-		      struct spdk_bdev_io_stat *stat)
+void spdk_bdev_init_iostat(struct spdk_bdev_channel *ch, struct spdk_bdev *bdev,
+			   struct spdk_io_channel *io_ch, struct spdk_bdev_io_stat *stat)
 {
 	int		i = 0;
 	bool		find = false;
@@ -95,9 +93,8 @@ spdk_bdev_init_iostat(struct spdk_bdev_channel *ch, struct spdk_bdev *bdev,
 	stat->interval_tsc = spdk_get_ticks_hz() / 10;
 }
 
-void
-spdk_bdev_destroy_iostat(struct spdk_bdev_channel *ch, struct spdk_bdev *bdev,
-			 struct spdk_io_channel *io_ch)
+void spdk_bdev_destroy_iostat(struct spdk_bdev_channel *ch, struct spdk_bdev *bdev,
+			      struct spdk_io_channel *io_ch)
 {
 	int		i = 0;
 	uint16_t	channel_id;
@@ -127,10 +124,9 @@ spdk_bdev_destroy_iostat(struct spdk_bdev_channel *ch, struct spdk_bdev *bdev,
 	}
 }
 
-int
-spdk_bdev_unmap_multiblocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
-			    void *unmap_d, uint16_t unmap_count,
-			    spdk_bdev_io_completion_cb cb, void *cb_arg)
+int spdk_bdev_unmap_multiblocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
+				void *unmap_d, uint32_t unmap_count,
+				spdk_bdev_io_completion_cb cb, void *cb_arg)
 {
 	struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(desc);
 	struct spdk_bdev_io *bdev_io = NULL;
@@ -152,38 +148,38 @@ spdk_bdev_unmap_multiblocks(struct spdk_bdev_desc *desc, struct spdk_io_channel
 	return 0;
 }
 
-void
-bdev_io_stat_update(struct spdk_bdev_io *bdev_io, uint64_t tsc, struct spdk_bdev_io_stat *stat)
+void bdev_io_stat_update(struct spdk_bdev_io *bdev_io, uint64_t tsc_diff,
+			 struct spdk_bdev_io_stat *stat)
 {
 	switch (bdev_io->type) {
 	case SPDK_BDEV_IO_TYPE_READ_NVME:
 		stat->bytes_read += bdev_io->u.contig.nbytes + bdev_io->u.contig.md_len;
 		stat->num_read_ops++;
-		stat->read_latency_ticks += (tsc - bdev_io->internal.submit_tsc);
+		stat->read_latency_ticks += tsc_diff;
 		break;
 	case SPDK_BDEV_IO_TYPE_WRITE_NVME:
 		stat->bytes_written += bdev_io->u.contig.nbytes + bdev_io->u.contig.md_len;
 		stat->num_write_ops++;
-		stat->write_latency_ticks += (tsc - bdev_io->internal.submit_tsc);
+		stat->write_latency_ticks += tsc_diff;
 		break;
 	case SPDK_BDEV_IO_TYPE_READV_NVME:
 		stat->bytes_read += bdev_io->u.bdev.nbytes;
 		stat->num_read_ops++;
-		stat->read_latency_ticks += (tsc - bdev_io->internal.submit_tsc);
+		stat->read_latency_ticks += tsc_diff;
 		break;
 	case SPDK_BDEV_IO_TYPE_WRITEV_NVME:
 		stat->bytes_written += bdev_io->u.bdev.nbytes;
 		stat->num_write_ops++;
-		stat->write_latency_ticks += (tsc - bdev_io->internal.submit_tsc);
+		stat->write_latency_ticks += tsc_diff;
 		break;
 	default:
 		break;
 	}
 }
 
-void
-bdev_update_iostat_map(struct spdk_bdev_io *bdev_io, uint64_t tsc, struct spdk_bdev_io_stat *stat,
-		       struct spdk_io_channel *channel, uint64_t io_outstanding)
+void bdev_update_iostat_map(struct spdk_bdev_io *bdev_io, uint64_t tsc,
+			    struct spdk_bdev_io_stat *stat,
+			    struct spdk_io_channel *channel, uint64_t io_outstanding)
 {
 	uint64_t	num_poll_timeout;
 
diff --git a/lib/env_dpdk/env.mk b/lib/env_dpdk/env.mk
index 4f45c29..3569368 100644
--- a/lib/env_dpdk/env.mk
+++ b/lib/env_dpdk/env.mk
@@ -126,7 +126,7 @@ endif
 DPDK_LIB_LIST_SORTED = $(sort $(DPDK_LIB_LIST))
 
 DPDK_SHARED_LIB = $(DPDK_LIB_LIST_SORTED:%=$(DPDK_LIB_DIR)/lib%.so)
-DPDK_STATIC_LIB = $(DPDK_LIB_LIST_SORTED:%=$(DPDK_LIB_DIR)/lib%.a)
+DPDK_STATIC_LIB = $(DPDK_LIB_LIST_SORTED:%=/usr/lib64/lib%.a)
 DPDK_SHARED_LIB_LINKER_ARGS = $(call add_no_as_needed,$(DPDK_SHARED_LIB)) -Wl,-rpath=$(DPDK_LIB_DIR)
 DPDK_STATIC_LIB_LINKER_ARGS = $(call add_whole_archive,$(DPDK_STATIC_LIB))
 
diff --git a/lib/env_dpdk/init.c b/lib/env_dpdk/init.c
index e94486c..fa32810 100644
--- a/lib/env_dpdk/init.c
+++ b/lib/env_dpdk/init.c
@@ -637,7 +637,7 @@ spdk_env_init(const struct spdk_env_opts *opts)
 		return -EINVAL;
 	}
 
-	SPDK_PRINTF("Starting %s / %s initialization...\n", SPDK_VERSION_STRING, rte_version());
+	printf("Starting %s / %s initialization...\n", SPDK_VERSION_STRING, rte_version());
 
 	args_print = _sprintf_alloc("[ DPDK EAL parameters: ");
 	if (args_print == NULL) {
diff --git a/lib/event/reactor.c b/lib/event/reactor.c
index 6f604e1..9a8e39a 100644
--- a/lib/event/reactor.c
+++ b/lib/event/reactor.c
@@ -29,6 +29,7 @@
 #endif
 
 #define SPDK_EVENT_BATCH_SIZE		8
+#define SPDK_EVENT_MAX_BATCH_SIZE	32
 
 #ifdef SPDK_CONFIG_APP_RW
 struct spdk_iodev_thread_info lcore_thread_info[RTE_MAX_LCORE];
@@ -225,7 +226,7 @@ spdk_reactors_init(size_t msg_mempool_size)
 	sp = spdk_conf_find_section(NULL, "Reactor");
 	if (sp != 0) {
 		g_reactor_batch_size = spdk_conf_section_get_intval(sp, "BatchSize");
-		if (g_reactor_batch_size <= 0 || g_reactor_batch_size > SPDK_EVENT_BATCH_SIZE) {
+		if (g_reactor_batch_size <= 0 || g_reactor_batch_size > SPDK_EVENT_MAX_BATCH_SIZE) {
 			g_reactor_batch_size = SPDK_EVENT_BATCH_SIZE;
 		}
 		syslog(LOG_INFO, "BatchSize is set to %d\n", g_reactor_batch_size);
@@ -990,9 +991,6 @@ reactor_run(void *arg)
 		}
 
 		if (g_reactor_state != SPDK_REACTOR_STATE_RUNNING) {
-#ifdef SPDK_CONFIG_APP_RW
-			lcore_thread_info[reactor->lcore].state = SPDK_THREAD_STATE_EXITED;
-#endif
 			break;
 		}
 	}
@@ -1029,7 +1027,10 @@ reactor_run(void *arg)
 			}
 		}
 	}
-
+#ifdef SPDK_CONFIG_APP_RW
+	/* When all thread in reactor is finish, inform libstorage to release resource. */
+	lcore_thread_info[reactor->lcore].state = SPDK_THREAD_STATE_EXITED;
+#endif
 	return 0;
 }
 
diff --git a/lib/nvme/nvme.c b/lib/nvme/nvme.c
index 28a48c3..32f46d1 100644
--- a/lib/nvme/nvme.c
+++ b/lib/nvme/nvme.c
@@ -12,6 +12,7 @@
 #include "spdk/nvme.h"
 #include "spdk_internal/debug.h"
 #include "spdk/bdev_module.h"
+#include <sys/prctl.h>
 
 #define SPDK_NVME_DRIVER_NAME "spdk_nvme_driver"
 
@@ -73,6 +74,9 @@ static void admin_timer_timeout(void)
 
 static void *nvme_ctrlr_run_admin_timer(void *arg)
 {
+#if defined(__linux__)
+	prctl(PR_SET_NAME, "nvme-admin", 0, 0, 0);
+#endif
 	sleep(20);
 
 	while (1) {
@@ -566,6 +570,11 @@ nvme_request_check_timeout(struct nvme_request *req, uint16_t cid,
 			   struct spdk_nvme_ctrlr_process *active_proc,
 			   uint64_t now_tick)
 {
+	if (req == NULL) {
+		SPDK_WARNLOG("Get invalid req from tracker!\n");
+		return 1;
+	}
+
 	struct spdk_nvme_qpair *qpair = req->qpair;
 	struct spdk_nvme_ctrlr *ctrlr = qpair->ctrlr;
 	uint64_t timeout_ticks = nvme_qpair_is_admin_queue(qpair) ?
@@ -606,26 +615,16 @@ nvme_request_check_timeout(struct nvme_request *req, uint16_t cid,
 				   nvme_qpair_is_admin_queue(qpair) ? NULL : qpair,
 				   cid);
 #else
-	if (!nvme_qpair_is_admin_queue(qpair) && (req->cmd.opc == SPDK_NVME_OPC_WRITE ||
-			req->cmd.opc == SPDK_NVME_OPC_READ)) {
-		SPDK_WARNLOG("IO timeout, OP[%u] NS[%u] LBA[%lu].\n", req->cmd.opc, req->cmd.nsid,
-			     *(uint64_t *)&req->cmd.cdw10);
-	} else {
-		SPDK_WARNLOG("%s Command[%u] timeout.\n", nvme_qpair_is_admin_queue(qpair) ?
-			     "Admin" : "IO", req->cmd.opc);
-	}
-	if (req->timed_out) {
-		/* Reset the controller if the command was already timed out. */
-		SPDK_WARNLOG("IO Command[%u] timeout again, reset controller.\n", cid);
-		active_proc->timeout_cb_fn(active_proc->timeout_cb_arg, ctrlr, NULL, cid);
-	} else {
+	if (!req->timed_out) {
 		req->timed_out = true;
-		active_proc->timeout_cb_fn(active_proc->timeout_cb_arg, ctrlr,
-					   nvme_qpair_is_admin_queue(qpair) ? NULL : qpair,
-					   cid);
-		/* Timing again. Reset the controller if it times out again */
-		req->submit_tick = spdk_get_ticks();
+		SPDK_WARNLOG("%s Command[%u] timeout. ctrlr=%p qpair=%p cid=%u\n",
+			     nvme_qpair_is_admin_queue(qpair) ? "Admin" : "IO",
+			     req->cmd.opc, ctrlr, qpair, cid);
 	}
+	active_proc->timeout_cb_fn(active_proc->timeout_cb_arg, ctrlr,
+				   nvme_qpair_is_admin_queue(qpair) ? NULL : qpair, cid);
+	/* Update submit tick to reduce timeout num. */
+	req->submit_tick = spdk_get_ticks();
 #endif
 	return 0;
 }
diff --git a/lib/nvme/nvme_ctrlr.c b/lib/nvme/nvme_ctrlr.c
index 4143c15..f935318 100644
--- a/lib/nvme/nvme_ctrlr.c
+++ b/lib/nvme/nvme_ctrlr.c
@@ -7,6 +7,7 @@
 #include "spdk/stdinc.h"
 
 #include "nvme_internal.h"
+#include "nvme_pcie_internal.h"
 #include "nvme_io_msg.h"
 
 #include "spdk/env.h"
@@ -591,7 +592,9 @@ spdk_nvme_ctrlr_free_io_qpair(struct spdk_nvme_qpair *qpair)
 	}
 
 	ctrlr = qpair->ctrlr;
-
+	if (ctrlr == NULL) {
+		return 0;
+	}
 	if (qpair->in_completion_context) {
 		/*
 		 * There are many cases where it is convenient to delete an io qpair in the context
@@ -1114,6 +1117,16 @@ nvme_ctrlr_shutdown_get_cc_done(void *_ctx, uint64_t value, const struct spdk_nv
 	}
 }
 
+#ifdef SPDK_CONFIG_APP_RW
+void
+spdk_nvme_ctrlr_fail_hotplug(struct spdk_nvme_ctrlr *ctrlr)
+{
+	nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
+	nvme_ctrlr_fail(ctrlr, true);
+	nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
+}
+#endif
+
 static void
 nvme_ctrlr_shutdown_async(struct spdk_nvme_ctrlr *ctrlr,
 			  struct nvme_ctrlr_detach_ctx *ctx)
@@ -3311,7 +3324,6 @@ struct spdk_nvme_ctrlr_process *
 nvme_ctrlr_get_process(struct spdk_nvme_ctrlr *ctrlr, pid_t pid)
 {
 	struct spdk_nvme_ctrlr_process	*active_proc;
-
 	TAILQ_FOREACH(active_proc, &ctrlr->active_procs, tailq) {
 		if (active_proc->pid == pid) {
 			return active_proc;
@@ -5326,6 +5338,10 @@ spdk_nvme_ctrlr_alloc_qid(struct spdk_nvme_ctrlr *ctrlr)
 void
 spdk_nvme_ctrlr_free_qid(struct spdk_nvme_ctrlr *ctrlr, uint16_t qid)
 {
+	if (ctrlr->free_io_qids == NULL) {
+		return;
+	}
+
 	assert(qid <= ctrlr->opts.num_io_queues);
 
 	nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
diff --git a/lib/nvme/nvme_ctrlr_cmd.c b/lib/nvme/nvme_ctrlr_cmd.c
index 416f099..f83ad92 100644
--- a/lib/nvme/nvme_ctrlr_cmd.c
+++ b/lib/nvme/nvme_ctrlr_cmd.c
@@ -611,17 +611,13 @@ nvme_ctrlr_retry_queued_abort(struct spdk_nvme_ctrlr *ctrlr)
 		}
 	}
 
+	return;
 #ifdef SPDK_CONFIG_APP_RW
-	nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
-	if (rc < 0) {
-		/* If abort fail, free all of the queued abort requests */
-		STAILQ_FOREACH_SAFE(next, &ctrlr->queued_aborts, stailq, tmp) {
-			STAILQ_REMOVE_HEAD(&ctrlr->queued_aborts, stailq);
-			nvme_free_request(next);
-			ctrlr->outstanding_aborts--;
-		}
+free:
+	STAILQ_FOREACH_SAFE(next, &ctrlr->queued_aborts, stailq, tmp) {
+		STAILQ_REMOVE_HEAD(&ctrlr->queued_aborts, stailq);
+		nvme_free_request(next);
 	}
-	nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
 #endif
 
 }
@@ -650,9 +646,10 @@ nvme_ctrlr_cmd_abort_cpl(void *ctx, const struct spdk_nvme_cpl *cpl)
 
 	assert(ctrlr->outstanding_aborts > 0);
 	ctrlr->outstanding_aborts--;
-	nvme_ctrlr_retry_queued_abort(ctrlr);
-
+	/* If abort is failed, just reset the ctrlr. */
 	req->user_cb_fn(req->user_cb_arg, cpl);
+
+	nvme_ctrlr_retry_queued_abort(ctrlr);
 }
 
 int
diff --git a/lib/nvme/nvme_ctrlr_self.c b/lib/nvme/nvme_ctrlr_self.c
index 6ad8bc9..e3f1d0c 100644
--- a/lib/nvme/nvme_ctrlr_self.c
+++ b/lib/nvme/nvme_ctrlr_self.c
@@ -219,5 +219,8 @@ int32_t spdk_nvme_ctrlr_identify_directives(struct spdk_nvme_ctrlr *ctrlr, uint1
 
 uint16_t spdk_nvme_get_qpair_id(struct spdk_nvme_qpair *qpair)
 {
+	if (qpair == NULL) {
+		return -1;
+	}
 	return qpair->id;
 }
diff --git a/lib/nvme/nvme_internal.h b/lib/nvme/nvme_internal.h
index a18fb78..ca64907 100644
--- a/lib/nvme/nvme_internal.h
+++ b/lib/nvme/nvme_internal.h
@@ -492,6 +492,7 @@ struct spdk_nvme_qpair {
 	STAILQ_HEAD(, nvme_request)		aborting_queued_req;
 
 	void					*req_buf;
+	uint32_t                                disconnected_time;
 };
 
 struct spdk_nvme_poll_group {
@@ -1288,8 +1289,8 @@ int	nvme_ctrlr_parse_ana_log_page(struct spdk_nvme_ctrlr *ctrlr,
 	} while (0);
 
 #ifdef SPDK_CONFIG_APP_RW
+bool   nvme_qpair_check_enabled(struct spdk_nvme_qpair *qpair);
 void	nvme_ctrlr_destruct_ublock(struct spdk_nvme_ctrlr *ctrlr);
-void	nvme_qpair_abort_reqs(struct spdk_nvme_qpair *qpair, uint32_t dnr);
 #endif
 
 static inline struct nvme_request *
diff --git a/lib/nvme/nvme_ns_cmd.c b/lib/nvme/nvme_ns_cmd.c
index 3f37cd7..9f88b4c 100644
--- a/lib/nvme/nvme_ns_cmd.c
+++ b/lib/nvme/nvme_ns_cmd.c
@@ -494,7 +494,6 @@ _nvme_ns_cmd_rw(struct spdk_nvme_ns *ns, struct spdk_nvme_qpair *qpair,
 	uint32_t		sector_size = _nvme_get_host_buffer_sector_size(ns, io_flags);
 	uint32_t		sectors_per_max_io = _nvme_get_sectors_per_max_io(ns, io_flags);
 	uint32_t		sectors_per_stripe = ns->sectors_per_stripe;
-	int			rc;
 
 	assert(rc != NULL);
 	assert(*rc == 0);
diff --git a/lib/nvme/nvme_pcie.c b/lib/nvme/nvme_pcie.c
index b4d2923..9e55427 100644
--- a/lib/nvme/nvme_pcie.c
+++ b/lib/nvme/nvme_pcie.c
@@ -1030,9 +1030,7 @@ nvme_pcie_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr)
 		spdk_pci_device_unclaim(devhandle);
 		spdk_pci_device_detach(devhandle);
 	}
-
 	spdk_free(pctrlr);
-
 	return 0;
 }
 
diff --git a/lib/nvme/nvme_pcie_common.c b/lib/nvme/nvme_pcie_common.c
index 669f66f..c268793 100644
--- a/lib/nvme/nvme_pcie_common.c
+++ b/lib/nvme/nvme_pcie_common.c
@@ -937,7 +937,7 @@ nvme_pcie_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_
 			__builtin_prefetch(&tr->req->stailq);
 			nvme_pcie_qpair_complete_tracker(qpair, tr, cpl, true);
 		} else {
-			SPDK_ERRLOG("cpl does not map to outstanding cmd\n");
+			SPDK_NOTICELOG("cpl does not map to outstanding cmd\n");
 			spdk_nvme_qpair_print_completion(qpair, cpl);
 			assert(0);
 		}
@@ -1038,7 +1038,6 @@ nvme_pcie_qpair_destroy(struct spdk_nvme_qpair *qpair)
 	}
 
 	spdk_free(pqpair);
-
 	return 0;
 }
 
@@ -1086,8 +1085,6 @@ nvme_pcie_ctrlr_delete_io_qpair(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_
 	struct nvme_completion_poll_status *status;
 	int rc;
 
-	assert(ctrlr != NULL);
-
 	if (ctrlr->is_removed) {
 		goto free;
 	}
@@ -1773,6 +1770,10 @@ nvme_pcie_poll_group_process_completions(struct spdk_nvme_transport_poll_group *
 		if (spdk_unlikely(local_completions < 0)) {
 			disconnected_qpair_cb(qpair, tgroup->group->ctx);
 			total_completions = -ENXIO;
+			qpair->disconnected_time++;
+			if (qpair->disconnected_time > 50) {
+				qpair->delete_after_completion_context = 1;
+			}
 		} else if (spdk_likely(total_completions >= 0)) {
 			total_completions += local_completions;
 		}
@@ -1787,7 +1788,6 @@ nvme_pcie_poll_group_destroy(struct spdk_nvme_transport_poll_group *tgroup)
 	if (!STAILQ_EMPTY(&tgroup->connected_qpairs) || !STAILQ_EMPTY(&tgroup->disconnected_qpairs)) {
 		return -EBUSY;
 	}
-
 	free(tgroup);
 
 	return 0;
diff --git a/lib/nvme/nvme_qpair.c b/lib/nvme/nvme_qpair.c
index 5e0aa73..11e49dd 100644
--- a/lib/nvme/nvme_qpair.c
+++ b/lib/nvme/nvme_qpair.c
@@ -632,7 +632,7 @@ nvme_qpair_abort_queued_reqs_with_cbarg(struct spdk_nvme_qpair *qpair, void *cmd
 	return aborting;
 }
 
-static inline bool
+bool
 nvme_qpair_check_enabled(struct spdk_nvme_qpair *qpair)
 {
 	struct nvme_request *req;
@@ -645,7 +645,7 @@ nvme_qpair_check_enabled(struct spdk_nvme_qpair *qpair)
 	 * to submit any queued requests that built up while we were in the connected or enabling state.
 	 */
 	if (spdk_unlikely(nvme_qpair_get_state(qpair) == NVME_QPAIR_CONNECTED &&
-			  !qpair->ctrlr->is_resetting && !qpair->ctrlr->is_removed && !qpair->ctrlr->is_destructed)) {
+			  !qpair->ctrlr->is_resetting)) {
 		nvme_qpair_set_state(qpair, NVME_QPAIR_ENABLING);
 		/*
 		 * PCIe is special, for fabrics transports, we can abort requests before disconnect during reset
@@ -972,13 +972,7 @@ _nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *r
 				rc = nvme_qpair_submit_request(qpair, child_req);
 				if (spdk_unlikely(rc != 0)) {
 					child_req_failed = true;
-#ifdef SPDK_CONFIG_APP_RW
-					if (rc == -ENXIO && child_req->num_children == 0) {
-						SPDK_WARNLOG("Warning: child req submit failed.\n");
-						nvme_request_remove_child(req, child_req);
-						nvme_free_request(child_req);
-					}
-#endif
+					SPDK_WARNLOG("Warning: child req submit failed.\n");
 				}
 			} else { /* free remaining child_reqs since one child_req fails */
 				nvme_request_remove_child(req, child_req);
diff --git a/lib/thread/thread.c b/lib/thread/thread.c
index 344869d..7d3169e 100644
--- a/lib/thread/thread.c
+++ b/lib/thread/thread.c
@@ -2782,6 +2782,12 @@ thread_interrupt_create(struct spdk_thread *thread)
 {
 	return -ENOTSUP;
 }
+
+uint32_t spdk_get_channel_ref(void *io_ch)
+{
+	struct spdk_io_channel *ch = io_ch;
+	return ch->ref;
+}
 #endif
 
 static int
diff --git a/mk/spdk.common.mk b/mk/spdk.common.mk
index a9cef8f..2765c04 100644
--- a/mk/spdk.common.mk
+++ b/mk/spdk.common.mk
@@ -340,7 +340,7 @@ endif
 SYS_LIBS += -lssl
 SYS_LIBS += -lcrypto
 SYS_LIBS += -lm
-SYS_LIBS += -lsecurec
+SYS_LIBS += -lboundscheck
 
 PKGCONF ?= pkg-config
 ifneq ($(strip $(CONFIG_OPENSSL_PATH)),)
diff --git a/module/bdev/nvme/bdev_nvme.c b/module/bdev/nvme/bdev_nvme.c
index 6cc2628..28c0eaf 100644
--- a/module/bdev/nvme/bdev_nvme.c
+++ b/module/bdev/nvme/bdev_nvme.c
@@ -8319,12 +8319,17 @@ bdev_nvme_get_discovery_info(struct spdk_json_write_ctx *w)
 }
 
 #ifdef SPDK_CONFIG_APP_RW
-void *
-nvme_channel_get_group(void *io_ch)
+void *nvme_channel_get_group(void *io_ch)
 {
 	struct nvme_io_channel *nvme_io_ch = io_ch;
 	return nvme_io_ch->group;
 }
+
+int nvme_channel_get_state(void *io_ch)
+{
+	struct nvme_io_channel *nvme_ch = io_ch;
+	return nvme_ch->state;
+}
 struct nvme_bdev_io *nvme_bdev_io_update_args(struct nvme_bdev_io *bio, struct iovec *iov,
 		int iovcnt)
 {
diff --git a/module/bdev/nvme/bdev_nvme_self.c b/module/bdev/nvme/bdev_nvme_self.c
index 1419b1f..dc480ff 100644
--- a/module/bdev/nvme/bdev_nvme_self.c
+++ b/module/bdev/nvme/bdev_nvme_self.c
@@ -15,7 +15,6 @@
 #include "spdk/json.h"
 #include "spdk/likely.h"
 #include "spdk/bdev_module.h"
-#include "spdk/nvme_ocssd.h"
 #include "spdk/nvme.h"
 
 #include "spdk_internal/bdev_stat.h"
@@ -23,11 +22,6 @@
 #include "common.h"
 #include <securec.h>
 
-enum data_direction {
-	BDEV_DISK_READ = 0,
-	BDEV_DISK_WRITE = 1
-};
-
 void bdev_update_ch_timeout(struct nvme_bdev_poll_group *group)
 {
 	uint64_t current_ticks = 0;
@@ -49,8 +43,7 @@ void bdev_update_ch_timeout(struct nvme_bdev_poll_group *group)
 	}
 }
 
-int
-_bdev_nvme_submit_request_self(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+int _bdev_nvme_submit_request_self(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
 {
 	struct nvme_io_channel *nvme_ch = spdk_io_channel_get_ctx(ch);
 
@@ -65,27 +58,27 @@ _bdev_nvme_submit_request_self(struct spdk_io_channel *ch, struct spdk_bdev_io *
 			      bdev_io->u.contig.offset_blocks);
 		return bdev_nvme_queue_cmd_with_md((struct nvme_bdev *)bdev_io->bdev->ctxt, nvme_ch->qpair,
 						   bdev_io->driver_ctx, bdev_io->u.contig.buf,
-						   bdev_io->u.contig.md_buf, BDEV_DISK_READ,
+						   bdev_io->u.contig.md_buf, SPDK_BDEV_IO_TYPE_READ,
 						   bdev_io->u.contig.num_blocks, bdev_io->u.contig.offset_blocks);
 	case SPDK_BDEV_IO_TYPE_WRITE_NVME:
 		SPDK_DEBUGLOG(bdev_nvme, "write %lu lbas with offset %#lx\n", bdev_io->u.contig.num_blocks,
 			      bdev_io->u.contig.offset_blocks);
 		return bdev_nvme_queue_cmd_with_md((struct nvme_bdev *)bdev_io->bdev->ctxt, nvme_ch->qpair,
 						   bdev_io->driver_ctx, bdev_io->u.contig.buf,
-						   bdev_io->u.contig.md_buf, BDEV_DISK_WRITE,
+						   bdev_io->u.contig.md_buf, SPDK_BDEV_IO_TYPE_WRITE,
 						   bdev_io->u.contig.num_blocks, bdev_io->u.contig.offset_blocks);
 	case SPDK_BDEV_IO_TYPE_READV_NVME:
 		SPDK_DEBUGLOG(bdev_nvme, "readv %lu lbas with offset %#lx\n", bdev_io->u.bdev.num_blocks,
 			      bdev_io->u.bdev.offset_blocks);
 		return bdev_nvme_queue_cmd_v_with_md((struct nvme_bdev *)bdev_io->bdev->ctxt, nvme_ch->qpair,
-						     bdev_io->driver_ctx, BDEV_DISK_READ,
+						     bdev_io->driver_ctx, SPDK_BDEV_IO_TYPE_READ,
 						     bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
 						     bdev_io->u.bdev.num_blocks, bdev_io->u.bdev.offset_blocks);
 	case SPDK_BDEV_IO_TYPE_WRITEV_NVME:
 		SPDK_DEBUGLOG(bdev_nvme, "writev %lu lbas with offset %#lx\n", bdev_io->u.bdev.num_blocks,
 			      bdev_io->u.bdev.offset_blocks);
 		return bdev_nvme_queue_cmd_v_with_md((struct nvme_bdev *)bdev_io->bdev->ctxt, nvme_ch->qpair,
-						     bdev_io->driver_ctx, BDEV_DISK_WRITE,
+						     bdev_io->driver_ctx, SPDK_BDEV_IO_TYPE_WRITE,
 						     bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
 						     bdev_io->u.bdev.num_blocks, bdev_io->u.bdev.offset_blocks);
 	case SPDK_BDEV_IO_TYPE_UNMAP_BLOCKS:
@@ -100,14 +93,12 @@ _bdev_nvme_submit_request_self(struct spdk_io_channel *ch, struct spdk_bdev_io *
 	return 0;
 }
 
-int
-bdev_nvme_dump_info_json_self(void *ctx, struct spdk_json_write_ctx *w)
+int bdev_nvme_dump_info_json_self(void *ctx, struct spdk_json_write_ctx *w)
 {
 	return 0;
 }
 
-uint16_t
-bdev_nvme_get_io_channel_id(struct spdk_io_channel *ch)
+uint16_t bdev_nvme_get_io_channel_id(struct spdk_io_channel *ch)
 {
 	struct nvme_io_channel *nvme_ch = spdk_io_channel_get_ctx(ch);
 	uint16_t channel_id;
@@ -116,15 +107,13 @@ bdev_nvme_get_io_channel_id(struct spdk_io_channel *ch)
 	return channel_id;
 }
 
-uint64_t
-bdev_nvme_get_timeout_count(struct spdk_io_channel *ch)
+uint64_t bdev_nvme_get_timeout_count(struct spdk_io_channel *ch)
 {
 	struct nvme_io_channel *nvme_ch = spdk_io_channel_get_ctx(ch);
 	return nvme_ch->group->num_poll_timeout;
 }
 
-int32_t
-nvme_ctrlr_get_info(const char *ctrlName, struct nvme_ctrlr_info **ppCtrlr)
+int32_t nvme_ctrlr_get_info(const char *ctrlName, struct nvme_ctrlr_info **ppCtrlr)
 {
 	uint32_t num_ctrlr = 0, i = 0;
 	struct nvme_bdev_ctrlr *nvme_bdev_ctrlr = NULL;
@@ -221,8 +210,7 @@ nvme_ctrlr_get_info(const char *ctrlName, struct nvme_ctrlr_info **ppCtrlr)
 	return num_ctrlr;
 }
 
-struct nvme_bdev_ctrlr *
-nvme_ctrlr_get_by_name(const char *name)
+struct nvme_bdev_ctrlr *nvme_ctrlr_get_by_name(const char *name)
 {
 	struct nvme_bdev_ctrlr *nvme_bdev_ctrlr = NULL;
 
@@ -239,8 +227,7 @@ nvme_ctrlr_get_by_name(const char *name)
 	return NULL;
 }
 
-struct spdk_nvme_ctrlr *
-spdk_nvme_ctrlr_get_by_name(const char *ctrlname)
+struct spdk_nvme_ctrlr *spdk_nvme_ctrlr_get_by_name(const char *ctrlname)
 {
 	struct nvme_bdev_ctrlr	*nvme_bdev_ctrlr = NULL;
 
@@ -253,8 +240,7 @@ spdk_nvme_ctrlr_get_by_name(const char *ctrlname)
 	return NULL;
 }
 
-struct spdk_nvme_ctrlr *
-spdk_nvme_ctrlr_get_by_ctrlr(const struct nvme_bdev_ctrlr *nvme_bdev_ctrlr)
+struct spdk_nvme_ctrlr *spdk_nvme_ctrlr_get_by_ctrlr(const struct nvme_bdev_ctrlr *nvme_bdev_ctrlr)
 {
 	if (nvme_bdev_ctrlr == NULL) {
 		return NULL;
@@ -262,8 +248,7 @@ spdk_nvme_ctrlr_get_by_ctrlr(const struct nvme_bdev_ctrlr *nvme_bdev_ctrlr)
 	return nvme_bdev_ctrlr->ctrlr;
 }
 
-void
-nvme_ctrlr_clear_iostat_by_name(const char *ctrlname)
+void nvme_ctrlr_clear_iostat_by_name(const char *ctrlname)
 {
 	int i;
 	size_t size = strnlen(ctrlname, 24);
@@ -288,8 +273,7 @@ nvme_ctrlr_clear_iostat_by_name(const char *ctrlname)
 	}
 }
 
-void
-nvme_ctrlr_clear_iostat_all(void)
+void nvme_ctrlr_clear_iostat_all(void)
 {
 	struct nvme_bdev_ctrlr	*nvme_bdev_ctrlr = NULL;
 
@@ -298,8 +282,7 @@ nvme_ctrlr_clear_iostat_all(void)
 	}
 }
 
-struct spdk_nvme_ns *
-bdev_nvme_get_ns(struct nvme_bdev *nbdev)
+struct spdk_nvme_ns *bdev_nvme_get_ns(struct nvme_bdev *nbdev)
 {
 	return nbdev->nvme_ns->ns;
 }
@@ -331,11 +314,10 @@ void bdev_nvme_update_block_by_nvme_ctrlr(struct spdk_nvme_ctrlr *ctrlr)
 	pthread_mutex_unlock(&g_bdev_nvme_mutex);
 }
 
-int
-bdev_nvme_update_ns(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
+int bdev_nvme_update_ns(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 {
-	struct spdk_nvme_ctrlr	*ctrlr = nvme_bdev_ctrlr->ctrlr;
 	struct nvme_bdev_ns	*ns = NULL;
+	bool ns_active = spdk_nvme_ctrlr_is_active_ns(nvme_bdev_ctrlr->ctrlr, nsid);
 
 	if (nvme_bdev_ctrlr == NULL || nsid > nvme_bdev_ctrlr->num_ns) {
 		SPDK_ERRLOG("Parameter error. nsid[%u], the max nsid is[%u]\n", nsid, nvme_bdev_ctrlr->num_ns);
@@ -343,14 +325,9 @@ bdev_nvme_update_ns(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 	}
 
 	ns = nvme_bdev_ctrlr->namespaces[nsid - 1];
+	ns->type = NVME_BDEV_NS_STANDARD;
 
-	if (spdk_nvme_ctrlr_is_ocssd_supported(ctrlr)) {
-		ns->type = NVME_BDEV_NS_OCSSD;
-	} else {
-		ns->type = NVME_BDEV_NS_STANDARD;
-	}
-
-	if (!ns->populated && spdk_nvme_ctrlr_is_active_ns(nvme_bdev_ctrlr->ctrlr, nsid)) {
+	if (!ns->populated && ns_active) {
 		SPDK_NOTICELOG("NSID %u to be added\n", nsid);
 		ns->id = nsid;
 		ns->ctrlr = nvme_bdev_ctrlr;
@@ -360,16 +337,16 @@ bdev_nvme_update_ns(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 		return 0;
 	}
 
-	if (ns->populated && !spdk_nvme_ctrlr_is_active_ns(nvme_bdev_ctrlr->ctrlr, nsid)) {
+	if (ns->populated && !ns_active) {
 		SPDK_NOTICELOG("NSID %u is removed\n", nsid);
 		nvme_ctrlr_depopulate_namespace(nvme_bdev_ctrlr, ns);
 		return 0;
 	}
-	return -1;
+
+	return 0;
 }
 
-bool
-spdk_bdev_can_remove(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
+bool spdk_bdev_can_remove(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 {
 	struct nvme_bdev_ns *ns = NULL;
 	struct nvme_bdev *bdev = NULL, *tmp = NULL;
@@ -398,8 +375,7 @@ spdk_bdev_can_remove(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 	return empty;
 }
 
-void
-spdk_bdev_set_ns_normal(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
+void spdk_bdev_set_ns_normal(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 {
 	struct nvme_bdev_ns *ns = NULL;
 	struct nvme_bdev *bdev = NULL, *tmp = NULL;
@@ -419,9 +395,18 @@ spdk_bdev_set_ns_normal(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr, uint32_t nsid)
 	}
 }
 
-int
-bdev_nvme_queue_cmd_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qpair, void *driver_ctx,
-			    void *buffer, void *metadata, int direction, uint64_t lba_count, uint64_t lba)
+static void check_error_type(int rc, bool read, void *qpair)
+{
+	if (rc == -ENOMEM) {
+		SPDK_NOTICELOG("%s failed: rc = %d\n", read ? "read" : "write", rc);
+	} else if (rc < 0) {
+		SPDK_ERRLOG("%s failed: rc = %d, qpair is %p\n", read ? "read" : "write", rc, qpair);
+	}
+}
+
+int bdev_nvme_queue_cmd_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qpair,
+				void *driver_ctx,
+				void *buffer, void *metadata, int direction, uint64_t lba_count, uint64_t lba)
 {
 	int rc;
 	uint32_t io_flags = 0;
@@ -452,7 +437,7 @@ bdev_nvme_queue_cmd_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qpai
 		io_flags |= SPDK_NVME_IO_FLAGS_FORCE_UNIT_ACCESS;
 	}
 
-	if (direction == BDEV_DISK_READ) {
+	if (direction == SPDK_BDEV_IO_TYPE_READ) {
 		rc = spdk_nvme_ns_cmd_read_with_md(bdev->nvme_ns->ns, qpair, buffer, metadata, lba,
 						   lba_count, bdev_nvme_queued_done, driver_ctx, io_flags, 0, 0);
 	} else {
@@ -460,21 +445,13 @@ bdev_nvme_queue_cmd_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qpai
 						    lba_count, bdev_nvme_queued_done, driver_ctx, io_flags, 0, 0);
 	}
 
-	if (rc != 0) {
-		if (rc == -ENOMEM) {
-			SPDK_NOTICELOG("%s failed: rc = %d\n", direction == BDEV_DISK_READ ? "read" : "write", rc);
-		} else {
-			SPDK_ERRLOG("%s failed: rc = %d, qpair is %p\n", direction == BDEV_DISK_READ ? "read" : "write",
-				    rc, qpair);
-		}
-	}
+	check_error_type(rc, direction == SPDK_BDEV_IO_TYPE_READ, qpair);
 	return rc;
 }
 
-int
-bdev_nvme_queue_cmd_v_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qpair,
-			      void *driver_ctx,
-			      int direction, struct iovec *iov, int iovcnt, uint64_t lba_count, uint64_t lba)
+int bdev_nvme_queue_cmd_v_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qpair,
+				  void *driver_ctx,
+				  int direction, struct iovec *iov, int iovcnt, uint64_t lba_count, uint64_t lba)
 {
 	int rc;
 	struct nvme_bdev_io *bio = NULL;
@@ -508,29 +485,21 @@ bdev_nvme_queue_cmd_v_with_md(struct nvme_bdev *bdev, struct spdk_nvme_qpair *qp
 
 	bio = nvme_bdev_io_update_args((struct nvme_bdev_io *)driver_ctx, iov, iovcnt);
 
-	if (direction == BDEV_DISK_READ) {
+	if (direction == SPDK_BDEV_IO_TYPE_READ) {
 		rc = spdk_nvme_ns_cmd_readv(bdev->nvme_ns->ns, qpair, lba,
 					    lba_count, bdev_nvme_queued_done, bio, io_flags,
 					    bdev_nvme_queued_reset_sgl, bdev_nvme_queued_next_sge);
 	} else {
 		rc = spdk_nvme_ns_cmd_writev(bdev->nvme_ns->ns, qpair, lba, lba_count,
-						    0, bdev_nvme_queued_done, bio, io_flags,
+						    bdev_nvme_queued_done, bio, io_flags,
 						    bdev_nvme_queued_reset_sgl, bdev_nvme_queued_next_sge);
 	}
 
-	if (rc != 0) {
-		if (rc == -ENOMEM) {
-			SPDK_NOTICELOG("%s failed: rc = %d\n", direction == BDEV_DISK_READ ? "readv" : "writev", rc);
-		} else {
-			SPDK_ERRLOG("%s failed: rc = %d, qpair is %p\n", direction == BDEV_DISK_READ ? "read" : "write", rc,
-				    qpair);
-		}
-	}
+	check_error_type(rc, direction == SPDK_BDEV_IO_TYPE_READ, qpair);
 	return rc;
 }
 
-struct nvme_bdev_ctrlr *
-bdev_nvme_get_ctrlr_by_bdev_desc(void *bdev_desc)
+struct nvme_bdev_ctrlr *bdev_nvme_get_ctrlr_by_bdev_desc(void *bdev_desc)
 {
 	struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(bdev_desc);
 	struct nvme_bdev *nbdev = (struct nvme_bdev *)bdev->ctxt;
@@ -540,12 +509,11 @@ bdev_nvme_get_ctrlr_by_bdev_desc(void *bdev_desc)
 	return nbdev->nvme_ns->ctrlr;
 }
 
-int
-bdev_nvme_unmap_blocks(struct nvme_bdev *nbdev, struct spdk_io_channel *ch, void *driver_ctx,
-		       struct spdk_nvme_dsm_range *unmap_d, uint16_t unmap_count)
+int bdev_nvme_unmap_blocks(struct nvme_bdev *nbdev, struct spdk_io_channel *ch, void *driver_ctx,
+			   struct spdk_nvme_dsm_range *unmap_d, uint32_t unmap_count)
 {
 	struct nvme_io_channel *nvme_ch = spdk_io_channel_get_ctx(ch);
-	int i;
+	uint32_t i;
 
 	if (unmap_count == 0 || unmap_count > SPDK_NVME_DATASET_MANAGEMENT_MAX_RANGES) {
 		SPDK_ERRLOG("Invalid parameter, unmap count: %u\n", unmap_count);
@@ -566,36 +534,39 @@ bdev_nvme_unmap_blocks(struct nvme_bdev *nbdev, struct spdk_io_channel *ch, void
 
 	spdk_bdev_set_io_location(driver_ctx, (uint8_t)LOCAL_LIBSTORAGE_BDEV_NVME);
 	return spdk_nvme_ns_cmd_dataset_management(nbdev->nvme_ns->ns, nvme_ch->qpair,
-						   SPDK_NVME_DSM_ATTR_DEALLOCATE,
-						   unmap_d, unmap_count,
-						   bdev_nvme_queued_done, driver_ctx);
+			SPDK_NVME_DSM_ATTR_DEALLOCATE,
+			unmap_d, unmap_count,
+			bdev_nvme_queued_done, driver_ctx);
 }
 
-void
-spdk_bdev_nvme_remove_cb(void *cb_ctx, void *ctrlr)
+void spdk_bdev_nvme_remove_cb(void *cb_ctx, void *ctrlr)
 {
 	remove_cb(cb_ctx, (struct spdk_nvme_ctrlr *)ctrlr);
 }
 
-void spdk_bdev_fail_ctrlr(const char *traddr)
+void spdk_bdev_fail_ctrlr(void *cb_ctx, void *ctrlr)
 {
-	struct nvme_bdev_ctrlr *nvme_bdev_ctrlr;
+	spdk_nvme_ctrlr_fail_hotplug((struct spdk_nvme_ctrlr *)ctrlr);
+	remove_cb(cb_ctx, (struct spdk_nvme_ctrlr *)ctrlr);
+}
+
+struct spdk_nvme_ctrlr *spdk_nvme_bdev_ctrlr_get(char *pci_trid)
+{
+	struct nvme_bdev_ctrlr	*nvme_bdev_ctrlr;
 
-	pthread_mutex_lock(&g_bdev_nvme_mutex);
 	TAILQ_FOREACH(nvme_bdev_ctrlr, &g_nvme_bdev_ctrlrs, tailq) {
-		if (strcmp(nvme_bdev_ctrlr->connected_trid->traddr, traddr) == 0) {
-			spdk_nvme_ctrlr_fail(nvme_bdev_ctrlr->ctrlr);
-			remove_cb(NULL, nvme_bdev_ctrlr->ctrlr);
-			return;
+		if (strcmp(nvme_bdev_ctrlr->connected_trid->traddr, pci_trid) == 0) {
+			return nvme_bdev_ctrlr->ctrlr;
 		}
 	}
+
+	return NULL;
 }
 
-int
-spdk_bdev_nvme_create_self(struct spdk_nvme_transport_id *trid,
-			   const char *base_name,
-			   const char **names, size_t *count,
-			   const char *hostnqn)
+int spdk_bdev_nvme_create_self(struct spdk_nvme_transport_id *trid,
+			       const char *base_name,
+			       const char **names, size_t *count,
+			       const char *hostnqn)
 {
 	struct nvme_probe_ctx	*probe_ctx;
 	struct nvme_bdev_ctrlr	*nvme_bdev_ctrlr;
@@ -616,7 +587,7 @@ spdk_bdev_nvme_create_self(struct spdk_nvme_transport_id *trid,
 		return -1;
 	}
 
-	if (spdk_nvme_probe(trid, probe_ctx, probe_cb, attach_cb, NULL)) {
+	if (spdk_nvme_probe(trid, probe_ctx, probe_cb, attach_cb, remove_cb)) {
 		SPDK_ERRLOG("Failed to probe for new devices\n");
 		free(probe_ctx);
 		return -1;
diff --git a/module/bdev/nvme/bdev_nvme_self.h b/module/bdev/nvme/bdev_nvme_self.h
index d7cc587..43ad7ee 100644
--- a/module/bdev/nvme/bdev_nvme_self.h
+++ b/module/bdev/nvme/bdev_nvme_self.h
@@ -40,4 +40,4 @@ bdev_nvme_get_ctrlr_by_bdev_desc(void *bdev_desc);
 
 int
 bdev_nvme_unmap_blocks(struct nvme_bdev *nbdev, struct spdk_io_channel *ch, void *driver_ctx,
-		       struct spdk_nvme_dsm_range *unmap_d, uint16_t unmap_count);
+		       struct spdk_nvme_dsm_range *unmap_d, uint32_t unmap_count);
diff --git a/scripts/setup_self.sh b/scripts/setup_self.sh
index 9e77c29..90b7f86 100755
--- a/scripts/setup_self.sh
+++ b/scripts/setup_self.sh
@@ -30,8 +30,15 @@ function linux_bind_driver() {
 
 	echo "$bdf ($ven_dev_id): $old_driver_name -> $driver_name"
 
-	echo "$ven_dev_id" > "/sys/bus/pci/drivers/$driver_name/new_id" 2> /dev/null || true
-	echo "$bdf" > "/sys/bus/pci/drivers/$driver_name/bind" 2> /dev/null || true
+	if [ "$driver_name" = "nvme" ]
+        then
+                echo 1 > /sys/bus/pci/devices/$bdf/remove
+                sleep 1
+                echo 1 > /sys/bus/pci/rescan
+        else
+                echo "$ven_dev_id" > "/sys/bus/pci/drivers/$driver_name/new_id" 2> /dev/null || true
+                echo "$bdf" > "/sys/bus/pci/drivers/$driver_name/bind" 2> /dev/null || true
+        fi
 }
 
 function linux_hugetlbfs_mount() {
-- 
2.43.0