Commit bf6caa75 authored by Daniel Verkamp's avatar Daniel Verkamp
Browse files

nvmf: refactor identify into a common function 



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: default avatarDaniel Verkamp <daniel.verkamp@intel.com>
Reviewed-on: https://review.gerrithub.io/374559


Tested-by: default avatarSPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
parent 89d35cef

lib/nvmf/ctrlr.c

+176 −67
Original line number Diff line number Diff line
@@ -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;

}

lib/nvmf/ctrlr.h

+7 −2
Original line number Diff line number Diff line
@@ -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

lib/nvmf/ctrlr_bdev.c

+7 −95
Original line number Diff line number Diff line
@@ -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:

lib/nvmf/ctrlr_discovery.c

+1 −12
Original line number Diff line number Diff line
@@ -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:

test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c

+10 −2
Original line number Diff line number Diff line
@@ -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