packages/spdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
spdk/0023-spdk-add-nvme-support-for-HSAK.patch
Weifeng Su 4970683a63 Add support for HSAK 
Signed-off-by: Weifeng Su <suweifeng1@huawei.com>
2022-07-18 14:59:26 +00:00

1652 lines
56 KiB
Diff
Raw Blame History

From fa58cf908e76613a4c9ea84bc96c83bd92354822 Mon Sep 17 00:00:00 2001
From: sunshihao <sunshihao@huawei.com>
Date: Mon, 1 Mar 2021 10:59:02 +0800
Subject: [PATCH 23/27] spdk: add nvme support for HSAK
Signed-off-by: sunshihao <sunshihao@huawei.com>
---
configure | 2 +-
include/spdk/bdev.h | 7 +-
include/spdk/bdev_module.h | 4 +-
include/spdk/nvme.h | 51 +--------
include/spdk/thread.h | 2 +
lib/bdev/bdev.c | 53 +++++++---
lib/bdev/bdev_self.c | 36 +++----
lib/env_dpdk/env.mk | 2 +-
lib/env_dpdk/init.c | 8 +-
lib/event/reactor.c | 13 +--
lib/nvme/nvme.c | 35 +++----
lib/nvme/nvme_ctrlr.c | 33 ++++--
lib/nvme/nvme_ctrlr_cmd.c | 33 +++---
lib/nvme/nvme_ctrlr_self.c | 3 +
lib/nvme/nvme_internal.h | 5 +-
lib/nvme/nvme_ns_cmd.c | 2 +-
lib/nvme/nvme_pcie.c | 6 +-
lib/nvme/nvme_pcie_common.c | 12 ++-
lib/nvme/nvme_qpair.c | 13 +--
lib/nvme/nvme_uevent.h | 2 -
lib/thread/thread.c | 21 ++--
mk/spdk.common.mk | 2 +-
module/bdev/nvme/bdev_nvme.c | 50 +++++----
module/bdev/nvme/bdev_nvme_self.c | 167 ++++++++++++------------------
module/bdev/nvme/bdev_nvme_self.h | 2 +-
module/bdev/nvme/common.h | 1 +
scripts/setup_self.sh | 11 +-
27 files changed, 279 insertions(+), 297 deletions(-)
diff --git a/configure b/configure
index 964322e..01db27a 100644
--- a/configure
+++ b/configure
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
set -e
diff --git a/include/spdk/bdev.h b/include/spdk/bdev.h
index d0284d9..5f30340 100644
--- a/include/spdk/bdev.h
+++ b/include/spdk/bdev.h
@@ -862,7 +862,7 @@ int spdk_bdev_read_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *c
* * -ENOMEM - spdk_bdev_io buffer cannot be allocated
*/
int spdk_bdev_read_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
- void *buf, void *md, int64_t offset_blocks, uint64_t num_blocks,
+ void *buf, void *md, uint64_t offset_blocks, uint64_t num_blocks,
spdk_bdev_io_completion_cb cb, void *cb_arg);
/**
@@ -1410,12 +1410,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 55dc980..e901e14 100644
--- a/include/spdk/bdev_module.h
+++ b/include/spdk/bdev_module.h
@@ -267,8 +267,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 9acfb89..fb2e5f9 100644
--- a/include/spdk/nvme.h
+++ b/include/spdk/nvme.h
@@ -3495,7 +3495,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);
@@ -3523,58 +3523,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 7c52433..9fea1bd 100644
--- a/include/spdk/thread.h
+++ b/include/spdk/thread.h
@@ -73,6 +73,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 1d8ce99..6daaef9 100644
--- a/lib/bdev/bdev.c
+++ b/lib/bdev/bdev.c
@@ -1546,7 +1546,11 @@ void
spdk_bdev_module_finish_done(void)
{
if (spdk_get_thread() != g_fini_thread) {
+#ifndef SPDK_CONFIG_APP_RW
spdk_thread_send_msg(g_fini_thread, bdev_module_finish_iter, NULL);
+#else
+ bdev_module_finish_iter(NULL);
+#endif
} else {
bdev_module_finish_iter(NULL);
}
@@ -3096,10 +3100,12 @@ bdev_channel_destroy(void *io_device, void *ctx_buf)
SPDK_DEBUGLOG(bdev, "Destroying channel %p for bdev %s on thread %p\n", ch, ch->bdev->name,
spdk_get_thread());
+#ifndef SPDK_CONFIG_APP_RW
/* This channel is going away, so add its statistics into the bdev so that they don't get lost. */
pthread_mutex_lock(&ch->bdev->internal.mutex);
bdev_io_stat_add(&ch->bdev->internal.stat, &ch->stat);
pthread_mutex_unlock(&ch->bdev->internal.mutex);
+#endif
mgmt_ch = shared_resource->mgmt_ch;
@@ -3592,7 +3598,7 @@ bdev_build_contig_io(uint8_t type, void *buf, void *md_buf, uint64_t offset_bloc
static int
bdev_read_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, void *buf,
- void *md_buf, int64_t offset_blocks, uint64_t num_blocks,
+ void *md_buf, uint64_t offset_blocks, uint64_t num_blocks,
spdk_bdev_io_completion_cb cb, void *cb_arg)
{
struct spdk_bdev *bdev = spdk_bdev_desc_get_bdev(desc);
@@ -3656,20 +3662,22 @@ spdk_bdev_read_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
int
spdk_bdev_read_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
- void *buf, void *md_buf, int64_t offset_blocks, uint64_t num_blocks,
+ void *buf, void *md_buf, uint64_t offset_blocks, uint64_t num_blocks,
spdk_bdev_io_completion_cb cb, void *cb_arg)
{
+#ifndef SPDK_CONFIG_APP_RW
struct iovec iov = {
.iov_base = buf,
};
-#ifndef SPDK_CONFIG_APP_RW
+
if (!spdk_bdev_is_md_separate(spdk_bdev_desc_get_bdev(desc))) {
return -EINVAL;
}
-#endif
+
if (!_bdev_io_check_md_buf(&iov, md_buf)) {
return -EINVAL;
}
+#endif
return bdev_read_blocks_with_md(desc, ch, buf, md_buf, offset_blocks, num_blocks,
cb, cb_arg);
@@ -3835,19 +3843,19 @@ spdk_bdev_write_blocks_with_md(struct spdk_bdev_desc *desc, struct spdk_io_chann
void *buf, void *md_buf, uint64_t offset_blocks, uint64_t num_blocks,
spdk_bdev_io_completion_cb cb, void *cb_arg)
{
+#ifndef SPDK_CONFIG_APP_RW
struct iovec iov = {
.iov_base = buf,
};
-#ifndef SPDK_CONFIG_APP_RW
if (!spdk_bdev_is_md_separate(spdk_bdev_desc_get_bdev(desc))) {
return -EINVAL;
}
-#endif
+
if (!_bdev_io_check_md_buf(&iov, md_buf)) {
return -EINVAL;
}
-
+#endif
return bdev_write_blocks_with_md(desc, ch, buf, md_buf, offset_blocks, num_blocks,
cb, cb_arg);
}
@@ -5158,12 +5166,14 @@ bdev_io_complete(void *ctx)
bdev_io->internal.io_submit_ch = NULL;
}
+ if (bdev_io->internal.in_submit_request) {
+ bdev_io->internal.in_submit_request = false;
+ }
/*
* Defer completion to avoid potential infinite recursion if the
* user's completion callback issues a new I/O.
*/
- spdk_thread_send_msg(spdk_bdev_io_get_thread(bdev_io),
- bdev_io_complete, bdev_io);
+ bdev_io_complete(bdev_io);
return;
}
@@ -5214,7 +5224,7 @@ bdev_io_complete(void *ctx)
break;
}
#ifdef SPDK_CONFIG_APP_RW
- bdev_io_stat_update(bdev_io, tsc, &bdev_io->internal.ch->stat);
+ bdev_io_stat_update(bdev_io, tsc_diff, &bdev_io->internal.ch->stat);
#endif
}
@@ -5647,10 +5657,12 @@ bdev_start(struct spdk_bdev *bdev)
SPDK_DEBUGLOG(bdev, "Inserting bdev %s into list\n", bdev->name);
TAILQ_INSERT_TAIL(&g_bdev_mgr.bdevs, bdev, internal.link);
+#ifndef SPDK_CONFIG_APP_RW
/* Examine configuration before initializing I/O */
bdev_examine(bdev);
spdk_bdev_wait_for_examine(bdev_start_finished, bdev);
+#endif
}
int
@@ -5729,7 +5741,14 @@ bdev_unregister_unsafe(struct spdk_bdev *bdev)
*/
desc->refs++;
pthread_mutex_unlock(&desc->mutex);
- spdk_thread_send_msg(desc->thread, _remove_notify, desc);
+ }
+
+ TAILQ_FOREACH_SAFE(desc, &bdev->internal.open_descs, link, tmp) {
+ pthread_mutex_unlock(&bdev->internal.mutex);
+ pthread_mutex_unlock(&g_bdev_mgr.mutex);
+ _remove_notify(desc);
+ pthread_mutex_lock(&bdev->internal.mutex);
+ pthread_mutex_lock(&g_bdev_mgr.mutex);
}
/* If there are no descriptors, proceed removing the bdev */
@@ -5794,7 +5813,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));
@@ -6010,7 +6028,6 @@ spdk_bdev_close(struct spdk_bdev_desc *desc)
if (bdev->internal.status == SPDK_BDEV_STATUS_REMOVING && TAILQ_EMPTY(&bdev->internal.open_descs)) {
rc = bdev_unregister_unsafe(bdev);
pthread_mutex_unlock(&bdev->internal.mutex);
-
if (rc == 0) {
bdev_fini(bdev);
}
@@ -7054,6 +7071,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 292dd91..1e4f63c 100644
--- a/lib/env_dpdk/env.mk
+++ b/lib/env_dpdk/env.mk
@@ -120,7 +120,7 @@ endif
endif
DPDK_SHARED_LIB = $(DPDK_LIB_LIST:%=$(DPDK_ABS_DIR)/lib/lib%.so)
-DPDK_STATIC_LIB = $(DPDK_LIB_LIST:%=$(DPDK_ABS_DIR)/lib/lib%.a)
+DPDK_STATIC_LIB = $(DPDK_LIB_LIST:%=/usr/lib64/lib%.a)
DPDK_SHARED_LIB_LINKER_ARGS = $(call add_no_as_needed,$(DPDK_SHARED_LIB))
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 3bb713d..1c18a8b 100644
--- a/lib/env_dpdk/init.c
+++ b/lib/env_dpdk/init.c
@@ -561,12 +561,12 @@ spdk_env_init(const struct spdk_env_opts *opts)
return -EINVAL;
}
- SPDK_PRINTF("Starting %s / %s initialization...\n", SPDK_VERSION_STRING, rte_version());
- SPDK_PRINTF("[ DPDK EAL parameters: ");
+ printf("Starting %s / %s initialization...\n", SPDK_VERSION_STRING, rte_version());
+ printf("[ DPDK EAL parameters: ");
for (i = 0; i < g_eal_cmdline_argcount; i++) {
- SPDK_PRINTF("%s ", g_eal_cmdline[i]);
+ printf("%s ", g_eal_cmdline[i]);
}
- SPDK_PRINTF("]\n");
+ printf("]\n");
/* DPDK rearranges the array we pass to it, so make a copy
* before passing so we can still free the individual strings
diff --git a/lib/event/reactor.c b/lib/event/reactor.c
index 3eb8799..9d92875 100644
--- a/lib/event/reactor.c
+++ b/lib/event/reactor.c
@@ -55,6 +55,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];
@@ -262,7 +263,7 @@ spdk_reactors_init(void)
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);
@@ -550,7 +551,7 @@ static inline uint32_t
event_queue_run_batch(struct spdk_reactor *reactor)
{
unsigned count, i;
- void *events[SPDK_EVENT_BATCH_SIZE];
+ void *events[SPDK_EVENT_MAX_BATCH_SIZE];
struct spdk_thread *thread;
struct spdk_lw_thread *lw_thread;
@@ -969,9 +970,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;
}
}
@@ -1003,7 +1001,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 fca2f41..b0cc321 100644
--- a/lib/nvme/nvme.c
+++ b/lib/nvme/nvme.c
@@ -39,6 +39,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"
@@ -100,6 +101,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) {
@@ -561,6 +565,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;
@@ -599,26 +608,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 fa28f07..27468a7 100644
--- a/lib/nvme/nvme_ctrlr.c
+++ b/lib/nvme/nvme_ctrlr.c
@@ -34,6 +34,7 @@
#include "spdk/stdinc.h"
#include "nvme_internal.h"
+#include "nvme_pcie_internal.h"
#include "nvme_io_msg.h"
#include "spdk/env.h"
@@ -512,7 +513,6 @@ spdk_nvme_ctrlr_free_io_qpair(struct spdk_nvme_qpair *qpair)
}
ctrlr = qpair->ctrlr;
-
if (qpair->in_completion_context) {
/*
* There are many cases where it is convenient to delete an io qpair in the context
@@ -543,12 +543,16 @@ spdk_nvme_ctrlr_free_io_qpair(struct spdk_nvme_qpair *qpair)
* exits unexpectedly. In that case, we must not try to abort any reqs associated
* with that qpair, since the callbacks will also be foreign to this process.
*/
+
+ if (ctrlr == NULL) {
+ return 0;
+ }
+
if (qpair->active_proc == nvme_ctrlr_get_current_process(ctrlr)) {
nvme_qpair_abort_reqs(qpair, 1);
}
nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
-
nvme_ctrlr_proc_remove_io_qpair(qpair);
TAILQ_REMOVE(&ctrlr->active_io_qpairs, qpair, tailq);
@@ -907,6 +911,16 @@ spdk_nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr)
nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
}
+#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)
@@ -1102,7 +1116,6 @@ nvme_ctrlr_disable(struct spdk_nvme_ctrlr *ctrlr)
return 0;
}
-#ifdef DEBUG
static const char *
nvme_ctrlr_state_string(enum nvme_ctrlr_state state)
{
@@ -1182,7 +1195,6 @@ nvme_ctrlr_state_string(enum nvme_ctrlr_state state)
}
return "unknown";
};
-#endif /* DEBUG */
static void
nvme_ctrlr_set_state(struct spdk_nvme_ctrlr *ctrlr, enum nvme_ctrlr_state state,
@@ -1209,12 +1221,12 @@ nvme_ctrlr_set_state(struct spdk_nvme_ctrlr *ctrlr, enum nvme_ctrlr_state state,
}
ctrlr->state_timeout_tsc = timeout_in_ticks + now_ticks;
- SPDK_DEBUGLOG(nvme, "setting state to %s (timeout %" PRIu64 " ms)\n",
- nvme_ctrlr_state_string(ctrlr->state), timeout_in_ms);
+ SPDK_NOTICELOG("setting state to %s (timeout %" PRIu64 " ms)\n",
+ nvme_ctrlr_state_string(ctrlr->state), timeout_in_ms);
return;
inf:
- SPDK_DEBUGLOG(nvme, "setting state to %s (no timeout)\n",
- nvme_ctrlr_state_string(ctrlr->state));
+ SPDK_NOTICELOG("setting state to %s (no timeout)\n",
+ nvme_ctrlr_state_string(ctrlr->state));
ctrlr->state_timeout_tsc = NVME_TIMEOUT_INFINITE;
}
@@ -2729,7 +2741,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;
@@ -4135,6 +4146,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 d335bc6..7a7e625 100644
--- a/lib/nvme/nvme_ctrlr_cmd.c
+++ b/lib/nvme/nvme_ctrlr_cmd.c
@@ -581,16 +581,18 @@ nvme_ctrlr_retry_queued_abort(struct spdk_nvme_ctrlr *ctrlr)
rc = nvme_ctrlr_submit_admin_request(ctrlr, next);
if (rc < 0) {
SPDK_ERRLOG("Failed to submit queued abort.\n");
-#ifndef SPDK_CONFIG_APP_RW
+#ifdef SPDK_CONFIG_APP_RW
+ /* If submit abort fail, free all req in queued aborts */
+ ctrlr->outstanding_aborts--;
+ nvme_free_request(next);
+ goto free;
+#else
memset(&next->cpl, 0, sizeof(next->cpl));
next->cpl.status.sct = SPDK_NVME_SCT_GENERIC;
next->cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
next->cpl.status.dnr = 1;
nvme_complete_request(next->cb_fn, next->cb_arg, next->qpair, next, &next->cpl);
nvme_free_request(next);
-#else
- nvme_free_request(next);
- break;
#endif
} else {
/* If the first abort succeeds, stop iterating. */
@@ -598,17 +600,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
}
@@ -635,9 +633,10 @@ nvme_ctrlr_cmd_abort_cpl(void *ctx, const struct spdk_nvme_cpl *cpl)
ctrlr = req->qpair->ctrlr;
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
@@ -1006,7 +1005,9 @@ nvme_ctrlr_cmd_directive(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
cmd->opc = opc_type;
cmd->nsid = nsid;
- cmd->cdw10 = (payload_size >> 2) - 1;
+ if (payload_size != 0) {
+ cmd->cdw10 = (payload_size >> 2) - 1;
+ }
cmd->cdw11_bits.directive.doper = doper;
cmd->cdw11_bits.directive.dtype = dtype;
cmd->cdw11_bits.directive.dspec = dspec;
diff --git a/lib/nvme/nvme_ctrlr_self.c b/lib/nvme/nvme_ctrlr_self.c
index 4ac1925..8adabfc 100644
--- a/lib/nvme/nvme_ctrlr_self.c
+++ b/lib/nvme/nvme_ctrlr_self.c
@@ -224,5 +224,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 6934f9f..31328f0 100644
--- a/lib/nvme/nvme_internal.h
+++ b/lib/nvme/nvme_internal.h
@@ -457,6 +457,8 @@ struct spdk_nvme_qpair {
const struct spdk_nvme_transport *transport;
uint8_t transport_failure_reason: 2;
+
+ uint32_t disconnected_time;
};
struct spdk_nvme_poll_group {
@@ -1069,10 +1071,9 @@ typedef int (*spdk_nvme_parse_ana_log_page_cb)(
const struct spdk_nvme_ana_group_descriptor *desc, void *cb_arg);
int nvme_ctrlr_parse_ana_log_page(struct spdk_nvme_ctrlr *ctrlr,
spdk_nvme_parse_ana_log_page_cb cb_fn, void *cb_arg);
-
+bool nvme_qpair_check_enabled(struct spdk_nvme_qpair *qpair);
#ifdef SPDK_CONFIG_APP_RW
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 9b67b8e..b8d9a90 100644
--- a/lib/nvme/nvme_ns_cmd.c
+++ b/lib/nvme/nvme_ns_cmd.c
@@ -462,7 +462,7 @@ _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 = ns->sectors_per_max_io;
uint32_t sectors_per_stripe = ns->sectors_per_stripe;
- int rc;
+ int rc = 0;
req = nvme_allocate_request(qpair, payload, lba_count * sector_size, lba_count * ns->md_size,
cb_fn, cb_arg);
diff --git a/lib/nvme/nvme_pcie.c b/lib/nvme/nvme_pcie.c
index 0e9e24d..1b4b958 100644
--- a/lib/nvme/nvme_pcie.c
+++ b/lib/nvme/nvme_pcie.c
@@ -755,9 +755,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;
}
@@ -1244,6 +1242,10 @@ nvme_pcie_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_reques
bool sgl_supported;
bool dword_aligned = true;
+ if (!nvme_qpair_check_enabled(qpair)) {
+ return -EBUSY;
+ }
+
if (spdk_unlikely(nvme_qpair_is_admin_queue(qpair))) {
nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
}
diff --git a/lib/nvme/nvme_pcie_common.c b/lib/nvme/nvme_pcie_common.c
index 564f81b..1dc9c99 100644
--- a/lib/nvme/nvme_pcie_common.c
+++ b/lib/nvme/nvme_pcie_common.c
@@ -840,7 +840,7 @@ nvme_pcie_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_
if (tr->req) {
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);
}
@@ -905,7 +905,6 @@ nvme_pcie_qpair_destroy(struct spdk_nvme_qpair *qpair)
nvme_qpair_deinit(qpair);
spdk_free(pqpair);
-
return 0;
}
@@ -952,8 +951,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;
}
@@ -1005,6 +1002,7 @@ free:
nvme_pcie_qpair_abort_trackers(qpair, 1);
}
+ nvme_qpair_abort_reqs(qpair, 1);
nvme_pcie_qpair_destroy(qpair);
return 0;
}
@@ -1064,6 +1062,11 @@ nvme_pcie_poll_group_process_completions(struct spdk_nvme_transport_poll_group *
local_completions = spdk_nvme_qpair_process_completions(qpair, completions_per_qpair);
if (local_completions < 0) {
disconnected_qpair_cb(qpair, tgroup->group->ctx);
+ qpair->disconnected_time++;
+ if (qpair->disconnected_time > 50) {
+ qpair->poll_group->num_qpairs_to_delete++;
+ qpair->delete_after_completion_context = 1;
+ }
local_completions = 0;
}
total_completions += local_completions;
@@ -1078,7 +1081,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 3aabd63..f11d070 100644
--- a/lib/nvme/nvme_qpair.c
+++ b/lib/nvme/nvme_qpair.c
@@ -600,7 +600,7 @@ nvme_qpair_abort_queued_reqs(struct spdk_nvme_qpair *qpair, void *cmd_cb_arg)
return aborting;
}
-static inline bool
+bool
nvme_qpair_check_enabled(struct spdk_nvme_qpair *qpair)
{
struct nvme_request *req;
@@ -612,8 +612,7 @@ nvme_qpair_check_enabled(struct spdk_nvme_qpair *qpair)
* from the old transport connection and encourage the application to retry them. We also need
* to submit any queued requests that built up while we were in the connected or enabling state.
*/
- if (nvme_qpair_get_state(qpair) == NVME_QPAIR_CONNECTED && !qpair->ctrlr->is_resetting
- && !qpair->ctrlr->is_removed && !qpair->ctrlr->is_destructed) {
+ if (nvme_qpair_get_state(qpair) == NVME_QPAIR_CONNECTED && !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
@@ -857,13 +856,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/nvme/nvme_uevent.h b/lib/nvme/nvme_uevent.h
index 1921801..94f6710 100644
--- a/lib/nvme/nvme_uevent.h
+++ b/lib/nvme/nvme_uevent.h
@@ -41,7 +41,6 @@
#ifndef SPDK_UEVENT_H_
#define SPDK_UEVENT_H_
-#ifndef SPDK_CONFIG_APP_RW
#define SPDK_NVME_UEVENT_SUBSYSTEM_UNRECOGNIZED 0
#define SPDK_NVME_UEVENT_SUBSYSTEM_UIO 1
#define SPDK_NVME_UEVENT_SUBSYSTEM_VFIO 2
@@ -59,6 +58,5 @@ struct spdk_uevent {
int nvme_uevent_connect(void);
int nvme_get_uevent(int fd, struct spdk_uevent *uevent);
-#endif
#endif /* SPDK_UEVENT_H_ */
diff --git a/lib/thread/thread.c b/lib/thread/thread.c
index 1ab822b..a3d342e 100644
--- a/lib/thread/thread.c
+++ b/lib/thread/thread.c
@@ -57,6 +57,12 @@ void spdk_set_thread_exited(struct spdk_thread *thread)
{
thread->state = SPDK_THREAD_STATE_EXITED;
}
+
+uint32_t spdk_get_channel_ref(void *io_ch)
+{
+ struct spdk_io_channel *ch = io_ch;
+ return ch->ref;
+}
#endif
static pthread_mutex_t g_devlist_mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -1147,11 +1153,6 @@ spdk_poller_unregister(struct spdk_poller **ppoller)
struct spdk_thread *thread;
struct spdk_poller *poller;
- if (!g_bRunReactor) {
- *ppoller = NULL;
- return;
- }
-
poller = *ppoller;
if (poller == NULL) {
return;
@@ -1413,12 +1414,10 @@ _finish_unregister(void *arg)
struct spdk_thread *thread;
thread = spdk_get_thread();
- assert(thread == dev->unregister_thread);
SPDK_DEBUGLOG(thread, "Finishing unregistration of io_device %s (%p) on thread %s\n",
dev->name, dev->io_device, thread->name);
- assert(thread->pending_unregister_count > 0);
thread->pending_unregister_count--;
dev->unregister_cb(dev->io_device);
@@ -1468,7 +1467,6 @@ spdk_io_device_unregister(void *io_device, spdk_io_device_unregister_cb unregist
if (!dev) {
SPDK_ERRLOG("io_device %p not found\n", io_device);
- assert(false);
pthread_mutex_unlock(&g_devlist_mutex);
return;
}
@@ -1545,8 +1543,8 @@ spdk_get_io_channel(void *io_device)
if (ch->dev == dev) {
ch->ref++;
- SPDK_DEBUGLOG(thread, "Get io_channel %p for io_device %s (%p) on thread %s refcnt %u\n",
- ch, dev->name, dev->io_device, thread->name, ch->ref);
+ SPDK_NOTICELOG("Get io_channel %p for io_device %s (%p) on thread %s refcnt %u\n",
+ ch, dev->name, dev->io_device, thread->name, ch->ref);
/*
* An I/O channel already exists for this device on this
@@ -1798,7 +1796,6 @@ spdk_for_each_channel(void *io_device, spdk_channel_msg fn, void *ctx,
#else
_call_channel(i);
#endif
- assert(rc == 0);
return;
}
}
@@ -1821,7 +1818,7 @@ spdk_for_each_channel_continue(struct spdk_io_channel_iter *i, int status)
struct spdk_io_channel *ch;
int rc __attribute__((unused));
- assert(i->cur_thread == spdk_get_thread());
+ /* assert(i->cur_thread == spdk_get_thread()); */
i->status = status;
diff --git a/mk/spdk.common.mk b/mk/spdk.common.mk
index 6bdc1dd..da214c8 100644
--- a/mk/spdk.common.mk
+++ b/mk/spdk.common.mk
@@ -254,7 +254,7 @@ CXXFLAGS += $(COMMON_CFLAGS)
SYS_LIBS += -lrt
SYS_LIBS += -luuid
SYS_LIBS += -lcrypto
-SYS_LIBS += -lsecurec
+SYS_LIBS += -lboundscheck
ifneq ($(CONFIG_NVME_CUSE)$(CONFIG_FUSE),nn)
SYS_LIBS += -lfuse3
diff --git a/module/bdev/nvme/bdev_nvme.c b/module/bdev/nvme/bdev_nvme.c
index 01d0238..d291646 100644
--- a/module/bdev/nvme/bdev_nvme.c
+++ b/module/bdev/nvme/bdev_nvme.c
@@ -280,9 +280,6 @@ bdev_nvme_poll(void *arg)
}
}
- if (!spdk_get_reactor_type()) {
- return num_completions;
- }
return num_completions > 0 ? SPDK_POLLER_BUSY : SPDK_POLLER_IDLE;
}
@@ -315,7 +312,6 @@ bdev_nvme_destruct(void *ctx)
pthread_mutex_unlock(&g_bdev_nvme_mutex);
nvme_bdev_ns_detach(nvme_ns);
-
free(nvme_disk->disk.name);
free(nvme_disk);
@@ -930,6 +926,7 @@ bdev_nvme_create_cb(void *io_device, void *ctx_buf)
goto err_qpair;
}
+ nvme_ch->state = 0;
return 0;
err_qpair:
@@ -956,6 +953,7 @@ bdev_nvme_destroy_cb(void *io_device, void *ctx_buf)
spdk_nvme_ctrlr_free_io_qpair(nvme_ch->qpair);
spdk_put_io_channel(spdk_io_channel_from_ctx(nvme_ch->group));
+ nvme_ch->state = 1;
}
static int
@@ -970,7 +968,7 @@ bdev_nvme_poll_group_create_cb(void *io_device, void *ctx_buf)
group->poller = SPDK_POLLER_REGISTER(bdev_nvme_poll, group, g_opts.nvme_ioq_poll_period_us);
- if (group->poller == NULL && spdk_get_reactor_type()) {
+ if (group->poller == NULL) {
spdk_nvme_poll_group_destroy(group->group);
return -1;
}
@@ -985,7 +983,7 @@ bdev_nvme_poll_group_destroy_cb(void *io_device, void *ctx_buf)
spdk_poller_unregister(&group->poller);
if (spdk_nvme_poll_group_destroy(group->group)) {
- SPDK_ERRLOG("Unable to destroy a poll group for the NVMe bdev module.");
+ SPDK_ERRLOG("Unable to destroy a poll group for the NVMe bdev module.\n");
assert(false);
}
}
@@ -1320,8 +1318,9 @@ nvme_abort_cpl(void *ctx, const struct spdk_nvme_cpl *cpl)
struct nvme_bdev_ctrlr *nvme_bdev_ctrlr = ctx;
if (spdk_nvme_cpl_is_error(cpl)) {
- SPDK_WARNLOG("Abort failed. Resetting controller.\n");
- _bdev_nvme_reset(nvme_bdev_ctrlr, NULL);
+ SPDK_WARNLOG("Abort failed, sc is %u, sct is %u. Resetting controller.\n", cpl->status.sc,
+ cpl->status.sct);
+ spdk_nvme_ctrlr_reset(nvme_bdev_ctrlr->ctrlr);
}
}
@@ -1335,8 +1334,6 @@ timeout_cb(void *cb_arg, struct spdk_nvme_ctrlr *ctrlr,
assert(nvme_bdev_ctrlr->ctrlr == ctrlr);
- SPDK_WARNLOG("Warning: Detected a timeout. ctrlr=%p qpair=%p cid=%u\n", ctrlr, qpair, cid);
-
/* Only try to read CSTS if it's a PCIe controller or we have a timeout on an I/O
* queue. (Note: qpair == NULL when there's an admin cmd timeout.) Otherwise we
* would submit another fabrics cmd on the admin queue to read CSTS and check for its
@@ -1359,8 +1356,7 @@ timeout_cb(void *cb_arg, struct spdk_nvme_ctrlr *ctrlr,
if (rc == 0) {
return;
}
-
- SPDK_ERRLOG("Unable to send abort. Resetting.\n");
+ SPDK_ERRLOG("Unable to send abort. Resetting, rc is %d.\n", rc);
}
/* FALLTHROUGH */
@@ -2245,9 +2241,14 @@ bdev_nvme_library_fini(void)
continue;
}
nvme_bdev_ctrlr->destruct = true;
-
+#ifndef SPDK_CONFIG_APP_RW
spdk_thread_send_msg(nvme_bdev_ctrlr->thread, _nvme_bdev_ctrlr_destruct,
nvme_bdev_ctrlr);
+#else
+ pthread_mutex_unlock(&g_bdev_nvme_mutex);
+ _nvme_bdev_ctrlr_destruct(nvme_bdev_ctrlr);
+ pthread_mutex_lock(&g_bdev_nvme_mutex);
+#endif
}
g_bdev_nvme_module_finish = true;
@@ -3028,12 +3029,18 @@ bdev_nvme_get_ctrlr(struct spdk_bdev *bdev)
}
#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_ch = io_ch;
+ return nvme_ch->group;
+}
+
+int nvme_channel_get_state(void *io_ch)
{
- struct nvme_io_channel *nvme_io_ch = io_ch;
- return nvme_io_ch->group;
+ 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)
{
@@ -3128,14 +3135,15 @@ int bdev_probe_ctrlr(void)
}
retry_count = spdk_conf_section_get_intval(sp, "RetryCount");
- if (retry_count >= 0) {
- g_opts.retry_count = retry_count;
- }
- if (retry_count > 255) {
+ if (retry_count < 0) {
+ retry_count = 4;
+ } else if (retry_count > 255) {
SPDK_WARNLOG("RetryCount:%d should not be greater than 255, set it to 255 this time\n",
retry_count);
retry_count = 255;
}
+
+ g_opts.retry_count = retry_count;
syslog(LOG_INFO, "RetryCount is set to %d\n", retry_count);
val = spdk_conf_section_get_val(sp, "TimeoutUsec");
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/module/bdev/nvme/common.h b/module/bdev/nvme/common.h
index 81b4009..8dbcd87 100644
--- a/module/bdev/nvme/common.h
+++ b/module/bdev/nvme/common.h
@@ -160,6 +160,7 @@ struct nvme_io_channel {
struct nvme_bdev_poll_group *group;
TAILQ_HEAD(, spdk_bdev_io) pending_resets;
struct ocssd_io_channel *ocssd_ch;
+ int state;
};
void nvme_ctrlr_populate_namespace_done(struct nvme_async_probe_ctx *ctx,
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.33.0
Reference in New Issue View Git Blame Copy Permalink