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

nvme: use nvme_robust_mutex related operations

Browse Source 
Change-Id: I35416506dbafe5e9d21861e207e295e114bdb3db
Signed-off-by: GangCao <gang.cao@intel.com>
This commit is contained in:
GangCao 2016-12-05 15:54:16 -05:00 committed by Daniel Verkamp
parent 47341b89b7
commit 6bdcf5abe8
5 changed files with 88 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
lib/nvme/nvme.c
View File

@ -59,7 +59,7 @@ nvme_attach(enum spdk_nvme_transport_type trtype,
int int
spdk_nvme_detach(struct spdk_nvme_ctrlr *ctrlr) spdk_nvme_detach(struct spdk_nvme_ctrlr *ctrlr)
{ {
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
nvme_ctrlr_proc_put_ref(ctrlr); nvme_ctrlr_proc_put_ref(ctrlr);
@ -68,7 +68,7 @@ spdk_nvme_detach(struct spdk_nvme_ctrlr *ctrlr)
nvme_ctrlr_destruct(ctrlr); nvme_ctrlr_destruct(ctrlr);
} }
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
return 0; return 0;
} }
@ -289,7 +289,7 @@ nvme_driver_init(void)
return ret; return ret;
} }
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
g_spdk_nvme_driver->initialized = false; g_spdk_nvme_driver->initialized = false;
@ -301,7 +301,7 @@ nvme_driver_init(void)
if (g_spdk_nvme_driver->request_mempool == NULL) { if (g_spdk_nvme_driver->request_mempool == NULL) {
SPDK_ERRLOG("unable to allocate pool of requests\n"); SPDK_ERRLOG("unable to allocate pool of requests\n");
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
pthread_mutex_destroy(&g_spdk_nvme_driver->lock); pthread_mutex_destroy(&g_spdk_nvme_driver->lock);
spdk_memzone_free(SPDK_NVME_DRIVER_NAME); spdk_memzone_free(SPDK_NVME_DRIVER_NAME);
@ -309,7 +309,7 @@ nvme_driver_init(void)
return -1; return -1;
} }
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
return ret; return ret;
} }
@ -343,7 +343,7 @@ nvme_init_controllers(void *cb_ctx, spdk_nvme_attach_cb attach_cb)
int start_rc; int start_rc;
struct spdk_nvme_ctrlr *ctrlr, *ctrlr_tmp; struct spdk_nvme_ctrlr *ctrlr, *ctrlr_tmp;
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
/* Initialize all new controllers in the init_ctrlrs list in parallel. */ /* Initialize all new controllers in the init_ctrlrs list in parallel. */
while (!TAILQ_EMPTY(&g_spdk_nvme_driver->init_ctrlrs)) { while (!TAILQ_EMPTY(&g_spdk_nvme_driver->init_ctrlrs)) {
@ -356,9 +356,9 @@ nvme_init_controllers(void *cb_ctx, spdk_nvme_attach_cb attach_cb)
* the functions it calls (in particular nvme_ctrlr_set_num_qpairs()) * the functions it calls (in particular nvme_ctrlr_set_num_qpairs())
* can assume it is held. * can assume it is held.
*/ */
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
start_rc = nvme_ctrlr_process_init(ctrlr); start_rc = nvme_ctrlr_process_init(ctrlr);
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
if (start_rc) { if (start_rc) {
/* Controller failed to initialize. */ /* Controller failed to initialize. */
@ -386,9 +386,9 @@ nvme_init_controllers(void *cb_ctx, spdk_nvme_attach_cb attach_cb)
* Unlock while calling attach_cb() so the user can call other functions * Unlock while calling attach_cb() so the user can call other functions
* that may take the driver lock, like nvme_detach(). * that may take the driver lock, like nvme_detach().
*/ */
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
attach_cb(cb_ctx, &ctrlr->probe_info, ctrlr, &ctrlr->opts); attach_cb(cb_ctx, &ctrlr->probe_info, ctrlr, &ctrlr->opts);
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
break; break;
} }
@ -397,7 +397,7 @@ nvme_init_controllers(void *cb_ctx, spdk_nvme_attach_cb attach_cb)
g_spdk_nvme_driver->initialized = true; g_spdk_nvme_driver->initialized = true;
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
return rc; return rc;
} }
@ -423,7 +423,7 @@ _spdk_nvme_probe(const struct spdk_nvme_discover_info *info, void *cb_ctx,
return rc; return rc;
} }
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
if (hotplug_fd < 0) { if (hotplug_fd < 0) {
hotplug_fd = spdk_uevent_connect(); hotplug_fd = spdk_uevent_connect();
@ -437,7 +437,7 @@ _spdk_nvme_probe(const struct spdk_nvme_discover_info *info, void *cb_ctx,
} else { } else {
if (!spdk_nvme_transport_available(info->trtype)) { if (!spdk_nvme_transport_available(info->trtype)) {
SPDK_ERRLOG("NVMe over Fabrics trtype %u not available\n", info->trtype); SPDK_ERRLOG("NVMe over Fabrics trtype %u not available\n", info->trtype);
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
return -1; return -1;
} }
@ -454,16 +454,16 @@ _spdk_nvme_probe(const struct spdk_nvme_discover_info *info, void *cb_ctx,
* Unlock while calling attach_cb() so the user can call other functions * Unlock while calling attach_cb() so the user can call other functions
* that may take the driver lock, like nvme_detach(). * that may take the driver lock, like nvme_detach().
*/ */
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
attach_cb(cb_ctx, &ctrlr->probe_info, ctrlr, &ctrlr->opts); attach_cb(cb_ctx, &ctrlr->probe_info, ctrlr, &ctrlr->opts);
pthread_mutex_lock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
} }
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
return 0; return 0;
} }
pthread_mutex_unlock(&g_spdk_nvme_driver->lock); nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
/* /*
* Keep going even if one or more nvme_attach() calls failed, * Keep going even if one or more nvme_attach() calls failed,
* but maintain the value of rc to signal errors when we return. * but maintain the value of rc to signal errors when we return.

64
lib/nvme/nvme_ctrlr.c
View File

@ -151,7 +151,7 @@ spdk_nvme_ctrlr_alloc_io_qpair(struct spdk_nvme_ctrlr *ctrlr,
return NULL; return NULL;
} }
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
/* /*
* Get the first available I/O queue ID. * Get the first available I/O queue ID.
@ -159,14 +159,14 @@ spdk_nvme_ctrlr_alloc_io_qpair(struct spdk_nvme_ctrlr *ctrlr,
qid = spdk_bit_array_find_first_set(ctrlr->free_io_qids, 1); qid = spdk_bit_array_find_first_set(ctrlr->free_io_qids, 1);
if (qid > ctrlr->opts.num_io_queues) { if (qid > ctrlr->opts.num_io_queues) {
SPDK_ERRLOG("No free I/O queue IDs\n"); SPDK_ERRLOG("No free I/O queue IDs\n");
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return NULL; return NULL;
} }
qpair = nvme_transport_ctrlr_create_io_qpair(ctrlr, qid, qprio); qpair = nvme_transport_ctrlr_create_io_qpair(ctrlr, qid, qprio);
if (qpair == NULL) { if (qpair == NULL) {
SPDK_ERRLOG("transport->ctrlr_create_io_qpair() failed\n"); SPDK_ERRLOG("transport->ctrlr_create_io_qpair() failed\n");
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return NULL; return NULL;
} }
spdk_bit_array_clear(ctrlr->free_io_qids, qid); spdk_bit_array_clear(ctrlr->free_io_qids, qid);
@ -174,7 +174,7 @@ spdk_nvme_ctrlr_alloc_io_qpair(struct spdk_nvme_ctrlr *ctrlr,
nvme_ctrlr_proc_add_io_qpair(qpair); nvme_ctrlr_proc_add_io_qpair(qpair);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return qpair; return qpair;
} }
@ -190,7 +190,7 @@ spdk_nvme_ctrlr_free_io_qpair(struct spdk_nvme_qpair *qpair)
ctrlr = qpair->ctrlr; ctrlr = qpair->ctrlr;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
nvme_ctrlr_proc_remove_io_qpair(qpair); nvme_ctrlr_proc_remove_io_qpair(qpair);
@ -198,11 +198,11 @@ spdk_nvme_ctrlr_free_io_qpair(struct spdk_nvme_qpair *qpair)
spdk_bit_array_set(ctrlr->free_io_qids, qpair->id); spdk_bit_array_set(ctrlr->free_io_qids, qpair->id);
if (nvme_transport_ctrlr_delete_io_qpair(ctrlr, qpair)) { if (nvme_transport_ctrlr_delete_io_qpair(ctrlr, qpair)) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -1; return -1;
} }
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return 0; return 0;
} }
@ -495,7 +495,7 @@ spdk_nvme_ctrlr_reset(struct spdk_nvme_ctrlr *ctrlr)
int rc = 0; int rc = 0;
struct spdk_nvme_qpair *qpair; struct spdk_nvme_qpair *qpair;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
if (ctrlr->is_resetting || ctrlr->is_failed) { if (ctrlr->is_resetting || ctrlr->is_failed) {
/* /*
@ -503,7 +503,7 @@ spdk_nvme_ctrlr_reset(struct spdk_nvme_ctrlr *ctrlr)
* immediately since there is no need to kick off another * immediately since there is no need to kick off another
* reset in these cases. * reset in these cases.
*/ */
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return 0; return 0;
} }
@ -541,7 +541,7 @@ spdk_nvme_ctrlr_reset(struct spdk_nvme_ctrlr *ctrlr)
ctrlr->is_resetting = false; ctrlr->is_resetting = false;
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -990,7 +990,7 @@ nvme_ctrlr_proc_get_ref(struct spdk_nvme_ctrlr *ctrlr)
struct spdk_nvme_ctrlr_process *active_proc; struct spdk_nvme_ctrlr_process *active_proc;
pid_t pid = getpid(); pid_t pid = getpid();
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
nvme_ctrlr_remove_inactive_proc(ctrlr); nvme_ctrlr_remove_inactive_proc(ctrlr);
@ -1001,7 +1001,7 @@ nvme_ctrlr_proc_get_ref(struct spdk_nvme_ctrlr *ctrlr)
} }
} }
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
void void
@ -1011,7 +1011,7 @@ nvme_ctrlr_proc_put_ref(struct spdk_nvme_ctrlr *ctrlr)
pid_t pid = getpid(); pid_t pid = getpid();
int proc_count; int proc_count;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
proc_count = nvme_ctrlr_remove_inactive_proc(ctrlr); proc_count = nvme_ctrlr_remove_inactive_proc(ctrlr);
@ -1032,7 +1032,7 @@ nvme_ctrlr_proc_put_ref(struct spdk_nvme_ctrlr *ctrlr)
} }
} }
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
int int
@ -1041,7 +1041,7 @@ nvme_ctrlr_get_ref_count(struct spdk_nvme_ctrlr *ctrlr)
struct spdk_nvme_ctrlr_process *active_proc; struct spdk_nvme_ctrlr_process *active_proc;
int ref = 0; int ref = 0;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
nvme_ctrlr_remove_inactive_proc(ctrlr); nvme_ctrlr_remove_inactive_proc(ctrlr);
@ -1049,7 +1049,7 @@ nvme_ctrlr_get_ref_count(struct spdk_nvme_ctrlr *ctrlr)
ref += active_proc->ref; ref += active_proc->ref;
} }
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return ref; return ref;
} }
@ -1362,12 +1362,12 @@ spdk_nvme_ctrlr_process_admin_completions(struct spdk_nvme_ctrlr *ctrlr)
{ {
int32_t num_completions; int32_t num_completions;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
if (ctrlr->keep_alive_interval_ticks) { if (ctrlr->keep_alive_interval_ticks) {
nvme_ctrlr_keep_alive(ctrlr); nvme_ctrlr_keep_alive(ctrlr);
} }
num_completions = spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); num_completions = spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return num_completions; return num_completions;
} }
@ -1447,9 +1447,9 @@ spdk_nvme_ctrlr_attach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
if (res) if (res)
return res; return res;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("spdk_nvme_ctrlr_attach_ns failed!\n"); SPDK_ERRLOG("spdk_nvme_ctrlr_attach_ns failed!\n");
@ -1472,9 +1472,9 @@ spdk_nvme_ctrlr_detach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
if (res) if (res)
return res; return res;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("spdk_nvme_ctrlr_detach_ns failed!\n"); SPDK_ERRLOG("spdk_nvme_ctrlr_detach_ns failed!\n");
@ -1495,9 +1495,9 @@ spdk_nvme_ctrlr_create_ns(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_ns_dat
if (res) if (res)
return 0; return 0;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("spdk_nvme_ctrlr_create_ns failed!\n"); SPDK_ERRLOG("spdk_nvme_ctrlr_create_ns failed!\n");
@ -1524,9 +1524,9 @@ spdk_nvme_ctrlr_delete_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
if (res) if (res)
return res; return res;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("spdk_nvme_ctrlr_delete_ns failed!\n"); SPDK_ERRLOG("spdk_nvme_ctrlr_delete_ns failed!\n");
@ -1549,9 +1549,9 @@ spdk_nvme_ctrlr_format(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
if (res) if (res)
return res; return res;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("spdk_nvme_ctrlr_format failed!\n"); SPDK_ERRLOG("spdk_nvme_ctrlr_format failed!\n");
@ -1594,9 +1594,9 @@ spdk_nvme_ctrlr_update_firmware(struct spdk_nvme_ctrlr *ctrlr, void *payload, ui
return res; return res;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("spdk_nvme_ctrlr_fw_image_download failed!\n"); SPDK_ERRLOG("spdk_nvme_ctrlr_fw_image_download failed!\n");
@ -1620,9 +1620,9 @@ spdk_nvme_ctrlr_update_firmware(struct spdk_nvme_ctrlr *ctrlr, void *payload, ui
return res; return res;
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ctrlr->adminq, 0);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
SPDK_ERRLOG("nvme_ctrlr_cmd_fw_commit failed!\n"); SPDK_ERRLOG("nvme_ctrlr_cmd_fw_commit failed!\n");

66
lib/nvme/nvme_ctrlr_cmd.c
View File

@ -62,10 +62,10 @@ spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr,
struct nvme_request *req; struct nvme_request *req;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_contig(buf, len, cb_fn, cb_arg); req = nvme_allocate_request_contig(buf, len, cb_fn, cb_arg);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -73,7 +73,7 @@ spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr,
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -135,11 +135,11 @@ nvme_ctrlr_cmd_attach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_user_copy(payload, sizeof(struct spdk_nvme_ctrlr_list), req = nvme_allocate_request_user_copy(payload, sizeof(struct spdk_nvme_ctrlr_list),
cb_fn, cb_arg, true); cb_fn, cb_arg, true);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -150,7 +150,7 @@ nvme_ctrlr_cmd_attach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -162,11 +162,11 @@ nvme_ctrlr_cmd_detach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_user_copy(payload, sizeof(struct spdk_nvme_ctrlr_list), req = nvme_allocate_request_user_copy(payload, sizeof(struct spdk_nvme_ctrlr_list),
cb_fn, cb_arg, true); cb_fn, cb_arg, true);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -177,7 +177,7 @@ nvme_ctrlr_cmd_detach_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid,
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -189,11 +189,11 @@ nvme_ctrlr_cmd_create_ns(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_ns_data
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_user_copy(payload, sizeof(struct spdk_nvme_ns_data), req = nvme_allocate_request_user_copy(payload, sizeof(struct spdk_nvme_ns_data),
cb_fn, cb_arg, true); cb_fn, cb_arg, true);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -203,7 +203,7 @@ nvme_ctrlr_cmd_create_ns(struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_ns_data
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -215,10 +215,10 @@ nvme_ctrlr_cmd_delete_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, spdk_nvme
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_null(cb_fn, cb_arg); req = nvme_allocate_request_null(cb_fn, cb_arg);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -229,7 +229,7 @@ nvme_ctrlr_cmd_delete_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, spdk_nvme
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -241,10 +241,10 @@ nvme_ctrlr_cmd_format(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, struct spdk_
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_null(cb_fn, cb_arg); req = nvme_allocate_request_null(cb_fn, cb_arg);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -254,7 +254,7 @@ nvme_ctrlr_cmd_format(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid, struct spdk_
memcpy(&cmd->cdw10, format, sizeof(uint32_t)); memcpy(&cmd->cdw10, format, sizeof(uint32_t));
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -268,10 +268,10 @@ spdk_nvme_ctrlr_cmd_set_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_null(cb_fn, cb_arg); req = nvme_allocate_request_null(cb_fn, cb_arg);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -282,7 +282,7 @@ spdk_nvme_ctrlr_cmd_set_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
cmd->cdw12 = cdw12; cmd->cdw12 = cdw12;
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -296,10 +296,10 @@ spdk_nvme_ctrlr_cmd_get_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_null(cb_fn, cb_arg); req = nvme_allocate_request_null(cb_fn, cb_arg);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -309,7 +309,7 @@ spdk_nvme_ctrlr_cmd_get_feature(struct spdk_nvme_ctrlr *ctrlr, uint8_t feature,
cmd->cdw11 = cdw11; cmd->cdw11 = cdw11;
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -356,10 +356,10 @@ spdk_nvme_ctrlr_cmd_get_log_page(struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page
numdl = numd & 0xFFFFu; numdl = numd & 0xFFFFu;
numdu = (numd >> 16) & 0xFFFFu; numdu = (numd >> 16) & 0xFFFFu;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_user_copy(payload, payload_size, cb_fn, cb_arg, false); req = nvme_allocate_request_user_copy(payload, payload_size, cb_fn, cb_arg, false);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -371,7 +371,7 @@ spdk_nvme_ctrlr_cmd_get_log_page(struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page
cmd->cdw11 = numdu; cmd->cdw11 = numdu;
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }
@ -404,10 +404,10 @@ nvme_ctrlr_cmd_fw_commit(struct spdk_nvme_ctrlr *ctrlr,
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_null(cb_fn, cb_arg); req = nvme_allocate_request_null(cb_fn, cb_arg);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -416,7 +416,7 @@ nvme_ctrlr_cmd_fw_commit(struct spdk_nvme_ctrlr *ctrlr,
memcpy(&cmd->cdw10, fw_commit, sizeof(uint32_t)); memcpy(&cmd->cdw10, fw_commit, sizeof(uint32_t));
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
@ -431,10 +431,10 @@ nvme_ctrlr_cmd_fw_image_download(struct spdk_nvme_ctrlr *ctrlr,
struct spdk_nvme_cmd *cmd; struct spdk_nvme_cmd *cmd;
int rc; int rc;
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
req = nvme_allocate_request_user_copy(payload, size, cb_fn, cb_arg, true); req = nvme_allocate_request_user_copy(payload, size, cb_fn, cb_arg, true);
if (req == NULL) { if (req == NULL) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return -ENOMEM; return -ENOMEM;
} }
@ -444,7 +444,7 @@ nvme_ctrlr_cmd_fw_image_download(struct spdk_nvme_ctrlr *ctrlr,
cmd->cdw11 = offset >> 2; cmd->cdw11 = offset >> 2;
rc = nvme_ctrlr_submit_admin_request(ctrlr, req); rc = nvme_ctrlr_submit_admin_request(ctrlr, req);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
return rc; return rc;
} }

4
lib/nvme/nvme_ns.c
View File

@ -55,9 +55,9 @@ int nvme_ns_identify_update(struct spdk_nvme_ns *ns)
} }
while (status.done == false) { while (status.done == false) {
pthread_mutex_lock(&ns->ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ns->ctrlr->ctrlr_lock);
spdk_nvme_qpair_process_completions(ns->ctrlr->adminq, 0); spdk_nvme_qpair_process_completions(ns->ctrlr->adminq, 0);
pthread_mutex_unlock(&ns->ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ns->ctrlr->ctrlr_lock);
} }
if (spdk_nvme_cpl_is_error(&status.cpl)) { if (spdk_nvme_cpl_is_error(&status.cpl)) {
/* This can occur if the namespace is not active. Simply zero the /* This can occur if the namespace is not active. Simply zero the

8
lib/nvme/nvme_pcie.c
View File

@ -1657,7 +1657,7 @@ nvme_pcie_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_reques
nvme_pcie_qpair_check_enabled(qpair); nvme_pcie_qpair_check_enabled(qpair);
if (nvme_qpair_is_admin_queue(qpair)) { if (nvme_qpair_is_admin_queue(qpair)) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
} }
tr = LIST_FIRST(&pqpair->free_tr); tr = LIST_FIRST(&pqpair->free_tr);
@ -1706,7 +1706,7 @@ nvme_pcie_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_reques
exit: exit:
if (nvme_qpair_is_admin_queue(qpair)) { if (nvme_qpair_is_admin_queue(qpair)) {
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
return rc; return rc;
@ -1733,7 +1733,7 @@ nvme_pcie_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_
} }
if (nvme_qpair_is_admin_queue(qpair)) { if (nvme_qpair_is_admin_queue(qpair)) {
pthread_mutex_lock(&ctrlr->ctrlr_lock); nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);
} }
if (max_completions == 0 || (max_completions > (qpair->num_entries - 1U))) { if (max_completions == 0 || (max_completions > (qpair->num_entries - 1U))) {
@ -1782,7 +1782,7 @@ nvme_pcie_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_
if (nvme_qpair_is_admin_queue(qpair)) { if (nvme_qpair_is_admin_queue(qpair)) {
nvme_pcie_qpair_complete_pending_admin_request(qpair); nvme_pcie_qpair_complete_pending_admin_request(qpair);
pthread_mutex_unlock(&ctrlr->ctrlr_lock); nvme_robust_mutex_unlock(&ctrlr->ctrlr_lock);
} }
return num_completions; return num_completions;