summaryrefslogtreecommitdiffstats
path: root/nvme.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--nvme.c1427
1 files changed, 1143 insertions, 284 deletions
diff --git a/nvme.c b/nvme.c
index 107f012..a2075bf 100644
--- a/nvme.c
+++ b/nvme.c
@@ -47,7 +47,6 @@
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include <sys/time.h>
#include "common.h"
#include "nvme-print.h"
@@ -85,7 +84,17 @@ static struct program nvme = {
.extensions = &builtin,
};
-static const char *output_format = "Output format: normal|json|binary";
+static __u16 nvme_feat_buf_len[0x100] = {
+ [NVME_FEAT_LBA_RANGE] = 4096,
+ [NVME_FEAT_AUTO_PST] = 256,
+ [NVME_FEAT_HOST_MEM_BUF] = 4096,
+ [NVME_FEAT_HOST_ID] = 8,
+ [NVME_FEAT_PLM_CONFIG] = 512,
+ [NVME_FEAT_TIMESTAMP] = 8,
+ [NVME_FEAT_HOST_BEHAVIOR] = 512
+};
+
+const char *output_format = "Output format: normal|json|binary";
static const char *output_format_no_binary = "Output format: normal|json";
static void *__nvme_alloc(size_t len, bool *huge)
@@ -100,10 +109,10 @@ static void *__nvme_alloc(size_t len, bool *huge)
return NULL;
}
-#ifdef LIBHUGETLBFS
#define HUGE_MIN 0x80000
-static void nvme_free(void *p, bool huge)
+#ifdef LIBHUGETLBFS
+void nvme_free(void *p, bool huge)
{
if (huge)
free_hugepage_region(p);
@@ -111,7 +120,7 @@ static void nvme_free(void *p, bool huge)
free(p);
}
-static void *nvme_alloc(size_t len, bool *huge)
+void *nvme_alloc(size_t len, bool *huge)
{
void *p;
@@ -126,17 +135,27 @@ static void *nvme_alloc(size_t len, bool *huge)
return p;
}
#else
-static void nvme_free(void *p, bool huge)
+void nvme_free(void *p, bool huge)
{
free(p);
}
-static void *nvme_alloc(size_t len, bool *huge)
+void *nvme_alloc(size_t len, bool *huge)
{
return __nvme_alloc(len, huge);
}
#endif
+static bool is_chardev(void)
+{
+ return S_ISCHR(nvme_stat.st_mode);
+}
+
+static bool is_blkdev(void)
+{
+ return S_ISBLK(nvme_stat.st_mode);
+}
+
static int open_dev(char *dev)
{
int err, fd;
@@ -152,7 +171,7 @@ static int open_dev(char *dev)
close(fd);
goto perror;
}
- if (!S_ISCHR(nvme_stat.st_mode) && !S_ISBLK(nvme_stat.st_mode)) {
+ if (!is_chardev() && !is_blkdev()) {
fprintf(stderr, "%s is not a block or character device\n", dev);
close(fd);
return -ENODEV;
@@ -200,7 +219,7 @@ int parse_and_open(int argc, char **argv, const char *desc,
return ret;
}
-enum nvme_print_flags validate_output_format(char *format)
+enum nvme_print_flags validate_output_format(const char *format)
{
if (!format)
return -EINVAL;
@@ -386,8 +405,7 @@ static int get_telemetry_log(int argc, char **argv, struct command *cmd, struct
hdr = malloc(bs);
page_log = malloc(bs);
if (!hdr || !page_log) {
- fprintf(stderr, "Failed to allocate %zu bytes for log: %s\n",
- bs, strerror(errno));
+ perror("failed to allocate buf for log\n");
err = -ENOMEM;
goto free_mem;
}
@@ -623,7 +641,7 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
cfg.log_entries = min(cfg.log_entries, ctrl.elpe + 1);
err_log = calloc(cfg.log_entries, sizeof(struct nvme_error_log_page));
if (!err_log) {
- fprintf(stderr, "could not alloc buffer for error log\n");
+ perror("could not alloc buffer for error log\n");
err = -ENOMEM;
goto close_fd;
}
@@ -738,6 +756,470 @@ ret:
return nvme_status_to_errno(err, false);
}
+static int get_pred_lat_per_nvmset_log(int argc, char **argv,
+ struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Retrieve Predictable latency per nvm set log "\
+ "page and prints it for the given device in either decoded " \
+ "format(default),json or binary.";
+ const char *nvmset_id = "NVM Set Identifier";
+ const char *raw = "use binary output";
+ struct nvme_predlat_per_nvmset_log_page plpns_log;
+ enum nvme_print_flags flags;
+ int err, fd;
+
+ struct config {
+ __u16 nvmset_id;
+ char *output_format;
+ int raw_binary;
+ };
+
+ struct config cfg = {
+ .nvmset_id = 1,
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_UINT("nvmset-id", 'i', &cfg.nvmset_id, nvmset_id),
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+ if (cfg.raw_binary)
+ flags = BINARY;
+
+ err = nvme_predictable_latency_per_nvmset_log(fd,
+ cfg.nvmset_id, &plpns_log);
+ if (!err)
+ nvme_show_predictable_latency_per_nvmset(&plpns_log,
+ cfg.nvmset_id, devicename, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("predictable latency per nvm set");
+
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
+static int get_pred_lat_event_agg_log(int argc, char **argv,
+ struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Retrieve Predictable Latency Event" \
+ "Aggregate Log page and prints it, for the given" \
+ "device in either decoded format(default)," \
+ "json or binary.";
+ const char *log_entries = "Number of pending NVM Set" \
+ "log Entries list";
+ const char *rae = "Retain an Asynchronous Event";
+ const char *raw = "use binary output";
+ void *pea_log;
+ struct nvme_id_ctrl ctrl;
+ enum nvme_print_flags flags;
+ int err, fd;
+ __u32 log_size;
+
+ struct config {
+ __u64 log_entries;
+ bool rae;
+ char *output_format;
+ int raw_binary;
+ };
+
+ struct config cfg = {
+ .log_entries = 2044,
+ .rae = false,
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_UINT("log-entries", 'e', &cfg.log_entries, log_entries),
+ OPT_FLAG("rae", 'r', &cfg.rae, rae),
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+ if (cfg.raw_binary)
+ flags = BINARY;
+
+ if (!cfg.log_entries) {
+ fprintf(stderr, "non-zero log-entries is required param\n");
+ err = -EINVAL;
+ goto close_fd;
+ }
+
+ err = nvme_identify_ctrl(fd, &ctrl);
+ if (err < 0) {
+ perror("identify controller");
+ goto close_fd;
+ } else if (err) {
+ nvme_show_status(err);
+ goto close_fd;
+ }
+
+ cfg.log_entries = min(cfg.log_entries, le32_to_cpu(ctrl.nsetidmax));
+ log_size = sizeof(__u64) + cfg.log_entries * sizeof(__u16);
+ pea_log = calloc(log_size, 1);
+ if (!pea_log) {
+ perror("could not alloc buffer for predictable " \
+ "latency event agggregate log entries\n");
+ err = -ENOMEM;
+ goto close_fd;
+ }
+
+ err = nvme_predictable_latency_event_agg_log(fd, pea_log, cfg.rae,
+ log_size);
+ if (!err)
+ nvme_show_predictable_latency_event_agg_log(pea_log, cfg.log_entries,
+ log_size, devicename, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("predictable latency event gggregate log page");
+ free(pea_log);
+
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
+static int get_persistent_event_log(int argc, char **argv,
+ struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Retrieve Persistent Event log info for"\
+ " the given device in either decoded format(default),"\
+ " json or binary.";
+ const char *action = "action the controller shall take during"\
+ " processing this persistent log page command.";
+ const char *log_len = "number of bytes to retrieve";
+ const char *raw = "use binary output";
+ void *pevent_log_info;
+ struct nvme_persistent_event_log_head *pevent_log_head;
+ enum nvme_print_flags flags;
+ int err, fd;
+ bool huge;
+
+ struct config {
+ __u8 action;
+ __u32 log_len;
+ int raw_binary;
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .action = 0xff,
+ .log_len = 0,
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_UINT("action", 'a', &cfg.action, action),
+ OPT_UINT("log_len", 'l', &cfg.log_len, log_len),
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+ if (cfg.raw_binary)
+ flags = BINARY;
+
+ pevent_log_head = calloc(sizeof(*pevent_log_head), 1);
+ if (!pevent_log_head) {
+ perror("could not alloc buffer for persistent " \
+ "event log header\n");
+ err = -ENOMEM;
+ goto close_fd;
+ }
+
+ err = nvme_persistent_event_log(fd, cfg.action,
+ sizeof(*pevent_log_head), pevent_log_head);
+ if (err < 0) {
+ perror("persistent event log");
+ goto close_fd;
+ } else if (err) {
+ nvme_show_status(err);
+ goto close_fd;
+ }
+
+ if (cfg.action == NVME_PEVENT_LOG_RELEASE_CTX) {
+ printf("Releasing Persistent Event Log Context\n");
+ goto close_fd;
+ }
+
+ if (!cfg.log_len && cfg.action != NVME_PEVENT_LOG_EST_CTX_AND_READ) {
+ cfg.log_len = le64_to_cpu(pevent_log_head->tll);
+ } else if (!cfg.log_len && cfg.action == NVME_PEVENT_LOG_EST_CTX_AND_READ) {
+ printf("Establishing Persistent Event Log Context\n");
+ goto close_fd;
+ }
+
+ /*
+ * if header aleady read with context establish action 0x1,
+ * action shall not be 0x1 again in the subsequent request,
+ * until the current context is released by issuing action
+ * with 0x2, otherwise throws command sequence error, make
+ * it as zero to read the log page
+ */
+ if (cfg.action == NVME_PEVENT_LOG_EST_CTX_AND_READ)
+ cfg.action = NVME_PEVENT_LOG_READ;
+
+ pevent_log_info = nvme_alloc(cfg.log_len, &huge);
+ if (!pevent_log_info) {
+ perror("could not alloc buffer for persistent event log page\n");
+ err = -ENOMEM;
+ goto close_fd;
+ }
+ err = nvme_persistent_event_log(fd, cfg.action,
+ cfg.log_len, pevent_log_info);
+ if (!err)
+ nvme_show_persistent_event_log(pevent_log_info, cfg.action,
+ cfg.log_len, devicename, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("persistent event log");
+
+ nvme_free(pevent_log_info, huge);
+
+close_fd:
+ free(pevent_log_head);
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
+static int get_endurance_event_agg_log(int argc, char **argv,
+ struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Retrieve Retrieve Predictable Latency " \
+ "Event Aggregate page and prints it, for the given " \
+ "device in either decoded format(default), " \
+ "json or binary.";
+ const char *log_entries = "Number of pending Endurance Group " \
+ "Event log Entries list";
+ const char *rae = "Retain an Asynchronous Event";
+ const char *raw = "use binary output";
+ void *endurance_log;
+ struct nvme_id_ctrl ctrl;
+ enum nvme_print_flags flags;
+ int err, fd;
+ __u32 log_size;
+
+ struct config {
+ __u64 log_entries;
+ bool rae;
+ char *output_format;
+ int raw_binary;
+ };
+
+ struct config cfg = {
+ .log_entries = 2044,
+ .rae = false,
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_UINT("log-entries", 'e', &cfg.log_entries, log_entries),
+ OPT_FLAG("rae", 'r', &cfg.rae, rae),
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+ if (cfg.raw_binary)
+ flags = BINARY;
+
+ if (!cfg.log_entries) {
+ fprintf(stderr, "non-zero log-entries is required param\n");
+ err = -EINVAL;
+ goto close_fd;
+ }
+
+ err = nvme_identify_ctrl(fd, &ctrl);
+ if (err < 0) {
+ perror("identify controller");
+ goto close_fd;
+ } else if (err) {
+ fprintf(stderr, "could not identify controller\n");
+ err = -ENODEV;
+ goto close_fd;
+ }
+
+ cfg.log_entries = min(cfg.log_entries, le16_to_cpu(ctrl.endgidmax));
+ log_size = sizeof(__u64) + cfg.log_entries * sizeof(__u16);
+ endurance_log = calloc(log_size, 1);
+ if (!endurance_log) {
+ perror("could not alloc buffer for endurance group" \
+ " event agggregate log entries\n");
+ err = -ENOMEM;
+ goto close_fd;
+ }
+
+ err = nvme_endurance_group_event_agg_log(fd, endurance_log, cfg.rae,
+ log_size);
+ if (!err)
+ nvme_show_endurance_group_event_agg_log(endurance_log, cfg.log_entries,
+ log_size, devicename, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("endurance group event aggregate log page");
+ free(endurance_log);
+
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
+static int get_lba_status_log(int argc, char **argv,
+ struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Retrieve Get LBA Status Info Log " \
+ "and prints it, for the given device in either " \
+ "decoded format(default),json or binary.";
+ const char *rae = "Retain an Asynchronous Event";
+ void *lab_status;
+ enum nvme_print_flags flags;
+ int err, fd;
+ __u32 lslplen;
+
+ struct config {
+ bool rae;
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .rae = false,
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_FLAG("rae", 'r', &cfg.rae, rae),
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+
+ err = nvme_lba_status_log(fd, &lslplen, true, sizeof(__u32));
+ if (err < 0) {
+ perror("lba status log page");
+ goto close_fd;
+ } else if (err) {
+ nvme_show_status(err);
+ goto close_fd;
+ }
+
+ lab_status = calloc(lslplen, 1);
+ if (!lab_status) {
+ perror("could not alloc buffer for lba status log");
+ err = -ENOMEM;
+ goto close_fd;
+ }
+
+ err = nvme_lba_status_log(fd, lab_status, cfg.rae, lslplen);
+ if (!err)
+ nvme_show_lba_status_log(lab_status, lslplen, devicename, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("lba status log page");
+ free(lab_status);
+
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
+static int get_resv_notif_log(int argc, char **argv,
+ struct command *cmd, struct plugin *plugin)
+{
+
+ const char *desc = "Retrieve Reservation Notification " \
+ "log page and prints it, for the given " \
+ "device in either decoded format(default), " \
+ "json or binary.";
+ struct nvme_resv_notif_log resv;
+ enum nvme_print_flags flags;
+ int err, fd;
+
+ struct config {
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+
+ err = nvme_resv_notif_log(fd, &resv);
+ if (!err)
+ nvme_show_resv_notif_log(&resv, devicename, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("resv notifi log");
+
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+
+}
+
static int get_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Retrieve desired number of bytes "\
@@ -756,7 +1238,7 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
struct config {
__u32 namespace_id;
- __u32 log_id;
+ __u8 log_id;
__u32 log_len;
__u32 aen;
__u64 lpo;
@@ -768,7 +1250,7 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
struct config cfg = {
.namespace_id = NVME_NSID_ALL,
- .log_id = 0xffffffff,
+ .log_id = 0xff,
.log_len = 0,
.lpo = NVME_NO_LOG_LPO,
.lsp = NVME_NO_LOG_LSP,
@@ -798,12 +1280,6 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
cfg.log_id = (cfg.aen >> 16) & 0xff;
}
- if (cfg.log_id > 0xff) {
- fprintf(stderr, "Invalid log identifier: %d. Valid range: 0-255\n", cfg.log_id);
- err = -EINVAL;
- goto close_fd;
- }
-
if (!cfg.log_len) {
fprintf(stderr, "non-zero log-len is required param\n");
err = -EINVAL;
@@ -812,9 +1288,8 @@ static int get_log(int argc, char **argv, struct command *cmd, struct plugin *pl
log = malloc(cfg.log_len);
if (!log) {
- fprintf(stderr, "could not alloc buffer for log: %s\n",
- strerror(errno));
- err = -EINVAL;
+ perror("could not alloc buffer for log\n");
+ err = -ENOMEM;
goto close_fd;
}
@@ -844,6 +1319,7 @@ ret:
static int sanitize_log(int argc, char **argv, struct command *command, struct plugin *plugin)
{
const char *desc = "Retrieve sanitize log and show it.";
+ const char *rae = "Retain an Asynchronous Event";
const char *raw = "show log in binary format";
const char *human_readable = "show log in readable format";
struct nvme_sanitize_log_page sanitize_log;
@@ -851,16 +1327,19 @@ static int sanitize_log(int argc, char **argv, struct command *command, struct p
int fd, err;
struct config {
+ bool rae;
int raw_binary;
int human_readable;
char *output_format;
};
struct config cfg = {
+ .rae = false,
.output_format = "normal",
};
OPT_ARGS(opts) = {
+ OPT_FLAG("rae", 'r', &cfg.rae, rae),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("human-readable",'H', &cfg.human_readable, human_readable),
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
@@ -879,7 +1358,7 @@ static int sanitize_log(int argc, char **argv, struct command *command, struct p
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_sanitize_log(fd, &sanitize_log);
+ err = nvme_sanitize_log(fd, cfg.rae, &sanitize_log);
if (!err)
nvme_show_sanitize_log(&sanitize_log, devicename, flags);
else if (err > 0)
@@ -932,8 +1411,7 @@ static int list_ctrl(int argc, char **argv, struct command *cmd, struct plugin *
for (i = 0; i < (min(num, 2048)); i++)
printf("[%4u]:%#x\n", i, le16_to_cpu(cntlist->identifier[i]));
- }
- else if (err > 0)
+ } else if (err > 0)
nvme_show_status(err);
else
perror("id controller list");
@@ -950,6 +1428,7 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
const char *desc = "For the specified controller handle, show the "\
"namespace list in the associated NVMe subsystem, optionally starting with a given nsid.";
const char *namespace_id = "first nsid returned list should start from";
+ const char *csi = "I/O command set identifier";
const char *all = "show all namespaces in the subsystem, whether attached or inactive";
int err, i, fd;
__le32 ns_list[1024];
@@ -957,6 +1436,7 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
struct config {
__u32 namespace_id;
int all;
+ __u16 csi;
};
struct config cfg = {
@@ -965,6 +1445,7 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
OPT_ARGS(opts) = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
+ OPT_BYTE("csi", 'y', &cfg.csi, csi),
OPT_FLAG("all", 'a', &cfg.all, all),
OPT_END()
};
@@ -979,8 +1460,8 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
goto close_fd;
}
- err = nvme_identify_ns_list(fd, cfg.namespace_id - 1, !!cfg.all,
- ns_list);
+ err = nvme_identify_ns_list_csi(fd, cfg.namespace_id - 1, cfg.csi,
+ !!cfg.all, ns_list);
if (!err) {
for (i = 0; i < 1024; i++)
if (ns_list[i])
@@ -1028,13 +1509,9 @@ static int delete_ns(int argc, char **argv, struct command *cmd, struct plugin *
goto ret;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id == 0) {
- err = -EINVAL;
- goto close_fd;
- }
- else if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -1145,15 +1622,18 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
"parameters. The next available namespace ID is used for the "\
"create operation. Note that create-ns does not attach the "\
"namespace to a controller, the attach-ns command is needed.";
- const char *nsze = "size of ns";
- const char *ncap = "capacity of ns";
- const char *flbas = "FLBA size";
- const char *dps = "data protection capabilities";
- const char *nmic = "multipath and sharing capabilities";
- const char *anagrpid = "ANA Group Identifier";
- const char *nvmsetid = "NVM Set Identifier";
+ const char *nsze = "size of ns (NSZE)";
+ const char *ncap = "capacity of ns (NCAP)";
+ const char *flbas = "Formatted LBA size (FLBAS), if entering this "\
+ "value ignore \'block-size\' field";
+ const char *dps = "data protection settings (DPS)";
+ const char *nmic = "multipath and sharing capabilities (NMIC)";
+ const char *anagrpid = "ANA Group Identifier (ANAGRPID)";
+ const char *nvmsetid = "NVM Set Identifier (NVMSETID)";
+ const char *csi = "command set identifier (CSI)";
const char *timeout = "timeout value, in milliseconds";
- const char *bs = "target block size";
+ const char *bs = "target block size, specify only if \'FLBAS\' "\
+ "value not entered";
int err = 0, fd, i;
struct nvme_id_ns ns;
@@ -1169,6 +1649,7 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
__u16 nvmsetid;
__u64 bs;
__u32 timeout;
+ __u8 csi;
};
struct config cfg = {
@@ -1189,6 +1670,7 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
OPT_UINT("nvmset-id", 'i', &cfg.nvmsetid, nvmsetid),
OPT_SUFFIX("block-size", 'b', &cfg.bs, bs),
OPT_UINT("timeout", 't', &cfg.timeout, timeout),
+ OPT_BYTE("csi", 'y', &cfg.csi, csi),
OPT_END()
};
@@ -1240,7 +1722,8 @@ static int create_ns(int argc, char **argv, struct command *cmd, struct plugin *
}
err = nvme_ns_create(fd, cfg.nsze, cfg.ncap, cfg.flbas, cfg.dps, cfg.nmic,
- cfg.anagrpid, cfg.nvmsetid, cfg.timeout, &nsid);
+ cfg.anagrpid, cfg.nvmsetid, cfg.csi, cfg.timeout,
+ &nsid);
if (!err)
printf("%s: Success, created nsid:%d\n", cmd->name, nsid);
else if (err > 0)
@@ -1263,7 +1746,7 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
const char *desc = "Retrieve information for subsystems";
const char *verbose = "Increase output verbosity";
__u32 ns_instance = 0;
- int err;
+ int err, nsid = 0;
struct config {
char *output_format;
@@ -1288,7 +1771,7 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
devicename = NULL;
if (optind < argc) {
char path[512];
- int id;
+ int id, fd;
devicename = basename(argv[optind]);
if (sscanf(devicename, "nvme%dn%d", &id, &ns_instance) != 2) {
@@ -1297,6 +1780,22 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
err = -EINVAL;
goto ret;
}
+ sprintf(path, "/dev/%s", devicename);
+ fd = open(path, O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "Cannot read nsid from %s\n",
+ devicename);
+ err = -EINVAL;
+ goto ret;
+ }
+ nsid = nvme_get_nsid(fd);
+ close(fd);
+ if (nsid < 0) {
+ fprintf(stderr, "Cannot read nsid from %s\n",
+ devicename);
+ err = -EINVAL;
+ goto ret;
+ }
sprintf(path, "/sys/block/%s/device", devicename);
subsysnqn = get_nvme_subsnqn(path);
if (!subsysnqn) {
@@ -1318,7 +1817,7 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
if (cfg.verbose)
flags |= VERBOSE;
- err = scan_subsystems(&t, subsysnqn, ns_instance);
+ err = scan_subsystems(&t, subsysnqn, ns_instance, nsid, NULL);
if (err) {
fprintf(stderr, "Failed to scan namespaces\n");
goto free;
@@ -1326,8 +1825,7 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
nvme_show_subsystem_list(&t, flags);
free:
free_topology(&t);
- if (subsysnqn)
- free(subsysnqn);
+ free(subsysnqn);
ret:
return nvme_status_to_errno(err, false);
}
@@ -1335,22 +1833,26 @@ ret:
static int list(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Retrieve basic information for all NVMe namespaces";
+ const char *device_dir = "Additional directory to search for devices";
const char *verbose = "Increase output verbosity";
struct nvme_topology t = { };
enum nvme_print_flags flags;
int err = 0;
struct config {
+ char *device_dir;
char *output_format;
int verbose;
};
struct config cfg = {
+ .device_dir = NULL,
.output_format = "normal",
.verbose = 0,
};
OPT_ARGS(opts) = {
+ OPT_STRING("directory", 'd', "DIR", &cfg.device_dir, device_dir),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format_no_binary),
OPT_FLAG("verbose", 'v', &cfg.verbose, verbose),
OPT_END()
@@ -1370,7 +1872,7 @@ static int list(int argc, char **argv, struct command *cmd, struct plugin *plugi
if (cfg.verbose)
flags |= VERBOSE;
- err = scan_subsystems(&t, NULL, 0);
+ err = scan_subsystems(&t, NULL, 0, 0, cfg.device_dir);
if (err) {
fprintf(stderr, "Failed to scan namespaces\n");
return err;
@@ -1447,6 +1949,50 @@ static int id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *pl
return __id_ctrl(argc, argv, cmd, plugin, NULL);
}
+static int nvm_id_ctrl(int argc, char **argv, struct command *cmd,
+ struct plugin *plugin)
+{
+ const char *desc = "Send an Identify Controller NVM Command Set "\
+ "command to the given device and report information about "\
+ "the specified controller in various formats.";
+ enum nvme_print_flags flags;
+ struct nvme_id_ctrl_nvm ctrl_nvm;
+ int fd, err = -1;
+
+ struct config {
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_END()
+ };
+
+ fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+
+ err = nvme_identify_ctrl_nvm(fd, &ctrl_nvm);
+ if (!err)
+ nvme_show_id_ctrl_nvm(&ctrl_nvm, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("nvm identify controller");
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Send Namespace Identification Descriptors command to the "\
@@ -1487,9 +2033,9 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
flags = BINARY;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -1569,15 +2115,9 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
flags |= VERBOSE;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
- goto close_fd;
- }
- else if (!cfg.namespace_id) {
- fprintf(stderr,
- "Error: requesting namespace-id from non-block device\n");
- err = -ENOTBLK;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -1749,6 +2289,48 @@ close_fd:
return err;
}
+static int id_iocs(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Send an Identify Command Set Data command to the "\
+ "given device, returns properties of the specified controller "\
+ "in either human-readable or binary format.";
+ const char *controller_id = "identifier of desired controller";
+ struct nvme_id_iocs iocs;
+ int err, fd;
+
+ struct config {
+ __u16 cntid;
+ };
+
+ struct config cfg = {
+ .cntid = 0xffff,
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_SHRT("controller-id", 'c', &cfg.cntid, controller_id),
+ OPT_END()
+ };
+
+ fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0) {
+ err = fd;
+ goto ret;
+ }
+
+ err = nvme_identify_iocs(fd, cfg.cntid, &iocs);
+ if (!err) {
+ printf("NVMe Identify I/O Command Set:\n");
+ nvme_show_id_iocs(&iocs);
+ } else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("NVMe Identify I/O Command Set");
+
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
static int get_ns_id(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
int err = 0, nsid, fd;
@@ -1795,29 +2377,27 @@ static int virtual_mgmt(int argc, char **argv, struct command *cmd, struct plugi
"9h: Secondary Online";
const char *nr = "Number of Controller Resources(NR)";
int fd, err;
- __u32 result;
+ __u32 result, cdw10;
struct config {
- int cntlid;
- int rt;
- int act;
- __u32 cdw10;
- __u32 cdw11;
+ __u16 cntlid;
+ __u8 rt;
+ __u8 act;
+ __u16 nr;
};
struct config cfg = {
.cntlid = 0,
.rt = 0,
.act = 0,
- .cdw10 = 0,
- .cdw11 = 0,
+ .nr = 0,
};
OPT_ARGS(opts) = {
OPT_UINT("cntlid", 'c', &cfg.cntlid, cntlid),
OPT_UINT("rt", 'r', &cfg.rt, rt),
OPT_UINT("act", 'a', &cfg.act, act),
- OPT_UINT("nr", 'n', &cfg.cdw11, nr),
+ OPT_UINT("nr", 'n', &cfg.nr, nr),
OPT_END()
};
@@ -1825,13 +2405,12 @@ static int virtual_mgmt(int argc, char **argv, struct command *cmd, struct plugi
if (fd < 0)
goto ret;
- cfg.cdw10 = cfg.cntlid << 16;
- cfg.cdw10 = cfg.cdw10 | (cfg.rt << 8);
- cfg.cdw10 = cfg.cdw10 | cfg.act;
+ cdw10 = cfg.act | (cfg.rt << 8) | (cfg.cntlid << 16);
- err = nvme_virtual_mgmt(fd, cfg.cdw10, cfg.cdw11, &result);
+ err = nvme_virtual_mgmt(fd, cdw10, cfg.nr, &result);
if (!err) {
- printf("success, Number of Resources allocated:%#x\n", result);
+ printf("success, Number of Controller Resources Modified "\
+ "(NRM):%#x\n", result);
} else if (err > 0) {
nvme_show_status(err);
} else
@@ -1842,6 +2421,55 @@ ret:
return nvme_status_to_errno(err, false);
}
+static int primary_ctrl_caps(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "Send an Identify Primary Controller Capabilities "\
+ "command to the given device and report the information in a "\
+ "decoded format (default), json or binary.";
+ const char *human_readable = "show info in readable format";
+ struct nvme_primary_ctrl_caps caps;
+
+ int err, fd;
+ enum nvme_print_flags flags;
+
+ struct config {
+ char *output_format;
+ int human_readable;
+ };
+
+ struct config cfg = {
+ .output_format = "normal",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
+ OPT_FLAG("human-readable", 'H', &cfg.human_readable, human_readable),
+ OPT_END()
+ };
+
+ err = fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0)
+ goto ret;
+
+ err = flags = validate_output_format(cfg.output_format);
+ if (flags < 0)
+ goto close_fd;
+ if (cfg.human_readable)
+ flags |= VERBOSE;
+
+ err = nvme_identify_primary_ctrl_caps(fd, &caps);
+ if (!err)
+ nvme_show_primary_ctrl_caps(&caps, flags);
+ else if (err > 0)
+ nvme_show_status(err);
+ else
+ perror("identify primary controller capabilities");
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Show secondary controller list associated with the primary controller "\
@@ -1927,17 +2555,17 @@ static int device_self_test(int argc, char **argv, struct command *cmd, struct p
struct config {
__u32 namespace_id;
- __u32 cdw10;
+ __u8 stc;
};
struct config cfg = {
.namespace_id = NVME_NSID_ALL,
- .cdw10 = 0,
+ .stc = 0,
};
OPT_ARGS(opts) = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
- OPT_UINT("self-test-code", 's', &cfg.cdw10, self_test_code),
+ OPT_UINT("self-test-code", 's', &cfg.stc, self_test_code),
OPT_END()
};
@@ -1945,12 +2573,14 @@ static int device_self_test(int argc, char **argv, struct command *cmd, struct p
if (fd < 0)
goto ret;
- err = nvme_self_test_start(fd, cfg.namespace_id, cfg.cdw10);
+ err = nvme_self_test_start(fd, cfg.namespace_id, cfg.stc);
if (!err) {
- if ((cfg.cdw10 & 0xf) == 0xf)
+ if (cfg.stc == 0xf)
printf("Aborting device self-test operation\n");
- else
- printf("Device self-test started\n");
+ else if (cfg.stc == 0x2)
+ printf("Extended Device self-test started\n");
+ else if (cfg.stc == 0x1)
+ printf("Short Device self-test started\n");
} else if (err > 0) {
nvme_show_status(err);
} else
@@ -1966,27 +2596,28 @@ static int self_test_log(int argc, char **argv, struct command *cmd, struct plug
const char *desc = "Retrieve the self-test log for the given device and given test "\
"(or optionally a namespace) in either decoded format "\
"(default) or binary.";
- const char *namespace_id = "Indicate the namespace from which the self-test "\
- "log has to be obtained";
+ const char *dst_entries = "Indicate how many DST log entries to be retrieved, "\
+ "by default all the 20 entries will be retrieved";
const char *verbose = "Increase output verbosity";
struct nvme_self_test_log self_test_log;
enum nvme_print_flags flags;
int err, fd;
+ __u32 log_size;
struct config {
- __u32 namespace_id;
+ __u8 dst_entries;
char *output_format;
int verbose;
};
struct config cfg = {
- .namespace_id = NVME_NSID_ALL,
+ .dst_entries = NVME_ST_REPORTS,
.output_format = "normal",
};
OPT_ARGS(opts) = {
- OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
+ OPT_UINT("dst-entries", 'e', &cfg.dst_entries, dst_entries),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_FLAG("verbose", 'v', &cfg.verbose, verbose),
OPT_END()
@@ -2002,9 +2633,11 @@ static int self_test_log(int argc, char **argv, struct command *cmd, struct plug
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_self_test_log(fd, cfg.namespace_id, &self_test_log);
+ log_size = NVME_ST_LOG_HEAD_SIZE + cfg.dst_entries * NVME_ST_LOG_ENTRY_SIZE;
+ err = nvme_self_test_log(fd, log_size, &self_test_log);
if (!err)
- nvme_show_self_test_log(&self_test_log, devicename, flags);
+ nvme_show_self_test_log(&self_test_log, cfg.dst_entries, log_size,
+ devicename, flags);
else if (err > 0)
nvme_show_status(err);
else
@@ -2039,7 +2672,7 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
struct config {
__u32 namespace_id;
- __u32 feature_id;
+ __u8 feature_id;
__u8 sel;
__u32 cdw11;
__u32 data_len;
@@ -2048,7 +2681,7 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
};
struct config cfg = {
- .namespace_id = 1,
+ .namespace_id = 0,
.feature_id = 0,
.sel = 0,
.cdw11 = 0,
@@ -2070,6 +2703,18 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
if (fd < 0)
goto ret;
+ if (!cfg.namespace_id) {
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ if (errno != ENOTTY) {
+ perror("get-namespace-id");
+ goto close_fd;
+ }
+
+ cfg.namespace_id = NVME_NSID_ALL;
+ }
+ }
+
if (cfg.sel > 7) {
fprintf(stderr, "invalid 'select' param:%d\n", cfg.sel);
err = -EINVAL;
@@ -2081,32 +2726,11 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
goto close_fd;
}
- switch (cfg.feature_id) {
- case NVME_FEAT_LBA_RANGE:
- cfg.data_len = 4096;
- break;
- case NVME_FEAT_AUTO_PST:
- cfg.data_len = 256;
- break;
- case NVME_FEAT_HOST_MEM_BUF:
- cfg.data_len = 4096;
- break;
- case NVME_FEAT_HOST_ID:
- cfg.data_len = 8;
- /* check for Extended Host Identifier */
- if (cfg.cdw11 & 0x1)
- cfg.data_len = 16;
- break;
- case NVME_FEAT_PLM_CONFIG:
- cfg.data_len = 512;
- break;
- case NVME_FEAT_TIMESTAMP:
- cfg.data_len = 8;
- break;
- case NVME_FEAT_HOST_BEHAVIOR:
- cfg.data_len = 512;
- break;
- }
+ cfg.data_len = nvme_feat_buf_len[cfg.feature_id];
+
+ /* check for Extended Host Identifier */
+ if (cfg.feature_id == NVME_FEAT_HOST_ID && (cfg.cdw11 & 0x1))
+ cfg.data_len = 16;
if (cfg.sel == 3)
cfg.data_len = 0;
@@ -2140,8 +2764,7 @@ static int get_feature(int argc, char **argv, struct command *cmd, struct plugin
} else
perror("get-feature");
- if (buf)
- free(buf);
+ free(buf);
close_fd:
close(fd);
@@ -2207,22 +2830,27 @@ static int fw_download(int argc, char **argv, struct command *cmd, struct plugin
}
fw_size = sb.st_size;
- if (fw_size & 0x3) {
+ if ((fw_size & 0x3) || (fw_size == 0)) {
fprintf(stderr, "Invalid size:%d for f/w image\n", fw_size);
err = -EINVAL;
goto close_fw_fd;
}
- fw_buf = nvme_alloc(fw_size, &huge);
+ if (cfg.xfer == 0 || cfg.xfer % 4096)
+ cfg.xfer = 4096;
+
+ if (cfg.xfer < HUGE_MIN)
+ fw_buf = __nvme_alloc(fw_size, &huge);
+ else
+ fw_buf = nvme_alloc(fw_size, &huge);
+
if (!fw_buf) {
- fprintf(stderr, "No memory for f/w size:%d\n", fw_size);
+ perror("No memory for f/w size:\n");
err = -ENOMEM;
goto close_fw_fd;
}
buf = fw_buf;
- if (cfg.xfer == 0 || cfg.xfer % 4096)
- cfg.xfer = 4096;
if (read(fw_fd, fw_buf, fw_size) != ((ssize_t)(fw_size))) {
err = -errno;
fprintf(stderr, "read :%s :%s\n", cfg.fw, strerror(errno));
@@ -2257,9 +2885,9 @@ ret:
return nvme_status_to_errno(err, false);
}
-static char *nvme_fw_status_reset_type(__u32 status)
+static char *nvme_fw_status_reset_type(__u16 status)
{
- switch (status & 0x3ff) {
+ switch (status & 0x7ff) {
case NVME_SC_FW_NEEDS_CONV_RESET: return "conventional";
case NVME_SC_FW_NEEDS_SUBSYS_RESET: return "subsystem";
case NVME_SC_FW_NEEDS_RESET: return "any controller";
@@ -2322,7 +2950,7 @@ static int fw_commit(int argc, char **argv, struct command *cmd, struct plugin *
if (err < 0)
perror("fw-commit");
else if (err != 0)
- switch (err & 0x3ff) {
+ switch (err & 0x7ff) {
case NVME_SC_FW_NEEDS_CONV_RESET:
case NVME_SC_FW_NEEDS_SUBSYS_RESET:
case NVME_SC_FW_NEEDS_RESET:
@@ -2486,8 +3114,8 @@ static int sanitize(int argc, char **argv, struct command *cmd, struct plugin *p
}
if (cfg.sanact == NVME_SANITIZE_ACT_OVERWRITE) {
- if (cfg.owpass > 16) {
- fprintf(stderr, "OWPASS out of range [0-16]\n");
+ if (cfg.owpass >= 16) {
+ fprintf(stderr, "OWPASS out of range [0-15]\n");
ret = -EINVAL;
goto close_fd;
}
@@ -2697,8 +3325,8 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
struct nvme_id_ns ns;
struct nvme_id_ctrl ctrl;
int err, fd, i;
+ int block_size;
__u8 prev_lbaf = 0;
- __u8 lbads = 0;
struct config {
__u32 namespace_id;
@@ -2771,13 +3399,11 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
* format of all namespaces.
*/
cfg.namespace_id = NVME_NSID_ALL;
- } else {
- if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
- goto close_fd;
- }
+ } else if (!cfg.namespace_id) {
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
+ goto close_fd;
}
}
@@ -2813,8 +3439,8 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
}
if (cfg.lbaf == 0xff) {
fprintf(stderr,
- "LBAF corresponding to block size %"PRIu64"(LBAF %u) not found\n",
- (uint64_t)cfg.bs, lbads);
+ "LBAF corresponding to given block size %"PRIu64" not found\n",
+ (uint64_t)cfg.bs);
fprintf(stderr,
"Please correct block size, or specify LBAF directly\n");
err = -EINVAL;
@@ -2822,8 +3448,7 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
}
} else if (cfg.lbaf == 0xff)
cfg.lbaf = prev_lbaf;
- }
- else {
+ } else {
if (cfg.lbaf == 0xff) cfg.lbaf = 0;
}
@@ -2874,13 +3499,38 @@ static int format(int argc, char **argv, struct command *cmd, struct plugin *plu
nvme_show_status(err);
else {
printf("Success formatting namespace:%x\n", cfg.namespace_id);
- if (cfg.lbaf != prev_lbaf && ioctl(fd, BLKRRPART) < 0) {
- fprintf(stderr, "failed to re-read partition table\n");
- err = -errno;
- goto close_fd;
- }
+ if (cfg.lbaf != prev_lbaf){
+ if (is_chardev()) {
+ if(ioctl(fd, NVME_IOCTL_RESCAN) < 0){
+ fprintf(stderr, "failed to rescan namespaces\n");
+ err = -errno;
+ goto close_fd;
+ }
+ } else {
+ block_size = 1 << ns.lbaf[cfg.lbaf].ds;
+
+ /*
+ * If block size has been changed by the format
+ * command up there, we should notify it to
+ * kernel blkdev to update its own block size
+ * to the given one because blkdev will not
+ * update by itself without re-opening fd.
+ */
+ if (ioctl(fd, BLKBSZSET, &block_size) < 0) {
+ fprintf(stderr, "failed to set block size to %d\n",
+ block_size);
+ err = -errno;
+ goto close_fd;
+ }
- if (cfg.reset && S_ISCHR(nvme_stat.st_mode))
+ if(ioctl(fd, BLKRRPART) < 0) {
+ fprintf(stderr, "failed to re-read partition table\n");
+ err = -errno;
+ goto close_fd;
+ }
+ }
+ }
+ if (cfg.reset && is_chardev())
nvme_reset_controller(fd);
}
@@ -2890,6 +3540,9 @@ ret:
return nvme_status_to_errno(err, false);
}
+#define STRTOUL_AUTO_BASE (0)
+#define NVME_FEAT_TIMESTAMP_DATA_SIZE (6)
+
static int set_feature(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Modify the saveable or changeable "\
@@ -2912,12 +3565,14 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
__u32 result;
void *buf = NULL;
int fd, ffd = STDIN_FILENO;
+ char *endptr = NULL;
+ uint64_t number = 0;
struct config {
char *file;
__u32 namespace_id;
- __u32 feature_id;
- __u32 value;
+ __u8 feature_id;
+ __u64 value;
__u32 cdw12;
__u32 data_len;
int save;
@@ -2935,7 +3590,7 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
OPT_ARGS(opts) = {
OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
OPT_UINT("feature-id", 'f', &cfg.feature_id, feature_id),
- OPT_UINT("value", 'v', &cfg.value, value),
+ OPT_LONG("value", 'v', &cfg.value, value),
OPT_UINT("cdw12", 'c', &cfg.cdw12, cdw12),
OPT_UINT("data-len", 'l', &cfg.data_len, data_len),
OPT_FILE("data", 'd', &cfg.file, data),
@@ -2947,13 +3602,26 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
if (fd < 0)
goto ret;
+ if (!cfg.namespace_id) {
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ if (errno != ENOTTY) {
+ perror("get-namespace-id");
+ goto close_fd;
+ }
+
+ cfg.namespace_id = NVME_NSID_ALL;
+ }
+ }
+
if (!cfg.feature_id) {
fprintf(stderr, "feature-id required param\n");
err = -EINVAL;
goto close_fd;
}
- if (cfg.feature_id == NVME_FEAT_LBA_RANGE)
- cfg.data_len = 4096;
+
+ cfg.data_len = nvme_feat_buf_len[cfg.feature_id];
+
if (cfg.data_len) {
if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
fprintf(stderr, "can not allocate feature payload\n");
@@ -2964,22 +3632,33 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
}
if (buf) {
- if (strlen(cfg.file)) {
- ffd = open(cfg.file, O_RDONLY);
- if (ffd <= 0) {
- fprintf(stderr, "Failed to open file %s: %s\n",
- cfg.file, strerror(errno));
- err = -EINVAL;
- goto free;
- }
- }
- err = read(ffd, (void *)buf, cfg.data_len);
- if (err < 0) {
- err = -errno;
- fprintf(stderr, "failed to read data buffer from input"
- " file: %s\n", strerror(errno));
- goto close_ffd;
- }
+ /* if feature ID is 0x0E, get timestamp value by -v option */
+ if (NVME_FEAT_TIMESTAMP == cfg.feature_id && cfg.value) {
+ memcpy(buf, &cfg.value, NVME_FEAT_TIMESTAMP_DATA_SIZE);
+ } else {
+ if (strlen(cfg.file)) {
+ ffd = open(cfg.file, O_RDONLY);
+ if (ffd <= 0) {
+ fprintf(stderr, "Failed to open file %s: %s\n",
+ cfg.file, strerror(errno));
+ err = -EINVAL;
+ goto free;
+ }
+ }
+ err = read(ffd, (void *)buf, cfg.data_len);
+ if (err < 0) {
+ err = -errno;
+ fprintf(stderr, "failed to read data buffer from input"
+ " file: %s\n", strerror(errno));
+ goto close_ffd;
+ }
+ /* if feature ID is 0x0E, then change string from file to integer */
+ if (NVME_FEAT_TIMESTAMP == cfg.feature_id) {
+ number = strtoul(buf, &endptr, STRTOUL_AUTO_BASE);
+ memset(buf, 0, cfg.data_len);
+ memcpy(buf, &number, NVME_FEAT_TIMESTAMP_DATA_SIZE);
+ }
+ }
}
err = nvme_set_feature(fd, cfg.namespace_id, cfg.feature_id, cfg.value,
@@ -2987,8 +3666,12 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
if (err < 0) {
perror("set-feature");
} else if (!err) {
- printf("set-feature:%02x (%s), value:%#08x\n", cfg.feature_id,
- nvme_feature_to_string(cfg.feature_id), cfg.value);
+ printf("set-feature:%#02x (%s), value:%#08"PRIx64", cdw12:%#08"PRIx32", \
+ save:%#x\n", cfg.feature_id, nvme_feature_to_string(cfg.feature_id),
+ (uint64_t)cfg.value, cfg.cdw12, cfg.save);
+ if (cfg.feature_id == NVME_LBA_STATUS_INFO) {
+ nvme_show_lba_status_info(result);
+ }
if (buf) {
if (cfg.feature_id == NVME_FEAT_LBA_RANGE)
nvme_show_lba_range((struct nvme_lba_range_type *)buf,
@@ -3002,8 +3685,7 @@ static int set_feature(int argc, char **argv, struct command *cmd, struct plugin
close_ffd:
close(ffd);
free:
- if (buf)
- free(buf);
+ free(buf);
close_fd:
close(fd);
ret:
@@ -3027,7 +3709,6 @@ static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *p
int err, fd, sec_fd = -1;
void *sec_buf;
unsigned int sec_size;
- __u32 result;
struct config {
__u32 namespace_id;
@@ -3089,13 +3770,13 @@ static int sec_send(int argc, char **argv, struct command *cmd, struct plugin *p
}
err = nvme_sec_send(fd, cfg.namespace_id, cfg.nssf, cfg.spsp, cfg.secp,
- cfg.tl, sec_size, sec_buf, &result);
+ cfg.tl, sec_size, sec_buf);
if (err < 0)
perror("security-send");
else if (err != 0)
- fprintf(stderr, "NVME Security Send Command Error:%d\n", err);
+ nvme_show_status(err);
else
- printf("NVME Security Send Command Success:%d\n", result);
+ printf("NVME Security Send Command Success\n");
free:
free(sec_buf);
@@ -3244,15 +3925,13 @@ static int dir_send(int argc, char **argv, struct command *cmd, struct plugin *p
else
d_raw(buf, cfg.data_len);
}
- }
- else if (err > 0)
+ } else if (err > 0)
nvme_show_status(err);
close_ffd:
close(ffd);
free:
- if (buf)
- free(buf);
+ free(buf);
close_fd:
close(fd);
ret:
@@ -3292,9 +3971,9 @@ static int write_uncor(int argc, char **argv, struct command *cmd, struct plugin
goto ret;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3384,9 +4063,9 @@ static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugi
if (cfg.deac)
control |= NVME_RW_DEAC;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3477,16 +4156,16 @@ static int dsm(int argc, char **argv, struct command *cmd, struct plugin *plugin
}
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
if (!cfg.cdw11)
cfg.cdw11 = (cfg.ad << 2) | (cfg.idw << 1) | (cfg.idr << 0);
- dsm = nvme_setup_dsm_range((__u32 *)ctx_attrs, (__u32 *)nlbs, (__u64 *)slbas, nr);
+ dsm = nvme_setup_dsm_range(ctx_attrs, nlbs, slbas, nr);
if (!dsm) {
fprintf(stderr, "failed to allocate data set payload\n");
err = -ENOMEM;
@@ -3501,6 +4180,144 @@ static int dsm(int argc, char **argv, struct command *cmd, struct plugin *plugin
else
printf("NVMe DSM: success\n");
+ free(dsm);
+
+close_fd:
+ close(fd);
+ret:
+ return nvme_status_to_errno(err, false);
+}
+
+static int copy(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+{
+ const char *desc = "The Copy command is used by the host to copy data "
+ "from one or more source logical block ranges to a "
+ "single consecutive destination logical block "
+ "range.";
+
+ const char *d_nsid = "identifier of desired namespace";
+ const char *d_sdlba = "64-bit addr of first destination logical block";
+ const char *d_slbas = "64-bit addr of first block per range (comma-separated list)";
+ const char *d_nlbs = "number of blocks per range (comma-separated list, zeroes-based values)";
+ const char *d_lr = "limited retry";
+ const char *d_fua = "force unit access";
+ const char *d_prinfor = "protection information and check field (read part)";
+ const char *d_prinfow = "protection information and check field (write part)";
+ const char *d_ilbrt = "initial lba reference tag (write part)";
+ const char *d_eilbrts = "expected lba reference tags (read part, comma-separated list)";
+ const char *d_lbat = "lba application tag (write part)";
+ const char *d_elbats = "expected lba application tags (read part, comma-separated list)";
+ const char *d_lbatm = "lba application tag mask (write part)";
+ const char *d_elbatms = "expected lba application tag masks (read part, comma-separated list)";
+ const char *d_dtype = "directive type (write part)";
+ const char *d_dspec = "directive specific (write part)";
+ const char *d_format = "source range entry format";
+
+ int err, fd;
+ uint16_t nr, nb, ns, nrts, natms, nats;
+ int nlbs[128] = { 0 };
+ unsigned long long slbas[128] = {0,};
+ int eilbrts[128] = { 0 };
+ int elbatms[128] = { 0 };
+ int elbats[128] = { 0 };
+ struct nvme_copy_range *copy;
+
+ struct config {
+ __u32 namespace_id;
+ __u64 sdlba;
+ char *nlbs;
+ char *slbas;
+ __u32 ilbrt;
+ char *eilbrts;
+ __u16 lbatm;
+ char *elbatms;
+ __u16 lbat;
+ char *elbats;
+ __u8 prinfow;
+ __u8 prinfor;
+ int lr;
+ int fua;
+ __u8 dtype;
+ __u16 dspec;
+ __u8 format;
+ };
+
+ struct config cfg = {
+ .namespace_id = 0,
+ .nlbs = "",
+ .slbas = "",
+ .eilbrts = "",
+ .elbatms = "",
+ .elbats = "",
+ };
+
+ OPT_ARGS(opts) = {
+ OPT_UINT("namespace-id", 'n', &cfg.namespace_id, d_nsid),
+ OPT_SUFFIX("sdlba", 'd', &cfg.sdlba, d_sdlba),
+ OPT_LIST("slbs", 's', &cfg.slbas, d_slbas),
+ OPT_LIST("blocks", 'b', &cfg.nlbs, d_nlbs),
+ OPT_FLAG("limited-retry", 'l', &cfg.lr, d_lr),
+ OPT_FLAG("force-unit-access", 'f', &cfg.fua, d_fua),
+ OPT_BYTE("prinfow", 'p', &cfg.prinfow, d_prinfow),
+ OPT_BYTE("prinfor", 'P', &cfg.prinfor, d_prinfor),
+ OPT_UINT("ref-tag", 'r', &cfg.ilbrt, d_ilbrt),
+ OPT_LIST("expected-ref-tags", 'R', &cfg.eilbrts, d_eilbrts),
+ OPT_SHRT("app-tag", 'a', &cfg.lbat, d_lbat),
+ OPT_LIST("expected-app-tags", 'A', &cfg.elbats, d_elbats),
+ OPT_SHRT("app-tag-mask", 'm', &cfg.lbatm, d_lbatm),
+ OPT_LIST("expected-app-tag-masks", 'M', &cfg.elbatms, d_elbatms),
+ OPT_BYTE("dir-type", 'T', &cfg.dtype, d_dtype),
+ OPT_SHRT("dir-spec", 'S', &cfg.dspec, d_dspec),
+ OPT_BYTE("format", 'F', &cfg.format, d_format),
+ OPT_END()
+ };
+
+ fd = parse_and_open(argc, argv, desc, opts);
+ if (fd < 0) {
+ err = fd;
+ goto ret;
+ }
+
+ nb = argconfig_parse_comma_sep_array(cfg.nlbs, nlbs, ARRAY_SIZE(nlbs));
+ ns = argconfig_parse_comma_sep_array_long(cfg.slbas, slbas, ARRAY_SIZE(slbas));
+ nrts = argconfig_parse_comma_sep_array(cfg.eilbrts, eilbrts, ARRAY_SIZE(eilbrts));
+ natms = argconfig_parse_comma_sep_array(cfg.elbatms, elbatms, ARRAY_SIZE(elbatms));
+ nats = argconfig_parse_comma_sep_array(cfg.elbats, elbats, ARRAY_SIZE(elbats));
+
+ nr = max(nb, max(ns, max(nrts, max(natms, nats))));
+ if (!nr || nr > 128) {
+ fprintf(stderr, "invalid range\n");
+ err = -EINVAL;
+ goto close_fd;
+ }
+
+ if (!cfg.namespace_id) {
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
+ goto close_fd;
+ }
+ }
+
+ copy = nvme_setup_copy_range(nlbs, slbas, eilbrts, elbatms, elbats, nr);
+ if (!copy) {
+ fprintf(stderr, "failed to allocate payload\n");
+ err = -ENOMEM;
+ goto close_fd;
+ }
+
+ err = nvme_copy(fd, cfg.namespace_id, copy, cfg.sdlba, nr, cfg.prinfor,
+ cfg.prinfow, cfg.dtype, cfg.dspec, cfg.format, cfg.lr,
+ cfg.fua, cfg.ilbrt, cfg.lbatm, cfg.lbat);
+ if (err < 0)
+ perror("NVMe Copy");
+ else if (err != 0)
+ nvme_show_status(err);
+ else
+ printf("NVMe Copy: success\n");
+
+ free(copy);
+
close_fd:
close(fd);
ret:
@@ -3535,9 +4352,9 @@ static int flush(int argc, char **argv, struct command *cmd, struct plugin *plug
goto ret;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3603,9 +4420,9 @@ static int resv_acquire(int argc, char **argv, struct command *cmd, struct plugi
goto ret;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3675,9 +4492,9 @@ static int resv_register(int argc, char **argv, struct command *cmd, struct plug
goto ret;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3755,9 +4572,9 @@ static int resv_release(int argc, char **argv, struct command *cmd, struct plugi
goto ret;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3833,9 +4650,9 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
flags = BINARY;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -3858,7 +4675,7 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
if (!err)
nvme_show_resv_report(status, size, cfg.cdw11, flags);
else if (err > 0)
- fprintf(stderr, "NVME IO command error:%04x\n", err);
+ nvme_show_status(err);
else
perror("reservation report");
free(status);
@@ -3868,7 +4685,7 @@ ret:
return nvme_status_to_errno(err, false);
}
-static unsigned long long elapsed_utime(struct timeval start_time,
+unsigned long long elapsed_utime(struct timeval start_time,
struct timeval end_time)
{
unsigned long long err = (end_time.tv_sec - start_time.tv_sec) * 1000000 +
@@ -3886,10 +4703,12 @@ static int submit_io(int opcode, char *command, const char *desc,
int flags = opcode & 1 ? O_RDONLY : O_WRONLY | O_CREAT;
int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
__u16 control = 0;
- __u32 dsmgmt = 0;
- int phys_sector_size = 0;
- long long buffer_size = 0;
+ __u32 dsmgmt = 0, nsid = 0;
+ int logical_block_size = 0;
+ long long buffer_size = 0, mbuffer_size = 0;
bool huge;
+ struct nvme_id_ns ns;
+ __u8 lba_index, ms = 0;
const char *start_block = "64-bit addr of first block to access";
const char *block_count = "number of blocks (zeroes based) on device to access";
@@ -4017,10 +4836,10 @@ static int submit_io(int opcode, char *command, const char *desc,
goto close_mfd;
}
- if (ioctl(fd, BLKPBSZGET, &phys_sector_size) < 0)
+ if (ioctl(fd, BLKSSZGET, &logical_block_size) < 0)
goto close_mfd;
- buffer_size = (cfg.block_count + 1) * phys_sector_size;
+ buffer_size = (cfg.block_count + 1) * logical_block_size;
if (cfg.data_size < buffer_size) {
fprintf(stderr, "Rounding data size to fit block count (%lld bytes)\n",
buffer_size);
@@ -4030,20 +4849,41 @@ static int submit_io(int opcode, char *command, const char *desc,
buffer = nvme_alloc(buffer_size, &huge);
if (!buffer) {
- fprintf(stderr, "can not allocate io payload\n");
+ perror("can not allocate io payload\n");
err = -ENOMEM;
goto close_mfd;
}
if (cfg.metadata_size) {
- mbuffer = malloc(cfg.metadata_size);
+ err = nsid = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
+ goto close_mfd;
+ }
+ err = nvme_identify_ns(fd, nsid, false, &ns);
+ if (err) {
+ nvme_show_status(err);
+ goto free_buffer;
+ } else if (err < 0) {
+ perror("identify namespace");
+ goto free_buffer;
+ }
+ lba_index = ns.flbas & NVME_NS_FLBAS_LBA_MASK;
+ ms = ns.lbaf[lba_index].ms;
+ mbuffer_size = (cfg.block_count + 1) * ms;
+ if (ms && cfg.metadata_size < mbuffer_size) {
+ fprintf(stderr, "Rounding metadata size to fit block count (%lld bytes)\n",
+ mbuffer_size);
+ } else {
+ mbuffer_size = cfg.metadata_size;
+ }
+ mbuffer = malloc(mbuffer_size);
if (!mbuffer) {
- fprintf(stderr, "can not allocate io metadata "
- "payload: %s\n", strerror(errno));
+ perror("can not allocate buf for io metadata payload\n");
err = -ENOMEM;
goto free_buffer;
}
- memset(mbuffer, 0, cfg.metadata_size);
+ memset(mbuffer, 0, mbuffer_size);
}
if ((opcode & 1)) {
@@ -4057,7 +4897,7 @@ static int submit_io(int opcode, char *command, const char *desc,
}
if ((opcode & 1) && cfg.metadata_size) {
- err = read(mfd, (void *)mbuffer, cfg.metadata_size);
+ err = read(mfd, (void *)mbuffer, mbuffer_size);
if (err < 0) {
err = -errno;
fprintf(stderr, "failed to read meta-data buffer from"
@@ -4071,7 +4911,6 @@ static int submit_io(int opcode, char *command, const char *desc,
printf("flags : %02x\n", 0);
printf("control : %04x\n", control);
printf("nblocks : %04x\n", cfg.block_count);
- printf("rsvd : %04x\n", 0);
printf("metadata : %"PRIx64"\n", (uint64_t)(uintptr_t)mbuffer);
printf("addr : %"PRIx64"\n", (uint64_t)(uintptr_t)buffer);
printf("slba : %"PRIx64"\n", (uint64_t)cfg.start_block);
@@ -4100,7 +4939,7 @@ static int submit_io(int opcode, char *command, const char *desc,
strerror(errno));
err = -EINVAL;
} else if (!(opcode & 1) && cfg.metadata_size &&
- write(mfd, (void *)mbuffer, cfg.metadata_size) < 0) {
+ write(mfd, (void *)mbuffer, mbuffer_size) < 0) {
fprintf(stderr, "write: %s: failed to write meta-data buffer to output file\n",
strerror(errno));
err = -EINVAL;
@@ -4109,8 +4948,7 @@ static int submit_io(int opcode, char *command, const char *desc,
}
free_mbuffer:
- if (cfg.metadata_size)
- free(mbuffer);
+ free(mbuffer);
free_buffer:
nvme_free(buffer, huge);
close_mfd:
@@ -4215,9 +5053,9 @@ static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin
control |= NVME_RW_FUA;
if (!cfg.namespace_id) {
- cfg.namespace_id = nvme_get_nsid(fd);
- if (cfg.namespace_id < 0) {
- err = cfg.namespace_id;
+ err = cfg.namespace_id = nvme_get_nsid(fd);
+ if (err < 0) {
+ perror("get-namespace-id");
goto close_fd;
}
}
@@ -4254,7 +5092,6 @@ static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *p
const char *nssf = "NVMe Security Specific Field";
int err, fd;
void *sec_buf = NULL;
- __u32 result;
struct config {
__u32 namespace_id;
@@ -4298,16 +5135,14 @@ static int sec_recv(int argc, char **argv, struct command *cmd, struct plugin *p
}
err = nvme_sec_recv(fd, cfg.namespace_id, cfg.nssf, cfg.spsp,
- cfg.secp, cfg.al, cfg.size, sec_buf, &result);
+ cfg.secp, cfg.al, cfg.size, sec_buf);
if (err < 0)
perror("security receive");
else if (err != 0)
- fprintf(stderr, "NVME Security Receive Command Error:%d\n",
- err);
+ nvme_show_status(err);
else {
+ printf("NVME Security Receive Command Success\n");
if (!cfg.raw_binary) {
- printf("NVME Security Receive Command Success:%d\n",
- result);
d(sec_buf, cfg.size, 16, 1);
} else if (cfg.size)
d_raw((unsigned char *)sec_buf, cfg.size);
@@ -4325,6 +5160,7 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
struct plugin *plugin)
{
const char *desc = "Information about potentially unrecoverable LBAs.";
+ const char *namespace_id = "Desired Namespace";
const char *slba = "Starting LBA(SLBA) in 64-bit address of the first"\
" logical block addressed by this command";
const char *mndw = "Maximum Number of Dwords(MNDW) specifies maximum"\
@@ -4334,6 +5170,7 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
" Status Descriptors to return.";
const char *rl = "Range Length(RL) specifies the length of the range"\
" of contiguous LBAs beginning at SLBA";
+ const char *timeout = "timeout value, in milliseconds";
enum nvme_print_flags flags;
unsigned long buf_len;
@@ -4341,26 +5178,32 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
void *buf;
struct config {
+ __u32 namespace_id;
__u64 slba;
__u32 mndw;
__u8 atype;
__u16 rl;
+ __u32 timeout;
char *output_format;
};
struct config cfg = {
+ .namespace_id = 0,
.slba = 0,
.mndw = 0,
.atype = 0,
.rl = 0,
+ .timeout = 0,
.output_format = "normal",
};
OPT_ARGS(opts) = {
+ OPT_UINT("namespace-id", 'n', &cfg.namespace_id, namespace_id),
OPT_SUFFIX("start-lba", 's', &cfg.slba, slba),
OPT_UINT("max-dw", 'm', &cfg.mndw, mndw),
OPT_BYTE("action", 'a', &cfg.atype, atype),
OPT_SHRT("range-len", 'l', &cfg.rl, rl),
+ OPT_UINT("timeout", 't', &cfg.timeout, timeout),
OPT_FMT("output-format", 'o', &cfg.output_format, output_format),
OPT_END()
};
@@ -4382,16 +5225,17 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
buf_len = (cfg.mndw + 1) * 4;
buf = calloc(1, buf_len);
if (!buf) {
+ perror("could not alloc memory for get lba status");
err = -ENOMEM;
goto close_fd;
}
- err = nvme_get_lba_status(fd, cfg.slba, cfg.mndw, cfg.atype, cfg.rl,
- buf);
+ err = nvme_get_lba_status(fd, cfg.namespace_id, cfg.slba, cfg.mndw,
+ cfg.atype, cfg.rl, buf, cfg.timeout);
if (!err)
nvme_show_lba_status(buf, buf_len, flags);
else if (err > 0)
- fprintf(stderr, "NVME command error:%04x\n", err);
+ nvme_show_status(err);
else
perror("get lba status");
free(buf);
@@ -4518,20 +5362,50 @@ static int dir_receive(int argc, char **argv, struct command *cmd, struct plugin
else if (err < 0)
perror("dir-receive");
- if (cfg.data_len)
- free(buf);
+ free(buf);
close_fd:
close(fd);
ret:
return nvme_status_to_errno(err, false);
}
-static int passthru(int argc, char **argv, int ioctl_cmd, const char *desc, struct command *cmd)
+/* rpmb_cmd_option is defined in nvme-rpmb.c */
+extern int rpmb_cmd_option(int, char **, struct command *, struct plugin *);
+static int rpmb_cmd(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
+ return rpmb_cmd_option(argc, argv, cmd, plugin);
+}
+
+static int passthru(int argc, char **argv, int ioctl_cmd, uint8_t cmd_type,
+ const char *desc, struct command *cmd)
+{
+ const char *opcode = "opcode (required)";
+ const char *flags = "command flags";
+ const char *rsvd = "value for reserved field";
+ const char *namespace_id = "desired namespace";
+ const char *data_len = "data I/O length (bytes)";
+ const char *metadata_len = "metadata seg. length (bytes)";
+ const char *timeout = "timeout value, in milliseconds";
+ const char *cdw2 = "command dword 2 value";
+ const char *cdw3 = "command dword 3 value";
+ const char *cdw10 = "command dword 10 value";
+ const char *cdw11 = "command dword 11 value";
+ const char *cdw12 = "command dword 12 value";
+ const char *cdw13 = "command dword 13 value";
+ const char *cdw14 = "command dword 14 value";
+ const char *cdw15 = "command dword 15 value";
+ const char *input = "write/send file (default stdin)";
+ const char *raw_binary = "dump output in binary format";
+ const char *show = "print command before sending";
+ const char *dry = "show command instead of sending";
+ const char *re = "set dataflow direction to receive";
+ const char *wr = "set dataflow direction to send";
+ const char *prefill = "prefill buffers with known byte-value, default 0";
void *data = NULL, *metadata = NULL;
int err = 0, wfd = STDIN_FILENO, fd;
__u32 result;
bool huge;
+ const char *cmd_name = NULL;
struct config {
__u8 opcode;
@@ -4578,29 +5452,6 @@ static int passthru(int argc, char **argv, int ioctl_cmd, const char *desc, stru
.prefill = 0,
};
- const char *opcode = "opcode (required)";
- const char *flags = "command flags";
- const char *rsvd = "value for reserved field";
- const char *namespace_id = "desired namespace";
- const char *data_len = "data I/O length (bytes)";
- const char *metadata_len = "metadata seg. length (bytes)";
- const char *timeout = "timeout value, in milliseconds";
- const char *cdw2 = "command dword 2 value";
- const char *cdw3 = "command dword 3 value";
- const char *cdw10 = "command dword 10 value";
- const char *cdw11 = "command dword 11 value";
- const char *cdw12 = "command dword 12 value";
- const char *cdw13 = "command dword 13 value";
- const char *cdw14 = "command dword 14 value";
- const char *cdw15 = "command dword 15 value";
- const char *input = "write/send file (default stdin)";
- const char *raw_binary = "dump output in binary format";
- const char *show = "print command before sending";
- const char *dry = "show command instead of sending";
- const char *re = "set dataflow direction to receive";
- const char *wr = "set dataflow direction to send";
- const char *prefill = "prefill buffers with known byte-value, default 0";
-
OPT_ARGS(opts) = {
OPT_BYTE("opcode", 'o', &cfg.opcode, opcode),
OPT_BYTE("flags", 'f', &cfg.flags, flags),
@@ -4631,7 +5482,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, const char *desc, stru
if (fd < 0)
goto ret;
- if (strlen(cfg.input_file)){
+ if (strlen(cfg.input_file)) {
wfd = open(cfg.input_file, O_RDONLY,
S_IRUSR | S_IRGRP | S_IROTH);
if (wfd < 0) {
@@ -4644,8 +5495,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, const char *desc, stru
if (cfg.metadata_len) {
metadata = malloc(cfg.metadata_len);
if (!metadata) {
- fprintf(stderr, "can not allocate metadata "
- "payload: %s\n", strerror(errno));
+ perror("can not allocate metadata payload\n");
err = -ENOMEM;
goto close_wfd;
}
@@ -4654,7 +5504,7 @@ static int passthru(int argc, char **argv, int ioctl_cmd, const char *desc, stru
if (cfg.data_len) {
data = nvme_alloc(cfg.data_len, &huge);
if (!data) {
- fprintf(stderr, "can not allocate data payload\n");
+ perror("can not allocate data payload\n");
err = -ENOMEM;
goto free_metadata;
}
@@ -4714,19 +5564,21 @@ static int passthru(int argc, char **argv, int ioctl_cmd, const char *desc, stru
else if (err)
nvme_show_status(err);
else {
+ cmd_name = nvme_cmd_to_string(cmd_type, cfg.opcode);
+ fprintf(stderr, "%s Command %s is Success and result: 0x%08x\n",
+ cmd_type ? "Admin": "IO",
+ strcmp(cmd_name, "Unknown") ? cmd_name: "Vendor Specific",
+ result);
if (!cfg.raw_binary) {
- fprintf(stderr, "NVMe command result:%08x\n", result);
if (data && cfg.read && !err)
d((unsigned char *)data, cfg.data_len, 16, 1);
} else if (data && cfg.read)
d_raw((unsigned char *)data, cfg.data_len);
}
free_data:
- if (cfg.data_len)
- nvme_free(data, huge);
+ nvme_free(data, huge);
free_metadata:
- if (cfg.metadata_len)
- free(metadata);
+ free(metadata);
close_wfd:
if (strlen(cfg.input_file))
close(wfd);
@@ -4740,35 +5592,42 @@ static int io_passthru(int argc, char **argv, struct command *cmd, struct plugin
{
const char *desc = "Send a user-defined IO command to the specified "\
"device via IOCTL passthrough, return results.";
- return passthru(argc, argv, NVME_IOCTL_IO_CMD, desc, cmd);
+ return passthru(argc, argv, NVME_IOCTL_IO_CMD, 0, desc, cmd);
}
static int admin_passthru(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Send a user-defined Admin command to the specified "\
"device via IOCTL passthrough, return results.";
- return passthru(argc, argv, NVME_IOCTL_ADMIN_CMD, desc, cmd);
+ return passthru(argc, argv, NVME_IOCTL_ADMIN_CMD, 1, desc, cmd);
}
-#ifdef LIBUUID
static int gen_hostnqn_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
{
- uuid_t uuid;
+ int ret;
char uuid_str[37]; /* e.g. 1b4e28ba-2fa1-11d2-883f-0016d3cca427 + \0 */
+#ifdef LIBUUID
+ uuid_t uuid;
+#endif
- uuid_generate_random(uuid);
- uuid_unparse_lower(uuid, uuid_str);
+ ret = uuid_from_dmi(uuid_str);
+ if (ret < 0)
+ ret = uuid_from_systemd(uuid_str);
+#ifdef LIBUUID
+ if (ret < 0) {
+ uuid_generate_random(uuid);
+ uuid_unparse_lower(uuid, uuid_str);
+ ret = 0;
+ }
+#endif
+ if (ret < 0) {
+ fprintf(stderr, "\"%s\" not supported. Install lib uuid and rebuild.\n",
+ command->name);
+ return -ENOTSUP;
+ }
printf("nqn.2014-08.org.nvmexpress:uuid:%s\n", uuid_str);
return 0;
}
-#else
-static int gen_hostnqn_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
-{
- fprintf(stderr, "\"%s\" not supported. Install lib uuid and rebuild.\n",
- command->name);
- return -ENOTSUP;
-}
-#endif
static int show_hostnqn_cmd(int argc, char **argv, struct command *command, struct plugin *plugin)
{
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-17 20:07:41 +0000