d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

nvmf: refactor identify into a common function

Browse Source 
Also remove the stored controller data from spdk_nvmf_ctrlr and instead
generate up-to-date information every time the command is called.

Change-Id: Icdcc7c826eff25711c6700d12089a86a8dedee54
Signed-off-by: Daniel Verkamp <daniel.verkamp@intel.com>
Reviewed-on: https://review.gerrithub.io/374559
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
This commit is contained in:
Daniel Verkamp 2017-08-16 19:08:50 -07:00
parent 89d35cefd5
commit bf6caa753d
7 changed files with 214 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
lib/nvmf/ctrlr.c
View File

@ -124,71 +124,6 @@ spdk_nvmf_ctrlr_create(struct spdk_nvmf_subsystem *subsystem,
SPDK_TRACELOG(SPDK_TRACE_NVMF, "cc 0x%x\n", ctrlr->vcprop.cc.raw);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "csts 0x%x\n", ctrlr->vcprop.csts.raw);
/*
* Common fields for discovery and NVM subsystems
*/
spdk_strcpy_pad(ctrlr->vcdata.fr, FW_VERSION, sizeof(ctrlr->vcdata.fr), ' ');
assert((g_nvmf_tgt.max_io_size % 4096) == 0);
ctrlr->vcdata.mdts = spdk_u32log2(g_nvmf_tgt.max_io_size / 4096);
ctrlr->vcdata.cntlid = ctrlr->cntlid;
ctrlr->vcdata.ver = ctrlr->vcprop.vs;
ctrlr->vcdata.lpa.edlp = 1;
ctrlr->vcdata.elpe = 127;
ctrlr->vcdata.maxcmd = g_nvmf_tgt.max_queue_depth;
ctrlr->vcdata.sgls.supported = 1;
ctrlr->vcdata.sgls.keyed_sgl = 1;
ctrlr->vcdata.sgls.sgl_offset = 1;
spdk_strcpy_pad(ctrlr->vcdata.subnqn, subsystem->subnqn, sizeof(ctrlr->vcdata.subnqn), '\0');
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ctrlr data: maxcmd 0x%x\n", ctrlr->vcdata.maxcmd);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "sgls data: 0x%x\n", *(uint32_t *)&ctrlr->vcdata.sgls);
/*
* NVM subsystem fields (reserved for discovery subsystems)
*/
if (subsystem->subtype == SPDK_NVMF_SUBTYPE_NVME) {
spdk_strcpy_pad(ctrlr->vcdata.mn, MODEL_NUMBER, sizeof(ctrlr->vcdata.mn), ' ');
spdk_strcpy_pad(ctrlr->vcdata.sn, spdk_nvmf_subsystem_get_sn(subsystem),
sizeof(ctrlr->vcdata.sn), ' ');
ctrlr->vcdata.aerl = 0;
ctrlr->vcdata.kas = 10;
ctrlr->vcdata.rab = 6;
ctrlr->vcdata.ctratt.host_id_exhid_supported = 1;
ctrlr->vcdata.aerl = 0;
ctrlr->vcdata.frmw.slot1_ro = 1;
ctrlr->vcdata.frmw.num_slots = 1;
ctrlr->vcdata.sqes.min = 6;
ctrlr->vcdata.sqes.max = 6;
ctrlr->vcdata.cqes.min = 4;
ctrlr->vcdata.cqes.max = 4;
ctrlr->vcdata.nn = subsystem->dev.max_nsid;
ctrlr->vcdata.vwc.present = 1;
ctrlr->vcdata.nvmf_specific.ioccsz = sizeof(struct spdk_nvme_cmd) / 16;
ctrlr->vcdata.nvmf_specific.iorcsz = sizeof(struct spdk_nvme_cpl) / 16;
ctrlr->vcdata.nvmf_specific.icdoff = 0; /* offset starts directly after SQE */
ctrlr->vcdata.nvmf_specific.ctrattr.ctrlr_model = SPDK_NVMF_CTRLR_MODEL_DYNAMIC;
ctrlr->vcdata.nvmf_specific.msdbd = 1; /* target supports single SGL in capsule */
/* TODO: this should be set by the transport */
ctrlr->vcdata.nvmf_specific.ioccsz += g_nvmf_tgt.in_capsule_data_size / 16;
spdk_nvmf_ctrlr_set_dsm(ctrlr);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: ioccsz 0x%x\n",
ctrlr->vcdata.nvmf_specific.ioccsz);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: iorcsz 0x%x\n",
ctrlr->vcdata.nvmf_specific.iorcsz);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: icdoff 0x%x\n",
ctrlr->vcdata.nvmf_specific.icdoff);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: ctrattr 0x%x\n",
*(uint8_t *)&ctrlr->vcdata.nvmf_specific.ctrattr);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: msdbd 0x%x\n",
ctrlr->vcdata.nvmf_specific.msdbd);
}
TAILQ_INSERT_TAIL(&subsystem->ctrlrs, ctrlr, link);
return ctrlr;
}
@ -386,7 +321,7 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_qpair *qpair,
qpair->ctrlr = ctrlr;
rsp->status.sc = SPDK_NVME_SC_SUCCESS;
rsp->status_code_specific.success.cntlid = ctrlr->vcdata.cntlid;
rsp->status_code_specific.success.cntlid = ctrlr->cntlid;
SPDK_TRACELOG(SPDK_TRACE_NVMF, "connect capsule response: cntlid = 0x%04x\n",
rsp->status_code_specific.success.cntlid);
}
@ -807,7 +742,7 @@ spdk_nvmf_ctrlr_async_event_request(struct spdk_nvmf_request *req)
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Async Event Request\n");
assert(ctrlr->vcdata.aerl + 1 == 1);
/* Only one asynchronous event is supported for now */
if (ctrlr->aer_req != NULL) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "AERL exceeded\n");
rsp->status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC;
@ -887,3 +822,177 @@ invalid_log_page:
response->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
static int
spdk_nvmf_ctrlr_identify_ns(struct spdk_nvmf_subsystem *subsystem,
struct spdk_nvme_cmd *cmd,
struct spdk_nvme_cpl *rsp,
struct spdk_nvme_ns_data *nsdata)
{
struct spdk_bdev *bdev;
if (cmd->nsid > subsystem->dev.max_nsid || cmd->nsid == 0) {
SPDK_ERRLOG("Identify Namespace for invalid NSID %u\n", cmd->nsid);
rsp->status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
bdev = subsystem->dev.ns_list[cmd->nsid - 1];
if (bdev == NULL) {
memset(nsdata, 0, sizeof(*nsdata));
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
return spdk_nvmf_bdev_ctrlr_identify_ns(bdev, nsdata);
}
static int
spdk_nvmf_ctrlr_identify_ctrlr(struct spdk_nvmf_ctrlr *ctrlr, struct spdk_nvme_ctrlr_data *cdata)
{
struct spdk_nvmf_subsystem *subsystem = ctrlr->subsys;
/*
* Common fields for discovery and NVM subsystems
*/
spdk_strcpy_pad(cdata->fr, FW_VERSION, sizeof(cdata->fr), ' ');
assert((g_nvmf_tgt.max_io_size % 4096) == 0);
cdata->mdts = spdk_u32log2(g_nvmf_tgt.max_io_size / 4096);
cdata->cntlid = ctrlr->cntlid;
cdata->ver = ctrlr->vcprop.vs;
cdata->lpa.edlp = 1;
cdata->elpe = 127;
cdata->maxcmd = g_nvmf_tgt.max_queue_depth;
cdata->sgls.supported = 1;
cdata->sgls.keyed_sgl = 1;
cdata->sgls.sgl_offset = 1;
spdk_strcpy_pad(cdata->subnqn, subsystem->subnqn, sizeof(cdata->subnqn), '\0');
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ctrlr data: maxcmd 0x%x\n", cdata->maxcmd);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "sgls data: 0x%x\n", *(uint32_t *)&cdata->sgls);
/*
* NVM subsystem fields (reserved for discovery subsystems)
*/
if (subsystem->subtype == SPDK_NVMF_SUBTYPE_NVME) {
spdk_strcpy_pad(cdata->mn, MODEL_NUMBER, sizeof(cdata->mn), ' ');
spdk_strcpy_pad(cdata->sn, spdk_nvmf_subsystem_get_sn(subsystem), sizeof(cdata->sn), ' ');
cdata->aerl = 0;
cdata->kas = 10;
cdata->rab = 6;
cdata->ctratt.host_id_exhid_supported = 1;
cdata->aerl = 0;
cdata->frmw.slot1_ro = 1;
cdata->frmw.num_slots = 1;
cdata->sqes.min = 6;
cdata->sqes.max = 6;
cdata->cqes.min = 4;
cdata->cqes.max = 4;
cdata->nn = subsystem->dev.max_nsid;
cdata->vwc.present = 1;
cdata->nvmf_specific.ioccsz = sizeof(struct spdk_nvme_cmd) / 16;
cdata->nvmf_specific.iorcsz = sizeof(struct spdk_nvme_cpl) / 16;
cdata->nvmf_specific.icdoff = 0; /* offset starts directly after SQE */
cdata->nvmf_specific.ctrattr.ctrlr_model = SPDK_NVMF_CTRLR_MODEL_DYNAMIC;
cdata->nvmf_specific.msdbd = 1; /* target supports single SGL in capsule */
/* TODO: this should be set by the transport */
cdata->nvmf_specific.ioccsz += g_nvmf_tgt.in_capsule_data_size / 16;
cdata->oncs.dsm = spdk_nvmf_ctrlr_dsm_supported(ctrlr);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: ioccsz 0x%x\n",
cdata->nvmf_specific.ioccsz);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: iorcsz 0x%x\n",
cdata->nvmf_specific.iorcsz);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: icdoff 0x%x\n",
cdata->nvmf_specific.icdoff);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: ctrattr 0x%x\n",
*(uint8_t *)&cdata->nvmf_specific.ctrattr);
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ext ctrlr data: msdbd 0x%x\n",
cdata->nvmf_specific.msdbd);
}
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
static int
spdk_nvmf_ctrlr_identify_active_ns_list(struct spdk_nvmf_subsystem *subsystem,
struct spdk_nvme_cmd *cmd,
struct spdk_nvme_cpl *rsp,
struct spdk_nvme_ns_list *ns_list)
{
uint32_t i, num_ns, count = 0;
if (cmd->nsid >= 0xfffffffeUL) {
SPDK_ERRLOG("Identify Active Namespace List with invalid NSID %u\n", cmd->nsid);
rsp->status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
num_ns = subsystem->dev.max_nsid;
for (i = 1; i <= num_ns; i++) {
if (i <= cmd->nsid) {
continue;
}
if (subsystem->dev.ns_list[i - 1] == NULL) {
continue;
}
ns_list->ns_list[count++] = i;
if (count == SPDK_COUNTOF(ns_list->ns_list)) {
break;
}
}
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
int
spdk_nvmf_ctrlr_identify(struct spdk_nvmf_request *req)
{
uint8_t cns;
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
struct spdk_nvmf_subsystem *subsystem = ctrlr->subsys;
if (req->data) {
memset(req->data, 0, req->length);
}
if (req->data == NULL || req->length < 4096) {
SPDK_ERRLOG("identify command with invalid buffer\n");
rsp->status.sct = SPDK_NVME_SCT_GENERIC;
rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
cns = cmd->cdw10 & 0xFF;
if (subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY &&
cns != SPDK_NVME_IDENTIFY_CTRLR) {
/* Discovery controllers only support Identify Controller */
goto invalid_cns;
}
switch (cns) {
case SPDK_NVME_IDENTIFY_NS:
return spdk_nvmf_ctrlr_identify_ns(subsystem, cmd, rsp, req->data);
case SPDK_NVME_IDENTIFY_CTRLR:
return spdk_nvmf_ctrlr_identify_ctrlr(ctrlr, req->data);
case SPDK_NVME_IDENTIFY_ACTIVE_NS_LIST:
return spdk_nvmf_ctrlr_identify_active_ns_list(subsystem, cmd, rsp, req->data);
default:
goto invalid_cns;
}
invalid_cns:
SPDK_ERRLOG("Identify command with unsupported CNS 0x%02x\n", cns);
rsp->status.sct = SPDK_NVME_SCT_GENERIC;
rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}

9
lib/nvmf/ctrlr.h
View File

@ -39,6 +39,8 @@
#include "spdk/nvmf_spec.h"
#include "spdk/queue.h"
struct spdk_bdev;
/* define a virtual controller limit to the number of QPs supported */
#define MAX_QPAIRS_PER_CTRLR 64
@ -76,7 +78,6 @@ struct spdk_nvmf_ctrlr {
union spdk_nvme_cc_register cc;
union spdk_nvme_csts_register csts;
} vcprop; /* virtual controller properties */
struct spdk_nvme_ctrlr_data vcdata; /* virtual controller data */
TAILQ_HEAD(, spdk_nvmf_qpair) qpairs;
int num_qpairs;
@ -136,6 +137,10 @@ int spdk_nvmf_ctrlr_async_event_request(struct spdk_nvmf_request *req);
int spdk_nvmf_ctrlr_get_log_page(struct spdk_nvmf_request *req);
void spdk_nvmf_ctrlr_set_dsm(struct spdk_nvmf_ctrlr *ctrlr);
int spdk_nvmf_ctrlr_identify(struct spdk_nvmf_request *req);
bool spdk_nvmf_ctrlr_dsm_supported(struct spdk_nvmf_ctrlr *ctrlr);
int spdk_nvmf_bdev_ctrlr_identify_ns(struct spdk_bdev *bdev, struct spdk_nvme_ns_data *nsdata);
#endif

102
lib/nvmf/ctrlr_bdev.c
View File

@ -58,8 +58,8 @@ struct __attribute__((packed)) nvme_read_cdw12 {
uint8_t lr : 1; /* limited retry */
};
void
spdk_nvmf_ctrlr_set_dsm(struct spdk_nvmf_ctrlr *ctrlr)
bool
spdk_nvmf_ctrlr_dsm_supported(struct spdk_nvmf_ctrlr *ctrlr)
{
uint32_t i;
@ -74,13 +74,13 @@ spdk_nvmf_ctrlr_set_dsm(struct spdk_nvmf_ctrlr *ctrlr)
SPDK_TRACELOG(SPDK_TRACE_NVMF,
"Subsystem%u Namespace %s does not support unmap - not enabling DSM\n",
i, spdk_bdev_get_name(bdev));
return;
return false;
}
}
SPDK_TRACELOG(SPDK_TRACE_NVMF, "All devices in Subsystem %s support unmap - enabling DSM\n",
spdk_nvmf_subsystem_get_nqn(ctrlr->subsys));
ctrlr->vcdata.oncs.dsm = 1;
return true;
}
static void
@ -105,28 +105,11 @@ nvmf_bdev_ctrlr_complete_cmd(struct spdk_bdev_io *bdev_io, bool success,
spdk_bdev_free_io(bdev_io);
}
static int
identify_ns(struct spdk_nvmf_subsystem *subsystem,
struct spdk_nvme_cmd *cmd,
struct spdk_nvme_cpl *rsp,
struct spdk_nvme_ns_data *nsdata)
int
spdk_nvmf_bdev_ctrlr_identify_ns(struct spdk_bdev *bdev, struct spdk_nvme_ns_data *nsdata)
{
struct spdk_bdev *bdev;
uint64_t num_blocks;
if (cmd->nsid > subsystem->dev.max_nsid || cmd->nsid == 0) {
SPDK_ERRLOG("Identify Namespace for invalid NSID %u\n", cmd->nsid);
rsp->status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
bdev = subsystem->dev.ns_list[cmd->nsid - 1];
if (bdev == NULL) {
memset(nsdata, 0, sizeof(*nsdata));
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
num_blocks = spdk_bdev_get_num_blocks(bdev);
nsdata->nsze = num_blocks;
@ -140,77 +123,6 @@ identify_ns(struct spdk_nvmf_subsystem *subsystem,
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
static int
identify_ctrlr(struct spdk_nvmf_ctrlr *ctrlr, struct spdk_nvme_ctrlr_data *cdata)
{
*cdata = ctrlr->vcdata;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
static int
identify_active_ns_list(struct spdk_nvmf_subsystem *subsystem,
struct spdk_nvme_cmd *cmd,
struct spdk_nvme_cpl *rsp,
struct spdk_nvme_ns_list *ns_list)
{
uint32_t i, num_ns, count = 0;
if (cmd->nsid >= 0xfffffffeUL) {
SPDK_ERRLOG("Identify Active Namespace List with invalid NSID %u\n", cmd->nsid);
rsp->status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
num_ns = subsystem->dev.max_nsid;
for (i = 1; i <= num_ns; i++) {
if (i <= cmd->nsid) {
continue;
}
if (subsystem->dev.ns_list[i - 1] == NULL) {
continue;
}
ns_list->ns_list[count++] = i;
if (count == SPDK_COUNTOF(ns_list->ns_list)) {
break;
}
}
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
static int
nvmf_bdev_ctrlr_identify(struct spdk_nvmf_request *req)
{
uint8_t cns;
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
struct spdk_nvmf_subsystem *subsystem = ctrlr->subsys;
if (req->data == NULL || req->length < 4096) {
SPDK_ERRLOG("identify command with invalid buffer\n");
rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
memset(req->data, 0, req->length);
cns = cmd->cdw10 & 0xFF;
switch (cns) {
case SPDK_NVME_IDENTIFY_NS:
return identify_ns(subsystem, cmd, rsp, req->data);
case SPDK_NVME_IDENTIFY_CTRLR:
return identify_ctrlr(ctrlr, req->data);
case SPDK_NVME_IDENTIFY_ACTIVE_NS_LIST:
return identify_active_ns_list(subsystem, cmd, rsp, req->data);
default:
SPDK_ERRLOG("Identify command with unsupported CNS 0x%02x\n", cns);
rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
}
static int
nvmf_bdev_ctrlr_abort(struct spdk_nvmf_request *req)
{
@ -322,7 +234,7 @@ nvmf_bdev_ctrlr_process_admin_cmd(struct spdk_nvmf_request *req)
case SPDK_NVME_OPC_GET_LOG_PAGE:
return spdk_nvmf_ctrlr_get_log_page(req);
case SPDK_NVME_OPC_IDENTIFY:
return nvmf_bdev_ctrlr_identify(req);
return spdk_nvmf_ctrlr_identify(req);
case SPDK_NVME_OPC_ABORT:
return nvmf_bdev_ctrlr_abort(req);
case SPDK_NVME_OPC_GET_FEATURES:

13
lib/nvmf/ctrlr_discovery.c
View File

@ -147,7 +147,6 @@ spdk_nvmf_get_discovery_log_page(void *buffer, uint64_t offset, uint32_t length)
static int
nvmf_discovery_ctrlr_process_admin_cmd(struct spdk_nvmf_request *req)
{
struct spdk_nvmf_ctrlr *ctrlr = req->qpair->ctrlr;
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
struct spdk_nvme_cpl *response = &req->rsp->nvme_cpl;
@ -162,17 +161,7 @@ nvmf_discovery_ctrlr_process_admin_cmd(struct spdk_nvmf_request *req)
switch (cmd->opc) {
case SPDK_NVME_OPC_IDENTIFY:
/* Only identify controller can be supported */
if ((cmd->cdw10 & 0xFF) == SPDK_NVME_IDENTIFY_CTRLR) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Identify Controller\n");
memcpy(req->data, (char *)&ctrlr->vcdata, sizeof(struct spdk_nvme_ctrlr_data));
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
} else {
SPDK_ERRLOG("Unsupported identify command\n");
response->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
}
break;
return spdk_nvmf_ctrlr_identify(req);
case SPDK_NVME_OPC_GET_LOG_PAGE:
return spdk_nvmf_ctrlr_get_log_page(req);
default:

12
test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c
View File

@ -102,10 +102,18 @@ spdk_nvmf_subsystem_get_sn(const struct spdk_nvmf_subsystem *subsystem)
return NULL;
}
void
spdk_nvmf_ctrlr_set_dsm(struct spdk_nvmf_ctrlr *ctrlr)
bool
spdk_nvmf_ctrlr_dsm_supported(struct spdk_nvmf_ctrlr *ctrlr)
{
abort();
return false;
}
int
spdk_nvmf_bdev_ctrlr_identify_ns(struct spdk_bdev *bdev, struct spdk_nvme_ns_data *nsdata)
{
abort();
return -1;
}
void

6
test/unit/lib/nvmf/ctrlr_bdev.c/ctrlr_bdev_ut.c
View File

@ -110,6 +110,12 @@ spdk_nvmf_ctrlr_get_log_page(struct spdk_nvmf_request *req)
return -1;
}
int
spdk_nvmf_ctrlr_identify(struct spdk_nvmf_request *req)
{
return -1;
}
int
spdk_nvmf_request_complete(struct spdk_nvmf_request *req)
{

13
test/unit/lib/nvmf/ctrlr_discovery.c/ctrlr_discovery_ut.c
View File

@ -162,6 +162,13 @@ spdk_nvmf_ctrlr_get_log_page(struct spdk_nvmf_request *req)
return -1;
}
int
spdk_nvmf_ctrlr_identify(struct spdk_nvmf_request *req)
{
abort();
return -1;
}
static void
test_process_discovery_cmd(void)
{
@ -182,14 +189,8 @@ test_process_discovery_cmd(void)
CU_ASSERT_EQUAL(ret, SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
CU_ASSERT_EQUAL(req.rsp->nvme_cpl.status.sc, SPDK_NVME_SC_INVALID_FIELD);
/* IDENTIFY opcode return value check */
req.cmd->nvme_cmd.opc = SPDK_NVME_OPC_IDENTIFY;
req.cmd->nvme_cmd.cdw10 = SPDK_NVME_IDENTIFY_CTRLR;
req.qpair->ctrlr = &req_ctrlr;
req.data = &req_data;
ret = nvmf_discovery_ctrlr_process_admin_cmd(&req);
CU_ASSERT_EQUAL(req.rsp->nvme_cpl.status.sc, SPDK_NVME_SC_SUCCESS);
CU_ASSERT_EQUAL(ret, SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
/* Invalid opcode return value check */
req.cmd->nvme_cmd.opc = 100;