static void
display_namespace(struct spdk_nvme_ns *ns)
{
const struct spdk_nvme_ns_data *nsdata;
uint32_t i;
nsdata = spdk_nvme_ns_get_data(ns);
printf("Namespace ID:%d\n", spdk_nvme_ns_get_id(ns));
printf("Size (in LBAs): %lld (%lldM)\n",
(long long)nsdata->nsze,
(long long)nsdata->nsze / 1024 / 1024);
printf("Capacity (in LBAs): %lld (%lldM)\n",
(long long)nsdata->ncap,
(long long)nsdata->ncap / 1024 / 1024);
printf("Utilization (in LBAs): %lld (%lldM)\n",
(long long)nsdata->nuse,
(long long)nsdata->nuse / 1024 / 1024);
printf("Format Progress Indicator: %s\n",
nsdata->fpi.fpi_supported ? "Supported" : "Not Supported");
if (nsdata->fpi.fpi_supported && nsdata->fpi.percentage_remaining)
printf("Formatted Percentage: %d%%\n", 100 - nsdata->fpi.percentage_remaining);
printf("Number of LBA Formats: %d\n", nsdata->nlbaf + 1);
printf("Current LBA Format: LBA Format #%02d\n",
nsdata->flbas.format);
for (i = 0; i <= nsdata->nlbaf; i++)
printf("LBA Format #%02d: Data Size: %5d Metadata Size: %5d\n",
i, 1 << nsdata->lbaf[i].lbads, nsdata->lbaf[i].ms);
printf("\n");
}
static void
format_nvm(void)
{
int i;
int ns_id;
int ses;
int pil;
int pi;
int ms;
int lbaf;
char option;
struct dev *ctrlr;
const struct spdk_nvme_ctrlr_data *cdata;
struct spdk_nvme_ns *ns;
const struct spdk_nvme_ns_data *nsdata;
ctrlr = get_controller();
if (ctrlr == NULL) {
printf("Invalid controller PCI BDF.\n");
return;
}
cdata = ctrlr->cdata;
if (!cdata->oacs.format) {
printf("Controller does not support Format NVM command\n");
return;
}
if (cdata->fna.format_all_ns) {
ns_id = SPDK_NVME_GLOBAL_NS_TAG;
ns = spdk_nvme_ctrlr_get_ns(ctrlr->ctrlr, 1);
} else {
printf("Please Input Namespace ID (1 - %d): \n", cdata->nn);
if (!scanf("%d", &ns_id)) {
printf("Invalid Namespace ID\n");
while (getchar() != '\n');
return;
}
ns = spdk_nvme_ctrlr_get_ns(ctrlr->ctrlr, ns_id);
}
if (ns == NULL) {
printf("Namespace ID %d not found\n", ns_id);
while (getchar() != '\n');
return;
}
nsdata = spdk_nvme_ns_get_data(ns);
printf("Please Input Secure Erase Setting: \n");
printf(" 0: No secure erase operation requested\n");
printf(" 1: User data erase\n");
if (cdata->fna.crypto_erase_supported) {
printf(" 2: Cryptographic erase\n");
}
if (!scanf("%d", &ses)) {
printf("Invalid Secure Erase Setting\n");
while (getchar() != '\n');
return;
}
for (i = 0; i <= nsdata->nlbaf; i++) {
printf("LBA Format #%02d: Data Size: %5d Metadata Size: %5d\n",
i, 1 << nsdata->lbaf[i].lbads, nsdata->lbaf[i].ms);
}
printf("Please Input LBA Format Number (0 - %d): \n", nsdata->nlbaf);
if (!scanf("%d", &lbaf)) {
printf("Invalid LBA format size\n");
while (getchar() != '\n');
return;
}
if (lbaf > nsdata->nlbaf) {
printf("Invalid LBA format number\n");
while (getchar() != '\n');
return;
}
if (nsdata->lbaf[lbaf].ms) {
printf("Please Input Protection Information: \n");
printf(" 0: Protection information is not enabled\n");
printf(" 1: Protection information is enabled, Type 1\n");
printf(" 2: Protection information is enabled, Type 2\n");
printf(" 3: Protection information is enabled, Type 3\n");
if (!scanf("%d", &pi)) {
printf("Invalid protection information\n");
while (getchar() != '\n');
return;
}
if (pi) {
printf("Please Input Protection Information Location: \n");
printf(" 0: Protection information transferred as the last eight bytes of metadata\n");
printf(" 1: Protection information transferred as the first eight bytes of metadata\n");
if (!scanf("%d", &pil)) {
printf("Invalid protection information location\n");
while (getchar() != '\n');
return;
}
} else {
pil = 0;
}
printf("Please Input Metadata Setting: \n");
printf(" 0: Metadata is transferred as part of a separate buffer\n");
printf(" 1: Metadata is transferred as part of an extended data LBA\n");
if (!scanf("%d", &ms)) {
printf("Invalid metadata setting\n");
while (getchar() != '\n');
return;
}
} else {
ms = 0;
pi = 0;
pil = 0;
}
printf("Warning: use this utility at your own risk.\n"
"This command will format your namespace and all data will be lost.\n"
"This command may take several minutes to complete,\n"
"so do not interrupt the utility until it completes.\n"
"Press 'Y' to continue with the format operation.\n");
while (getchar() != '\n');
if (!scanf("%c", &option)) {
printf("Invalid option\n");
while (getchar() != '\n');
return;
}
if (option == 'y' || option == 'Y') {
nvme_manage_format(ctrlr, ns_id, ses, pi, pil, ms, lbaf);
} else {
printf("NVMe format abort\n");
}
}
static bool
nvmf_process_admin_cmd(struct spdk_nvmf_request *req)
{
struct nvmf_session *session = req->conn->sess;
struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd;
struct spdk_nvme_cpl *response = &req->rsp->nvme_cpl;
struct spdk_nvmf_subsystem *subsystem = session->subsys;
struct spdk_nvme_ctrlr *ctrlr = NULL;
uint32_t nsid = 0;
int rc = 0;
uint8_t feature;
/* pre-set response details for this command */
response->status.sc = SPDK_NVME_SC_SUCCESS;
response->cid = cmd->cid;
/* verify subsystem */
if (subsystem == NULL) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Subsystem Not Initialized!\n");
response->status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
return true;
}
if (cmd->nsid == 0) {
/* may be valid for the requested command. but need
to at least map to a known valid controller.
Note: Issue when in multi-controller subsystem
mode, commands that do not provide ns_id can not
be mapped to valid HW ctrlr! This is where
definition of a virtual controller is required */
ctrlr = subsystem->ns_list_map[0].ctrlr;
nsid = 0;
} else {
/* verify namespace id */
if (cmd->nsid > MAX_PER_SUBSYSTEM_NAMESPACES) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Invalid NS_ID %u\n",
cmd->nsid);
response->status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
return true;
}
ctrlr = subsystem->ns_list_map[cmd->nsid - 1].ctrlr;
nsid = subsystem->ns_list_map[cmd->nsid - 1].nvme_ns_id;
}
SPDK_TRACELOG(SPDK_TRACE_NVMF, "ctrlr %p nvme ns_id %u\n", ctrlr, nsid);
switch (cmd->opc) {
case SPDK_NVME_OPC_IDENTIFY:
if (req->data == NULL) {
SPDK_ERRLOG("identify command with no buffer\n");
response->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return true;
}
if (cmd->cdw10 == 0) {
/* identify namespace */
struct spdk_nvme_ns *ns;
const struct spdk_nvme_ns_data *nsdata;
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Identify Namespace\n");
if (nsid == 0) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Invalid NS_ID = 0\n");
response->status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
return true;
}
ns = spdk_nvme_ctrlr_get_ns(ctrlr, nsid);
if (ns == NULL) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Unsuccessful query for Namespace reference\n");
response->status.sc = SPDK_NVME_SC_INVALID_FIELD;
return true;
}
nsdata = spdk_nvme_ns_get_data(ns);
memcpy(req->data, (char *)nsdata, sizeof(struct spdk_nvme_ns_data));
return true;
} else if (cmd->cdw10 == 1) {
/* identify controller */
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Identify Controller\n");
/* pull from virtual controller context */
memcpy(req->data, (char *)&session->vcdata, sizeof(struct spdk_nvme_ctrlr_data));
return true;
} else {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Identify Namespace List\n");
response->status.sc = SPDK_NVME_SC_INVALID_OPCODE;
return true;
}
break;
case SPDK_NVME_OPC_GET_FEATURES:
feature = cmd->cdw10 & 0xff; /* mask out the FID value */
switch (feature) {
case SPDK_NVME_FEAT_NUMBER_OF_QUEUES:
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Get Features - Number of Queues\n");
response->cdw0 = ((session->max_io_queues - 1) << 16) | (session->max_io_queues - 1);
return true;
case SPDK_NVME_FEAT_LBA_RANGE_TYPE:
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Get Features - LBA Range Type\n");
cmd->nsid = nsid;
goto passthrough;
default:
goto passthrough;
}
break;
case SPDK_NVME_OPC_SET_FEATURES:
feature = cmd->cdw10 & 0xff; /* mask out the FID value */
switch (feature) {
case SPDK_NVME_FEAT_NUMBER_OF_QUEUES:
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Set Features - Number of Queues, cdw11 0x%x\n", cmd->cdw11);
/* verify that the contoller is ready to process commands */
if (session->active_queues != 0) {
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Queue pairs already active!\n");
response->status.sc = SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR;
} else {
response->cdw0 = ((session->max_io_queues - 1) << 16) | (session->max_io_queues - 1);
}
return true;
default:
goto passthrough;
}
break;
case SPDK_NVME_OPC_ASYNC_EVENT_REQUEST:
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Async Event Request\n");
/*
Trap request here and save in the session context
until NVMe library indicates some event.
*/
if (session->aer_req == NULL) {
session->aer_req = req;
return false;
} else {
/* AER already recorded, send error response */
SPDK_TRACELOG(SPDK_TRACE_NVMF, "AER already active!\n");
response->status.sc = SPDK_NVME_SC_ASYNC_EVENT_REQUEST_LIMIT_EXCEEDED;
return true;
}
break;
case SPDK_NVME_OPC_KEEP_ALIVE:
SPDK_TRACELOG(SPDK_TRACE_NVMF, "Keep Alive\n");
/*
To handle keep alive just clear or reset the
session based keep alive duration counter.
When added, a separate timer based process
will monitor if the time since last recorded
keep alive has exceeded the max duration and
take appropriate action.
*/
//session->keep_alive_timestamp = ;
return true;
case SPDK_NVME_OPC_CREATE_IO_SQ:
case SPDK_NVME_OPC_CREATE_IO_CQ:
case SPDK_NVME_OPC_DELETE_IO_SQ:
case SPDK_NVME_OPC_DELETE_IO_CQ:
SPDK_ERRLOG("Admin opc 0x%02X not allowed in NVMf\n", cmd->opc);
response->status.sc = SPDK_NVME_SC_INVALID_OPCODE;
return true;
default:
passthrough:
SPDK_TRACELOG(SPDK_TRACE_NVMF, "admin_cmd passthrough: opc 0x%02x\n", cmd->opc);
cmd->nsid = nsid;
rc = spdk_nvme_ctrlr_cmd_admin_raw(ctrlr,
cmd,
req->data, req->length,
nvmf_complete_cmd,
req);
if (rc) {
SPDK_ERRLOG("Error submitting admin opc 0x%02x\n", cmd->opc);
response->status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
return true;
}
return false;
}
}
static int
write_read_e2e_dp_tests(struct dev *dev, nvme_build_io_req_fn_t build_io_fn, const char *test_name)
{
int rc = 0;
uint32_t lba_count;
uint32_t io_flags = 0;
struct io_request *req;
struct spdk_nvme_ns *ns;
struct spdk_nvme_qpair *qpair;
const struct spdk_nvme_ns_data *nsdata;
ns = spdk_nvme_ctrlr_get_ns(dev->ctrlr, 1);
if (!ns) {
fprintf(stderr, "Null namespace\n");
return 0;
}
if (!(spdk_nvme_ns_get_flags(ns) & SPDK_NVME_NS_DPS_PI_SUPPORTED))
return 0;
nsdata = spdk_nvme_ns_get_data(ns);
if (!nsdata || !spdk_nvme_ns_get_sector_size(ns)) {
fprintf(stderr, "Empty nsdata or wrong sector size\n");
return 0;
}
req = rte_zmalloc(NULL, sizeof(*req), 0);
if (!req) {
fprintf(stderr, "Allocate request failed\n");
return 0;
}
/* IO parameters setting */
lba_count = build_io_fn(ns, req, &io_flags);
if (!lba_count) {
fprintf(stderr, "%s: %s bypass the test case\n", dev->name, test_name);
free_req(req);
return 0;
}
qpair = spdk_nvme_ctrlr_alloc_io_qpair(dev->ctrlr, 0);
if (!qpair) {
free_req(req);
return -1;
}
ns_data_buffer_reset(ns, req, DATA_PATTERN);
if (req->use_extended_lba)
rc = spdk_nvme_ns_cmd_write(ns, qpair, req->contig, req->lba, lba_count,
io_complete, req, io_flags);
else
rc = spdk_nvme_ns_cmd_write_with_md(ns, qpair, req->contig, req->metadata, req->lba, lba_count,
io_complete, req, io_flags, req->apptag_mask, req->apptag);
if (rc != 0) {
fprintf(stderr, "%s: %s write submit failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
io_complete_flag = 0;
while (!io_complete_flag)
spdk_nvme_qpair_process_completions(qpair, 1);
if (io_complete_flag != 1) {
fprintf(stderr, "%s: %s write exec failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
/* reset completion flag */
io_complete_flag = 0;
ns_data_buffer_reset(ns, req, 0);
if (req->use_extended_lba)
rc = spdk_nvme_ns_cmd_read(ns, qpair, req->contig, req->lba, lba_count,
io_complete, req, io_flags);
else
rc = spdk_nvme_ns_cmd_read_with_md(ns, qpair, req->contig, req->metadata, req->lba, lba_count,
io_complete, req, io_flags, req->apptag_mask, req->apptag);
if (rc != 0) {
fprintf(stderr, "%s: %s read failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
while (!io_complete_flag)
spdk_nvme_qpair_process_completions(qpair, 1);
if (io_complete_flag != 1) {
fprintf(stderr, "%s: %s read failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
rc = ns_data_buffer_compare(ns, req, DATA_PATTERN);
if (rc < 0) {
fprintf(stderr, "%s: %s write/read success, but memcmp Failed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return -1;
}
fprintf(stdout, "%s: %s test passed\n", dev->name, test_name);
spdk_nvme_ctrlr_free_io_qpair(qpair);
free_req(req);
return rc;
}
