ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test/nvme: Simplify the nvme_pcie_hotplug_monitor test

Browse Source 
Change-Id: I6eef2a81b03df7fc257b59fe22b3679830249c59
Signed-off-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/475777
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
This commit is contained in:
Ben Walker 2019-11-25 11:21:39 -07:00 committed by Tomasz Zawadzki
parent 8c81d7ed01
commit 15427fd1ac
1 changed files with 62 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
test/unit/lib/nvme/nvme_pcie.c/nvme_pcie_ut.c
View File

@ -43,25 +43,10 @@ struct spdk_log_flag SPDK_LOG_NVME = {
.enabled = false, .enabled = false,
}; };
static struct nvme_driver _g_nvme_driver = { struct nvme_driver *g_spdk_nvme_driver = NULL;
.lock = PTHREAD_MUTEX_INITIALIZER,
};
struct nvme_driver *g_spdk_nvme_driver = &_g_nvme_driver;
struct spdk_nvme_ctrlr *g_ctrlr = NULL;
bool g_add_device = false;
bool g_device_is_enumerated = false; bool g_device_is_enumerated = false;
bool g_device_is_removed = false;
bool g_remove_cb_done = false;
bool g_vfio_is_enabled = false;
char *g_pcie_traddr_str = "";
void void
nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr, bool hot_remove) nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr, bool hot_remove)
{ {
@ -73,30 +58,30 @@ nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr, bool hot_remove)
ctrlr->is_failed = true; ctrlr->is_failed = true;
} }
struct spdk_uevent_entry {
struct spdk_uevent uevent;
STAILQ_ENTRY(spdk_uevent_entry) link;
};
static STAILQ_HEAD(, spdk_uevent_entry) g_uevents = STAILQ_HEAD_INITIALIZER(g_uevents);
int int
spdk_get_uevent(int fd, struct spdk_uevent *uevent) spdk_get_uevent(int fd, struct spdk_uevent *uevent)
{ {
snprintf(uevent->traddr, sizeof(uevent->traddr), "%s", g_pcie_traddr_str); struct spdk_uevent_entry *entry;
if (g_vfio_is_enabled) {
uevent->subsystem = SPDK_NVME_UEVENT_SUBSYSTEM_VFIO;
} else {
uevent->subsystem = SPDK_NVME_UEVENT_SUBSYSTEM_UIO;
}
if (g_add_device) {
uevent->action = SPDK_NVME_UEVENT_ADD;
} else {
uevent->action = SPDK_NVME_UEVENT_REMOVE;
}
if (!g_remove_cb_done && !g_device_is_enumerated) {
return 1;
}
if (STAILQ_EMPTY(&g_uevents)) {
return 0; return 0;
} }
entry = STAILQ_FIRST(&g_uevents);
STAILQ_REMOVE_HEAD(&g_uevents, link);
*uevent = entry->uevent;
return 1;
}
int int
spdk_pci_enumerate(struct spdk_pci_driver *driver, spdk_pci_enum_cb enum_cb, void *enum_ctx) spdk_pci_enumerate(struct spdk_pci_driver *driver, spdk_pci_enum_cb enum_cb, void *enum_ctx)
{ {
@ -130,50 +115,14 @@ spdk_nvme_ctrlr_get_current_process(struct spdk_nvme_ctrlr *ctrlr)
return (struct spdk_nvme_ctrlr_process *)0x1; return (struct spdk_nvme_ctrlr_process *)0x1;
} }
bool DEFINE_STUB(spdk_pci_device_is_removed, bool, (struct spdk_pci_device *dev), false);
spdk_pci_device_is_removed(struct spdk_pci_device *dev) DEFINE_STUB(spdk_nvme_get_ctrlr_by_trid_unsafe, struct spdk_nvme_ctrlr *,
{ (const struct spdk_nvme_transport_id *trid), NULL);
return g_device_is_removed;
}
static void
ut_remove_cb(void *cb_ctx, struct spdk_nvme_ctrlr *ctrlr)
{
g_remove_cb_done = true;
if (cb_ctx == NULL) {
return;
}
CU_ASSERT(ctrlr != NULL);
CU_ASSERT(g_ctrlr == NULL || g_ctrlr == ctrlr);
free(g_ctrlr);
g_ctrlr = NULL;
}
struct spdk_nvme_ctrlr *
spdk_nvme_get_ctrlr_by_trid_unsafe(const struct spdk_nvme_transport_id *trid)
{
struct spdk_nvme_ctrlr *ctrlr;
ctrlr = calloc(1, sizeof(*ctrlr));
SPDK_CU_ASSERT_FATAL(ctrlr != NULL);
ctrlr->remove_cb = (void *)ut_remove_cb;
ctrlr->is_failed = false;
ctrlr->is_removed = false;
g_ctrlr = ctrlr;
return ctrlr;
}
union spdk_nvme_csts_register spdk_nvme_ctrlr_get_regs_csts(struct spdk_nvme_ctrlr *ctrlr) union spdk_nvme_csts_register spdk_nvme_ctrlr_get_regs_csts(struct spdk_nvme_ctrlr *ctrlr)
{ {
union spdk_nvme_csts_register csts = {}; union spdk_nvme_csts_register csts = {};
if (g_device_is_removed) {
csts.raw = 0xFFFFFFFFu;
}
return csts; return csts;
} }
@ -318,62 +267,75 @@ static void
test_nvme_pcie_hotplug_monitor(void) test_nvme_pcie_hotplug_monitor(void)
{ {
struct spdk_nvme_ctrlr ctrlr = {}; struct spdk_nvme_ctrlr ctrlr = {};
struct nvme_driver dummy; struct spdk_uevent_entry entry = {};
struct nvme_driver driver;
pthread_mutexattr_t attr; pthread_mutexattr_t attr;
struct spdk_nvme_probe_ctx test_nvme_probe_ctx = {}; struct spdk_nvme_probe_ctx test_nvme_probe_ctx = {};
/* Initiate variables and ctrlr */ /* Initiate variables and ctrlr */
g_device_is_removed = false; driver.initialized = true;
dummy.initialized = true;
CU_ASSERT(pthread_mutexattr_init(&attr) == 0); CU_ASSERT(pthread_mutexattr_init(&attr) == 0);
CU_ASSERT(pthread_mutex_init(&dummy.lock, &attr) == 0); CU_ASSERT(pthread_mutex_init(&driver.lock, &attr) == 0);
TAILQ_INIT(&dummy.shared_attached_ctrlrs); TAILQ_INIT(&driver.shared_attached_ctrlrs);
g_spdk_nvme_driver = &dummy; g_spdk_nvme_driver = &driver;
test_nvme_probe_ctx.cb_ctx = (void *)ut_remove_cb;
/* Case 1: SPDK_NVME_UEVENT_ADD/ NVME_VFIO */ /* Case 1: SPDK_NVME_UEVENT_ADD/ NVME_VFIO */
g_add_device = true; entry.uevent.subsystem = SPDK_NVME_UEVENT_SUBSYSTEM_VFIO;
g_vfio_is_enabled = true; entry.uevent.action = SPDK_NVME_UEVENT_ADD;
g_pcie_traddr_str = "0000:05:00.0"; snprintf(entry.uevent.traddr, sizeof(entry.uevent.traddr), "0000:05:00.0");
CU_ASSERT(g_device_is_enumerated == false); CU_ASSERT(STAILQ_EMPTY(&g_uevents));
STAILQ_INSERT_TAIL(&g_uevents, &entry, link);
_nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx); _nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx);
CU_ASSERT(STAILQ_EMPTY(&g_uevents));
CU_ASSERT(g_device_is_enumerated == true); CU_ASSERT(g_device_is_enumerated == true);
g_device_is_enumerated = false; g_device_is_enumerated = false;
/* Case 2: SPDK_NVME_UEVENT_ADD/ NVME_UIO */ /* Case 2: SPDK_NVME_UEVENT_ADD/ NVME_UIO */
g_vfio_is_enabled = false; entry.uevent.subsystem = SPDK_NVME_UEVENT_SUBSYSTEM_UIO;
entry.uevent.action = SPDK_NVME_UEVENT_ADD;
snprintf(entry.uevent.traddr, sizeof(entry.uevent.traddr), "0000:05:00.0");
CU_ASSERT(STAILQ_EMPTY(&g_uevents));
STAILQ_INSERT_TAIL(&g_uevents, &entry, link);
_nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx); _nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx);
CU_ASSERT(STAILQ_EMPTY(&g_uevents));
CU_ASSERT(g_device_is_enumerated == true); CU_ASSERT(g_device_is_enumerated == true);
g_device_is_enumerated = false; g_device_is_enumerated = false;
/* Case 3: SPDK_NVME_UEVENT_REMOVE/ NVME_UIO */ /* Case 3: SPDK_NVME_UEVENT_REMOVE/ NVME_UIO */
g_add_device = false; entry.uevent.subsystem = SPDK_NVME_UEVENT_SUBSYSTEM_UIO;
g_pcie_traddr_str = "0000:04:00.0"; entry.uevent.action = SPDK_NVME_UEVENT_REMOVE;
test_nvme_probe_ctx.cb_ctx = NULL; snprintf(entry.uevent.traddr, sizeof(entry.uevent.traddr), "0000:05:00.0");
CU_ASSERT(STAILQ_EMPTY(&g_uevents));
STAILQ_INSERT_TAIL(&g_uevents, &entry, link);
MOCK_SET(spdk_nvme_get_ctrlr_by_trid_unsafe, &ctrlr);
_nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx); _nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx);
CU_ASSERT(g_remove_cb_done == true); CU_ASSERT(STAILQ_EMPTY(&g_uevents));
CU_ASSERT(g_ctrlr != NULL); CU_ASSERT(ctrlr.is_failed == true);
free(g_ctrlr); ctrlr.is_failed = false;
g_ctrlr = NULL; MOCK_CLEAR(spdk_nvme_get_ctrlr_by_trid_unsafe);
g_remove_cb_done = false;
/* Case 4: SPDK_NVME_UEVENT_REMOVE/ NVME_VFIO */ /* Case 4: SPDK_NVME_UEVENT_REMOVE/ NVME_VFIO */
g_vfio_is_enabled = true; entry.uevent.subsystem = SPDK_NVME_UEVENT_SUBSYSTEM_VFIO;
test_nvme_probe_ctx.cb_ctx = (void *)ut_remove_cb; entry.uevent.action = SPDK_NVME_UEVENT_REMOVE;
snprintf(entry.uevent.traddr, sizeof(entry.uevent.traddr), "0000:05:00.0");
CU_ASSERT(STAILQ_EMPTY(&g_uevents));
STAILQ_INSERT_TAIL(&g_uevents, &entry, link);
MOCK_SET(spdk_nvme_get_ctrlr_by_trid_unsafe, &ctrlr);
_nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx); _nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx);
CU_ASSERT(g_remove_cb_done == true); CU_ASSERT(STAILQ_EMPTY(&g_uevents));
CU_ASSERT(g_ctrlr == NULL); CU_ASSERT(ctrlr.is_failed == true);
ctrlr.is_failed = false;
MOCK_CLEAR(spdk_nvme_get_ctrlr_by_trid_unsafe);
/* Case 5: test only for VFIO hot remove detection */ /* Case 5: Removed device detected in another process */
g_remove_cb_done = true;
ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE; ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
snprintf(ctrlr.trid.traddr, sizeof(ctrlr.trid.traddr), "0000:02:00.0"); snprintf(ctrlr.trid.traddr, sizeof(ctrlr.trid.traddr), "0000:02:00.0");
ctrlr.remove_cb = NULL; ctrlr.remove_cb = NULL;
@ -381,23 +343,21 @@ test_nvme_pcie_hotplug_monitor(void)
ctrlr.is_removed = false; ctrlr.is_removed = false;
TAILQ_INSERT_TAIL(&g_spdk_nvme_driver->shared_attached_ctrlrs, &ctrlr, tailq); TAILQ_INSERT_TAIL(&g_spdk_nvme_driver->shared_attached_ctrlrs, &ctrlr, tailq);
MOCK_SET(spdk_pci_device_is_removed, false);
_nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx); _nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx);
CU_ASSERT(ctrlr.is_failed == false); CU_ASSERT(ctrlr.is_failed == false);
g_device_is_removed = true; MOCK_SET(spdk_pci_device_is_removed, true);
g_remove_cb_done = false;
ctrlr.remove_cb = (void *)ut_remove_cb;
_nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx); _nvme_pcie_hotplug_monitor(&test_nvme_probe_ctx);
CU_ASSERT(ctrlr.is_failed == true); CU_ASSERT(ctrlr.is_failed == true);
CU_ASSERT(ctrlr.is_removed == true);
CU_ASSERT(g_remove_cb_done == true);
pthread_mutex_destroy(&dummy.lock); pthread_mutex_destroy(&driver.lock);
pthread_mutexattr_destroy(&attr); pthread_mutexattr_destroy(&attr);
g_spdk_nvme_driver = &_g_nvme_driver; g_spdk_nvme_driver = NULL;
} }
static void test_shadow_doorbell_update(void) static void test_shadow_doorbell_update(void)