unsigned char *msg_buf = NULL;
unsigned int msg_size = 0;
unsigned int key_size = 0;
- int fd = -1, err = -1;
struct nvme_id_ctrl ctrl;
+ struct nvme_dev *dev;
+ int err = -1;
union ctrl_rpmbs_reg {
struct {
unsigned int rpmbs;
} regs;
- if ((fd = parse_and_open(argc, argv, desc, opts)) < 0)
- return fd;
+ if ((err = parse_and_open(&dev, argc, argv, desc, opts)) < 0)
+ return err;
/* before parsing commands, check if controller supports any RPMB targets */
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err)
goto out;
switch (cfg.opt) {
case RPMB_REQ_READ_WRITE_CNTR:
- err = rpmb_read_write_counter(fd, cfg.target, &write_cntr);
+ err = rpmb_read_write_counter(dev->fd, cfg.target,
+ &write_cntr);
if (err == 0)
printf("Write Counter is: %u\n", write_cntr);
break;
case RPMB_REQ_AUTH_DCB_READ:
- write_cntr = rpmb_read_config_block(fd, &msg_buf);
+ write_cntr = rpmb_read_config_block(dev->fd, &msg_buf);
if (msg_buf == NULL) {
fprintf(stderr, "failed read config blk\n");
goto out;
msg_size);
break;
}
- err = rpmb_auth_data_read(fd, cfg.target, cfg.address,
- &msg_buf, cfg.blocks,
+ err = rpmb_auth_data_read(dev->fd, cfg.target,
+ cfg.address, &msg_buf,
+ cfg.blocks,
(regs.access_size + 1));
if (err > 0 && msg_buf != NULL) {
printf("Writting %d bytes to file %s\n",
} else if ((cfg.blocks * 512) < msg_size) {
msg_size = cfg.blocks * 512;
}
- err = rpmb_auth_data_write(fd, cfg.target, cfg.address,
+ err = rpmb_auth_data_write(dev->fd, cfg.target,
+ cfg.address,
((regs.access_size + 1) * 512),
msg_buf, msg_size,
key_buf, key_size);
break;
case RPMB_REQ_AUTH_DCB_WRITE:
- err = rpmb_write_config_block(fd, msg_buf, key_buf, key_size);
+ err = rpmb_write_config_block(dev->fd, msg_buf,
+ key_buf, key_size);
break;
case RPMB_REQ_AUTH_KEY_PROGRAM:
- err = rpmb_program_auth_key(fd, cfg.target, key_buf, key_size);
+ err = rpmb_program_auth_key(dev->fd, cfg.target,
+ key_buf, key_size);
break;
default:
break;
free(key_buf);
free(msg_buf);
- /* close file descriptor */
- close(fd);
+ /* close device */
+ dev_close(dev);
return err;
}
return S_ISBLK(nvme_dev->stat.st_mode);
}
-static int open_dev(char *dev, int flags)
+static int open_dev(struct nvme_dev **devp, char *dev, int flags)
{
int err, fd;
+ /* Temporary: we use the global nvme_dev pointer for the nvme device.
+ * This keeps the global in sync with the returned device. Later, we'll
+ * remove the global entirely and allocate here instead.
+ */
+ *devp = nvme_dev;
+
nvme_dev->name = basename(dev);
err = open(dev, flags);
if (err < 0)
close(fd);
return -ENODEV;
}
- return fd;
+ nvme_dev->fd = fd;
+ return 0;
perror:
perror(dev);
return err;
return 0;
}
-static int get_dev(int argc, char **argv, int flags)
+static int get_dev(struct nvme_dev **dev, int argc, char **argv, int flags)
{
int ret;
if (ret)
return ret;
- return open_dev(argv[optind], flags);
+ return open_dev(dev, argv[optind], flags);
}
-int parse_and_open(int argc, char **argv, const char *desc,
- const struct argconfig_commandline_options *opts)
+int parse_and_open(struct nvme_dev **dev, int argc, char **argv,
+ const char *desc,
+ const struct argconfig_commandline_options *opts)
{
int ret;
if (ret)
return ret;
- ret = get_dev(argc, argv, O_RDONLY);
+ ret = get_dev(dev, argc, argv, O_RDONLY);
if (ret < 0)
argconfig_print_help(desc, opts);
return ret;
}
-int open_exclusive(int argc, char **argv, int ignore_exclusive)
+int open_exclusive(struct nvme_dev **dev, int argc, char **argv,
+ int ignore_exclusive)
{
- int flags = O_RDONLY;
+ int flags = O_RDONLY;
if (!ignore_exclusive)
flags |= O_EXCL;
- return get_dev(argc, argv, flags);
+ return get_dev(dev, argc, argv, flags);
}
enum nvme_print_flags validate_output_format(const char *format)
return -EINVAL;
}
+void dev_close(struct nvme_dev *dev)
+{
+ close(dev->fd);
+}
+
static int get_smart_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct nvme_smart_log smart_log;
const char *raw = "output in binary format";
const char *human_readable = "show info in readable format";
enum nvme_print_flags flags;
- int err = -1, fd;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_smart(fd, cfg.namespace_id, false, &smart_log);
+ err = nvme_get_log_smart(dev->fd, cfg.namespace_id, false, &smart_log);
if (!err)
nvme_show_smart_log(&smart_log, cfg.namespace_id,
nvme_dev->name, flags);
else
fprintf(stderr, "smart log: %s\n", nvme_strerror(errno));
close_fd:
- close(fd);
+ dev_close(dev);
ret:
return err;
}
"decoded format (default), json or binary.";
const char *groups = "Return ANA groups only.";
void *ana_log;
- int err = -1, fd;
size_t ana_log_len;
struct nvme_id_ctrl ctrl;
enum nvme_print_flags flags;
enum nvme_log_ana_lsp lsp;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
bool groups;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto close_fd;
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err) {
fprintf(stderr, "ERROR : nvme_identify_ctrl() failed: %s\n",
nvme_strerror(errno));
lsp = cfg.groups ? NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY :
NVME_LOG_ANA_LSP_RGO_NAMESPACES;
- err = nvme_get_log_ana(fd, lsp, true, 0, ana_log_len, ana_log);
+ err = nvme_get_log_ana(dev->fd, lsp, true, 0, ana_log_len, ana_log);
if (!err) {
nvme_show_ana_log(ana_log, nvme_dev->name, flags, ana_log_len);
} else if (err > 0)
fprintf(stderr, "ana-log: %s", nvme_strerror(errno));
free(ana_log);
close_fd:
- close(fd);
+ dev_close(dev);
ret:
return err;
}
const char *cgen = "Gather report generated by the controller.";
const char *dgen = "Pick which telemetry data area to report. Default is 3 to fetch areas 1-3. Valid options are 1, 2, 3, 4.";
struct nvme_telemetry_log *log;
- int err = 0, fd, output;
+ int err = 0, output;
size_t total_size;
__u8 *data_ptr = NULL;
int data_written = 0, data_remaining = 0;
+ struct nvme_dev *dev;
struct config {
char *file_name;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.file_name) {
fprintf(stderr, "Please provide an output file!\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
cfg.host_gen = !!cfg.host_gen;
fprintf(stderr, "Failed to open output file %s: %s!\n",
cfg.file_name, strerror(errno));
err = output;
- goto close_fd;
+ goto close_dev;
}
if (cfg.ctrl_init)
- err = nvme_get_ctrl_telemetry(fd, true, &log, cfg.data_area, &total_size);
+ err = nvme_get_ctrl_telemetry(dev->fd, true, &log,
+ cfg.data_area, &total_size);
else if (cfg.host_gen)
- err = nvme_get_new_host_telemetry(fd, &log, cfg.data_area, &total_size);
+ err = nvme_get_new_host_telemetry(dev->fd, &log,
+ cfg.data_area, &total_size);
else
- err = nvme_get_host_telemetry(fd, &log, cfg.data_area, &total_size);
+ err = nvme_get_host_telemetry(dev->fd, &log,
+ cfg.data_area, &total_size);
if (err < 0) {
fprintf(stderr, "get-telemetry-log: %s\n",
close_output:
close(output);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *desc = "Retrieves endurance groups log page and prints the log.";
const char *group_id = "The endurance group identifier";
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
- err = nvme_get_log_endurance_group(fd, cfg.group_id, &endurance_log);
+ err = nvme_get_log_endurance_group(dev->fd, cfg.group_id,
+ &endurance_log);
if (!err)
nvme_show_endurance_log(&endurance_log, cfg.group_id,
nvme_dev->name, flags);
nvme_show_status(err);
else
fprintf(stderr, "endurance log: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *csi = "";
struct list_head log_pages;
nvme_effects_log_node_t *node;
+ struct nvme_dev *dev;
void *bar = NULL;
- int err = -1, fd;
+ int err = -1;
enum nvme_print_flags flags;
struct config {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.human_readable)
nvme_free_tree(nvme_root);
if (!bar) {
- goto close_fd;
+ goto close_dev;
}
cap = mmio_read64(bar + NVME_REG_CAP);
munmap(bar, getpagesize());
other_command_sets_supported = NVME_CAP_CSS(cap) & NVME_CAP_CSS_CSI;
if (nvme_command_set_supported)
- err = collect_effects_log(fd, NVME_CSI_NVM,
+ err = collect_effects_log(dev->fd, NVME_CSI_NVM,
&log_pages, flags);
if (!err && other_command_sets_supported)
- err = collect_effects_log(fd, NVME_CSI_ZNS,
+ err = collect_effects_log(dev->fd, NVME_CSI_ZNS,
&log_pages, flags);
} else {
- err = collect_effects_log(fd, cfg.csi, &log_pages, flags);
+ err = collect_effects_log(dev->fd, cfg.csi, &log_pages, flags);
}
if (!err)
else
perror("effects log page");
-close_fd:
- while ((node = list_pop(&log_pages, nvme_effects_log_node_t, node)))
+close_dev:
+ while ((node = list_pop(&log_pages, nvme_effects_log_node_t, node))) {
free(node);
- close(fd);
+ }
+
+ dev_close(dev);
ret:
return err;
}
const char *desc = "Retrieve supported logs and print the table.";
const char *verbose = "Increase output verbosity";
struct nvme_supported_log_pages supports;
-
- int err = -1, fd;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_get_log_supported_log_pages(fd, false, &supports);
+ err = nvme_get_log_supported_log_pages(dev->fd, false, &supports);
if (!err)
nvme_show_supported_log(&supports, nvme_dev->name, flags);
else if (err > 0)
fprintf(stderr, "supported log pages: %s",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_error_log_page *err_log;
struct nvme_id_ctrl ctrl;
enum nvme_print_flags flags;
- int err = -1, fd;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u32 log_entries;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (!cfg.log_entries) {
fprintf(stderr, "non-zero log-entries is required param\n");
err = -1;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err < 0) {
perror("identify controller");
- goto close_fd;
+ goto close_dev;
} else if (err) {
fprintf(stderr, "could not identify controller\n");
err = -1;
- goto close_fd;
+ goto close_dev;
}
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) {
err = -1;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_get_log_error(fd, cfg.log_entries, false, err_log);
+ err = nvme_get_log_error(dev->fd, cfg.log_entries, false, err_log);
if (!err)
nvme_show_error_log(err_log, cfg.log_entries,
nvme_dev->name, flags);
else
perror("error log");
free(err_log);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *raw = "use binary output";
struct nvme_firmware_slot fw_log;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_fw_slot(fd, false, &fw_log);
+ err = nvme_get_log_fw_slot(dev->fd, false, &fw_log);
if (!err)
nvme_show_fw_log(&fw_log, nvme_dev->name, flags);
else if (err > 0)
nvme_show_status(err);
else
fprintf(stderr, "fw log: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *raw = "output in binary format";
struct nvme_ns_list changed_ns_list_log;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_changed_ns_list(fd, true, &changed_ns_list_log);
+ err = nvme_get_log_changed_ns_list(dev->fd, true, &changed_ns_list_log);
if (!err)
nvme_show_changed_ns_list_log(&changed_ns_list_log,
nvme_dev->name, flags);
else
fprintf(stderr, "changed ns list log: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *raw = "use binary output";
struct nvme_nvmset_predictable_lat_log plpns_log;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 nvmset_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_predictable_lat_nvmset(fd, cfg.nvmset_id, &plpns_log);
+ err = nvme_get_log_predictable_lat_nvmset(dev->fd, cfg.nvmset_id,
+ &plpns_log);
if (!err)
nvme_show_predictable_latency_per_nvmset(&plpns_log,
cfg.nvmset_id, nvme_dev->name, flags);
fprintf(stderr, "predictable latency per nvm set: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *raw = "use binary output";
enum nvme_print_flags flags;
struct nvme_id_ctrl ctrl;
+ struct nvme_dev *dev;
__u32 log_size;
void *pea_log;
- int err, fd;
+ int err;
struct config {
__u64 log_entries;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
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;
+ goto close_dev;
}
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err < 0) {
fprintf(stderr, "identify controller: %s\n",
nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
} else if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
cfg.log_entries = min(cfg.log_entries, le32_to_cpu(ctrl.nsetidmax));
pea_log = calloc(log_size, 1);
if (!pea_log) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_get_log_predictable_lat_event(fd, cfg.rae, 0, log_size, pea_log);
+ err = nvme_get_log_predictable_lat_event(dev->fd, cfg.rae, 0, log_size,
+ pea_log);
if (!err)
nvme_show_predictable_latency_event_agg_log(pea_log, cfg.log_entries,
log_size, nvme_dev->name, flags);
nvme_strerror(errno));
free(pea_log);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_persistent_event_log *pevent, *pevent_collected;
enum nvme_print_flags flags;
void *pevent_log_info;
- int err, fd;
+ struct nvme_dev *dev;
bool huge;
+ int err;
struct config {
__u8 action;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
pevent = calloc(sizeof(*pevent), 1);
if (!pevent) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_get_log_persistent_event(fd, cfg.action,
+ err = nvme_get_log_persistent_event(dev->fd, cfg.action,
sizeof(*pevent), pevent);
if (err < 0) {
fprintf(stderr, "persistent event log: %s\n",
err = -ENOMEM;
goto free_pevent;
}
- err = nvme_get_log_persistent_event(fd, cfg.action,
+ err = nvme_get_log_persistent_event(dev->fd, cfg.action,
cfg.log_len, pevent_log_info);
if (!err) {
- err = nvme_get_log_persistent_event(fd, cfg.action,
+ err = nvme_get_log_persistent_event(dev->fd, cfg.action,
sizeof(*pevent), pevent);
if (err < 0) {
fprintf(stderr, "persistent event log: %s\n",
nvme_free(pevent_log_info, huge);
free_pevent:
free(pevent);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
void *endurance_log;
struct nvme_id_ctrl ctrl;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
__u32 log_size;
+ int err;
struct config {
__u64 log_entries;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
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;
+ goto close_dev;
}
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err < 0) {
fprintf(stderr, "identify controller: %s\n",
nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
} else if (err) {
fprintf(stderr, "could not identify controller\n");
err = -ENODEV;
- goto close_fd;
+ goto close_dev;
}
cfg.log_entries = min(cfg.log_entries, le16_to_cpu(ctrl.endgidmax));
endurance_log = calloc(log_size, 1);
if (!endurance_log) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_get_log_endurance_grp_evt(fd, cfg.rae, 0, log_size, endurance_log);
+ err = nvme_get_log_endurance_grp_evt(dev->fd, cfg.rae, 0, log_size,
+ endurance_log);
if (!err)
nvme_show_endurance_group_event_agg_log(endurance_log, cfg.log_entries,
log_size, nvme_dev->name, flags);
nvme_strerror(errno));
free(endurance_log);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *rae = "Retain an Asynchronous Event";
void *lab_status;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
__u32 lslplen;
+ int err;
struct config {
bool rae;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
- err = nvme_get_log_lba_status(fd, true, 0, sizeof(__u32), &lslplen);
+ err = nvme_get_log_lba_status(dev->fd, true, 0, sizeof(__u32), &lslplen);
if (err < 0) {
fprintf(stderr, "lba status log page: %s\n",
nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
} else if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
lab_status = calloc(lslplen, 1);
if (!lab_status) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_get_log_lba_status(fd, cfg.rae, 0, lslplen, lab_status);
+ err = nvme_get_log_lba_status(dev->fd, cfg.rae, 0, lslplen, lab_status);
if (!err)
nvme_show_lba_status_log(lab_status, lslplen, nvme_dev->name, flags);
else if (err > 0)
nvme_strerror(errno));
free(lab_status);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"json or binary.";
struct nvme_resv_notification_log resv;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
- err = nvme_get_log_reservation(fd, false, &resv);
+ err = nvme_get_log_reservation(dev->fd, false, &resv);
if (!err)
nvme_show_resv_notif_log(&resv, nvme_dev->name, flags);
else if (err > 0)
fprintf(stderr, "resv notifi log: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
struct nvme_boot_partition boot;
__u8 *bp_log;
enum nvme_print_flags flags;
- int err = -1, fd = 0, output = 0;
+ int err = -1, output = 0;
+ struct nvme_dev *dev;
__u32 bpsz = 0;
struct config {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (!cfg.file_name) {
fprintf(stderr, "Please provide an output file!\n");
err = -1;
- goto close_fd;
+ goto close_dev;
}
if (cfg.lsp > 128) {
fprintf(stderr, "invalid lsp param: %u\n", cfg.lsp);
err = -1;
- goto close_fd;
+ goto close_dev;
}
output = open(cfg.file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
fprintf(stderr, "Failed to open output file %s: %s!\n",
cfg.file_name, strerror(errno));
err = output;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_get_log_boot_partition(fd, false, cfg.lsp,
+ err = nvme_get_log_boot_partition(dev->fd, false, cfg.lsp,
sizeof(boot), &boot);
if (err < 0) {
fprintf(stderr, "boot partition log: %s\n",
goto close_output;
}
- err = nvme_get_log_boot_partition(fd, false, cfg.lsp,
+ err = nvme_get_log_boot_partition(dev->fd, false, cfg.lsp,
sizeof(boot) + bpsz,
(struct nvme_boot_partition *)bp_log);
if (!err)
close_output:
close(output);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *domainid = "Domain Identifier";
const char *raw = "use binary output";
struct nvme_media_unit_stat_log mus;
-
- int err = -1, fd;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u16 domainid;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_media_unit_stat(fd, cfg.domainid, &mus);
+ err = nvme_get_log_media_unit_stat(dev->fd, cfg.domainid, &mus);
if (!err)
nvme_show_media_unit_stat_log(&mus, flags);
else if (err > 0)
fprintf(stderr, "media unit status log: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *domainid = "Domain Identifier";
const char *raw = "use binary output";
struct nvme_supported_cap_config_list_log cap_log;
-
- int err = -1, fd;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u16 domainid;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_support_cap_config_list(fd, cfg.domainid, &cap_log);
+ err = nvme_get_log_support_cap_config_list(dev->fd, cfg.domainid, &cap_log);
if (!err)
nvme_show_supported_cap_config_log(&cap_log, flags);
else if (err > 0)
else
perror("supported capacity configuration list log");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *uuid_index = "UUID index";
const char *csi = "command set identifier";
const char *offset_type = "offset type";
- int err, fd;
+ struct nvme_dev *dev;
unsigned char *log;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.aen) {
if (!cfg.log_len) {
perror("non-zero log-len is required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.lsp > 128) {
perror("invalid lsp param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.uuid_index > 128) {
perror("invalid uuid index param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
log = malloc(cfg.log_len);
if (!log) {
perror("could not alloc buffer for log\n");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.lid = cfg.log_id,
.nsid = cfg.namespace_id,
.lpo = cfg.lpo,
fprintf(stderr, "log page: %s\n", nvme_strerror(errno));
free(log);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *human_readable = "show log in readable format";
struct nvme_sanitize_log_page sanitize_log;
enum nvme_print_flags flags;
- int fd, err;
+ struct nvme_dev *dev;
+ int err;
struct config {
bool rae;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_sanitize(fd, cfg.rae, &sanitize_log);
+ err = nvme_get_log_sanitize(dev->fd, cfg.rae, &sanitize_log);
if (!err)
nvme_show_sanitize_log(&sanitize_log, nvme_dev->name, flags);
else if (err > 0)
else
fprintf(stderr, "sanitize status log: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *human_readable = "show log in readable format";
struct nvme_fid_supported_effects_log fid_support_log;
enum nvme_print_flags flags;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_fid_supported_effects(fd, false, &fid_support_log);
+ err = nvme_get_log_fid_supported_effects(dev->fd, false, &fid_support_log);
if (!err)
nvme_show_fid_support_effects_log(&fid_support_log,
nvme_dev->name, flags);
else
fprintf(stderr, "fid support effects log: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *human_readable = "show log in readable format";
struct nvme_mi_cmd_supported_effects_log mi_cmd_support_log;
enum nvme_print_flags flags;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_mi_cmd_supported_effects(fd, false, &mi_cmd_support_log);
+ err = nvme_get_log_mi_cmd_supported_effects(dev->fd, false, &mi_cmd_support_log);
if (!err)
nvme_show_mi_cmd_support_effects_log(&mi_cmd_support_log,
nvme_dev->name, flags);
else
fprintf(stderr, "mi command support effects log: %s\n",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"given device is part of, or optionally controllers attached to a specific namespace.";
const char *controller = "controller to display";
const char *namespace_id = "optional namespace attached to controller";
- int err, fd;
struct nvme_ctrl_list *cntlist;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 cntid;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (posix_memalign((void *)&cntlist, getpagesize(), 0x1000)) {
fprintf(stderr, "can not allocate controller list payload\n");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
if (cfg.namespace_id == NVME_NSID_NONE)
- err = nvme_identify_ctrl_list(fd, cfg.cntid, cntlist);
- else
- err = nvme_identify_nsid_ctrl_list(fd, cfg.namespace_id,
- cfg.cntid, cntlist);
+ err = nvme_identify_ctrl_list(dev->fd, cfg.cntid, cntlist);
+ else
+ err = nvme_identify_nsid_ctrl_list(dev->fd, cfg.namespace_id,
+ cfg.cntid, cntlist);
if (!err)
nvme_show_list_ctrl(cntlist, flags);
else if (err > 0)
nvme_strerror(errno));
free(cntlist);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
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, fd;
struct nvme_ns_list ns_list;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (flags != JSON && flags != NORMAL) {
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (!cfg.namespace_id) {
err = -EINVAL;
fprintf(stderr, "invalid nsid parameter\n");
- goto close_fd;
+ goto close_dev;
}
struct nvme_identify_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
.data = &ns_list,
.nsid = cfg.namespace_id - 1.
else
fprintf(stderr, "id namespace list: %s",
nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *verbose = "Increase output verbosity";
enum nvme_print_flags flags;
struct nvme_id_ns ns;
- int err = -1, fd;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u16 lba_format_index;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_identify_ns_csi_user_data_format(fd, cfg.lba_format_index,
+ err = nvme_identify_ns_csi_user_data_format(dev->fd, cfg.lba_format_index,
cfg.uuid_index, NVME_CSI_NVM, &ns);
if (!err)
nvme_show_id_ns(&ns, 0, cfg.lba_format_index, true, flags);
nvme_show_status(err);
else
perror("identify namespace for specific LBA format");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return nvme_status_to_errno(err, false);
}
const char *desc = "Show endurance group list information for the given endurance "\
"group id";
const char *endurance_grp_id = "Endurance Group ID";
- int err = -1, fd;
struct nvme_id_endurance_group_list *endgrp_list;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u16 endgrp_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (flags != JSON && flags != NORMAL) {
err = -EINVAL;
fprintf(stderr, "invalid output format\n");
- goto close_fd;
+ goto close_dev;
}
if (posix_memalign((void *)&endgrp_list, getpagesize(), 0x1000)) {
err = -1;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_endurance_group_list(fd, cfg.endgrp_id, endgrp_list);
+ err = nvme_identify_endurance_group_list(dev->fd, cfg.endgrp_id, endgrp_list);
if (!err)
nvme_show_endurance_group_list(endgrp_list, flags);
else if (err > 0)
nvme_strerror(errno));
free(endgrp_list);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"the namespace is not already inactive, once deleted.";
const char *namespace_id = "namespace to delete";
const char *timeout = "timeout value, in milliseconds";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n",
nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_ns_mgmt_delete(fd, cfg.namespace_id);
+ err = nvme_ns_mgmt_delete(dev->fd, cfg.namespace_id);
if (!err)
printf("%s: Success, deleted nsid:%d\n", cmd->name,
cfg.namespace_id);
else
fprintf(stderr, "delete namespace: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
static int nvme_attach_ns(int argc, char **argv, int attach, const char *desc, struct command *cmd)
{
- int err, num, fd, i, list[2048];
struct nvme_ctrl_list cntlist;
+ int err, num, i, list[2048];
+ struct nvme_dev *dev;
__u16 ctrlist[2048];
const char *namespace_id = "namespace to attach";
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
fprintf(stderr, "%s: namespace-id parameter required\n",
cmd->name);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
num = argconfig_parse_comma_sep_array(cfg.cntlist, list, 2047);
fprintf(stderr, "%s: controller id list is malformed\n",
cmd->name);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
for (i = 0; i < num; i++)
nvme_init_ctrl_list(&cntlist, num, ctrlist);
if (attach)
- err = nvme_ns_attach_ctrls(fd, cfg.namespace_id, &cntlist);
+ err = nvme_ns_attach_ctrls(dev->fd, cfg.namespace_id, &cntlist);
else
- err = nvme_ns_detach_ctrls(fd, cfg.namespace_id, &cntlist);
+ err = nvme_ns_detach_ctrls(dev->fd, cfg.namespace_id, &cntlist);
if (!err)
printf("%s: Success, nsid:%d\n", cmd->name, cfg.namespace_id);
else
perror(attach ? "attach namespace" : "detach namespace");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *bs = "target block size, specify only if \'FLBAS\' "\
"value not entered";
- int err = 0, fd, i;
struct nvme_id_ns ns;
+ struct nvme_dev *dev;
+ int err = 0, i;
__u32 nsid;
struct config {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.flbas != 0xff && cfg.bs != 0x00) {
fprintf(stderr,
"Invalid specification of both FLBAS and Block Size, please specify only one\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.bs) {
if ((cfg.bs & (~cfg.bs + 1)) != cfg.bs) {
"Invalid value for block size (%"PRIu64"). Block size must be a power of two\n",
(uint64_t)cfg.bs);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ns(fd, NVME_NSID_ALL, &ns);
+ err = nvme_identify_ns(dev->fd, NVME_NSID_ALL, &ns);
if (err) {
if (err < 0)
fprintf(stderr, "identify-namespace: %s",
fprintf(stderr, "identify failed\n");
nvme_show_status(err);
}
- goto close_fd;
+ goto close_dev;
}
for (i = 0; i <= ns.nlbaf; ++i) {
if ((1 << ns.lbaf[i].ds) == cfg.bs && ns.lbaf[i].ms == 0) {
"Please correct block size, or specify FLBAS directly\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_id_ns ns2 = {
.lbstm = cpu_to_le64(cfg.lbstm),
};
- err = nvme_ns_mgmt_create(fd, &ns2, &nsid, cfg.timeout, cfg.csi);
+ err = nvme_ns_mgmt_create(dev->fd, &ns2, &nsid, cfg.timeout, cfg.csi);
if (!err)
printf("%s: Success, created nsid:%d\n", cmd->name, nsid);
else if (err > 0)
else
fprintf(stderr, "create namespace: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *human_readable = "show identify in readable format";
enum nvme_print_flags flags;
struct nvme_id_ctrl ctrl;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
bool vendor_specific;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.vendor_specific)
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (!err)
nvme_show_id_ctrl(&ctrl, flags, vs);
else if (err > 0)
nvme_show_status(err);
else
fprintf(stderr, "identify controller: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"the specified controller in various formats.";
enum nvme_print_flags flags;
struct nvme_id_ctrl_nvm ctrl_nvm;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
- err = nvme_nvm_identify_ctrl(fd, &ctrl_nvm);
+ err = nvme_nvm_identify_ctrl(dev->fd, &ctrl_nvm);
if (!err)
nvme_show_id_ctrl_nvm(&ctrl_nvm, flags);
else if (err > 0)
nvme_show_status(err);
else
fprintf(stderr, "nvm identify controller: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
enum nvme_print_flags flags;
struct nvme_nvm_id_ns id_ns;
struct nvme_id_ns ns;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.verbose)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ns_csi(fd, cfg.namespace_id, cfg.uuid_index,
+ err = nvme_identify_ns_csi(dev->fd, cfg.namespace_id, cfg.uuid_index,
NVME_CSI_NVM, &id_ns);
if (!err)
nvme_show_nvm_id_ns(&id_ns, cfg.namespace_id, &ns, 0, false, flags);
nvme_show_status(err);
else
perror("nvm identify namespace");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return nvme_status_to_errno(err, false);
}
enum nvme_print_flags flags;
struct nvme_id_ns ns;
struct nvme_nvm_id_ns nvm_ns;
- int err = -1, fd;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u16 lba_format_index;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_identify_ns(fd, NVME_NSID_ALL, &ns);
+ err = nvme_identify_ns(dev->fd, NVME_NSID_ALL, &ns);
if (err) {
ns.nlbaf = NVME_FEAT_LBA_RANGE_MAX - 1;
ns.nulbaf = 0;
}
- err = nvme_identify_iocs_ns_csi_user_data_format(fd, cfg.lba_format_index,
+ err = nvme_identify_iocs_ns_csi_user_data_format(dev->fd, cfg.lba_format_index,
cfg.uuid_index, NVME_CSI_NVM, &nvm_ns);
if (!err)
nvme_show_nvm_id_ns(&nvm_ns, 0, &ns, cfg.lba_format_index, true,
nvme_show_status(err);
else
perror("NVM identify namespace for specific LBA format");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return nvme_status_to_errno(err, false);
}
const char *raw = "show descriptors in binary format";
const char *namespace_id = "identifier of desired namespace";
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
void *nsdescs;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (posix_memalign(&nsdescs, getpagesize(), 0x1000)) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ns_descs(fd, cfg.namespace_id, nsdescs);
+ err = nvme_identify_ns_descs(dev->fd, cfg.namespace_id, nsdescs);
if (!err)
nvme_show_id_ns_descs(nsdescs, cfg.namespace_id, flags);
else if (err > 0)
else
fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
free(nsdescs);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
enum nvme_print_flags flags;
struct nvme_id_ns ns;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.vendor_specific)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.force)
- err = nvme_identify_allocated_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_allocated_ns(dev->fd, cfg.namespace_id, &ns);
else
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (!err)
nvme_show_id_ns(&ns, cfg.namespace_id, 0, false, flags);
nvme_show_status(err);
else
fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
enum nvme_print_flags flags;
struct nvme_id_independent_id_ns ns;
- int err = -1, fd;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.human_readable)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = cfg.namespace_id = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = cfg.namespace_id = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_independent_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_independent_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (!err)
nvme_show_cmd_set_independent_id_ns(&ns, cfg.namespace_id, flags);
else if (err > 0)
nvme_show_status(err);
else
fprintf(stderr, "I/O command set independent identify namespace: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_id_ns_granularity_list *granularity_list;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (posix_memalign((void *)&granularity_list, getpagesize(), NVME_IDENTIFY_DATA_SIZE)) {
fprintf(stderr, "can not allocate granularity list payload\n");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ns_granularity(fd, granularity_list);
+ err = nvme_identify_ns_granularity(dev->fd, granularity_list);
if (!err)
nvme_show_id_ns_granularity_list(granularity_list, flags);
else if (err > 0)
else
fprintf(stderr, "identify namespace granularity: %s\n", nvme_strerror(errno));
free(granularity_list);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_id_nvmset_list nvmset;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 nvmset_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
- err = nvme_identify_nvmset_list(fd, cfg.nvmset_id, &nvmset);
+ err = nvme_identify_nvmset_list(dev->fd, cfg.nvmset_id, &nvmset);
if (!err)
nvme_show_id_nvmset(&nvmset, cfg.nvmset_id, flags);
else if (err > 0)
else
fprintf(stderr, "identify nvm set list: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_id_uuid_list uuid_list;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_identify_uuid(fd, &uuid_list);
+ err = nvme_identify_uuid(dev->fd, &uuid_list);
if (!err)
nvme_show_id_uuid_list(&uuid_list, flags);
else if (err > 0)
nvme_show_status(err);
else
fprintf(stderr, "identify UUID list: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;;
}
"in either human-readable or binary format.";
const char *controller_id = "identifier of desired controller";
struct nvme_id_iocs iocs;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 cntid;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- err = fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- }
- err = nvme_identify_iocs(fd, cfg.cntid, &iocs);
+ err = nvme_identify_iocs(dev->fd, cfg.cntid, &iocs);
if (!err) {
printf("NVMe Identify I/O Command Set:\n");
nvme_show_id_iocs(&iocs);
else
fprintf(stderr, "NVMe Identify I/O Command Set: %s\n", nvme_strerror(errno));
- close(fd);
+ dev_close(dev);
ret:
return err;
}
const char *domain_id = "identifier of desired domain";
struct nvme_id_domain_list id_domain;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 dom_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- err = fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- }
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
- err = nvme_identify_domain_list(fd, cfg.dom_id, &id_domain);
+ err = nvme_identify_domain_list(dev->fd, cfg.dom_id, &id_domain);
if (!err) {
printf("NVMe Identify command for Domain List is successful:\n");
printf("NVMe Identify Domain List:\n");
else
fprintf(stderr, "NVMe Identify Domain List: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
static int get_ns_id(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get namespace ID of a the block device.";
- int err = 0, fd;
+ struct nvme_dev *dev;
unsigned int nsid;
+ int err = 0;
OPT_ARGS(opts) = {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- err = nvme_get_nsid(fd, &nsid);
+ err = nvme_get_nsid(dev->fd, &nsid);
if (err < 0) {
fprintf(stderr, "get namespace ID: %s\n", nvme_strerror(errno));
err = errno;
printf("%s: namespace-id:%d\n", nvme_dev->name, nsid);
close_fd:
- close(fd);
+ dev_close(dev);
ret:
return err;
}
"8h: Secondary Assign\n"\
"9h: Secondary Online";
const char *nr = "Number of Controller Resources(NR)";
- int fd, err;
+ struct nvme_dev *dev;
__u32 result;
+ int err;
struct config {
__u16 cntlid;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
struct nvme_virtual_mgmt_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.act = cfg.act,
.rt = cfg.rt,
.cntlid = cfg.cntlid,
} else
fprintf(stderr, "virt-mgmt: %s\n", nvme_strerror(errno));
- close(fd);
+ dev_close(dev);
ret:
return err;
}
"decoded format (default), json or binary.";
const char *human_readable = "show info in readable format";
struct nvme_primary_ctrl_cap caps;
-
- int err, fd;
enum nvme_print_flags flags;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 cntlid;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_identify_primary_ctrl(fd, cfg.cntlid, &caps);
+ err = nvme_identify_primary_ctrl(dev->fd, cfg.cntlid, &caps);
if (!err)
nvme_show_primary_ctrl_cap(&caps, flags);
else if (err > 0)
nvme_show_status(err);
else
fprintf(stderr, "identify primary controller capabilities: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_secondary_ctrl_list *sc_list;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u16 cntid;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_err;
if (!cfg.num_entries) {
fprintf(stderr, "non-zero num-entries is required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_err;
}
if (posix_memalign((void *)&sc_list, getpagesize(), sizeof(*sc_list))) {
fprintf(stderr, "can not allocate controller list payload\n");
err = -ENOMEM;
- goto close_fd;
+ goto close_err;
}
- err = nvme_identify_secondary_ctrl_list(fd, cfg.namespace_id, cfg.cntid, sc_list);
+ err = nvme_identify_secondary_ctrl_list(dev->fd, cfg.namespace_id,
+ cfg.cntid, sc_list);
if (!err)
nvme_show_list_secondary_ctrl(sc_list, cfg.num_entries, flags);
else if (err > 0)
fprintf(stderr, "id secondary controller list: %s\n", nvme_strerror(errno));
free(sc_list);
-
-close_fd:
- close(fd);
+
+close_err:
+ dev_close(dev);
ret:
return err;
}
"2h Start a extended device self-test operation\n"\
"eh Start a vendor specific device self-test operation\n"\
"fh abort the device self-test operation\n";
- int fd, err;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
struct nvme_dev_self_test_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.stc = cfg.stc,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
} else
fprintf(stderr, "Device self-test: %s\n", nvme_strerror(errno));
- close(fd);
+ dev_close(dev);
ret:
return err;
}
struct nvme_self_test_log log;
enum nvme_print_flags flags;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u8 dst_entries;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_get_log_device_self_test(fd, &log);
+ err = nvme_get_log_device_self_test(dev->fd, &log);
if (!err)
nvme_show_self_test_log(&log, cfg.dst_entries, 0,
nvme_dev->name, flags);
nvme_show_status(err);
else
fprintf(stderr, "self test log: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *cdw11 = "dword 11 for interrupt vector config";
const char *human_readable = "show feature in readable format";
const char *uuid_index = "specify uuid index";
+ struct nvme_dev *dev;
int err;
- int fd;
struct feat_cfg cfg = {
.feature_id = 0,
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
if (errno != ENOTTY) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
cfg.namespace_id = NVME_NSID_ALL;
}
if (cfg.sel > 8) {
fprintf(stderr, "invalid 'select' param:%d\n", cfg.sel);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.uuid_index > 128) {
fprintf(stderr, "invalid uuid index param: %u\n", cfg.uuid_index);
err = -1;
- goto close_fd;
+ goto close_dev;
}
- err = get_feature_ids(fd, cfg);
+ err = get_feature_ids(dev->fd, cfg);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
const char *fw = "firmware file (required)";
const char *xfer = "transfer chunksize limit";
const char *offset = "starting dword offset, default 0";
- int err, fd, fw_fd = -1;
unsigned int fw_size;
- struct stat sb;
+ struct nvme_dev *dev;
void *fw_buf, *buf;
+ int err, fw_fd = -1;
+ struct stat sb;
bool huge;
struct config {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
fw_fd = open(cfg.fw, O_RDONLY);
fprintf(stderr, "Failed to open firmware file %s: %s\n",
cfg.fw, strerror(errno));
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
err = fstat(fw_fd, &sb);
struct nvme_fw_download_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.offset = cfg.offset,
.data_len = cfg.xfer,
.data = fw_buf,
nvme_free(buf, huge);
close_fw_fd:
close(fw_fd);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *slot = "[0-7]: firmware slot for commit action";
const char *action = "[0-7]: commit action";
const char *bpid = "[0,1]: boot partition identifier, if applicable (default: 0)";
- int err, fd;
+ struct nvme_dev *dev;
__u32 result;
+ int err;
struct config {
__u8 slot;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.slot > 7) {
fprintf(stderr, "invalid slot:%d\n", cfg.slot);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.action > 7 || cfg.action == 4 || cfg.action == 5) {
fprintf(stderr, "invalid action:%d\n", cfg.action);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.bpid > 1) {
fprintf(stderr, "invalid boot partition id:%d\n", cfg.bpid);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_fw_commit_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.slot = cfg.slot,
.action = cfg.action,
.bpid = cfg.bpid,
"sequence due to processing a command from an Admin SQ on a controller");
}
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
static int subsystem_reset(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Resets the NVMe subsystem\n";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- err = nvme_subsystem_reset(fd);
+ err = nvme_subsystem_reset(dev->fd);
if (err < 0) {
if (errno == ENOTTY)
fprintf(stderr,
fprintf(stderr, "Subsystem-reset: %s\n", nvme_strerror(errno));
}
- close(fd);
+ dev_close(dev);
ret:
return err;
}
static int reset(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Resets the NVMe controller\n";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- err = nvme_ctrl_reset(fd);
+ err = nvme_ctrl_reset(dev->fd);
if (err < 0)
fprintf(stderr, "Reset: %s\n", nvme_strerror(errno));
- close(fd);
+ dev_close(dev);
ret:
return err;
}
static int ns_rescan(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Rescans the NVMe namespaces\n";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- err = nvme_ns_rescan(fd);
+ err = nvme_ns_rescan(dev->fd);
if (err < 0)
fprintf(stderr, "Namespace Rescan");
- close(fd);
+ dev_close(dev);
ret:
return err;
}
const char *ause_desc = "Allow unrestricted sanitize exit.";
const char *sanact_desc = "Sanitize action.";
const char *ovrpat_desc = "Overwrite pattern.";
- int fd, err;
+ struct nvme_dev *dev;
+ int err;
struct config {
bool no_dealloc;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
switch (cfg.sanact) {
default:
fprintf(stderr, "Invalid Sanitize Action\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.sanact == NVME_SANITIZE_SANACT_EXIT_FAILURE) {
if (cfg.ause || cfg.no_dealloc) {
fprintf(stderr, "SANACT is Exit Failure Mode\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.owpass > 16) {
fprintf(stderr, "OWPASS out of range [0-16]\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
} else {
if (cfg.owpass || cfg.oipbp || cfg.ovrpat) {
fprintf(stderr, "SANACT is not Overwrite\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_sanitize_nvm_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.sanact = cfg.sanact,
.ause = cfg.ause,
.owpass = cfg.owpass,
else if (err > 0)
nvme_show_status(err);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"output_format == normal";
enum nvme_print_flags flags;
- nvme_root_t r;
+ struct nvme_dev *dev;
bool fabrics = true;
- int fd, err;
+ nvme_root_t r;
void *bar;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
r = nvme_scan(NULL);
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_properties(fd, &bar);
+ err = nvme_get_properties(dev->fd, &bar);
if (err) {
bar = mmap_registers(r, nvme_dev->name);
fabrics = false;
err = 0;
}
if (!bar)
- goto close_fd;
+ goto close_dev;
nvme_show_ctrl_registers(bar, fabrics, flags);
if (fabrics)
free(bar);
else
munmap(bar, getpagesize());
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
nvme_free_tree(r);
ret:
return err;
const char *offset = "offset of the requested property";
const char *human_readable = "show property in readable format";
- int fd, err;
+ struct nvme_dev *dev;
__u64 value;
+ int err;
struct config {
int offset;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.offset == -1) {
fprintf(stderr, "offset required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_get_property_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.offset = cfg.offset,
.value = &value,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
nvme_show_status(err);
}
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"for NVMe over Fabric";
const char *offset = "the offset of the property";
const char *value = "the value of the property to be set";
- int fd, err;
+ struct nvme_dev *dev;
+ int err;
struct config {
int offset;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.offset == -1) {
fprintf(stderr, "offset required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.value == -1) {
fprintf(stderr, "value required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_set_property_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.offset = cfg.offset,
.value = cfg.value,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
nvme_show_status(err);
}
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *force = "The \"I know what I'm doing\" flag, skip confirmation before sending command";
struct nvme_id_ns ns;
struct nvme_id_ctrl ctrl;
- int err, fd, i;
- int block_size;
+ struct nvme_dev *dev;
__u8 prev_lbaf = 0;
+ int block_size;
+ int err, i;
struct config {
__u32 namespace_id;
if (err)
goto ret;
- err = fd = open_exclusive(argc, argv, cfg.force);
- if (fd < 0) {
+ err = open_exclusive(&dev, argc, argv, cfg.force);
+ if (err < 0) {
if (errno == EBUSY) {
fprintf(stderr, "Failed to open %s.\n",
basename(argv[optind]));
fprintf(stderr,
"Invalid specification of both LBAF and Block Size, please specify only one\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.bs) {
if ((cfg.bs & (~cfg.bs + 1)) != cfg.bs) {
"Invalid value for block size (%"PRIu64"), must be a power of two\n",
(uint64_t) cfg.bs);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err) {
fprintf(stderr, "identify-ctrl: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
if ((ctrl.fna & 1) == 1) {
*/
cfg.namespace_id = NVME_NSID_ALL;
} else if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
"specify a namespace to format or use '-n 0xffffffff' "
"to format all namespaces on this controller.\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.namespace_id != NVME_NSID_ALL) {
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err) {
if (err < 0)
fprintf(stderr, "identify-namespace: %s\n", nvme_strerror(errno));
fprintf(stderr, "identify failed\n");
nvme_show_status(err);
}
- goto close_fd;
+ goto close_dev;
}
nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &prev_lbaf);
fprintf(stderr,
"Please correct block size, or specify LBAF directly\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
} else if (cfg.lbaf == 0xff)
cfg.lbaf = prev_lbaf;
if (cfg.ses > 7) {
fprintf(stderr, "invalid secure erase settings:%d\n", cfg.ses);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.lbaf > 63) {
fprintf(stderr, "invalid lbaf:%d\n", cfg.lbaf);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.pi > 7) {
fprintf(stderr, "invalid pi:%d\n", cfg.pi);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.pil > 1) {
fprintf(stderr, "invalid pil:%d\n", cfg.pil);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.ms > 1) {
fprintf(stderr, "invalid ms:%d\n", cfg.ms);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (!cfg.force) {
struct nvme_format_nvm_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.lbafu = (cfg.lbaf & NVME_NS_FLBAS_HIGHER_MASK) >> 4,
.lbaf = cfg.lbaf & NVME_NS_FLBAS_LOWER_MASK,
printf("Success formatting namespace:%x\n", cfg.namespace_id);
if (cfg.lbaf != prev_lbaf){
if (is_chardev()) {
- if(ioctl(fd, NVME_IOCTL_RESCAN) < 0){
+ if (ioctl(dev->fd, NVME_IOCTL_RESCAN) < 0) {
fprintf(stderr, "failed to rescan namespaces\n");
err = -errno;
- goto close_fd;
+ goto close_dev;
}
} else {
block_size = 1 << ns.lbaf[cfg.lbaf].ds;
* to the given one because blkdev will not
* update by itself without re-opening fd.
*/
- if (ioctl(fd, BLKBSZSET, &block_size) < 0) {
+ if (ioctl(dev->fd, BLKBSZSET, &block_size) < 0) {
fprintf(stderr, "failed to set block size to %d\n",
block_size);
err = -errno;
- goto close_fd;
+ goto close_dev;
}
- if(ioctl(fd, BLKRRPART) < 0) {
+ if (ioctl(dev->fd, BLKRRPART) < 0) {
fprintf(stderr, "failed to re-read partition table\n");
err = -errno;
- goto close_fd;
+ goto close_dev;
}
}
}
if (cfg.reset && is_chardev())
- nvme_ctrl_reset(fd);
+ nvme_ctrl_reset(dev->fd);
}
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *cdw12 = "feature cdw12, if used";
const char *save = "specifies that the controller shall save the attribute";
const char *uuid_index = "specify uuid index";
+ struct nvme_dev *dev;
int err;
__u32 result;
void *buf = NULL;
- int fd, ffd = STDIN_FILENO;
+ int ffd = STDIN_FILENO;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
if (errno != ENOTTY) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
cfg.namespace_id = NVME_NSID_ALL;
if (!cfg.feature_id) {
fprintf(stderr, "feature-id required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.uuid_index > 128) {
fprintf(stderr, "invalid uuid index param: %u\n", cfg.uuid_index);
err = -1;
- goto close_fd;
+ goto close_dev;
}
if (!cfg.data_len)
if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
fprintf(stderr, "can not allocate feature payload\n");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
memset(buf, 0, cfg.data_len);
}
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = cfg.feature_id,
.nsid = cfg.namespace_id,
.cdw11 = cfg.value,
close(ffd);
free:
free(buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *tl = "transfer length (cf. SPC-4)";
const char *namespace_id = "desired namespace";
const char *nssf = "NVMe Security Specific Field";
- int err, fd, sec_fd = STDIN_FILENO;
+ int err, sec_fd = STDIN_FILENO;
+ struct nvme_dev *dev;
void *sec_buf;
unsigned int sec_size;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.tl == 0) {
fprintf(stderr, "--tl unspecified or zero\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if ((cfg.tl & 3) != 0)
fprintf(stderr, "WARNING: --tl not dword aligned; unaligned bytes may be truncated\n");
fprintf(stderr, "Failed to open %s: %s\n",
cfg.file, strerror(errno));
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
err = fstat(sec_fd, &sb);
struct nvme_security_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.nssf = cfg.nssf,
.spsp0 = cfg.spsp & 0xff,
free(sec_buf);
close_sec_fd:
close(sec_fd);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *ttype = "target directive type to be enabled/disabled";
const char *human_readable = "show directive in readable format";
const char *input = "write/send file (default stdin)";
- int err, fd;
+ struct nvme_dev *dev;
__u32 result;
__u32 dw12 = 0;
void *buf = NULL;
int ffd = STDIN_FILENO;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
switch (cfg.dtype) {
if (!cfg.ttype) {
fprintf(stderr, "target-dir required param\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
dw12 = cfg.ttype << 8 | cfg.endir;
break;
default:
fprintf(stderr, "invalid directive operations for Identify Directives\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
break;
case NVME_DIRECTIVE_DTYPE_STREAMS:
default:
fprintf(stderr, "invalid directive operations for Streams Directives\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
break;
default:
fprintf(stderr, "invalid directive type\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.data_len) {
if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
memset(buf, 0, cfg.data_len);
}
struct nvme_directive_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.dspec = cfg.dspec,
.doper = cfg.doper,
close(ffd);
free:
free(buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
static int write_uncor(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err, fd;
const char *desc = "The Write Uncorrectable command is used to set a "\
"range of logical blocks to invalid.";
const char *namespace_id = "desired namespace";
const char *start_block = "64-bit LBA of first block to access";
const char *block_count = "number of blocks (zeroes based) on device to access";
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
else
printf("NVME Write Uncorrectable Success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
static int write_zeroes(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err, fd;
__u16 control = 0;
__u8 lba_index, sts = 0, pif = 0;
struct nvme_id_ns ns;
+ struct nvme_dev *dev;
struct nvme_nvm_id_ns nvm_ns;
+ int err;
const char *desc = "The Write Zeroes command is used to set a "\
"range of logical blocks to zero.";
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.prinfo > 0xf) {
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
control |= (cfg.prinfo << 10);
if (cfg.storage_tag_check)
control |= NVME_IO_STC;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
} else if (err < 0) {
fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ns_csi(fd, cfg.namespace_id, 0, NVME_CSI_NVM, &nvm_ns);
+ err = nvme_identify_ns_csi(dev->fd, cfg.namespace_id, 0, NVME_CSI_NVM, &nvm_ns);
if (!err) {
nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &lba_index);
sts = nvm_ns.elbaf[lba_index] & NVME_NVM_ELBAF_STS_MASK;
if (invalid_tags(cfg.storage_tag, cfg.ref_tag, sts, pif)) {
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
else
printf("NVME Write Zeroes Success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *idr = "Attribute Integral Dataset for Read";
const char *cdw11 = "All the command DWORD 11 attributes. Use instead of specifying individual attributes";
- int err, fd;
uint16_t nr, nc, nb, ns;
__u32 ctx_attrs[256] = {0,};
__u32 nlbs[256] = {0,};
__u64 slbas[256] = {0,};
struct nvme_dsm_range dsm[256];
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
nc = argconfig_parse_comma_sep_array(cfg.ctx_attrs, (int *)ctx_attrs, ARRAY_SIZE(ctx_attrs));
if (!nr || nr > 256) {
fprintf(stderr, "No range definition provided\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (!cfg.cdw11)
nvme_init_dsm_range(dsm, ctx_attrs, nlbs, slbas, nr);
struct nvme_dsm_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.attrs = cfg.cdw11,
.nr_ranges = nr,
else
printf("NVMe DSM: success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
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;
__u16 nlbs[128] = { 0 };
unsigned long long slbas[128] = {0,};
+ struct nvme_dev *dev;
+ int err;
union {
__u32 f0[128];
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- err = fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- }
nb = argconfig_parse_comma_sep_array_short(cfg.nlbs, nlbs, ARRAY_SIZE(nlbs));
ns = argconfig_parse_comma_sep_array_long(cfg.slbas, slbas, ARRAY_SIZE(slbas));
else {
fprintf(stderr, "invalid format\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
natms = argconfig_parse_comma_sep_array(cfg.elbatms, (int *)elbatms, ARRAY_SIZE(elbatms));
if (!nr || nr > 128 || (cfg.format == 1 && nr > 101)) {
fprintf(stderr, "invalid range\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_copy_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.copy = copy.f0,
.sdlba = cfg.sdlba,
else
printf("NVMe Copy: success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"flushed by the controller, from any namespace, depending on controller and "\
"associated namespace status.";
const char *namespace_id = "identifier of desired namespace";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_flush(fd, cfg.namespace_id);
+ err = nvme_flush(dev->fd, cfg.namespace_id);
if (err < 0)
fprintf(stderr, "flush: %s\n", nvme_strerror(errno));
else if (err != 0)
nvme_show_status(err);
else
printf("NVMe Flush: success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *rtype = "reservation type";
const char *racqa = "reservation acquire action";
const char *iekey = "ignore existing res. key";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.racqa > 7) {
fprintf(stderr, "invalid racqa:%d\n", cfg.racqa);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_resv_acquire_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.rtype = cfg.rtype,
.racqa = cfg.racqa,
else
printf("NVME Reservation Acquire success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *nrkey = "new reservation key";
const char *rrega = "reservation registration action";
const char *cptpl = "change persistence through power loss setting";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.cptpl > 3) {
fprintf(stderr, "invalid cptpl:%d\n", cfg.cptpl);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.rrega > 7) {
fprintf(stderr, "invalid rrega:%d\n", cfg.rrega);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_resv_register_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.rrega = cfg.rrega,
.cptpl = cfg.cptpl,
else
printf("NVME Reservation success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *iekey = "ignore existing res. key";
const char *rtype = "reservation type";
const char *rrela = "reservation release action";
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.rrela > 7) {
fprintf(stderr, "invalid rrela:%d\n", cfg.rrela);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_resv_release_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.rtype = cfg.rtype,
.rrela = cfg.rrela,
else
printf("NVME Reservation Release success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct nvme_resv_status *status;
enum nvme_print_flags flags;
- int err, fd, size;
+ struct nvme_dev *dev;
+ int err, size;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.raw_binary)
flags = BINARY;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
if (posix_memalign((void **)&status, getpagesize(), size)) {
fprintf(stderr, "No memory for resv report:%d\n", size);
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
memset(status, 0, size);
struct nvme_resv_report_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.eds = cfg.eds,
.len = size,
else
fprintf(stderr, "reservation report: %s\n", nvme_strerror(errno));
free(status);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
struct timeval start_time, end_time;
void *buffer, *mbuffer = NULL;
int err = 0;
- int dfd, mfd, fd;
+ int dfd, mfd;
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;
struct nvme_id_ns ns;
struct nvme_nvm_id_ns nvm_ns;
__u8 lba_index, ms = 0, sts = 0, pif = 0;
+ struct nvme_dev *dev;
const char *namespace_id = "Identifier of desired namespace";
const char *start_block = "64-bit addr of first block to access";
};
if (opcode != nvme_cmd_write) {
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
} else {
err = argconfig_parse(argc, argv, desc, opts);
if (err)
goto ret;
- err = fd = open_exclusive(argc, argv, cfg.force);
+ err = open_exclusive(&dev, argc, argv, cfg.force);
if (err < 0) {
if (errno == EBUSY) {
fprintf(stderr, "Failed to open %s.\n",
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
dfd = mfd = opcode & 1 ? STDIN_FILENO : STDOUT_FILENO;
if (cfg.prinfo > 0xf) {
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
dsmgmt = cfg.dsmgmt;
fprintf(stderr, "Invalid directive type, %x\n",
cfg.dtype);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
control |= cfg.dtype << 4;
dsmgmt |= ((__u32)cfg.dspec) << 16;
if (dfd < 0) {
perror(cfg.data);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
}
goto close_mfd;
}
- if (nvme_get_logical_block_size(fd, cfg.namespace_id,
+ if (nvme_get_logical_block_size(dev->fd, cfg.namespace_id,
&logical_block_size) < 0)
- goto close_mfd;
+ goto close_mfd;
buffer_size = ((long long)cfg.block_count + 1) * logical_block_size;
if (cfg.data_size < buffer_size) {
}
if (cfg.metadata_size) {
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err > 0) {
nvme_show_status(err);
goto free_buffer;
nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &lba_index);
ms = ns.lbaf[lba_index].ms;
- err = nvme_identify_ns_csi(fd, 1, 0, NVME_CSI_NVM, &nvm_ns);
+ err = nvme_identify_ns_csi(dev->fd, 1, 0, NVME_CSI_NVM, &nvm_ns);
if (!err) {
sts = nvm_ns.elbaf[lba_index] & NVME_NVM_ELBAF_STS_MASK;
pif = (nvm_ns.elbaf[lba_index] & NVME_NVM_ELBAF_PIF_MASK) >> 7;
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
close(mfd);
close_dfd:
close(dfd);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
static int verify_cmd(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err, fd;
__u16 control = 0;
__u8 lba_index, sts = 0, pif = 0;
struct nvme_id_ns ns;
struct nvme_nvm_id_ns nvm_ns;
+ struct nvme_dev *dev;
+ int err;
const char *desc = "Verify specified logical blocks on the given device.";
const char *namespace_id = "desired namespace";
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.prinfo > 0xf) {
err = EINVAL;
- goto close_fd;
+ goto close_dev;
}
control |= (cfg.prinfo << 10);
control |= NVME_IO_STC;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
} else if (err < 0) {
fprintf(stderr, "identify namespace: %s\n", nvme_strerror(errno));
- goto close_fd;
+ goto close_dev;
}
- err = nvme_identify_ns_csi(fd, cfg.namespace_id, 0, NVME_CSI_NVM, &nvm_ns);
+ err = nvme_identify_ns_csi(dev->fd, cfg.namespace_id, 0, NVME_CSI_NVM, &nvm_ns);
if (!err) {
nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &lba_index);
sts = nvm_ns.elbaf[lba_index] & NVME_NVM_ELBAF_STS_MASK;
if (invalid_tags(cfg.storage_tag, cfg.ref_tag, sts, pif)) {
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
else
printf("NVME Verify Success\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *raw = "dump output in binary format";
const char *namespace_id = "desired namespace";
const char *nssf = "NVMe Security Specific Field";
- int err, fd;
+ struct nvme_dev *dev;
void *sec_buf = NULL;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.size) {
fprintf(stderr, "No memory for security size:%d\n",
cfg.size);
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_security_receive_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.nssf = cfg.nssf,
.spsp0 = cfg.spsp & 0xff,
free(sec_buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
enum nvme_print_flags flags;
unsigned long buf_len;
- int err, fd;
+ struct nvme_dev *dev;
void *buf;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto err;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (!cfg.atype) {
fprintf(stderr, "action type (--action) has to be given\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
buf_len = (cfg.mndw + 1) * 4;
buf = calloc(1, buf_len);
if (!buf) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
struct nvme_get_lba_status_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.slba,
.mndw = cfg.mndw,
else
fprintf(stderr, "get lba status: %s\n", nvme_strerror(errno));
free(buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
err:
return err;
}
const char *cap_upper = "Most significant 32 bits of the capacity in bytes of the "\
"Endurance Group or NVM Set to be created";
- int err = -1, fd;
+ struct nvme_dev *dev;
+ int err = -1;
__u32 result;
struct config {
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.operation > 0xf) {
fprintf(stderr, "invalid operation field: %u\n", cfg.operation);
err = -1;
- goto close_fd;
+ goto close_dev;
}
struct nvme_capacity_mgmt_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.op = cfg.operation,
.element_id = cfg.element_id,
.cdw11 = cfg.dw11,
else if (err < 0)
fprintf(stderr, "capacity management: %s\n", nvme_strerror(errno));
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *human_readable = "show directive in readable format";
enum nvme_print_flags flags = NORMAL;
- int err, fd;
+ struct nvme_dev *dev;
__u32 result;
__u32 dw12 = 0;
void *buf = NULL;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.human_readable)
default:
fprintf(stderr, "invalid directive operations for Identify Directives\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
break;
case NVME_DIRECTIVE_DTYPE_STREAMS:
default:
fprintf(stderr, "invalid directive operations for Streams Directives\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
break;
default:
fprintf(stderr, "invalid directive type\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.data_len) {
if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
memset(buf, 0, cfg.data_len);
}
struct nvme_directive_recv_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.dspec = cfg.dspec,
.doper = cfg.doper,
fprintf(stderr, "dir-receive: %s\n", nvme_strerror(errno));
free(buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
"List that is used by the command.If this field is cleared to 0h,"\
"then no UUID index is specified";
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
__u8 ofi;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
/* check for input argument limit */
if (cfg.ifc > 3) {
fprintf(stderr, "invalid interface settings:%d\n", cfg.ifc);
err = -1;
- goto close_fd;
+ goto close_dev;
}
if (cfg.prhbt > 1) {
fprintf(stderr, "invalid prohibit settings:%d\n", cfg.prhbt);
err = -1;
- goto close_fd;
+ goto close_dev;
}
if (cfg.scp > 15) {
fprintf(stderr, "invalid scope settings:%d\n", cfg.scp);
err = -1;
- goto close_fd;
+ goto close_dev;
}
if (cfg.uuid > 127) {
fprintf(stderr, "invalid UUID index settings:%d\n", cfg.uuid);
err = -1;
- goto close_fd;
+ goto close_dev;
}
struct nvme_lockdown_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.scp = cfg.scp,
.prhbt = cfg.prhbt,
.ifc = cfg.ifc,
else
printf("Lockdown Command is Successful\n");
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
int flags;
int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
void *data = NULL, *mdata = NULL;
- int err = 0, dfd, mfd, fd;
+ int err = 0, dfd, mfd;
+ struct nvme_dev *dev;
__u32 result;
bool huge = false;
const char *cmd_name = NULL;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
if (cfg.opcode & 0x01)
if (dfd < 0) {
perror(cfg.input_file);
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
}
gettimeofday(&start_time, NULL);
if (admin)
- err = nvme_admin_passthru(fd, cfg.opcode, cfg.flags, cfg.rsvd,
+ err = nvme_admin_passthru(dev->fd, cfg.opcode, cfg.flags, cfg.rsvd,
cfg.namespace_id, cfg.cdw2, cfg.cdw3, cfg.cdw10,
cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
mdata, cfg.timeout, &result);
else
- err = nvme_io_passthru(fd, cfg.opcode, cfg.flags, cfg.rsvd,
+ err = nvme_io_passthru(dev->fd, cfg.opcode, cfg.flags, cfg.rsvd,
cfg.namespace_id, cfg.cdw2, cfg.cdw3, cfg.cdw10,
cfg.cdw11, cfg.cdw12, cfg.cdw13, cfg.cdw14,
cfg.cdw15, cfg.data_len, data, cfg.metadata_len,
close_mfd:
if (strlen(cfg.metadata))
close(mfd);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
#define SYS_NVME "/sys/class/nvme"
-void register_extension(struct plugin *plugin);
-int parse_and_open(int argc, char **argv, const char *desc,
- const struct argconfig_commandline_options *clo);
-
struct nvme_dev {
+ int fd;
struct stat stat;
const char *name;
};
+void register_extension(struct plugin *plugin);
+
+/*
+ * parse_and_open - parses arguments and opens the NVMe device, populating @dev
+ */
+int parse_and_open(struct nvme_dev **dev, int argc, char **argv, const char *desc,
+ const struct argconfig_commandline_options *clo);
+
+void dev_close(struct nvme_dev *dev);
+
extern struct nvme_dev *nvme_dev;
extern const char *output_format;
static int get_status(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int fd, err;
struct nvme_dera_smart_info_log log;
enum dera_device_status state = DEVICE_STATUS_FATAL_ERROR;
char *desc = "Get the Dera device status";
+ struct nvme_dev *dev;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_log_simple(fd, 0xc0, sizeof(log), &log);
+ err = nvme_get_log_simple(dev->fd, 0xc0, sizeof(log), &log);
if (err) {
goto exit;
}
"Runtime Low",
};
- err = nvme_dera_get_device_status(fd, &state);
+ err = nvme_dera_get_device_status(dev->fd, &state);
if (!err){
if (state > 0 && state < 4){
printf("device_status : %s %d%% completed\n", dev_status[state], log.rebuild_percent);
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
struct plugin *plugin)
{
struct nvme_smart_log smart_log = { 0 };
- int fd, i, iindex;
struct vsc_smart_log *pvsc_smart = (struct vsc_smart_log *)smart_log.rsvd232;
const char *desc = "Retrieve additional SMART log for the given device ";
const char *namespace = "(optional) desired namespace";
+ struct nvme_dev *dev;
+ int err, i, iindex;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- nvme_get_log_smart(fd, cfg.namespace_id, false, &smart_log);
+ nvme_get_log_smart(dev->fd, cfg.namespace_id, false, &smart_log);
nvme_show_smart_log(&smart_log, cfg.namespace_id,
nvme_dev->name, NORMAL);
unsigned int isize, icheck_stopvalue, iend;
unsigned char bSortLog = false, bget_nextlog = true;
struct evlg_flush_hdr *pevlog = (struct evlg_flush_hdr *)data;
- int fd, ret = -1;
const char *desc = "Recrieve event log for the given device ";
const char *clean_opt = "(optional) 1 for clean event log";
+ struct nvme_dev *dev;
+ int ret = -1;
struct config {
__u32 clean_flg;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
if (getcwd(currentdir, 128) == NULL)
icount++;
memset(data, 0, 4096);
- ret = nvme_vucmd(fd, NVME_VSC_GET_EVENT_LOG, 0, 0, (SRB_SIGNATURE >> 32),
- (SRB_SIGNATURE & 0xFFFFFFFF), (char *)data, 4096);
+ ret = nvme_vucmd(dev->fd, NVME_VSC_GET_EVENT_LOG, 0, 0,
+ (SRB_SIGNATURE >> 32),
+ (SRB_SIGNATURE & 0xFFFFFFFF),
+ (char *)data, 4096);
if (ret == -1)
return ret;
if (cfg.clean_flg == 1) {
printf("Clean eventlog\n");
- nvme_vucmd(fd, NVME_VSC_CLEAN_EVENT_LOG, 0, 0, (SRB_SIGNATURE >> 32),
+ nvme_vucmd(dev->fd, NVME_VSC_CLEAN_EVENT_LOG, 0, 0, (SRB_SIGNATURE >> 32),
(SRB_SIGNATURE & 0xFFFFFFFF), (char *)NULL, 0);
}
+ dev_close(dev);
+
return ret;
}
unsigned char busevsc = false;
unsigned int ipackcount, ipackindex;
char fwvera[32];
- int fd, ret = -1;
const char *desc = "Recrieve cdump data for the given device ";
+ struct nvme_dev *dev;
+ int ret = -1;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
if (getcwd(currentdir, 128) == NULL)
return -1;
ipackindex = 0;
memset(data, 0, 4096);
- if (nvme_vucmd(fd, NVME_VSC_GET, VSC_FN_GET_CDUMP, 0x00, (SRB_SIGNATURE >> 32),
- (SRB_SIGNATURE & 0xFFFFFFFF), (char *)data, 4096) == 0) {
+ if (nvme_vucmd(dev->fd, NVME_VSC_GET, VSC_FN_GET_CDUMP, 0x00,
+ (SRB_SIGNATURE >> 32), (SRB_SIGNATURE & 0xFFFFFFFF),
+ (char *)data, 4096) == 0) {
memcpy(&cdumpinfo, &data[3072], sizeof(cdumpinfo));
if (cdumpinfo.sig == 0x5a5b5c5d) {
busevsc = true;
if (busevsc == false) {
memset(data, 0, 4096);
- ret = nvme_get_nsid_log(fd, true, 0x07, NVME_NSID_ALL, 4096, data);
+ ret = nvme_get_nsid_log(dev->fd, true, 0x07, NVME_NSID_ALL,
+ 4096, data);
if (ret != 0)
return ret;
for (icur = 0; icur < itotal; icur += 4096) {
memset(data, 0, 4096);
if (busevsc)
- ret = nvme_vucmd(fd, NVME_VSC_GET, VSC_FN_GET_CDUMP, 0x00, (SRB_SIGNATURE >> 32),
- (SRB_SIGNATURE & 0xFFFFFFFF), (char *)data, 4096);
+ ret = nvme_vucmd(dev->fd, NVME_VSC_GET,
+ VSC_FN_GET_CDUMP, 0x00,
+ (SRB_SIGNATURE >> 32),
+ (SRB_SIGNATURE & 0xFFFFFFFF),
+ (char *)data, 4096);
else
- ret = nvme_get_nsid_log(fd, true, 0x07, NVME_NSID_ALL, 4096, data);
+ ret = nvme_get_nsid_log(dev->fd, true, 0x07,
+ NVME_NSID_ALL, 4096, data);
if (ret != 0)
return ret;
if (ipackindex != ipackcount) {
memset(data, 0, 4096);
if (busevsc)
- ret = nvme_vucmd(fd, NVME_VSC_GET, VSC_FN_GET_CDUMP, 0x00, (SRB_SIGNATURE >> 32),
- (SRB_SIGNATURE & 0xFFFFFFFF), (char *)data, 4096);
+ ret = nvme_vucmd(dev->fd, NVME_VSC_GET,
+ VSC_FN_GET_CDUMP, 0x00,
+ (SRB_SIGNATURE >> 32),
+ (SRB_SIGNATURE & 0xFFFFFFFF),
+ (char *)data, 4096);
else
- ret = nvme_get_nsid_log(fd, true, 0x07, NVME_NSID_ALL, 4096, data);
+ ret = nvme_get_nsid_log(dev->fd, true, 0x07,
+ NVME_NSID_ALL, 4096,
+ data);
if (ret != 0)
return ret;
}
printf("\n");
+ dev_close(dev);
return ret;
}
const char *json= "Dump output in json format";
struct nvme_additional_smart_log smart_log;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_log_simple(fd, 0xca, sizeof(smart_log), &smart_log);
+ err = nvme_get_log_simple(dev->fd, 0xca, sizeof(smart_log), &smart_log);
if (!err) {
if (cfg.json)
show_intel_smart_log_jsn(&smart_log, cfg.namespace_id,
}
else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
{
const char *desc = "Get Intel Marketing Name log and show it.";
const char *raw = "dump output in binary format";
-
+ struct nvme_dev *dev;
char log[512];
- int err, fd;
+ int err;
struct config {
bool raw_binary;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_log_simple(fd, 0xdd, sizeof(log), log);
+ err = nvme_get_log_simple(dev->fd, 0xdd, sizeof(log), log);
if (!err) {
if (!cfg.raw_binary)
printf("Intel Marketing Name Log:\n%s\n", log);
d_raw((unsigned char *)&log, sizeof(log));
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int get_temp_stats_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct intel_temp_stats stats;
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
const char *desc = "Get Temperature Statistics log and show it.";
const char *raw = "dump output in binary format";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_log_simple(fd, 0xc5, sizeof(stats), &stats);
+ err = nvme_get_log_simple(dev->fd, 0xc5, sizeof(stats), &stats);
if (!err) {
if (!cfg.raw_binary)
show_temp_stats(&stats);
d_raw((unsigned char *)&stats, sizeof(stats));
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int get_lat_stats_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
-
- int err, fd;
__u8 data[NAND_LAT_STATS_LEN];
+ struct nvme_dev *dev;
+ int err;
const char *desc = "Get Intel Latency Statistics log and show it.";
const char *raw = "Dump output in binary format";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
/* For optate, latency stats are deleted every time their LID is pulled.
* Therefore, we query the longest lat_stats log page first.
*/
- err = nvme_get_log_simple(fd, cfg.write ? 0xc2 : 0xc1,
+ err = nvme_get_log_simple(dev->fd, cfg.write ? 0xc2 : 0xc1,
sizeof(data), &data);
media_version[0] = (data[1] << 8) | data[0];
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = 0xf7,
.nsid = 0,
.sel = 0,
}
close_fd:
- close(fd);
+ dev_close(dev);
return err;
}
{
__u8 buf[0x2000];
char f[0x100];
- int err, fd, output, i, j, count = 0, core_num = 1;
+ int err, output, i, j, count = 0, core_num = 1;
struct nvme_passthru_cmd cmd;
struct intel_cd_log cdlog;
struct intel_vu_log *intel = malloc(sizeof(struct intel_vu_log));
struct intel_vu_nlog *intel_nlog = (struct intel_vu_nlog *)buf;
struct intel_assert_dump *ad = (struct intel_assert_dump *) intel->reserved;
struct intel_event_header *ehdr = (struct intel_event_header *)intel->reserved;
+ struct nvme_dev *dev;
const char *desc = "Get Intel Firmware Log and save it.";
const char *log = "Log type: 0, 1, or 2 for nlog, event log, and assert log, respectively.";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
free(intel);
- return fd;
+ return err;
}
if (cfg.log > 2 || cfg.core > 4 || cfg.lnum > 255) {
}
if (!cfg.file) {
- err = setup_file(f, cfg.file, fd, cfg.log);
+ err = setup_file(f, cfg.file, dev->fd, cfg.log);
if (err)
goto out_free;
cfg.file = f;
goto out_free;
}
- err = read_header(&cmd, buf, fd, cdlog.u.entireDword, cfg.namespace_id);
+ err = read_header(&cmd, buf, dev->fd, cdlog.u.entireDword, cfg.namespace_id);
if (err)
goto out;
memcpy(intel, buf, sizeof(*intel));
if ((intel->ver.major < 1 && intel->ver.minor < 1) ||
(intel->ver.major <= 1 && intel->ver.minor <= 1 && cfg.log == 0)) {
cmd.addr = (unsigned long)(void *)buf;
- err = get_internal_log_old(buf, output, fd, &cmd);
+ err = get_internal_log_old(buf, output, dev->fd, &cmd);
goto out;
}
cmd.cdw10 = 0x400;
cmd.data_len = min(0x400, ad[i].assertsize) * 4;
err = read_entire_cmd(&cmd, ad[i].assertsize,
- 0x400, output, fd, buf);
+ 0x400, output, dev->fd,
+ buf);
if (err)
goto out;
if (count > 1)
cdlog.u.fields.selectNlog = i;
- err = read_header(&cmd, buf, fd, cdlog.u.entireDword,
- cfg.namespace_id);
+ err = read_header(&cmd, buf, dev->fd,
+ cdlog.u.entireDword,
+ cfg.namespace_id);
if (err)
goto out;
err = write_header(buf, output, sizeof(*intel_nlog));
cmd.cdw10 = 0x400;
cmd.data_len = min(0x1000, intel_nlog->nlogbytesize);
err = read_entire_cmd(&cmd, intel_nlog->nlogbytesize / 4,
- 0x400, output, fd, buf);
+ 0x400, output, dev->fd,
+ buf);
if (err)
goto out;
} else if (cfg.log == 1) {
cmd.cdw10 = 0x400;
cmd.data_len = 0x400;
err = read_entire_cmd(&cmd, ehdr->edumps[j].coresize,
- 0x400, output, fd, buf);
+ 0x400, output, dev->fd,
+ buf);
if (err)
goto out;
}
close(output);
out_free:
free(intel);
- close(fd);
+ dev_close(dev);
return err;
}
static int enable_lat_stats_tracking(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
- int err, fd;
const char *desc = (
"Enable/Disable Intel Latency Statistics Tracking.\n"
"No argument prints current status.");
const __u32 cdw12 = 0x0;
const __u32 data_len = 32;
const __u32 save = 0;
- __u32 result;
+ struct nvme_dev *dev;
void *buf = NULL;
+ __u32 result;
+ int err;
struct config {
bool enable, disable;
{NULL}
};
- fd = parse_and_open(argc, argv, desc, command_line_options);
+ err = parse_and_open(&dev, argc, argv, desc, command_line_options);
enum Option {
None = -1,
else if (cfg.enable || cfg.disable)
option = cfg.enable;
- if (fd < 0)
- return fd;
+ if (err < 0)
+ return err;
struct nvme_get_features_args args_get = {
.args_size = sizeof(args_get),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = nsid,
.sel = sel,
struct nvme_set_features_args args_set = {
.args_size = sizeof(args_set),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = nsid,
.cdw11 = option,
fid, result);
} else {
printf("Could not read feature id 0xE2.\n");
- close(fd);
+ dev_close(dev);
return err;
}
break;
printf("%d not supported.\n", option);
return EINVAL;
}
- close(fd);
- return fd;
+ dev_close(dev);
+ return err;
}
static int set_lat_stats_thresholds(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
- int err, fd, num;
const char *desc = "Write Intel Bucket Thresholds for Latency Statistics Tracking";
const char *bucket_thresholds = "Bucket Threshold List, comma separated list: 0, 10, 20 ...";
const char *write = "Set write bucket Thresholds for latency tracking (read default)";
const __u8 fid = 0xf7;
const __u32 cdw12 = 0x0;
const __u32 save = 0;
+ struct nvme_dev *dev;
__u32 result;
+ int err, num;
struct config {
bool write;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
+ err = parse_and_open(&dev, argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ if (err < 0)
+ return err;
/* Query maj and minor version first to figure out the amount of
* valid buckets a user is allowed to modify. Read or write doesn't
* matter
*/
- err = nvme_get_log_simple(fd, 0xc2,
+ err = nvme_get_log_simple(dev->fd, 0xc2,
sizeof(media_version), media_version);
if (err) {
fprintf(stderr, "Querying media version failed. ");
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
if (media_version[0] == 1000) {
sizeof(thresholds));
if (num == -1) {
fprintf(stderr, "ERROR: Bucket list is malformed\n");
- goto close_fd;
+ goto close_dev;
}
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = nsid,
.cdw11 = cfg.write ? 0x1 : 0x0,
fprintf(stderr, "Unsupported command\n");
}
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
static int mb_get_additional_smart_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct nvme_memblaze_smart_log smart_log;
- int err, fd;
char *desc = "Get Memblaze vendor specific additional smart log (optionally, "\
"for the specified namespace), and show it.";
const char *namespace = "(optional) desired namespace";
const char *raw = "dump output in binary format";
+ struct nvme_dev *dev;
struct config {
__u32 namespace_id;
bool raw_binary;
};
+ int err;
struct config cfg = {
.namespace_id = NVME_NSID_ALL,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
- err = show_memblaze_smart_log(fd, cfg.namespace_id,
+ err = show_memblaze_smart_log(dev->fd, cfg.namespace_id,
nvme_dev->name,
&smart_log);
else
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int mb_get_powermanager_status(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get Memblaze power management ststus\n (value 0 - 25w, 1 - 20w, 2 - 15w)";
- int err, fd;
__u32 result;
__u32 feature_id = MB_FEAT_POWER_MGMT;
+ struct nvme_dev *dev;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = feature_id,
.nsid = 0,
.sel = 0,
nvme_select_to_string(0), result);
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
const char *desc = "Set Memblaze power management status\n (value 0 - 25w, 1 - 20w, 2 - 15w)";
const char *value = "new value of feature (required)";
const char *save = "specifies that the controller shall save the attribute";
- int err, fd;
+ struct nvme_dev *dev;
__u32 result;
+ int err;
struct config {
__u32 feature_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = cfg.feature_id,
.nsid = 0,
.cdw11 = cfg.value,
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
" p1 value: 0 is disable, 1 is enable\n"\
" p2 value: 1 .. 5000 ms";
const char *param = "input parameters";
- int err, fd;
- __u32 result;
int param1 = 0, param2 = 0;
+ struct nvme_dev *dev;
+ __u32 result;
+ int err;
struct config {
__u32 feature_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (parse_params(cfg.param, 2, ¶m1, ¶m2)) {
printf("setfeature: invalid formats %s\n", cfg.param);
- close(fd);
+ dev_close(dev);
return EINVAL;
}
if ((param1 == 1) && (param2 < P2MIN || param2 > P2MAX)) {
printf("setfeature: invalid high io latency threshold %d\n", param2);
- close(fd);
+ dev_close(dev);
return EINVAL;
}
cfg.value = (param1 << MB_FEAT_HIGH_LATENCY_VALUE_SHIFT) | param2;
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = cfg.feature_id,
.nsid = 0,
.cdw11 = cfg.value,
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int mb_high_latency_log_print(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get Memblaze high latency log";
- int err, fd;
char buf[LOG_PAGE_SIZE];
+ struct nvme_dev *dev;
FILE *fdi = NULL;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
fdi = fopen(FID_C3_LOG_FILENAME, "w+");
glp_high_latency_show_bar(fdi, DO_PRINT_FLAG);
- err = nvme_get_log_simple(fd, GLP_ID_VU_GET_HIGH_LATENCY_LOG, sizeof(buf), &buf);
+ err = nvme_get_log_simple(dev->fd, GLP_ID_VU_GET_HIGH_LATENCY_LOG,
+ sizeof(buf), &buf);
while (1) {
if (!glp_high_latency(fdi, buf, LOG_PAGE_SIZE, DO_PRINT_FLAG)) break;
- err = nvme_get_log_simple(fd, GLP_ID_VU_GET_HIGH_LATENCY_LOG, sizeof(buf), &buf);
+ err = nvme_get_log_simple(dev->fd, GLP_ID_VU_GET_HIGH_LATENCY_LOG,
+ sizeof(buf), &buf);
if ( err) {
nvme_show_status(err);
break;
}
if (NULL != fdi) fclose(fdi);
- close(fd);
+ dev_close(dev);
return err;
}
const char *select = "FW Select (e.g., --select=OOB, EEP, ALL)";
int xfer = 4096;
void *fw_buf;
- int fd, selectNo,fw_fd,fw_size,err,offset = 0;
+ int selectNo,fw_fd,fw_size,err,offset = 0;
+ struct nvme_dev *dev;
struct stat sb;
int i;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (strlen(cfg.select) != 3) {
fprintf(stderr, "Invalid select flag\n");
struct nvme_fw_download_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.offset = offset,
.data_len = xfer,
.data = fw_buf,
offset += xfer;
}
- err = memblaze_fw_commit(fd,selectNo);
+ err = memblaze_fw_commit(dev->fd, selectNo);
if(err == 0x10B || err == 0x20B) {
err = 0;
out_close:
close(fw_fd);
out:
- close(fd);
+ dev_close(dev);
return err;
}
static int mb_lat_stats_log_print(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
char stats[LOG_PAGE_SIZE];
- int err = 0;
- int fd;
char f1[] = FID_C1_LOG_FILENAME;
char f2[] = FID_C2_LOG_FILENAME;
+ struct nvme_dev *dev;
+ int err;
const char *desc = "Get Latency Statistics log and show it.";
const char *write = "Get write statistics (read default)";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_log_simple(fd, cfg.write ? 0xc2 : 0xc1, sizeof(stats), &stats);
+ err = nvme_get_log_simple(dev->fd, cfg.write ? 0xc2 : 0xc1,
+ sizeof(stats), &stats);
if (!err)
io_latency_histogram(cfg.write ? f2 : f1, stats, DO_PRINT_FLAG,
cfg.write ? GLP_ID_VU_GET_WRITE_LATENCY_HISTOGRAM : GLP_ID_VU_GET_READ_LATENCY_HISTOGRAM);
else
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
#define FID 0x68
static int memblaze_clear_error_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err, fd;
char *desc = "Clear Memblaze devices error log.";
+ struct nvme_dev *dev;
+ int err;
//const char *value = "new value of feature (required)";
//const char *save = "specifies that the controller shall save the attribute";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = cfg.feature_id,
.nsid = 0,
.cdw11 = cfg.value,
printf("NVMe Status:%s(%x)\n", nvme_status_to_string(err), err);
};
*/
- close(fd);
+ dev_close(dev);
return err;
}
static int mb_set_lat_stats(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
- int err, fd;
const char *desc = (
"Enable/Disable Latency Statistics Tracking.\n"
"No argument prints current status.");
const __u32 cdw12 = 0x0;
const __u32 data_len = 32;
const __u32 save = 0;
- __u32 result;
+ struct nvme_dev *dev;
void *buf = NULL;
+ __u32 result;
+ int err;
struct config {
bool enable, disable;
{NULL}
};
- fd = parse_and_open(argc, argv, desc, command_line_options);
+ err = parse_and_open(&dev, argc, argv, desc, command_line_options);
enum Option {
None = -1,
struct nvme_get_features_args args_get = {
.args_size = sizeof(args_get),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = nsid,
.sel = sel,
struct nvme_set_features_args args_set = {
.args_size = sizeof(args_set),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = nsid,
.cdw11 = option,
.result = &result,
};
- if (fd < 0)
- return fd;
+ if (err < 0)
+ return err;
switch (option) {
case None:
err = nvme_get_features(&args_get);
fid, result);
} else {
printf("Could not read feature id 0xE2.\n");
- close(fd);
+ dev_close(dev);
return err;
}
break;
printf("%d not supported.\n", option);
err = EINVAL;
}
- close(fd);
+ dev_close(dev);
return err;
}
/*
* Plugin Commands
*/
-static int micron_parse_options(int argc, char **argv, const char *desc,
- const struct argconfig_commandline_options *opts, eDriveModel *modelp)
+static int micron_parse_options(struct nvme_dev **dev, int argc, char **argv,
+ const char *desc,
+ const struct argconfig_commandline_options *opts,
+ eDriveModel *modelp)
{
int idx = 0;
- int fd = parse_and_open(argc, argv, desc, opts);
+ int err = parse_and_open(dev, argc, argv, desc, opts);
- if (fd < 0) {
+ if (err < 0) {
perror("open");
return -1;
}
*modelp = GetDriveModel(idx);
}
- return fd;
+ return 0;
}
static int micron_fw_commit(int fd, int select)
const char *select = "FW Select (e.g., --select=ALL)";
int xfer = 4096;
void *fw_buf;
- int fd, selectNo, fw_fd, fw_size, err, offset = 0;
+ int selectNo, fw_fd, fw_size, err, offset = 0;
+ struct nvme_dev *dev;
struct stat sb;
struct config {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (strlen(cfg.select) != 3) {
fprintf(stderr, "Invalid select flag\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
selectNo = 26;
} else {
fprintf(stderr, "Invalid select flag\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
fw_fd = open(cfg.fw, O_RDONLY);
if (fw_fd < 0) {
fprintf(stderr, "no firmware file provided\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
struct nvme_fw_download_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.offset = offset,
.data_len = xfer,
.data = fw_buf,
offset += xfer;
}
- err = micron_fw_commit(fd, selectNo);
+ err = micron_fw_commit(dev->fd, selectNo);
if (err == 0x10B || err == 0x20B) {
err = 0;
free(fw_buf);
out:
close(fw_fd);
- close(fd);
+ dev_close(dev);
return err;
}
"temperature (default) for enable option, 0 (current), "
"1 (default), 2 (saved) for status options";
const char *save = "1 - persistent, 0 - non-persistent (default)";
- int err = 0;
- int fd = 0;
int fid = MICRON_FEATURE_SMBUS_OPTION;
eDriveModel model = UNKNOWN_MODEL;
+ struct nvme_dev *dev;
+ int err = 0;
struct {
char *option;
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return err;
if (model != M5407 && model != M5411) {
printf ("This option is not supported for specified drive\n");
- close(fd);
+ dev_close(dev);
return err;
}
if (!strcmp(opt.option, "enable")) {
cdw11 = opt.value << 1 | 1;
- err = nvme_set_features_simple(fd, fid, 1, cdw11, opt.save, &result);
+ err = nvme_set_features_simple(dev->fd, fid, 1, cdw11, opt.save,
+ &result);
if (err == 0) {
printf("successfully enabled SMBus on drive\n");
} else {
else if (!strcmp(opt.option, "status")) {
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = 1,
.sel = opt.value,
}
else if (!strcmp(opt.option, "disable")) {
cdw11 = opt.value << 1 | 0;
- err = nvme_set_features_simple(fd, fid, 1, cdw11, opt.save, &result);
+ err = nvme_set_features_simple(dev->fd, fid, 1, cdw11, opt.save,
+ &result);
if (err == 0) {
printf("Successfully disabled SMBus on drive\n");
} else {
} else {
printf("Invalid option %s, valid values are enable, disable or status\n",
opt.option);
- close(fd);
+ dev_close(dev);
return -1;
}
- close(fd);
+ close(dev->fd);
return err;
}
bool is_json = false;
struct json_object *root;
struct json_object *logPages;
- int fd;
+ struct nvme_dev *dev;
OPT_ARGS(opts) = {
OPT_FMT("format", 'f', &cfg.fmt, fmt),
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf("\nDevice not found \n");;
return -1;
}
if (strcmp(cfg.fmt, "json") == 0)
is_json = true;
- err = nvme_get_log_smart(fd, 0xffffffff, false, &smart_log);
+ err = nvme_get_log_smart(dev->fd, 0xffffffff, false, &smart_log);
if (!err) {
temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]);
temperature = temperature ? temperature - 273 : 0;
}
}
}
- close(fd);
+ dev_close(dev);
return err;
}
static int micron_pcie_stats(int argc, char **argv,
struct command *cmd, struct plugin *plugin)
{
- int i, fd, err = 0, bus = 0, domain = 0, device = 0, function = 0, ctrlIdx;
+ int i, err = 0, bus = 0, domain = 0, device = 0, function = 0, ctrlIdx;
char strTempFile[1024], strTempFile2[1024], command[1024];
+ struct nvme_dev *dev;
char *businfo = NULL;
char *devicename = NULL;
char tdevice[NAME_MAX] = { 0 };
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf("\nDevice not found \n");;
return -1;
}
admin_cmd.addr = (__u64)(uintptr_t)&pcie_error_counters;
admin_cmd.data_len = sizeof(pcie_error_counters);
admin_cmd.cdw10 = 1;
- err = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (!err) {
counters = true;
correctable_errors = 10;
}
out:
- if (fd > 0)
- close(fd);
+ dev_close(dev);
return err;
}
{
int err = -EINVAL, bus = 0, domain = 0, device = 0, function = 0;
char strTempFile[1024], strTempFile2[1024], command[1024];
+ struct nvme_dev *dev;
char *businfo = NULL;
char *devicename = NULL;
char tdevice[PATH_MAX] = { 0 };
eDriveModel model = UNKNOWN_MODEL;
struct nvme_passthru_cmd admin_cmd = { 0 };
char correctable[8] = { 0 };
- int fd = -1;
FILE *fp;
char *res;
const char *desc = "Clear PCIe Device Correctable Errors";
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return err;
/* For M51CX models, PCIe errors are cleared using 0xC3 feature */
if (model == M51CX) {
- err = nvme_set_features_simple(fd, fid, 0, (1 << 31), false, &result);
+ err = nvme_set_features_simple(dev->fd, fid, 0, (1 << 31), false,
+ &result);
if (err == 0 && (err = (int)result) == 0) {
printf("Device correctable errors are cleared!\n");
goto out;
admin_cmd.opcode = 0xD6;
admin_cmd.addr = 0;
admin_cmd.cdw10 = 0;
- err = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (err == 0) {
printf("Device correctable error counters are cleared!\n");
goto out;
printf("Device correctable errors detected: %s\n", correctable);
err = 0;
out:
- close(fd);
+ dev_close(dev);
return err;
}
unsigned int logFB[FB_log_size/sizeof(int)] = { 0 };
eDriveModel eModel = UNKNOWN_MODEL;
struct nvme_id_ctrl ctrl;
- int fd, err, ctrlIdx;
+ struct nvme_dev *dev;
+ int err, ctrlIdx;
__u8 nsze;
bool has_d0_log = true;
bool has_fb_log = false;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf("\nDevice not found \n");;
return -1;
}
if (strcmp(cfg.fmt, "normal") == 0)
is_json = false;
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err) {
printf("Error %d retrieving controller identification data\n", err);
goto out;
goto out;
}
- err = nvme_get_log_simple(fd, 0xD0, D0_log_size, extSmartLog);
+ err = nvme_get_log_simple(dev->fd, 0xD0, D0_log_size, extSmartLog);
has_d0_log = (0 == err);
/* should check for firmware version if this log is supported or not */
if (eModel == M5407 || eModel == M5410) {
- err = nvme_get_log_simple(fd, 0xFB, FB_log_size, logFB);
+ err = nvme_get_log_simple(dev->fd, 0xFB, FB_log_size, logFB);
has_fb_log = (0 == err);
}
err = -ENOTTY;
}
out:
- close(fd);
+ dev_close(dev);
if (err > 0)
nvme_show_status(err);
const char *desc = "Retrieve extended SMART logs for the given device ";
unsigned int extSmartLog[E1_log_size/sizeof(int)] = { 0 };
eDriveModel eModel = UNKNOWN_MODEL;
- int fd = 0, err = 0, ctrlIdx = 0;
+ int err = 0, ctrlIdx = 0;
+ struct nvme_dev *dev;
bool is_json = true;
struct format {
char *fmt;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf("\nDevice not found \n");;
return -1;
}
err = -1;
goto out;
}
- err = nvme_get_log_simple(fd, 0xE1, E1_log_size, extSmartLog);
+ err = nvme_get_log_simple(dev->fd, 0xE1, E1_log_size, extSmartLog);
if (!err) {
print_ext_smart_logs_e1((__u8 *)extSmartLog, is_json);
}
out:
- close(fd);
+ dev_close(dev);
if (err > 0)
nvme_show_status(err);
return err;
struct plugin *plugin)
{
const char *desc = "Get drive HW information";
- int fd, err = 0;
struct nvme_id_ctrl ctrl = { 0 };
struct nvme_passthru_cmd admin_cmd = { 0 };
struct fb_drive_info {
eDriveModel model = UNKNOWN_MODEL;
bool is_json = false;
struct json_object *root, *driveInfo;
+ struct nvme_dev *dev;
struct format {
char *fmt;
};
+ int err = 0;
const char *fmt = "output format normal";
struct format cfg = {
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return err;
if (model == UNKNOWN_MODEL) {
fprintf(stderr, "ERROR : Unsupported drive for vs-drive-info cmd");
- close(fd);
+ dev_close(dev);
return -1;
}
admin_cmd.addr = (__u64) (uintptr_t) &dinfo;
admin_cmd.data_len = (__u32)sizeof(dinfo);
admin_cmd.cdw12 = 3;
- err = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (err) {
fprintf(stderr, "ERROR : drive-info opcode failed with 0x%x\n", err);
- close(fd);
+ dev_close(dev);
return -1;
}
} else {
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err) {
fprintf(stderr, "ERROR : identify_ctrl() failed with 0x%x\n", err);
- close(fd);
+ dev_close(dev);
return -1;
}
dinfo.hw_ver_major = ctrl.vs[820];
}
}
- close(fd);
+ dev_close(dev);
return 0;
}
int count = 0;
unsigned int logC2[C2_log_size/sizeof(int)] = { 0 };
eDriveModel eModel = UNKNOWN_MODEL;
- int fd, err;
+ struct nvme_dev *dev;
struct format {
char *fmt;
};
+ int err;
const char *fmt = "output format normal";
struct format cfg = {
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &eModel)) < 0) {
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &eModel);
+ if (err < 0)
return -1;
- }
if (strcmp(cfg.fmt, "normal") != 0) {
fprintf (stderr, "only normal format is supported currently\n");
- close(fd);
+ dev_close(dev);
return -1;
}
goto out;
}
- err = nvme_get_log_simple(fd, 0xC2, C2_log_size, logC2);
+ err = nvme_get_log_simple(dev->fd, 0xC2, C2_log_size, logC2);
if (err) {
fprintf(stderr, "Failed to retrieve fw activation history log, error: %x\n", err);
goto out;
}
}
out:
- close(fd);
+ dev_close(dev);
return err;
}
const char *thrtime = "The threshold value to use for latency monitoring in"
" milliseconds, default is 800ms";
- int fd = 0;
int fid = MICRON_FID_LATENCY_MONITOR;
eDriveModel model = UNKNOWN_MODEL;
uint32_t command_mask = 0x7; /* 1:read 2:write 4:trim 7:all */
uint32_t timing_mask = 0x08080800; /* R[31-24]:W[23:16]:T[15:8]:0 */
uint32_t enable = 2;
+ struct nvme_dev *dev;
struct {
char *option;
char *command;
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0) {
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return -1;
- }
if (!strcmp(opt.option, "enable")) {
enable = 1;
enable = 0;
} else if (strcmp(opt.option, "status")) {
printf("Invalid control option %s specified\n", opt.option);
- close(fd);
+ dev_close(dev);
return -1;
}
struct nvme_get_features_args g_args = {
.args_size = sizeof(g_args),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = 0,
.sel = 0,
err = nvme_get_features(&g_args);
if (err != 0) {
printf("Failed to retrieve latency monitoring feature status\n");
- close(fd);
+ dev_close(dev);
return err;
}
} else if (result == 0) {
printf("\n");
}
- close(fd);
+ dev_close(dev);
return err;
}
if (enable == 1) {
if (opt.threshold > 2550) {
printf("The maximum threshold value cannot be more than 2550 ms\n");
- close(fd);
+ dev_close(dev);
return -1;
}
/* timing mask is in terms of 10ms units, so min allowed is 10ms */
else if ((opt.threshold % 10) != 0) {
printf("The threshold value should be multiple of 10 ms\n");
- close(fd);
+ dev_close(dev);
return -1;
}
opt.threshold /= 10;
} else if (strcmp(opt.command, "all")) {
printf("Invalid command %s specified for option %s\n",
opt.command, opt.option);
- close(fd);
+ dev_close(dev);
return -1;
}
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = MICRON_FID_LATENCY_MONITOR,
.nsid = 0,
.cdw11 = enable,
opt.option, opt.command, opt.threshold == 0 ? 800 : opt.threshold * 10);
}
- close(fd);
+ dev_close(dev);
return err;
}
uint32_t rfu[6];
} log[LATENCY_LOG_ENTRIES];
eDriveModel model = UNKNOWN_MODEL;
+ struct nvme_dev *dev;
int err = -1;
- int fd = -1;
const char *desc = "Display Latency tracking log information";
OPT_ARGS(opts) = {
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err)
return err;
memset(&log, 0, sizeof(log));
- err = nvme_get_log_simple(fd, 0xD1, sizeof(log), &log);
+ err = nvme_get_log_simple(dev->fd, 0xD1, sizeof(log), &log);
if (err) {
if (err < 0)
printf("Unable to retrieve latency stats log the drive\n");
- close(fd);
+ dev_close(dev);
return err;
}
/* print header and each log entry */
log[i].deac, log[i].prinfo, log[i].fua, log[i].lr);
}
printf("\n");
- close(fd);
+ dev_close(dev);
return err;
}
const char *command = "command to display stats - all|read|write|trim"
"default is all";
int err = 0;
- int fd = -1;
+ struct nvme_dev *dev;
eDriveModel model = UNKNOWN_MODEL;
#define LATENCY_BUCKET_COUNT 32
#define LATENCY_BUCKET_RSVD 32
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return err;
if (!strcmp(opt.command, "read")) {
cmd_stats = &log.read_cmds[0];
cmd_str = "Trim";
} else if (strcmp(opt.command, "all")) {
printf("Invalid command option %s to display latency stats\n", opt.command);
- close(fd);
+ dev_close(dev);
return -1;
}
memset(&log, 0, sizeof(log));
- err = nvme_get_log_simple(fd, 0xD0, sizeof(log), &log);
+ err = nvme_get_log_simple(dev->fd, 0xD0, sizeof(log), &log);
if (err) {
if (err < 0)
printf("Unable to retrieve latency stats log the drive\n");
- close(fd);
+ dev_close(dev);
return err;
}
printf("Micron IO %s Command Latency Statistics\n"
printf("%2d %8s %8s %8"PRIu64"\n",
bucket, start, end, cmd_stats[b]);
}
- close(fd);
+ dev_close(dev);
return err;
}
unsigned int logFB[FB_log_size/sizeof(int)] = { 0 };
struct nvme_id_ctrl ctrl;
eDriveModel eModel = UNKNOWN_MODEL;
- int fd, err = 0;
+ struct nvme_dev *dev;
bool is_json = true;
struct format {
char *fmt;
struct format cfg = {
.fmt = "json",
};
+ int err = 0;
OPT_ARGS(opts) = {
OPT_FMT("format", 'f', &cfg.fmt, fmt),
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &eModel)) < 0) {
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &eModel);
+ if (err < 0)
return -1;
- }
if (strcmp(cfg.fmt, "normal") == 0)
is_json = false;
__u8 spec = (eModel == M5410) ? 0 : 1;
__u8 nsze;
- if ((err = nvme_identify_ctrl(fd, &ctrl)) == 0)
- err = nvme_get_log_simple(fd, 0xFB,
+ if ((err = nvme_identify_ctrl(dev->fd, &ctrl)) == 0)
+ err = nvme_get_log_simple(dev->fd, 0xFB,
FB_log_size, logFB);
if (err) {
if (err < 0)
goto out;
}
- err = nvme_get_log_simple(fd, 0xC0, C0_log_size, logC0);
+ err = nvme_get_log_simple(dev->fd, 0xC0, C0_log_size, logC0);
if (err == 0) {
print_smart_cloud_health_log((__u8 *)logC0, is_json);
} else if (err < 0) {
printf("Unable to retrieve extended smart log 0xC0 for the drive\n");
}
out:
- close(fd);
+ dev_close(dev);
if (err > 0)
nvme_show_status(err);
return err;
struct command *cmd, struct plugin *plugin)
{
const char *desc = "Clear FW activation history";
- int fd, err = 0;
__u32 result = 0;
__u8 fid = MICRON_FEATURE_CLEAR_FW_ACTIVATION_HISTORY;
eDriveModel model = UNKNOWN_MODEL;
+ struct nvme_dev *dev;
OPT_ARGS(opts) = {
OPT_END()
};
+ int err = 0;
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return err;
if (model != M51CX) {
printf ("This option is not supported for specified drive\n");
- close(fd);
+ dev_close(dev);
return err;
}
- err = nvme_set_features_simple(fd, fid, 1 << 31, 0, 0, &result);
+ err = nvme_set_features_simple(dev->fd, fid, 1 << 31, 0, 0, &result);
if (err == 0) err = (int)result;
else printf ("Failed to clear fw activation history, error = 0x%x\n", err);
- close(fd);
+ dev_close(dev);
return err;
}
const char *select = "select/save values: enable/disable options"
"1 - save (persistent), 0 - non-persistent and for "
"status options: 0 - current, 1 - default, 2-saved";
- int fd = 0;
int fid = MICRON_FEATURE_TELEMETRY_CONTROL_OPTION;
eDriveModel model = UNKNOWN_MODEL;
struct nvme_id_ctrl ctrl = { 0 };
+ struct nvme_dev *dev;
struct {
char *option;
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0) {
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return -1;
- }
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if ((ctrl.lpa & 0x8) != 0x8) {
printf("drive doesn't support host/controller generated telemetry logs\n");
- close(fd);
+ dev_close(dev);
return err;
}
if (!strcmp(opt.option, "enable")) {
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = 1,
.cdw11 = 1,
} else if (!strcmp(opt.option, "disable")) {
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = 1,
.cdw11 = 0,
} else if (!strcmp(opt.option, "status")) {
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = fid,
.nsid = 1,
.sel = opt.select & 0x3,
}
} else {
printf("invalid option %s, valid values are enable,disable or status\n", opt.option);
- close(fd);
+ dev_close(dev);
return -1;
}
- close(fd);
+ dev_close(dev);
return err;
}
struct plugin *plugin)
{
int err = -EINVAL;
- int fd = 0;
int ctrlIdx, telemetry_option = 0;
char strOSDirName[1024];
char strCtrlDirName[1024];
char sn[20] = { 0 };
char msg[256] = { 0 };
int c_logs_index = 8; /* should be current size of aVendorLogs */
+ struct nvme_dev *dev;
struct {
unsigned char ucLogPage;
const char *strFileName;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
-
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
/* if telemetry type is specified, check for data area */
if (strlen(cfg.type) != 0) {
goto out;
}
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err)
goto out;
if (telemetry_option) {
if ((ctrl.lpa & 0x8) != 0x8) {
printf("telemetry option is not supported for specified drive\n");
- close(fd);
+ dev_close(dev);
goto out;
}
int logSize = 0; __u8 *buffer = NULL; const char *dir = ".";
- err = micron_telemetry_log(fd, cfg.log, &buffer, &logSize, cfg.data_area);
+ err = micron_telemetry_log(dev->fd, cfg.log, &buffer, &logSize,
+ cfg.data_area);
if (err == 0 && logSize > 0 && buffer != NULL) {
sprintf(msg, "telemetry log: 0x%X", cfg.log);
WriteData(buffer, logSize, dir, cfg.package, msg);
GetDriveInfo(strOSDirName, ctrlIdx, &ctrl);
for (int i = 1; i <= ctrl.nn; i++)
- GetNSIDDInfo(fd, strCtrlDirName, i);
+ GetNSIDDInfo(dev->fd, strCtrlDirName, i);
- GetSmartlogData(fd, strCtrlDirName);
- GetErrorlogData(fd, ctrl.elpe, strCtrlDirName);
- GetGenericLogs(fd, strCtrlDirName);
+ GetSmartlogData(dev->fd, strCtrlDirName);
+ GetErrorlogData(dev->fd, ctrl.elpe, strCtrlDirName);
+ GetGenericLogs(dev->fd, strCtrlDirName);
/* pull if telemetry log data is supported */
if ((ctrl.lpa & 0x8) == 0x8)
- GetTelemetryData(fd, strCtrlDirName);
+ GetTelemetryData(dev->fd, strCtrlDirName);
- GetFeatureSettings(fd, strCtrlDirName);
+ GetFeatureSettings(dev->fd, strCtrlDirName);
if (eModel != M5410 && eModel != M5407) {
memcpy(&aVendorLogs[c_logs_index], aM51XXLogs, sizeof(aM51XXLogs));
case 0xE4:
case 0xE8:
case 0xEA:
- err = get_common_log(fd, aVendorLogs[i].ucLogPage, &dataBuffer, &bSize);
+ err = get_common_log(dev->fd, aVendorLogs[i].ucLogPage,
+ &dataBuffer, &bSize);
break;
case 0xC1:
case 0xC2:
case 0xC4:
- err = GetLogPageSize(fd, aVendorLogs[i].ucLogPage, &bSize);
+ err = GetLogPageSize(dev->fd, aVendorLogs[i].ucLogPage, &bSize);
if (err == 0 && bSize > 0)
- err = GetCommonLogPage(fd, aVendorLogs[i].ucLogPage, &dataBuffer, bSize);
+ err = GetCommonLogPage(dev->fd, aVendorLogs[i].ucLogPage, &dataBuffer, bSize);
break;
case 0xE6:
if (bSize != 0 && (dataBuffer = (unsigned char *)malloc(bSize)) != NULL) {
memset(dataBuffer, 0, bSize);
if (eModel == M5410 || eModel == M5407)
- err = NVMEGetLogPage(fd, aVendorLogs[i].ucLogPage, dataBuffer, bSize);
+ err = NVMEGetLogPage(dev->fd, aVendorLogs[i].ucLogPage, dataBuffer, bSize);
else
- err = nvme_get_log_simple(fd, aVendorLogs[i].ucLogPage,
+ err = nvme_get_log_simple(dev->fd, aVendorLogs[i].ucLogPage,
bSize, dataBuffer);
}
break;
case 0xFC:
case 0xFD:
if (eModel == M51BX) {
- (void)NVMEResetLog(fd, aVendorLogs[i].ucLogPage,
+ (void)NVMEResetLog(dev->fd, aVendorLogs[i].ucLogPage,
aVendorLogs[i].nLogSize, aVendorLogs[i].nMaxSize);
}
/* fallthrough */
break;
}
memset(dataBuffer, 0, bSize);
- err = nvme_get_log_simple(fd, aVendorLogs[i].ucLogPage,
+ err = nvme_get_log_simple(dev->fd, aVendorLogs[i].ucLogPage,
bSize, dataBuffer);
maxSize = aVendorLogs[i].nMaxSize - bSize;
while (err == 0 && maxSize > 0 && ((unsigned int *)dataBuffer)[0] != 0xdeadbeef) {
sprintf(msg, "log 0x%x", aVendorLogs[i].ucLogPage);
WriteData(dataBuffer, bSize, strCtrlDirName, aVendorLogs[i].strFileName, msg);
- err = nvme_get_log_simple(fd, aVendorLogs[i].ucLogPage,
+ err = nvme_get_log_simple(dev->fd, aVendorLogs[i].ucLogPage,
bSize, dataBuffer);
if (err || (((unsigned int *)dataBuffer)[0] == 0xdeadbeef))
break;
err = ZipAndRemoveDir(strMainDirName, cfg.package);
out:
- close(fd);
+ dev_close(dev);
return err;
}
struct plugin *plugin)
{
int err = -1;
- int fd = -1;
const char *desc = "List the supported log pages";
eDriveModel model = UNKNOWN_MODEL;
char logbuf[MIN_LOG_SIZE];
+ struct nvme_dev *dev;
int i;
OPT_ARGS(opts) = {
OPT_END()
};
- if ((fd = micron_parse_options(argc, argv, desc, opts, &model)) < 0)
+ err = micron_parse_options(&dev, argc, argv, desc, opts, &model);
+ if (err < 0)
return err;
struct nvme_supported_logs {
printf("Supported log page list\nLog ID : Description\n");
for (i = 0; i < sizeof(log_list)/sizeof(log_list[0]); i++) {
- err = nvme_get_log_simple(fd, log_list[i].log_id,
+ err = nvme_get_log_simple(dev->fd, log_list[i].log_id,
MIN_LOG_SIZE, &logbuf[0]);
if (err) continue;
printf("%02Xh : %s\n", log_list[i].log_id, log_list[i].desc);
struct plugin *plugin)
{
const char *desc = "Retrieve latency monitor log data.";
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
struct config {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
- ret = get_c0_log_page(fd, cfg.output_format);
+ ret = get_c0_log_page(dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : OCP : Failure reading the C0 Log Page, ret = %d\n",
ret);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve latency monitor log data.";
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
struct config {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
- ret = get_c3_log_page(fd, cfg.output_format);
+ ret = get_c3_log_page(dev->fd, cfg.output_format);
if (ret)
fprintf(stderr,
"ERROR : OCP : Failure reading the C3 Log Page, ret = %d\n",
ret);
- close(fd);
+ dev_close(dev);
return ret;
}
static int get_additional_smart_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct nvme_additional_smart_log smart_log;
- int err, fd;
char *desc = "Get ScaleFlux vendor specific additional smart log (optionally, "\
"for the specified namespace), and show it.";
const char *namespace = "(optional) desired namespace";
const char *raw = "dump output in binary format";
const char *json= "Dump output in json format";
+ struct nvme_dev *dev;
struct config {
__u32 namespace_id;
bool raw_binary;
bool json;
};
+ int err;
struct config cfg = {
.namespace_id = 0xffffffff,
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), (void *)&smart_log);
if (!err) {
if (cfg.json)
}
else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int get_lat_stats_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct sfx_lat_stats stats;
- int err, fd;
-
char *desc = "Get ScaleFlux Latency Statistics log and show it.";
const char *raw = "dump output in binary format";
const char *write = "Get write statistics (read default)";
+ struct nvme_dev *dev;
struct config {
bool raw_binary;
bool write;
};
+ int err;
struct config cfg = {
};
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_log_simple(fd, cfg.write ? 0xc3 : 0xc1, sizeof(stats), (void *)&stats);
+ err = nvme_get_log_simple(dev->fd, cfg.write ? 0xc3 : 0xc1,
+ sizeof(stats), (void *)&stats);
if (!err) {
if ((stats.ver.maj == VANDA_MAJOR_IDX) && (stats.ver.min == VANDA_MINOR_IDX)) {
if (!cfg.raw_binary) {
}
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
*/
static int sfx_get_bad_block(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int fd;
- unsigned char *data_buf;
const __u64 buf_size = 256*4096*sizeof(unsigned char);
+ unsigned char *data_buf;
+ struct nvme_dev *dev;
int err = 0;
char *desc = "Get bad block table of sfx block device.";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
data_buf = malloc(buf_size);
if (!data_buf) {
fprintf(stderr, "malloc fail, errno %d\r\n", errno);
- close(fd);
+ dev_close(dev);
return -1;
}
- err = get_bb_table(fd, 0xffffffff, data_buf, buf_size);
+ err = get_bb_table(dev->fd, 0xffffffff, data_buf, buf_size);
if (err < 0) {
perror("get-bad-block");
} else if (err != 0) {
}
free(data_buf);
- close(fd);
+ dev_close(dev);
return 0;
}
static int query_cap_info(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct sfx_freespace_ctx ctx = { 0 };
- int err = 0, fd;
char *desc = "query current capacity info";
const char *raw = "dump output in binary format";
+ struct nvme_dev *dev;
struct config {
bool raw_binary;
};
struct config cfg;
+ int err = 0;
OPT_ARGS(opts) = {
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- if (nvme_query_cap(fd, 0xffffffff, sizeof(ctx), &ctx)) {
+ if (nvme_query_cap(dev->fd, 0xffffffff, sizeof(ctx), &ctx)) {
perror("sfx-query-cap");
err = -1;
}
d_raw((unsigned char *)&ctx, sizeof(ctx));
}
}
- close(fd);
+ dev_close(dev);
return err;
}
static int change_cap(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err = -1, fd;
char *desc = "dynamic change capacity";
const char *cap_gb = "cap size in GB";
const char *cap_byte = "cap size in byte";
const char *force = "The \"I know what I'm doing\" flag, skip confirmation before sending command";
+ struct nvme_dev *dev;
__u64 cap_in_4k = 0;
__u64 cap_in_sec = 0;
int shrink = 0;
+ int err = -1;
struct config {
__u64 cap_in_byte;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
cap_in_sec = IDEMA_CAP(cfg.capacity_in_gb);
cap_in_4k = cap_in_sec >> 3;
printf("%dG %"PRIu64"B %"PRIu64" 4K\n",
cfg.capacity_in_gb, (uint64_t)cfg.cap_in_byte, (uint64_t)cap_in_4k);
- if (change_sanity_check(fd, cap_in_4k, &shrink)) {
+ if (change_sanity_check(dev->fd, cap_in_4k, &shrink)) {
printf("ScaleFlux change-capacity: fail\n");
- close(fd);
+ dev_close(dev);
return err;
}
if (!cfg.force && shrink && !sfx_confirm_change("Changing Cap may irrevocably delete this device's data")) {
- close(fd);
+ dev_close(dev);
return 0;
}
- err = nvme_change_cap(fd, 0xffffffff, cap_in_4k);
+ err = nvme_change_cap(dev->fd, 0xffffffff, cap_in_4k);
if (err < 0)
perror("sfx-change-cap");
else if (err != 0)
nvme_show_status(err);
else {
printf("ScaleFlux change-capacity: success\n");
- ioctl(fd, BLKRRPART);
+ ioctl(dev->fd, BLKRRPART);
}
- close(fd);
+ dev_close(dev);
return err;
}
static int sfx_set_feature(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err = 0, fd;
char *desc = "ScaleFlux internal set features\n"
"feature id 1: ATOMIC\n"
"value 0: Disable atomic write\n"
const char *feature_id = "hex feature name (required)";
const char *namespace_id = "desired namespace";
const char *force = "The \"I know what I'm doing\" flag, skip confirmation before sending command";
-
+ struct nvme_dev *dev;
struct nvme_id_ns ns;
+ int err = 0;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (!cfg.feature_id) {
fprintf(stderr, "feature-id required param\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
if (cfg.feature_id == SFX_FEAT_CLR_CARD) {
/*Warning for clean card*/
if (!cfg.force && !sfx_confirm_change("Going to clean device's data, confirm umount fs and try again")) {
- close(fd);
+ dev_close(dev);
return 0;
} else {
- return sfx_clean_card(fd);
+ return sfx_clean_card(dev->fd);
}
}
if (cfg.feature_id == SFX_FEAT_ATOMIC && cfg.value != 0) {
if (cfg.namespace_id != 0xffffffff) {
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err) {
if (err < 0)
perror("identify-namespace");
else
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
/*
*/
if ((ns.flbas & 0xf) != 1) {
printf("Please change-sector size to 4K, then retry\n");
- close(fd);
+ dev_close(dev);
return EFAULT;
}
}
} else if (cfg.feature_id == SFX_FEAT_UP_P_CAP) {
if (cfg.value <= 0) {
fprintf(stderr, "Invalid Param\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
/*Warning for change pacp by GB*/
if (!cfg.force && !sfx_confirm_change("Changing physical capacity may irrevocably delete this device's data")) {
- close(fd);
+ dev_close(dev);
return 0;
}
}
- err = nvme_sfx_set_features(fd, cfg.namespace_id, cfg.feature_id, cfg.value);
+ err = nvme_sfx_set_features(dev->fd, cfg.namespace_id, cfg.feature_id,
+ cfg.value);
if (err < 0) {
perror("ScaleFlux-set-feature");
- close(fd);
+ dev_close(dev);
return errno;
} else if (!err) {
printf("ScaleFlux set-feature:%#02x (%s), value:%d\n", cfg.feature_id,
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int sfx_get_feature(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err = 0, fd;
char *desc = "ScaleFlux internal set features\n"
"feature id 1: ATOMIC";
const char *feature_id = "hex feature name (required)";
const char *namespace_id = "desired namespace";
+ struct nvme_dev *dev;
__u32 result = 0;
+ int err = 0;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (!cfg.feature_id) {
fprintf(stderr, "feature-id required param\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
- err = nvme_sfx_get_features(fd, cfg.namespace_id, cfg.feature_id, &result);
+ err = nvme_sfx_get_features(dev->fd, cfg.namespace_id, cfg.feature_id, &result);
if (err < 0) {
perror("ScaleFlux-get-feature");
- close(fd);
+ dev_close(dev);
return errno;
} else if (!err) {
printf("ScaleFlux get-feature:%02x (%s), value:%d\n", cfg.feature_id,
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
struct plugin *plugin)
{
int err = 0;
- int fd = 0;
__u32 i = 0;
log_page_map logPageMap;
const char *desc = "Retrieve Seagate Supported Log-Page information for the given device ";
const char *output_format = "output in binary format";
+ struct nvme_dev *dev;
int fmt;
struct config {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
- err = nvme_get_log_simple(fd, 0xc5, sizeof(logPageMap), &logPageMap);
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
+ err = nvme_get_log_simple(dev->fd, 0xc5,
+ sizeof(logPageMap), &logPageMap);
if (!err) {
if (strcmp(cfg.output_format,"json")) {
printf ("Seagate Supported Log-pages count :%d\n",
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
{
EXTENDED_SMART_INFO_T ExtdSMARTInfo;
vendor_log_page_CF logPageCF;
- int fd;
struct json_object *root = json_create_object();
struct json_object *lbafs = json_create_array();
struct json_object *lbafs_ExtSmart, *lbafs_DramSmart;
const char *desc = "Retrieve Seagate Extended SMART information for the given device ";
const char *output_format = "output in binary format";
+ struct nvme_dev *dev;
int err, index=0;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf ("\nDevice not found \n");
return -1;
}
if (strcmp(cfg.output_format,"json"))
printf("Seagate Extended SMART Information :\n");
- err = nvme_get_log_simple(fd, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
+ err = nvme_get_log_simple(dev->fd, 0xC4,
+ sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
if (!err) {
if (strcmp(cfg.output_format,"json")) {
printf("%-39s %-15s %-19s \n", "Description", "Ext-Smart-Id", "Ext-Smart-Value");
* Next get Log Page 0xCF
*/
- err = nvme_get_log_simple(fd, 0xCF, sizeof(logPageCF), &logPageCF);
+ err = nvme_get_log_simple(dev->fd, 0xCF,
+ sizeof(logPageCF), &logPageCF);
if (!err) {
if(strcmp(cfg.output_format,"json")) {
/*printf("Seagate DRAM Supercap SMART Attributes :\n");*/
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
EXTENDED_SMART_INFO_T ExtdSMARTInfo;
vendor_log_page_CF logPageCF;
- int fd;
int err, cf_err;
int index;
const char *desc = "Retrieve Seagate Temperature Stats information for the given device ";
const char *output_format = "output in binary format";
unsigned int temperature = 0, PcbTemp = 0, SocTemp = 0, scCurrentTemp = 0, scMaxTemp = 0;
unsigned long long maxTemperature = 0, MaxSocTemp = 0;
+ struct nvme_dev *dev;
struct config {
char *output_format;
};
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf ("\nDevice not found \n");;
return -1;
}
if(strcmp(cfg.output_format,"json"))
printf("Seagate Temperature Stats Information :\n");
/*STEP-1 : Get Current Temperature from SMART */
- err = nvme_get_log_smart(fd, 0xffffffff, false, &smart_log);
+ err = nvme_get_log_smart(dev->fd, 0xffffffff, false, &smart_log);
if (!err) {
temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]);
temperature = temperature ? temperature - 273 : 0;
}
/* STEP-2 : Get Max temperature form Ext SMART-id 194 */
- err = nvme_get_log_simple(fd, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
+ err = nvme_get_log_simple(dev->fd, 0xC4,
+ sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
if (!err) {
for(index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++) {
if (ExtdSMARTInfo.vendorData[index].AttributeNumber == VS_ATTR_ID_MAX_LIFE_TEMPERATURE) {
else if (err > 0)
nvme_show_status(err);
- cf_err = nvme_get_log_simple(fd, 0xCF, sizeof(ExtdSMARTInfo), &logPageCF);
+ cf_err = nvme_get_log_simple(dev->fd, 0xCF,
+ sizeof(ExtdSMARTInfo), &logPageCF);
if(!cf_err) {
scCurrentTemp = logPageCF.AttrCF.SuperCapCurrentTemperature;
if(!strcmp(cfg.output_format,"json"))
json_temp_stats(temperature, PcbTemp, SocTemp, maxTemperature, MaxSocTemp, cf_err, scCurrentTemp, scMaxTemp);
- close(fd);
+ dev_close(dev);
return err;
}
/* EOF Temperature Stats information */
static int vs_pcie_error_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
pcie_error_log_page pcieErrorLog;
- int fd;
+ struct nvme_dev *dev;
const char *desc = "Retrieve Seagate PCIe error counters for the given device ";
const char *output_format = "output in binary format";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf ("\nDevice not found \n");;
return -1;
}
if(strcmp(cfg.output_format,"json"))
printf("Seagate PCIe error counters Information :\n");
- err = nvme_get_log_simple(fd, 0xCB, sizeof(pcieErrorLog), &pcieErrorLog);
+ err = nvme_get_log_simple(dev->fd, 0xCB,
+ sizeof(pcieErrorLog), &pcieErrorLog);
if (!err) {
if(strcmp(cfg.output_format,"json")) {
print_vs_pcie_error_log(pcieErrorLog);
} else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
/* EOF PCIE error-log information */
{
const char *desc = "Clear Seagate PCIe Correctable counters for the given device ";
const char *save = "specifies that the controller shall save the attribute";
- int err, fd;
+ struct nvme_dev *dev;
__u32 result;
+ int err;
struct config {
bool save;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
printf ("\nDevice not found \n");;
return -1;
}
- err = nvme_set_features_simple(fd, 0xE1, 0, 0xCB, cfg.save, &result);
+ err = nvme_set_features_simple(dev->fd, 0xE1, 0, 0xCB, cfg.save,
+ &result);
if (err < 0) {
perror("set-feature");
}
- close(fd);
+ dev_close(dev);
return err;
}
"state of the controller at the time the command is processed. " \
"0 - controller shall not update the Telemetry Host Initiated Data.";
const char *raw = "output in raw format";
- int err, fd, dump_fd;
struct nvme_temetry_log_hdr tele_log;
- __le64 offset = 0;
int blkCnt, maxBlk = 0, blksToGet;
+ struct nvme_dev *dev;
unsigned char *log;
+ __le64 offset = 0;
+ int err, dump_fd;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
dump_fd = STDOUT_FILENO;
cfg.log_id = (cfg.log_id << 8) | 0x07;
- err = nvme_get_nsid_log(fd, false, cfg.log_id, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev->fd, false, cfg.log_id, cfg.namespace_id,
sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
if(blksToGet == 0) {
- close(fd);
+ dev_close(dev);
return err;
}
if (!log) {
fprintf(stderr, "could not alloc buffer for log\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.lid = cfg.log_id,
.nsid = cfg.namespace_id,
.lpo = offset,
free(log);
}
- close(fd);
+ dev_close(dev);
return err;
}
"hex-dump (default) or binary format";
const char *namespace_id = "desired namespace";
const char *raw = "output in raw format";
- int err, fd, dump_fd;
+ struct nvme_dev *dev;
+ int err, dump_fd;
struct nvme_temetry_log_hdr tele_log;
__le64 offset = 0;
__u16 log_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
dump_fd = STDOUT_FILENO;
log_id = 0x08;
- err = nvme_get_nsid_log(fd, false, log_id, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev->fd, false, log_id, cfg.namespace_id,
sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.lid = log_id,
.nsid = cfg.namespace_id,
.lpo = offset,
free(log);
}
- close(fd);
+ dev_close(dev);
return err;
}
const char *namespace_id = "desired namespace";
const char *file = "dump file";
- int err, fd, dump_fd;
+ struct nvme_dev *dev;
+ int err, dump_fd;
int flags = O_WRONLY | O_CREAT;
int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
struct nvme_temetry_log_hdr tele_log;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
dump_fd = STDOUT_FILENO;
if(strlen(cfg.file)) {
dump_fd = open(cfg.file, flags, mode);
if (dump_fd < 0) {
perror(cfg.file);
- close(fd);
+ dev_close(dev);
return EINVAL;
}
}
log_id = 0x08;
- err = nvme_get_nsid_log(fd, false, log_id, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev->fd, false, log_id, cfg.namespace_id,
sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.lid = log_id,
.nsid = cfg.namespace_id,
.lpo = offset,
if(strlen(cfg.file))
close(dump_fd);
- close(fd);
+ dev_close(dev);
return err;
}
static int get_additional_smart_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct nvme_shannon_smart_log smart_log;
- int err, fd;
char *desc = "Get Shannon vendor specific additional smart log (optionally, "\
"for the specified namespace), and show it.";
const char *namespace = "(optional) desired namespace";
const char *raw = "dump output in binary format";
+ struct nvme_dev *dev;
struct config {
__u32 namespace_id;
bool raw_binary;
};
+ int err;
struct config cfg = {
.namespace_id = NVME_NSID_ALL,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
- err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
+ err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
}
else if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
const char *data_len = "buffer len (if) data is returned";
const char *cdw11 = "dword 11 for interrupt vector config";
const char *human_readable = "show infos in readable format";
- int err, fd;
- __u32 result;
+ struct nvme_dev *dev;
void *buf = NULL;
+ __u32 result;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (cfg.sel > 7) {
fprintf(stderr, "invalid 'select' param:%d\n", cfg.sel);
- close(fd);
+ dev_close(dev);
return EINVAL;
}
if (!cfg.feature_id) {
fprintf(stderr, "feature-id required param\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
if (cfg.data_len) {
if (posix_memalign(&buf, getpagesize(), cfg.data_len))
{
- close(fd);
+ dev_close(dev);
exit(ENOMEM);
}
memset(buf, 0, cfg.data_len);
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = cfg.feature_id,
.nsid = cfg.namespace_id,
.sel = cfg.sel,
const char *data = "optional file for feature data (default stdin)";
const char *value = "new value of feature (required)";
const char *save = "specifies that the controller shall save the attribute";
- int err, fd;
- __u32 result;
- void *buf = NULL;
int ffd = STDIN_FILENO;
+ struct nvme_dev *dev;
+ void *buf = NULL;
+ __u32 result;
+ int err;
struct config {
char *file;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
if (!cfg.feature_id) {
fprintf(stderr, "feature-id required param\n");
- close(fd);
+ dev_close(dev);
return EINVAL;
}
if (cfg.data_len) {
if (posix_memalign(&buf, getpagesize(), cfg.data_len)){
fprintf(stderr, "can not allocate feature payload\n");
- close(fd);
+ dev_close(dev);
return ENOMEM;
}
memset(buf, 0, cfg.data_len);
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = cfg.feature_id,
.nsid = cfg.namespace_id,
.cdw11 = cfg.value,
int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get and parse Solidigm vendor specific garbage collection event log.";
+ struct nvme_dev *dev;
+ int err;
struct config {
char *output_format;
OPT_END()
};
- int fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
enum nvme_print_flags flags = validate_output_format(cfg.output_format);
if (flags == -EINVAL) {
fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
- close(fd);
+ dev_close(dev);
return flags;
}
garbage_control_collection_log_t gc_log;
const int solidigm_vu_gc_log_id = 0xfd;
- int err = nvme_get_log_simple(fd, solidigm_vu_gc_log_id, sizeof(gc_log), &gc_log);
+ err = nvme_get_log_simple(dev->fd, solidigm_vu_gc_log_id,
+ sizeof(gc_log), &gc_log);
if (!err) {
if (flags & BINARY) {
d_raw((unsigned char *)&gc_log, sizeof(gc_log));
else if (err > 0) {
nvme_show_status(err);
}
-
- close(fd);
+
+ dev_close(dev);
return err;
}
struct plugin *plugin)
{
const char *desc = "Get and Parse Solidigm Latency Tracking Statistics log.";
+ struct nvme_dev *dev;
__u32 enabled;
int err;
OPT_END()
};
- lt.fd = parse_and_open(argc, argv, desc, opts);
- if (lt.fd < 0)
- return lt.fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
+
+ lt.fd = dev->fd;
lt.print_flags = validate_output_format(lt.cfg.output_format);
if (lt.print_flags == -EINVAL) {
fprintf(stderr, "Invalid output format '%s'\n", lt.cfg.output_format);
- close(lt.fd);
+ dev_close(dev);
return EINVAL;
}
if (lt.cfg.type > 0xf) {
fprintf(stderr, "Invalid Log type value '%d'\n", lt.cfg.type);
- close(lt.fd);
+ dev_close(dev);
return EINVAL;
}
if (lt.cfg.type && !(lt.cfg.read || lt.cfg.write)) {
fprintf(stderr, "Log type option valid only when retrieving statistics\n");
- close(lt.fd);
+ dev_close(dev);
return EINVAL;
}
err = latency_tracking_enable(<);
if (err){
- close(lt.fd);
+ dev_close(dev);
return err;
}
err = latency_tracker_get_log(<);
if (err){
- close(lt.fd);
+ dev_close(dev);
return err;
}
if ((lt.cfg.read || lt.cfg.write || lt.cfg.enable || lt.cfg.disable)) {
- close(lt.fd);
+ dev_close(dev);
return 0;
}
} else {
fprintf(stderr, "Could not read feature id 0xE2.\n");
}
- close(lt.fd);
+ dev_close(dev);
return err;
}
const int solidigm_vu_smart_log_id = 0xCA;
vu_smart_log_t smart_log_payload;
enum nvme_print_flags flags;
- int fd, err;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- return fd;
- }
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
flags = validate_output_format(cfg.output_format);
if (flags == -EINVAL) {
fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
- close(fd);
+ dev_close(dev);
return flags;
}
- err = nvme_get_log_simple(fd, solidigm_vu_smart_log_id, sizeof(smart_log_payload), &smart_log_payload);
+ err = nvme_get_log_simple(dev->fd, solidigm_vu_smart_log_id,
+ sizeof(smart_log_payload), &smart_log_payload);
if (!err) {
if (flags & JSON) {
vu_smart_log_show_json(&smart_log_payload,
nvme_show_status(err);
}
- close(fd);
+ dev_close(dev);
return err;
}
static int vendor_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err, fd;
char *desc = "Get extended SMART information and show it.";
const char *namespace = "(optional) desired namespace";
const char *output_file = "(optional) binary output filename";
const char *log = "(optional) log ID (0xC0, or 0xCA), default 0xCA";
+ struct nvme_dev *dev;
+ int err;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
fprintf(stderr,"%s: failed to parse arguments\n", __func__);
return EINVAL;
}
goto end;
}
- err = nvme_get_vendor_log(fd, cfg.namespace_id, cfg.log, cfg.output_file);
+ err = nvme_get_vendor_log(dev->fd, cfg.namespace_id, cfg.log,
+ cfg.output_file);
if (err)
fprintf(stderr, "%s: couldn't get vendor log 0x%x\n", __func__, cfg.log);
end:
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int internal_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err, fd;
char *desc = "Get internal status log and show it.";
const char *output_file = "(optional) binary output filename";
const char *prev_log = "(optional) use previous log. Otherwise uses current log.";
+ struct nvme_dev *dev;
+ int err;
struct config {
const char* output_file;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
fprintf(stderr,"%s: failed to parse arguments\n", __func__);
return EINVAL;
}
else
printf("Getting current log\n");
- err = nvme_get_internal_log_file(fd, cfg.output_file, !cfg.prev_log);
+ err = nvme_get_internal_log_file(dev->fd, cfg.output_file,
+ !cfg.prev_log);
if (err < 0)
fprintf(stderr, "%s: couldn't get fw log \n", __func__);
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
static int clear_correctable_errors(int argc, char **argv, struct command *cmd,
struct plugin *plugin)
{
- int err, fd;
char *desc = "Clear PCIe correctable error count.";
const __u32 namespace_id = 0xFFFFFFFF;
const __u32 feature_id = 0xCA;
const __u32 value = 1; /* Bit0 - reset clear PCIe correctable count */
const __u32 cdw12 = 0;
const bool save = false;
+ struct nvme_dev *dev;
__u32 result;
+ int err;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
fprintf(stderr,"%s: failed to parse arguments\n", __func__);
return EINVAL;
}
/* Check device supported */
- err = nvme_get_sct_status(fd, MASK_0 | MASK_1);
+ err = nvme_get_sct_status(dev->fd, MASK_0 | MASK_1);
if (err)
goto end;
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.fid = feature_id,
.nsid = namespace_id,
.cdw11 = value,
end:
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
{
struct nvme_smart_log smart_log;
char *desc = "Get nvme health percentage.";
- int result=0, fd;
int percent_used = 0, healthvalue=0;
-
+ struct nvme_dev *dev;
+ int result;
+
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
-
- if (fd < 0) {
+ result = parse_and_open(&dev, argc, argv, desc, opts);
+ if (result < 0) {
printf("\nDevice not found \n");;
return -1;
}
- result = nvme_get_log_smart(fd, 0xffffffff, false, &smart_log);
+ result = nvme_get_log_smart(dev->fd, 0xffffffff, false, &smart_log);
if (!result) {
printf("Transcend NVME heath value: ");
percent_used =smart_log.percent_used;
}
}
- close(fd);
+ dev_close(dev);
return result;
}
{
char *desc = "Get nvme bad block number.";
- int result=0, fd;
+ struct nvme_dev *dev;
+ int result;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ result = parse_and_open(&dev, argc, argv, desc, opts);
+ if (result < 0) {
printf("\nDevice not found \n");;
return -1;
}
nvmecmd.cdw12=DW12_BAD_BLOCK;
nvmecmd.addr = (__u64)(uintptr_t)data;
nvmecmd.data_len = 0x1;
- result = nvme_submit_admin_passthru(fd, &nvmecmd, NULL);
+ result = nvme_submit_admin_passthru(dev->fd, &nvmecmd, NULL);
if(!result) {
int badblock = data[0];
printf("Transcend NVME badblock count: %d\n",badblock);
}
- close(fd);
+ dev_close(dev);
return result;
}
static int vt_save_smart_to_vtview_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err = 0;
- int fd, ret;
+ int ret, err = 0;
long int total_time = 0;
long int freq_time = 0;
long int cur_time = 0;
const char *freq = "(optional) How often you want to log SMART data (0.25 = 15' , 0.5 = 30' , 1 = 1 hour, 2 = 2 hours, etc.). Default = 10 hours.";
const char *output_file = "(optional) Name of the log file (give it a name that easy for you to remember what the test is). You can leave it blank too, we will take care it for you.";
const char *test_name = "(optional) Name of the test you are doing. We use this as part of the name of the log file.";
+ struct nvme_dev *dev;
struct vtview_save_log_settings cfg = {
.run_time_hrs = 20,
strcpy(path, argv[1]);
}
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- printf("Error parse and open (fd = %d)\n", fd);
- return (fd);
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
+ printf("Error parse and open (err = %d)\n", err);
+ return err;
}
printf("Running...\n");
printf("Running for %lf hour(s)\n", cfg.run_time_hrs);
printf("Logging SMART data for every %lf hour(s)\n", cfg.log_record_frequency_hrs);
- ret = vt_update_vtview_log_header(fd, path, &cfg);
+ ret = vt_update_vtview_log_header(dev->fd, path, &cfg);
if (ret) {
err = EINVAL;
- close(fd);
+ dev_close(dev);
return (err);
}
if(cur_time >= end_time)
break;
- ret = vt_add_entry_to_log(fd, path, &cfg);
+ ret = vt_add_entry_to_log(dev->fd, path, &cfg);
if (ret) {
printf("Cannot update driver log\n");
break;
fflush(stdout);
}
- close (fd);
+ dev_close(dev);
return (err);
}
static int vt_show_identify(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- int err = 0;
- int fd ,ret;
+ int ret, err = 0;
struct nvme_id_ctrl ctrl;
+ struct nvme_dev *dev;
char *desc = "Parse identify data to json format\n\n"
"Typical usages:\n\n"
"virtium show-identify /dev/yourDevice\n";
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
- printf("Error parse and open (fd = %d)\n", fd);
- return (fd);
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0) {
+ printf("Error parse and open (err = %d)\n", err);
+ return err;
}
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
printf("Cannot read identify device\n");
- close (fd);
+ dev_close(dev);
return (-1);
}
vt_process_string(ctrl.mn, sizeof(ctrl.mn));
vt_parse_detail_identify(&ctrl);
- close(fd);
+ dev_close(dev);
return (err);
}
char *desc = "Capture Diagnostics Log.";
char *file = "Output file pathname.";
char *size = "Data retrieval transfer size.";
+ __u64 capabilities = 0;
char f[PATH_MAX] = {0};
+ struct nvme_dev *dev;
__u32 xfer_size = 0;
- int fd, ret = 0;
- __u64 capabilities = 0;
+ int ret = 0;
struct config {
char *file;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
strncpy(f, cfg.file, PATH_MAX - 1);
if (cfg.xfer_size != 0)
xfer_size = cfg.xfer_size;
- ret = wdc_get_serial_name(fd, f, PATH_MAX, "cap_diag");
+ ret = wdc_get_serial_name(dev->fd, f, PATH_MAX, "cap_diag");
if (ret) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
goto out;
strcat(f, ".bin");
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CAP_DIAG) == WDC_DRIVE_CAP_CAP_DIAG)
- ret = wdc_do_cap_diag(r, fd, f, xfer_size, 0, 0);
+ ret = wdc_do_cap_diag(r, dev->fd, f, xfer_size, 0, 0);
else
fprintf(stderr,
"ERROR : WDC: unsupported device for this command\n");
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
char *verbose = "Display more debug messages.";
char f[PATH_MAX] = {0};
char fileSuffix[PATH_MAX] = {0};
+ struct nvme_dev *dev;
nvme_root_t r;
__u32 xfer_size = 0;
- int fd, ret = -1;
int telemetry_type = 0, telemetry_data_area = 0;
UtilsTimeInfo timeInfo;
__u8 timeStamp[MAX_PATH_LEN];
__u64 capabilities = 0;
+ int ret = -1;
struct config {
char *file;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev->fd))
goto out;
if (cfg.xfer_size != 0)
timeInfo.hour, timeInfo.minute, timeInfo.second);
snprintf(fileSuffix, PATH_MAX, "_internal_fw_log_%s", (char*)timeStamp);
- ret = wdc_get_serial_name(fd, f, PATH_MAX, fileSuffix);
+ ret = wdc_get_serial_name(dev->fd, f, PATH_MAX, fileSuffix);
if (ret) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
goto out;
goto out;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_INTERNAL_LOG) == WDC_DRIVE_CAP_INTERNAL_LOG) {
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
- ret = wdc_do_cap_diag(r, fd, f, xfer_size,
+ ret = wdc_do_cap_diag(r, dev->fd, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
}
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(fd, f, xfer_size,
+ ret = wdc_do_cap_telemetry_log(dev->fd, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
} else {
/* FW requirement - xfer size must be 256k for data area 4 */
if (cfg.data_area >= 4)
xfer_size = 0x40000;
- ret = wdc_do_cap_dui(fd, f, xfer_size, cfg.data_area,
+ ret = wdc_do_cap_dui(dev->fd, f, xfer_size, cfg.data_area,
cfg.verbose, cfg.file_size,
cfg.offset);
goto out;
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(fd, f, xfer_size,
+ ret = wdc_do_cap_telemetry_log(dev->fd, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
} else {
- ret = wdc_do_cap_dui(fd, f, xfer_size,
+ ret = wdc_do_cap_dui(dev->fd, f, xfer_size,
WDC_NVME_DUI_MAX_DATA_AREA,
cfg.verbose, 0, 0);
goto out;
}
}
if ((capabilities & WDC_SN730B_CAP_VUC_LOG) == WDC_SN730B_CAP_VUC_LOG)
- ret = wdc_do_sn730_get_and_tar(fd, f);
+ ret = wdc_do_sn730_get_and_tar(dev->fd, f);
else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
const char *desc = "Capture Drive Log.";
const char *file = "Output file pathname.";
char f[PATH_MAX] = {0};
- int fd;
+ struct nvme_dev *dev;
int ret;
nvme_root_t r;
__u64 capabilities = 0;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev->fd)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_LOG) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
if (cfg.file != NULL) {
strncpy(f, cfg.file, PATH_MAX - 1);
}
- ret = wdc_get_serial_name(fd, f, PATH_MAX, "drive_log");
+ ret = wdc_get_serial_name(dev->fd, f, PATH_MAX, "drive_log");
if (ret)
fprintf(stderr, "ERROR : WDC : failed to generate file name\n");
else
- ret = wdc_do_drive_log(fd, f);
+ ret = wdc_do_drive_log(dev->fd, f);
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
{
const char *desc = "Get Crash Dump.";
const char *file = "Output file pathname.";
- int fd, ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
char *file;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev->fd)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CRASH_DUMP) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_crash_dump(fd, cfg.file, WDC_NVME_CRASH_DUMP_TYPE);
+ ret = wdc_crash_dump(dev->fd, cfg.file, WDC_NVME_CRASH_DUMP_TYPE);
if (ret != 0) {
fprintf(stderr, "ERROR : WDC : failed to read crash dump\n");
}
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
{
char *desc = "Get Pfail Crash Dump.";
char *file = "Output file pathname.";
- int fd;
- int ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
struct config {
char *file;
};
+ nvme_root_t r;
+ int ret;
struct config cfg = {
.file = NULL,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev->fd)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_PFAIL_DUMP) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_crash_dump(fd, cfg.file, WDC_NVME_PFAIL_DUMP_TYPE);
+ ret = wdc_crash_dump(dev->fd, cfg.file, WDC_NVME_PFAIL_DUMP_TYPE);
if (ret != 0) {
fprintf(stderr, "ERROR : WDC : failed to read pfail crash dump\n");
}
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct command *command, struct plugin *plugin)
{
const char *desc = "Send a Purge command.";
- char *err_str;
- int fd, ret;
- nvme_root_t r;
struct nvme_passthru_cmd admin_cmd;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ char *err_str;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev->fd)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if((capabilities & WDC_DRIVE_CAP_PURGE) == 0) {
ret = -1;
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
memset(&admin_cmd, 0, sizeof (admin_cmd));
admin_cmd.opcode = WDC_NVME_PURGE_CMD_OPCODE;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (ret > 0) {
switch (ret) {
case WDC_NVME_PURGE_CMD_SEQ_ERR:
nvme_show_status(ret);
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct command *command, struct plugin *plugin)
{
const char *desc = "Send a Purge Monitor command.";
- int fd, ret;
- nvme_root_t r;
__u8 output[WDC_NVME_PURGE_MONITOR_DATA_LEN];
double progress_percent;
struct nvme_passthru_cmd admin_cmd;
struct wdc_nvme_purge_monitor_data *mon;
+ struct nvme_dev *dev;
__u64 capabilities;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev->fd)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if((capabilities & WDC_DRIVE_CAP_PURGE) == 0) {
ret = -1;
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
admin_cmd.cdw10 = WDC_NVME_PURGE_MONITOR_CMD_CDW10;
admin_cmd.timeout_ms = WDC_NVME_PURGE_MONITOR_TIMEOUT;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (ret == 0) {
mon = (struct wdc_nvme_purge_monitor_data *) output;
printf("Purge state = 0x%0x\n", admin_cmd.result);
nvme_show_status(ret);
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
{
const char *desc = "Retrieve additional performance statistics.";
const char *interval = "Interval to read the statistics from [1, 15].";
- int fd;
const char *log_page_version = "Log Page Version: 0 = vendor, 1 = WDC";
const char *log_page_mask = "Log Page Mask, comma separated list: 0xC0, 0xC1, 0xCA, 0xD0";
const char *namespace_id = "desired namespace id";
+ struct nvme_dev *dev;
nvme_root_t r;
int ret = 0;
int uuid_index = 0;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
if (cfg.log_page_version == 0) {
fprintf(stderr, "ERROR : WDC: Unknown log page mask - %s\n", cfg.log_page_mask);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_SMART_LOG_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
if (((capabilities & WDC_DRIVE_CAP_C0_LOG_PAGE) == WDC_DRIVE_CAP_C0_LOG_PAGE) &&
(page_mask & WDC_C0_PAGE_MASK)) {
/* Get 0xC0 log page if possible. */
- ret = wdc_get_c0_log_page(r, fd, cfg.output_format, uuid_index, cfg.namespace_id);
+ ret = wdc_get_c0_log_page(r, dev->fd, cfg.output_format,
+ uuid_index, cfg.namespace_id);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the C0 Log Page, ret = %d\n", ret);
}
if (((capabilities & (WDC_DRIVE_CAP_CA_LOG_PAGE)) == (WDC_DRIVE_CAP_CA_LOG_PAGE)) &&
(page_mask & WDC_CA_PAGE_MASK)) {
/* Get the CA Log Page */
- ret = wdc_get_ca_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_ca_log_page(r, dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the CA Log Page, ret = %d\n", ret);
}
if (((capabilities & WDC_DRIVE_CAP_C1_LOG_PAGE) == WDC_DRIVE_CAP_C1_LOG_PAGE) &&
(page_mask & WDC_C1_PAGE_MASK)) {
/* Get the C1 Log Page */
- ret = wdc_get_c1_log_page(r, fd, cfg.output_format, cfg.interval);
+ ret = wdc_get_c1_log_page(r, dev->fd, cfg.output_format,
+ cfg.interval);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the C1 Log Page, ret = %d\n", ret);
}
if (((capabilities & WDC_DRIVE_CAP_D0_LOG_PAGE) == WDC_DRIVE_CAP_D0_LOG_PAGE) &&
(page_mask & WDC_D0_PAGE_MASK)) {
/* Get the D0 Log Page */
- ret = wdc_get_d0_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_d0_log_page(r, dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the D0 Log Page, ret = %d\n", ret);
}
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
{
const char *desc = "Retrieve Cloud Log Smart/Health Information";
const char *namespace_id = "desired namespace id";
- int fd;
- nvme_root_t r;
- int ret = 0;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ int ret, fmt = -1;
+ nvme_root_t r;
__u8 *data;
- int fmt = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CLOUD_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
}
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, cfg.namespace_id);
if (strcmp(cfg.output_format, "json"))
nvme_show_status(ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
{
const char *desc = "Retrieve Hardware Revision Log Information";
const char *namespace_id = "desired namespace id";
- int fd;
- nvme_root_t r;
- int ret = 0;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ int ret, fmt = -1;
__u8 *data = NULL;
- int fmt = -1;
+ nvme_root_t r;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_HW_REV_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = nvme_get_hw_rev_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_hw_rev_log(dev->fd, &data, 0, cfg.namespace_id);
if (strcmp(cfg.output_format, "json"))
nvme_show_status(ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
const char *desc = "Retrieve Device Write Amplication Factor";
const char *namespace_id = "desired namespace id";
struct nvme_smart_log smart_log;
+ struct nvme_dev *dev;
__u8 *data;
- int fd;
nvme_root_t r;
int ret = 0;
int fmt = -1;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_DEVICE_WAF) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
}
/* get data units written from the smart log page */
- ret = nvme_get_log_smart(fd, cfg.namespace_id, false, &smart_log);
+ ret = nvme_get_log_smart(dev->fd, cfg.namespace_id, false, &smart_log);
if (!ret) {
data_units_written = int128_to_double(smart_log.data_units_written);
}
/* get Physical Media Units Written from extended smart/C0 log page */
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, cfg.namespace_id);
if (ret == 0) {
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve latency monitor log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_C3_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_c3_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_c3_log_page(r, dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Latency Monitor (C3) Log Page, ret = %d\n", ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve error recovery log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_OCP_C1_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_ocp_c1_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_ocp_c1_log_page(r, dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Error Recovery (C1) Log Page, ret = 0x%x\n", ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve device capabilities log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_OCP_C4_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_ocp_c4_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_ocp_c4_log_page(r, dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Device Capabilities (C4) Log Page, ret = 0x%x\n", ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve unsupported requirements log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_OCP_C5_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_ocp_c5_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_ocp_c5_log_page(r, dev->fd, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Unsupported Requirements (C5) Log Page, ret = 0x%x\n", ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
char *desc = "Clear PCIE Correctable Errors.";
- int fd, ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev->fd)) {
ret = -1;
goto out;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CLEAR_PCIE_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
if (capabilities & WDC_DRIVE_CAP_CLEAR_PCIE) {
- ret = wdc_do_clear_pcie_correctable_errors(fd);
+ ret = wdc_do_clear_pcie_correctable_errors(dev->fd);
}
else if (capabilities & WDC_DRIVE_CAP_VUC_CLEAR_PCIE) {
- ret = wdc_do_clear_pcie_correctable_errors_vuc(fd);
+ ret = wdc_do_clear_pcie_correctable_errors_vuc(dev->fd);
}
else {
- ret = wdc_do_clear_pcie_correctable_errors_fid(fd);
+ ret = wdc_do_clear_pcie_correctable_errors_fid(dev->fd);
}
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
char *desc = "Get Drive Status.";
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
nvme_root_t r;
__le32 system_eol_state;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_STATUS) != WDC_DRIVE_CAP_DRIVE_STATUS) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
/* verify the 0xC2 Device Manageability log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev->fd,
+ WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE) == false) {
fprintf(stderr, "ERROR : WDC : 0xC2 Log Page not supported\n");
ret = -1;
goto out;
}
/* Get the assert dump present status */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &assert_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &assert_status,
WDC_C2_ASSERT_DUMP_PRESENT_ID))
fprintf(stderr, "ERROR : WDC : Get Assert Status Failed\n");
/* Get the thermal throttling status */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &thermal_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &thermal_status,
WDC_C2_THERMAL_THROTTLE_STATUS_ID))
fprintf(stderr, "ERROR : WDC : Get Thermal Throttling Status Failed\n");
/* Get EOL status */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &eol_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &eol_status,
WDC_C2_USER_EOL_STATUS_ID)) {
fprintf(stderr, "ERROR : WDC : Get User EOL Status Failed\n");
eol_status = cpu_to_le32(-1);
}
/* Get Customer EOL state */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &user_eol_state,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &user_eol_state,
WDC_C2_USER_EOL_STATE_ID))
fprintf(stderr, "ERROR : WDC : Get User EOL State Failed\n");
/* Get System EOL state*/
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &system_eol_state,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &system_eol_state,
WDC_C2_SYSTEM_EOL_STATE_ID))
fprintf(stderr, "ERROR : WDC : Get System EOL State Failed\n");
/* Get format corrupt reason*/
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &format_corrupt_reason,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &format_corrupt_reason,
WDC_C2_FORMAT_CORRUPT_REASON_ID))
fprintf(stderr, "ERROR : WDC : Get Format Corrupt Reason Failed\n");
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
char *desc = "Clear Assert Dump Present Status.";
- int fd;
+ struct nvme_dev *dev;
int ret = -1;
nvme_root_t r;
__le32 assert_status = cpu_to_le32(0xFFFFFFFF);
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CLEAR_ASSERT) != WDC_DRIVE_CAP_CLEAR_ASSERT) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
goto out;
}
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &assert_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &assert_status,
WDC_C2_ASSERT_DUMP_PRESENT_ID)) {
fprintf(stderr, "ERROR : WDC : Get Assert Status Failed\n");
ret = -1;
admin_cmd.cdw12 = ((WDC_NVME_CLEAR_ASSERT_DUMP_SUBCMD << WDC_NVME_SUBCMD_SHIFT) |
WDC_NVME_CLEAR_ASSERT_DUMP_CMD);
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
nvme_show_status(ret);
} else
fprintf(stderr, "INFO : WDC : No Assert Dump Present\n");
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
static int wdc_vs_fw_activate_history(int argc, char **argv, struct command *command,
struct plugin *plugin)
{
- int fd;
- int ret = 0;
- nvme_root_t r;
- __u64 capabilities = 0;
const char *desc = "Retrieve FW activate history table.";
-
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
-
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_FW_ACTIVATE_HISTORY_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
.nsid = 0xFFFFFFFF,
.lpo = 0,
free(data);
if (c0GuidMatch) {
- ret = wdc_get_fw_act_history_C2(r, fd,
+ ret = wdc_get_fw_act_history_C2(r, dev->fd,
cfg.output_format);
}
else {
- ret = wdc_get_fw_act_history(r, fd, cfg.output_format);
+ ret = wdc_get_fw_act_history(r, dev->fd,
+ cfg.output_format);
}
} else {
- ret = wdc_get_fw_act_history_C2(r, fd, cfg.output_format);
+ ret = wdc_get_fw_act_history_C2(r, dev->fd, cfg.output_format);
}
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the FW Activate History, ret = %d\n", ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
char *desc = "Clear FW activate history table.";
- int fd;
- int ret = -1;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
if (capabilities & WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY)
- ret = wdc_do_clear_fw_activate_history_vuc(fd);
+ ret = wdc_do_clear_fw_activate_history_vuc(dev->fd);
else
- ret = wdc_do_clear_fw_activate_history_fid(fd);
+ ret = wdc_do_clear_fw_activate_history_fid(dev->fd);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
char *disable = "Disable controller option of the telemetry log page.";
char *enable = "Enable controller option of the telemetry log page.";
char *status = "Displays the current state of the controller initiated log page.";
- int fd;
- int ret = -1;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
__u32 result;
+ int ret = -1;
struct config {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRVIE_CAP_DISABLE_CTLR_TELE_LOG) != WDC_DRVIE_CAP_DISABLE_CTLR_TELE_LOG) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
if (cfg.disable) {
- ret = nvme_set_features_simple(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0, 1,
- false, &result);
+ ret = nvme_set_features_simple(dev->fd,
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, 1, false, &result);
- wdc_clear_reason_id(fd);
+ wdc_clear_reason_id(dev->fd);
}
else {
if (cfg.enable) {
- ret = nvme_set_features_simple(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0, 0,
- false, &result);
+ ret = nvme_set_features_simple(dev->fd,
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, 0, false, &result);
}
else if (cfg.status) {
- ret = nvme_get_features_simple(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0,
- &result);
+ ret = nvme_get_features_simple(dev->fd,
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, &result);
if (ret == 0) {
if (result)
fprintf(stderr, "Controller Option Telemetry Log Page State: Disabled\n");
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
char *dirName = "Output directory pathname.";
char d[PATH_MAX] = {0};
char k[PATH_MAX] = {0};
- char *d_ptr;
- int fd, ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ char *d_ptr;
+ int ret;
struct config {
char *dirName;
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_ESSENTIALS) != WDC_DRIVE_CAP_DRIVE_ESSENTIALS) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
d_ptr = NULL;
}
- ret = wdc_do_drive_essentials(r, fd, d_ptr, k);
+ ret = wdc_do_drive_essentials(r, dev->fd, d_ptr, k);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
{
const char *desc = "Send a Resize command.";
const char *size = "The new size (in GB) to resize the drive to.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
uint64_t size;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_RESIZE) == WDC_DRIVE_CAP_RESIZE) {
- ret = wdc_do_drive_resize(fd, cfg.size);
+ ret = wdc_do_drive_resize(dev->fd, cfg.size);
} else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
const char *desc = "Send a Namespace Resize command.";
const char *namespace_id = "The namespace id to resize.";
const char *op_option = "The over provisioning option to set for namespace.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
__u32 namespace_id;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
if ((cfg.op_option != 0x1) &&
(cfg.op_option != 0x2) &&
(cfg.op_option != 0xF))
{
fprintf(stderr, "ERROR : WDC: unsupported OP option parameter\n");
- close(fd);
+ dev_close(dev);
return -1;
}
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_NS_RESIZE) == WDC_DRIVE_CAP_NS_RESIZE) {
- ret = wdc_do_namespace_resize(fd, cfg.namespace_id, cfg.op_option);
+ ret = wdc_do_namespace_resize(dev->fd, cfg.namespace_id,
+ cfg.op_option);
if (ret != 0)
printf("ERROR : WDC: Namespace Resize of namespace id 0x%x, op option 0x%x failed\n", cfg.namespace_id, cfg.op_option);
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
const char *desc = "Retrieve telemetry log reason identifier.";
const char *log_id = "Log ID to retrieve - host - 7 or controller - 8";
const char *fname = "File name to save raw binary identifier";
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret;
uint64_t capabilities = 0;
char f[PATH_MAX] = {0};
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
else
snprintf(fileSuffix, PATH_MAX, "_error_reason_identifier_host_%s", (char*)timeStamp);
- if (wdc_get_serial_name(fd, f, PATH_MAX, fileSuffix) == -1) {
+ if (wdc_get_serial_name(dev->fd, f, PATH_MAX, fileSuffix) == -1) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
ret = -1;
goto close_fd;
fprintf(stderr, "%s: filename = %s\n", __func__, f);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_REASON_ID) == WDC_DRIVE_CAP_REASON_ID) {
- ret = wdc_do_get_reason_id(fd, f, cfg.log_id);
+ ret = wdc_do_get_reason_id(dev->fd, f, cfg.log_id);
} else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
nvme_show_status(ret);
close_fd:
- close(fd);
+ dev_close(dev);
nvme_free_tree(r);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve Log Page Directory.";
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
nvme_root_t r;
__u64 capabilities = 0;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
ret = validate_output_format(cfg.output_format);
if (ret < 0) {
fprintf(stderr, "%s: ERROR : WDC : invalid output format\n", __func__);
- close(fd);
+ dev_close(dev);
return ret;
}
ret = 0;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_LOG_PAGE_DIR) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
log_id = (device_id == WDC_NVME_ZN350_DEV_ID || device_id == WDC_NVME_ZN350_DEV_ID_1) ?
WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE_C8 : WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE;
/* verify the 0xC2 Device Manageability log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, log_id) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev->fd, log_id) == false) {
fprintf(stderr, "%s: ERROR : WDC : 0x%x Log Page not supported\n", __func__, log_id);
ret = -1;
goto out;
}
- if (get_dev_mgment_cbs_data(r, fd, WDC_C2_LOG_PAGES_SUPPORTED_ID, (void *)&cbs_data)) {
+ if (get_dev_mgment_cbs_data(r, dev->fd, WDC_C2_LOG_PAGES_SUPPORTED_ID, (void *)&cbs_data)) {
if (cbs_data != NULL) {
printf("Log Page Directory\n");
/* print the supported pages */
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve NAND statistics.";
-
- int fd;
- int ret = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
__u64 capabilities = 0;
uint32_t read_device_id = 0, read_vendor_id = 0;
+ int ret;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_NAND_STATS) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
switch (read_device_id) {
case WDC_NVME_SN820CL_DEV_ID:
- ret = wdc_do_vs_nand_stats_sn810_2(fd, cfg.output_format);
+ ret = wdc_do_vs_nand_stats_sn810_2(dev->fd,
+ cfg.output_format);
break;
default:
- ret = wdc_do_vs_nand_stats(fd, cfg.output_format);
+ ret = wdc_do_vs_nand_stats(dev->fd, cfg.output_format);
break;
}
}
fprintf(stderr, "ERROR : WDC : Failure reading NAND statistics, ret = %d\n", ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct plugin *plugin)
{
const char *desc = "Retrieve PCIE statistics.";
-
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
nvme_root_t r;
__u64 capabilities = 0;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
memset((void *)pcieStatsPtr, 0, pcie_stats_size);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_PCIE_STATS) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_do_vs_pcie_stats(fd, pcieStatsPtr);
+ ret = wdc_do_vs_pcie_stats(dev->fd, pcieStatsPtr);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading PCIE statistics, ret = 0x%x\n", ret);
else {
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
const char *desc = "Send a vs-drive-info command.";
nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret;
+ struct nvme_dev *dev;
+ int ret;
__le32 result;
__u16 size;
double rev;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
fmt = validate_output_format(cfg.output_format);
if (fmt < 0) {
fprintf(stderr, "ERROR : WDC %s invalid output format\n", __func__);
- close(fd);
+ dev_close(dev);
return fmt;
}
/* get the id ctrl data used to fill in drive info below */
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC %s: Identify Controller failed\n", __func__);
- close(fd);
+ dev_close(dev);
return ret;
}
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_INFO) == WDC_DRIVE_CAP_INFO) {
ret = wdc_get_pci_ids(r, &read_device_id, &read_vendor_id);
if (ret < 0)
case WDC_NVME_SN550_DEV_ID:
case WDC_NVME_ZN350_DEV_ID:
case WDC_NVME_ZN350_DEV_ID_1:
- ret = wdc_do_drive_info(fd, &result);
+ ret = wdc_do_drive_info(dev->fd, &result);
if (!ret) {
size = (__u16)((cpu_to_le32(result) & 0xffff0000) >> 16);
break;
case WDC_NVME_SN820CL_DEV_ID:
/* Get the Drive HW Rev from the C6 Log page */
- ret = nvme_get_hw_rev_log(fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_hw_rev_log(dev->fd, &data, 0,
+ NVME_NSID_ALL);
if (ret == 0) {
wdc_nvme_hw_rev_log *log_data = (wdc_nvme_hw_rev_log *)data;
major_rev = log_data->hw_rev_gdr;
goto out;
}
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, NVME_NSID_ALL);
if (ret == 0) {
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
out:
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
const char *desc = "Send a vs-temperature-stats command.";
struct nvme_smart_log smart_log;
struct nvme_id_ctrl id_ctrl;
+ struct nvme_dev *dev;
nvme_root_t r;
uint64_t capabilities = 0;
__u32 hctm_tmt;
- int fd, ret;
int temperature, temp_tmt1, temp_tmt2;
- int fmt = -1;
+ int ret, fmt = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
r = nvme_scan(NULL);
fmt = validate_output_format(cfg.output_format);
}
/* check if command is supported */
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_TEMP_STATS) != WDC_DRIVE_CAP_TEMP_STATS) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
/* get the temperature stats or report errors */
- ret = nvme_identify_ctrl(fd, &id_ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &id_ctrl);
if (ret != 0)
goto out;
- ret = nvme_get_log_smart(fd, NVME_NSID_ALL, false, &smart_log);
+ ret = nvme_get_log_smart(dev->fd, NVME_NSID_ALL, false, &smart_log);
if (ret != 0)
goto out;
temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]) - 273;
/* retrieve HCTM Thermal Management Temperatures */
- nvme_get_features_simple(fd, 0x10, 0, &hctm_tmt);
+ nvme_get_features_simple(dev->fd, 0x10, 0, &hctm_tmt);
temp_tmt1 = ((hctm_tmt >> 16) & 0xffff) ? ((hctm_tmt >> 16) & 0xffff) - 273 : 0;
temp_tmt2 = (hctm_tmt & 0xffff) ? (hctm_tmt & 0xffff) - 273 : 0;
out:
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
struct command *command, struct plugin *plugin)
{
const char *desc = "Send a capabilities command.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) =
{
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
/* print command and supported status */
printf("WDC Plugin Capabilities for NVME device:%s\n", nvme_dev->name);
capabilities & WDC_DRIVE_CAP_DEVICE_WAF ? "Supported" : "Not Supported");
printf("capabilities : Supported\n");
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return 0;
}
struct command *command, struct plugin *plugin)
{
const char *desc = "Get Cloud SSD Plugin Version command.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CLOUD_SSD_VERSION) == WDC_DRIVE_CAP_CLOUD_SSD_VERSION) {
/* print command and supported status */
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return 0;
}
const char *namespace_id = "desired namespace id";
nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret = -1;
+ struct nvme_dev *dev;
+ int ret;
int major = 0, minor = 0;
__u8 *data = NULL;
wdc_nvme_ext_smart_log *ext_smart_log_ptr = NULL;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret < 0)
+ return ret;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev->fd);
if ((capabilities & WDC_DRIVE_CAP_CLOUD_BOOT_SSD_VERSION) == WDC_DRIVE_CAP_CLOUD_BOOT_SSD_VERSION) {
/* Get the 0xC0 Smart Cloud Attribute V1 log data */
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0,
+ cfg.namespace_id);
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
if (ret == 0) {
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
char *file = "Output file pathname.";
char *size = "Data retrieval transfer size.";
char *log = "Enclosure Log Page ID.";
+ struct nvme_dev *dev;
FILE *output_fd;
int xfer_size = 0;
- int fd;
int len;
int err = 0;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
- }
- if (!wdc_enc_check_model(fd)) {
+ if (!wdc_enc_check_model(dev->fd)) {
err = -EINVAL;
goto closed_fd;
}
if (cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_1 || cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_2
|| cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_3 || cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_4) {
fprintf(stderr, "args - sz:%x logid:%x of:%s\n",xfer_size,cfg.log_id,cfg.file);
- err = wdc_enc_get_nic_log(fd, cfg.log_id, xfer_size, WDC_NVME_ENC_NIC_LOG_SIZE, output_fd);
+ err = wdc_enc_get_nic_log(dev->fd, cfg.log_id,
+ xfer_size,
+ WDC_NVME_ENC_NIC_LOG_SIZE,
+ output_fd);
} else {
fprintf(stderr, "args - sz:%x logid:%x of:%s\n",xfer_size,cfg.log_id,cfg.file);
- err = wdc_enc_submit_move_data(fd, NULL, 0, xfer_size, output_fd, cfg.log_id, 0, 0);
+ err = wdc_enc_submit_move_data(dev->fd, NULL, 0,
+ xfer_size, output_fd,
+ cfg.log_id, 0, 0);
}
if (err == WDC_RESULT_NOT_AVAILABLE) {
}
}
closed_fd:
- close(fd);
+ dev_close(dev);
ret:
return err;
}
static int get_additional_smart_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct nvme_ymtc_smart_log smart_log;
- int err, fd;
char *desc = "Get Ymtc vendor specific additional smart log (optionally, "\
"for the specified namespace), and show it.";
const char *namespace = "(optional) desired namespace";
const char *raw = "dump output in binary format";
+ struct nvme_dev *dev;
struct config {
__u32 namespace_id;
bool raw_binary;
};
+ int err;
struct config cfg = {
.namespace_id = NVME_NSID_ALL,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
+ return err;
- err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
- err = show_ymtc_smart_log(fd, cfg.namespace_id, nvme_dev->name, &smart_log);
+ err = show_ymtc_smart_log(dev->fd, cfg.namespace_id, nvme_dev->name, &smart_log);
else
d_raw((unsigned char *)&smart_log, sizeof(smart_log));
}
if (err > 0)
nvme_show_status(err);
- close(fd);
+ dev_close(dev);
return err;
}
enum nvme_print_flags flags;
struct nvme_zns_id_ctrl ctrl;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
err = flags = validate_output_format(cfg.output_format);
if (flags < 0)
goto close_fd;
- err = nvme_zns_identify_ctrl(fd, &ctrl);
+ err = nvme_zns_identify_ctrl(dev->fd, &ctrl);
if (!err)
nvme_show_zns_id_ctrl(&ctrl, flags);
else if (err > 0)
else
perror("zns identify controller");
close_fd:
- close(fd);
+ dev_close(dev);
return err;
}
enum nvme_print_flags flags;
struct nvme_zns_id_ns ns;
struct nvme_id_ns id_ns;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
flags = validate_output_format(cfg.output_format);
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_fd;
}
}
- err = nvme_identify_ns(fd, cfg.namespace_id, &id_ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &id_ns);
if (err) {
nvme_show_status(err);
goto close_fd;
}
- err = nvme_zns_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_zns_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (!err)
nvme_show_zns_id_ns(&ns, &id_ns, flags);
else if (err > 0)
else
perror("zns identify namespace");
close_fd:
- close(fd);
+ dev_close(dev);
return err;
}
const char *zslba = "starting LBA of the zone for this command";
const char *select_all = "send command to all zones";
const char *timeout = "timeout value, in milliseconds";
-
- int err, fd, zcapc = 0;
+ struct nvme_dev *dev;
+ int err, zcapc = 0;
char *command;
__u32 result;
OPT_END()
};
- err = fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
goto ret;
err = asprintf(&command, "%s-%s", plugin->name, cmd->name);
if (err < 0)
- goto close_fd;
+ goto close_dev;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto free;
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = zsa,
perror(desc);
free:
free(command);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
ret:
return err;
}
const char *data = "optional file for data (default stdin)";
const char *timeout = "timeout value, in milliseconds";
- int fd, ffd = STDIN_FILENO, err = -1;
+ int ffd = STDIN_FILENO, err = -1;
+ struct nvme_dev *dev;
void *buf = NULL;
struct config {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
if (!cfg.zsa) {
fprintf(stderr, "zone send action must be specified\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.zsa == NVME_ZNS_ZSA_SET_DESC_EXT) {
if(!cfg.data_len) {
- int data_len = get_zdes_bytes(fd, cfg.namespace_id);
+ int data_len = get_zdes_bytes(dev->fd, cfg.namespace_id);
if (data_len == 0) {
fprintf(stderr,
"Zone Descriptor Extensions are not supported\n");
- goto close_fd;
+ goto close_dev;
} else if (data_len < 0) {
err = data_len;
- goto close_fd;
+ goto close_dev;
}
cfg.data_len = data_len;
}
if (posix_memalign(&buf, getpagesize(), cfg.data_len)) {
fprintf(stderr, "can not allocate feature payload\n");
- goto close_fd;
+ goto close_dev;
}
memset(buf, 0, cfg.data_len);
fprintf(stderr,
"data, data_len only valid with set extended descriptor\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = cfg.zsa,
close(ffd);
free:
free(buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
const char *zrwaa = "Allocate Zone Random Write Area to zone";
const char *select_all = "send command to all zones";
const char *timeout = "timeout value, in milliseconds";
-
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u64 zslba;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = NVME_ZNS_ZSA_OPEN,
(uint64_t)cfg.zslba, cfg.namespace_id);
else
nvme_show_status(err);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
const char *data = "optional file for zone extention data (default stdin)";
const char *timeout = "timeout value, in milliseconds";
- int fd, ffd = STDIN_FILENO, err;
+ int ffd = STDIN_FILENO, err;
+ struct nvme_dev *dev;
void *buf = NULL;
int data_len;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
- data_len = get_zdes_bytes(fd, cfg.namespace_id);
+ data_len = get_zdes_bytes(dev->fd, cfg.namespace_id);
if (!data_len || data_len < 0) {
fprintf(stderr,
"zone format does not provide descriptor extention\n");
errno = EINVAL;
err = -1;
- goto close_fd;
+ goto close_dev;
}
buf = calloc(1, data_len);
if (!buf) {
perror("could not alloc memory for zone desc");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
if (cfg.file) {
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = NVME_ZNS_ZSA_SET_DESC_EXT,
close(ffd);
free:
free(buf);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
const char *desc = "Flush Explicit ZRWA Range";
const char *slba = "LBA to flush up to";
const char *timeout = "timeout value, in milliseconds";
-
- int err, fd;
+ struct nvme_dev *dev;
+ int err;
struct config {
__u64 lba;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.lba,
.zsa = NVME_ZNS_ZSA_ZRWA_FLUSH,
(uint64_t)cfg.lba, cfg.namespace_id);
else
nvme_show_status(err);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
const char *data_len = "length of data in bytes";
enum nvme_print_flags flags;
- int fd, err = -1;
+ struct nvme_dev *dev;
void *data = NULL;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.zra == NVME_ZNS_ZRA_REPORT_ZONES && !cfg.data_len) {
fprintf(stderr, "error: data len is needed for NVME_ZRA_ZONE_REPORT\n");
err = -EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.data_len) {
data = calloc(1, cfg.data_len);
if (!data) {
perror("could not alloc memory for zone mgmt receive data");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_zns_mgmt_recv_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zra = cfg.zra,
perror("zns zone-mgmt-recv");
free(data);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
const char *verbose = "show report zones verbosity";
enum nvme_print_flags flags;
- int fd, zdes = 0, err = -1;
+ int zdes = 0, err = -1;
+ struct nvme_dev *dev;
__u32 report_size;
void *report;
bool huge = false;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
flags = validate_output_format(cfg.output_format);
if (flags < 0)
- goto close_fd;
+ goto close_dev;
if (cfg.verbose)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
if (cfg.extended) {
- zdes = get_zdes_bytes(fd, cfg.namespace_id);
+ zdes = get_zdes_bytes(dev->fd, cfg.namespace_id);
if (zdes < 0) {
err = zdes;
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_ns(fd, cfg.namespace_id, &id_ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &id_ns);
if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
- err = nvme_zns_identify_ns(fd, cfg.namespace_id, &id_zns);
+ err = nvme_zns_identify_ns(dev->fd, cfg.namespace_id, &id_zns);
if (!err) {
/* get zsze field from zns id ns data - needed for offset calculation */
nvme_id_ns_flbas_to_lbaf_inuse(id_ns.flbas, &lbaf);
}
else {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
log_len = sizeof(struct nvme_zone_report);
buff = calloc(1, log_len);
if (!buff) {
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
- err = nvme_zns_report_zones(fd, cfg.namespace_id, 0,
+ err = nvme_zns_report_zones(dev->fd, cfg.namespace_id, 0,
cfg.state, false, false,
log_len, buff,
NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
if (!report) {
perror("alloc");
err = -ENOMEM;
- goto close_fd;
+ goto close_dev;
}
offset = cfg.zslba;
log_len = sizeof(struct nvme_zone_report) + ((sizeof(struct nvme_zns_desc) * nr_zones_chunks) + (nr_zones_chunks * zdes));
}
- err = nvme_zns_report_zones(fd, cfg.namespace_id, offset,
+ err = nvme_zns_report_zones(dev->fd, cfg.namespace_id, offset,
cfg.state, cfg.extended,
cfg.partial, log_len, report,
NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
free_buff:
free(buff);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
const char *data_size = "size of data in bytes";
const char *latency = "output latency statistics";
- int err = -1, fd, dfd = STDIN_FILENO, mfd = STDIN_FILENO;
+ int err = -1, dfd = STDIN_FILENO, mfd = STDIN_FILENO;
unsigned int lba_size, meta_size;
void *buf = NULL, *mbuf = NULL;
__u16 nblocks, control = 0;
+ struct nvme_dev *dev;
__u64 result;
__u8 lba_index;
struct timeval start_time, end_time;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
if (!cfg.data_size) {
fprintf(stderr, "Append size not provided\n");
errno = EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
- goto close_fd;
+ goto close_dev;
}
}
- err = nvme_identify_ns(fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
- goto close_fd;
+ goto close_dev;
}
nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &lba_index);
"Data size:%#"PRIx64" not aligned to lba size:%#x\n",
(uint64_t)cfg.data_size, lba_size);
errno = EINVAL;
- goto close_fd;
+ goto close_dev;
}
meta_size = ns.lbaf[lba_index].ms;
"Metadata size:%#"PRIx64" not aligned to metadata size:%#x\n",
(uint64_t)cfg.metadata_size, meta_size);
errno = EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.prinfo > 0xf) {
fprintf(stderr, "Invalid value for prinfo:%#x\n", cfg.prinfo);
errno = EINVAL;
- goto close_fd;
+ goto close_dev;
}
if (cfg.data) {
dfd = open(cfg.data, O_RDONLY);
if (dfd < 0) {
perror(cfg.data);
- goto close_fd;
+ goto close_dev;
}
}
struct nvme_zns_append_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.nsid = cfg.namespace_id,
.zslba = cfg.zslba,
.nlb = nblocks,
close_dfd:
if (cfg.data)
close(dfd);
-close_fd:
- close(fd);
+close_dev:
+ dev_close(dev);
return err;
}
struct nvme_zns_changed_zone_log log;
enum nvme_print_flags flags;
- int fd, err = -1;
+ struct nvme_dev *dev;
+ int err = -1;
struct config {
char *output_format;
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err < 0)
return errno;
flags = validate_output_format(cfg.output_format);
goto close_fd;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_fd;
}
}
- err = nvme_get_log_zns_changed_zones(fd, cfg.namespace_id, cfg.rae, &log);
+ err = nvme_get_log_zns_changed_zones(dev->fd, cfg.namespace_id,
+ cfg.rae, &log);
if (!err)
nvme_show_zns_changed(&log, flags);
else if (err > 0)
perror("zns changed-zone-list");
close_fd:
- close(fd);
+ dev_close(dev);
return err;
}
projects / users / sagi / nvme-cli.git / commitdiff