return err;
/* before parsing commands, check if controller supports any RPMB targets */
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err)
goto out;
switch (cfg.opt) {
case RPMB_REQ_READ_WRITE_CNTR:
- err = rpmb_read_write_counter(dev->fd, cfg.target,
+ err = rpmb_read_write_counter(dev_fd(dev), 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(dev->fd, &msg_buf);
+ write_cntr = rpmb_read_config_block(dev_fd(dev),
+ &msg_buf);
if (msg_buf == NULL) {
fprintf(stderr, "failed read config blk\n");
goto out;
msg_size);
break;
}
- err = rpmb_auth_data_read(dev->fd, cfg.target,
+ err = rpmb_auth_data_read(dev_fd(dev), cfg.target,
cfg.address, &msg_buf,
cfg.blocks,
(regs.access_size + 1));
} else if ((cfg.blocks * 512) < msg_size) {
msg_size = cfg.blocks * 512;
}
- err = rpmb_auth_data_write(dev->fd, cfg.target,
+ err = rpmb_auth_data_write(dev_fd(dev), cfg.target,
cfg.address,
((regs.access_size + 1) * 512),
msg_buf, msg_size,
break;
case RPMB_REQ_AUTH_DCB_WRITE:
- err = rpmb_write_config_block(dev->fd, msg_buf,
+ err = rpmb_write_config_block(dev_fd(dev), msg_buf,
key_buf, key_size);
break;
case RPMB_REQ_AUTH_KEY_PROGRAM:
- err = rpmb_program_auth_key(dev->fd, cfg.target,
+ err = rpmb_program_auth_key(dev_fd(dev), cfg.target,
key_buf, key_size);
break;
default:
dev = calloc(1, sizeof(*dev));
if (!dev)
return -1;
-
dev->name = basename(devstr);
err = open(devstr, flags);
if (err < 0) {
}
dev->fd = err;
- err = fstat(dev->fd, &dev->stat);
+ err = fstat(dev_fd(dev), &dev->stat);
if (err < 0) {
perror(devstr);
goto err_close;
return 0;
err_close:
- close(dev->fd);
+ close(dev_fd(dev));
err_free:
free(dev);
return err;
void dev_close(struct nvme_dev *dev)
{
- close(dev->fd);
+ close(dev_fd(dev));
free(dev);
}
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_smart(dev->fd, cfg.namespace_id, false, &smart_log);
+ err = nvme_get_log_smart(dev_fd(dev), cfg.namespace_id, false,
+ &smart_log);
if (!err)
nvme_show_smart_log(&smart_log, cfg.namespace_id,
dev->name, flags);
if (flags < 0)
goto close_fd;
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &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(dev->fd, lsp, true, 0, ana_log_len, ana_log);
+ err = nvme_get_log_ana(dev_fd(dev), lsp, true, 0, ana_log_len,
+ ana_log);
if (!err) {
nvme_show_ana_log(ana_log, dev->name, flags, ana_log_len);
} else if (err > 0)
}
if (cfg.ctrl_init)
- err = nvme_get_ctrl_telemetry(dev->fd, true, &log,
+ err = nvme_get_ctrl_telemetry(dev_fd(dev), true, &log,
cfg.data_area, &total_size);
else if (cfg.host_gen)
- err = nvme_get_new_host_telemetry(dev->fd, &log,
+ err = nvme_get_new_host_telemetry(dev_fd(dev), &log,
cfg.data_area, &total_size);
else
- err = nvme_get_host_telemetry(dev->fd, &log,
+ err = nvme_get_host_telemetry(dev_fd(dev), &log,
cfg.data_area, &total_size);
if (err < 0) {
if (flags < 0)
goto close_dev;
- err = nvme_get_log_endurance_group(dev->fd, cfg.group_id,
+ err = nvme_get_log_endurance_group(dev_fd(dev), cfg.group_id,
&endurance_log);
if (!err)
nvme_show_endurance_log(&endurance_log, cfg.group_id,
other_command_sets_supported = NVME_CAP_CSS(cap) & NVME_CAP_CSS_CSI;
if (nvme_command_set_supported)
- err = collect_effects_log(dev->fd, NVME_CSI_NVM,
+ err = collect_effects_log(dev_fd(dev), NVME_CSI_NVM,
&log_pages, flags);
if (!err && other_command_sets_supported)
- err = collect_effects_log(dev->fd, NVME_CSI_ZNS,
+ err = collect_effects_log(dev_fd(dev), NVME_CSI_ZNS,
&log_pages, flags);
} else {
- err = collect_effects_log(dev->fd, cfg.csi, &log_pages, flags);
+ err = collect_effects_log(dev_fd(dev), cfg.csi, &log_pages,
+ flags);
}
if (!err)
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_get_log_supported_log_pages(dev->fd, false, &supports);
+ err = nvme_get_log_supported_log_pages(dev_fd(dev), false, &supports);
if (!err)
nvme_show_supported_log(&supports, dev->name, flags);
else if (err > 0)
goto close_dev;
}
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err < 0) {
perror("identify controller");
goto close_dev;
goto close_dev;
}
- err = nvme_get_log_error(dev->fd, cfg.log_entries, false, err_log);
+ err = nvme_get_log_error(dev_fd(dev), cfg.log_entries, false, err_log);
if (!err)
nvme_show_error_log(err_log, cfg.log_entries,
dev->name, flags);
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_fw_slot(dev->fd, false, &fw_log);
+ err = nvme_get_log_fw_slot(dev_fd(dev), false, &fw_log);
if (!err)
nvme_show_fw_log(&fw_log, dev->name, flags);
else if (err > 0)
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_changed_ns_list(dev->fd, true, &changed_ns_list_log);
+ err = nvme_get_log_changed_ns_list(dev_fd(dev), true,
+ &changed_ns_list_log);
if (!err)
nvme_show_changed_ns_list_log(&changed_ns_list_log,
dev->name, flags);
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_predictable_lat_nvmset(dev->fd, cfg.nvmset_id,
+ err = nvme_get_log_predictable_lat_nvmset(dev_fd(dev), cfg.nvmset_id,
&plpns_log);
if (!err)
nvme_show_predictable_latency_per_nvmset(&plpns_log,
goto close_dev;
}
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err < 0) {
fprintf(stderr, "identify controller: %s\n",
nvme_strerror(errno));
goto close_dev;
}
- err = nvme_get_log_predictable_lat_event(dev->fd, cfg.rae, 0, log_size,
- pea_log);
+ err = nvme_get_log_predictable_lat_event(dev_fd(dev), cfg.rae, 0,
+ log_size, pea_log);
if (!err)
nvme_show_predictable_latency_event_agg_log(pea_log, cfg.log_entries,
log_size, dev->name, flags);
goto close_dev;
}
- err = nvme_get_log_persistent_event(dev->fd, cfg.action,
- sizeof(*pevent), pevent);
+ err = nvme_get_log_persistent_event(dev_fd(dev), cfg.action,
+ sizeof(*pevent), pevent);
if (err < 0) {
fprintf(stderr, "persistent event log: %s\n",
nvme_strerror(errno));
err = -ENOMEM;
goto free_pevent;
}
- err = nvme_get_log_persistent_event(dev->fd, cfg.action,
- cfg.log_len, pevent_log_info);
+ err = nvme_get_log_persistent_event(dev_fd(dev), cfg.action,
+ cfg.log_len, pevent_log_info);
if (!err) {
- err = nvme_get_log_persistent_event(dev->fd, cfg.action,
- sizeof(*pevent), pevent);
+ err = nvme_get_log_persistent_event(dev_fd(dev), cfg.action,
+ sizeof(*pevent), pevent);
if (err < 0) {
fprintf(stderr, "persistent event log: %s\n",
nvme_strerror(errno));
goto close_dev;
}
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err < 0) {
fprintf(stderr, "identify controller: %s\n",
nvme_strerror(errno));
goto close_dev;
}
- err = nvme_get_log_endurance_grp_evt(dev->fd, cfg.rae, 0, log_size,
- endurance_log);
+ err = nvme_get_log_endurance_grp_evt(dev_fd(dev), cfg.rae, 0,
+ log_size, endurance_log);
if (!err)
nvme_show_endurance_group_event_agg_log(endurance_log, cfg.log_entries,
log_size, dev->name, flags);
if (flags < 0)
goto close_dev;
- err = nvme_get_log_lba_status(dev->fd, true, 0, sizeof(__u32), &lslplen);
+ err = nvme_get_log_lba_status(dev_fd(dev), true, 0, sizeof(__u32),
+ &lslplen);
if (err < 0) {
fprintf(stderr, "lba status log page: %s\n",
nvme_strerror(errno));
goto close_dev;
}
- err = nvme_get_log_lba_status(dev->fd, cfg.rae, 0, lslplen, lab_status);
+ err = nvme_get_log_lba_status(dev_fd(dev), cfg.rae, 0, lslplen,
+ lab_status);
if (!err)
nvme_show_lba_status_log(lab_status, lslplen, dev->name, flags);
else if (err > 0)
if (flags < 0)
goto close_dev;
- err = nvme_get_log_reservation(dev->fd, false, &resv);
+ err = nvme_get_log_reservation(dev_fd(dev), false, &resv);
if (!err)
nvme_show_resv_notif_log(&resv, dev->name, flags);
else if (err > 0)
goto close_dev;
}
- err = nvme_get_log_boot_partition(dev->fd, false, cfg.lsp,
+ err = nvme_get_log_boot_partition(dev_fd(dev), 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(dev->fd, false, cfg.lsp,
+ err = nvme_get_log_boot_partition(dev_fd(dev), false, cfg.lsp,
sizeof(boot) + bpsz,
(struct nvme_boot_partition *)bp_log);
if (!err)
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_media_unit_stat(dev->fd, cfg.domainid, &mus);
+ err = nvme_get_log_media_unit_stat(dev_fd(dev), cfg.domainid, &mus);
if (!err)
nvme_show_media_unit_stat_log(&mus, flags);
else if (err > 0)
if (cfg.raw_binary)
flags = BINARY;
- err = nvme_get_log_support_cap_config_list(dev->fd, cfg.domainid, &cap_log);
+ err = nvme_get_log_support_cap_config_list(dev_fd(dev), cfg.domainid,
+ &cap_log);
if (!err)
nvme_show_supported_cap_config_log(&cap_log, flags);
else if (err > 0)
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = cfg.log_id,
.nsid = cfg.namespace_id,
.lpo = cfg.lpo,
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_sanitize(dev->fd, cfg.rae, &sanitize_log);
+ err = nvme_get_log_sanitize(dev_fd(dev), cfg.rae, &sanitize_log);
if (!err)
nvme_show_sanitize_log(&sanitize_log, dev->name, flags);
else if (err > 0)
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_fid_supported_effects(dev->fd, false, &fid_support_log);
+ err = nvme_get_log_fid_supported_effects(dev_fd(dev), false,
+ &fid_support_log);
if (!err)
nvme_show_fid_support_effects_log(&fid_support_log,
dev->name, flags);
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_log_mi_cmd_supported_effects(dev->fd, false, &mi_cmd_support_log);
+ err = nvme_get_log_mi_cmd_supported_effects(dev_fd(dev), false,
+ &mi_cmd_support_log);
if (!err)
nvme_show_mi_cmd_support_effects_log(&mi_cmd_support_log,
dev->name, flags);
}
if (cfg.namespace_id == NVME_NSID_NONE)
- err = nvme_identify_ctrl_list(dev->fd, cfg.cntid, cntlist);
+ err = nvme_identify_ctrl_list(dev_fd(dev), cfg.cntid,
+ cntlist);
else
- err = nvme_identify_nsid_ctrl_list(dev->fd, cfg.namespace_id,
+ err = nvme_identify_nsid_ctrl_list(dev_fd(dev),
+ cfg.namespace_id,
cfg.cntid, cntlist);
if (!err)
nvme_show_list_ctrl(cntlist, flags);
struct nvme_identify_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
.data = &ns_list,
.nsid = cfg.namespace_id - 1.
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_identify_ns_csi_user_data_format(dev->fd, cfg.lba_format_index,
+ err = nvme_identify_ns_csi_user_data_format(dev_fd(dev),
+ 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);
goto close_dev;
}
- err = nvme_identify_endurance_group_list(dev->fd, cfg.endgrp_id, endgrp_list);
+ err = nvme_identify_endurance_group_list(dev_fd(dev), cfg.endgrp_id,
+ endgrp_list);
if (!err)
nvme_show_endurance_group_list(endgrp_list, flags);
else if (err > 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n",
nvme_strerror(errno));
}
}
- err = nvme_ns_mgmt_delete(dev->fd, cfg.namespace_id);
+ err = nvme_ns_mgmt_delete(dev_fd(dev), cfg.namespace_id);
if (!err)
printf("%s: Success, deleted nsid:%d\n", cmd->name,
cfg.namespace_id);
nvme_init_ctrl_list(&cntlist, num, ctrlist);
if (attach)
- err = nvme_ns_attach_ctrls(dev->fd, cfg.namespace_id, &cntlist);
+ err = nvme_ns_attach_ctrls(dev_fd(dev), cfg.namespace_id,
+ &cntlist);
else
- err = nvme_ns_detach_ctrls(dev->fd, cfg.namespace_id, &cntlist);
+ err = nvme_ns_detach_ctrls(dev_fd(dev), cfg.namespace_id,
+ &cntlist);
if (!err)
printf("%s: Success, nsid:%d\n", cmd->name, cfg.namespace_id);
err = -EINVAL;
goto close_dev;
}
- err = nvme_identify_ns(dev->fd, NVME_NSID_ALL, &ns);
+ err = nvme_identify_ns(dev_fd(dev), NVME_NSID_ALL, &ns);
if (err) {
if (err < 0)
fprintf(stderr, "identify-namespace: %s",
.lbstm = cpu_to_le64(cfg.lbstm),
};
- err = nvme_ns_mgmt_create(dev->fd, &ns2, &nsid, cfg.timeout, cfg.csi);
+ err = nvme_ns_mgmt_create(dev_fd(dev), &ns2, &nsid, cfg.timeout,
+ cfg.csi);
if (!err)
printf("%s: Success, created nsid:%d\n", cmd->name, nsid);
else if (err > 0)
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (!err)
nvme_show_id_ctrl(&ctrl, flags, vs);
else if (err > 0)
if (flags < 0)
goto close_dev;
- err = nvme_nvm_identify_ctrl(dev->fd, &ctrl_nvm);
+ err = nvme_nvm_identify_ctrl(dev_fd(dev), &ctrl_nvm);
if (!err)
nvme_show_id_ctrl_nvm(&ctrl_nvm, flags);
else if (err > 0)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
}
}
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
goto close_dev;
}
- err = nvme_identify_ns_csi(dev->fd, cfg.namespace_id, cfg.uuid_index,
+ err = nvme_identify_ns_csi(dev_fd(dev), 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);
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_identify_ns(dev->fd, NVME_NSID_ALL, &ns);
+ err = nvme_identify_ns(dev_fd(dev), 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(dev->fd, cfg.lba_format_index,
+ err = nvme_identify_iocs_ns_csi_user_data_format(dev_fd(dev),
+ 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,
flags = BINARY;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
goto close_dev;
}
- err = nvme_identify_ns_descs(dev->fd, cfg.namespace_id, nsdescs);
+ err = nvme_identify_ns_descs(dev_fd(dev), cfg.namespace_id, nsdescs);
if (!err)
nvme_show_id_ns_descs(nsdescs, cfg.namespace_id, flags);
else if (err > 0)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
}
if (cfg.force)
- err = nvme_identify_allocated_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_allocated_ns(dev_fd(dev),
+ cfg.namespace_id, &ns);
else
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (!err)
nvme_show_id_ns(&ns, cfg.namespace_id, 0, false, flags);
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = cfg.namespace_id = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = cfg.namespace_id = nvme_get_nsid(dev_fd(dev),
+ &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
}
}
- err = nvme_identify_independent_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_independent_identify_ns(dev_fd(dev),
+ cfg.namespace_id, &ns);
if (!err)
nvme_show_cmd_set_independent_id_ns(&ns, cfg.namespace_id, flags);
else if (err > 0)
goto close_dev;
}
- err = nvme_identify_ns_granularity(dev->fd, granularity_list);
+ err = nvme_identify_ns_granularity(dev_fd(dev), granularity_list);
if (!err)
nvme_show_id_ns_granularity_list(granularity_list, flags);
else if (err > 0)
if (flags < 0)
goto close_dev;
- err = nvme_identify_nvmset_list(dev->fd, cfg.nvmset_id, &nvmset);
+ err = nvme_identify_nvmset_list(dev_fd(dev), cfg.nvmset_id, &nvmset);
if (!err)
nvme_show_id_nvmset(&nvmset, cfg.nvmset_id, flags);
else if (err > 0)
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_identify_uuid(dev->fd, &uuid_list);
+ err = nvme_identify_uuid(dev_fd(dev), &uuid_list);
if (!err)
nvme_show_id_uuid_list(&uuid_list, flags);
else if (err > 0)
if (err < 0)
goto ret;
- err = nvme_identify_iocs(dev->fd, cfg.cntid, &iocs);
+ err = nvme_identify_iocs(dev_fd(dev), cfg.cntid, &iocs);
if (!err) {
printf("NVMe Identify I/O Command Set:\n");
nvme_show_id_iocs(&iocs);
if (flags < 0)
goto close_dev;
- err = nvme_identify_domain_list(dev->fd, cfg.dom_id, &id_domain);
+ err = nvme_identify_domain_list(dev_fd(dev), cfg.dom_id, &id_domain);
if (!err) {
printf("NVMe Identify command for Domain List is successful:\n");
printf("NVMe Identify Domain List:\n");
if (err < 0)
goto ret;
- err = nvme_get_nsid(dev->fd, &nsid);
+ err = nvme_get_nsid(dev_fd(dev), &nsid);
if (err < 0) {
fprintf(stderr, "get namespace ID: %s\n", nvme_strerror(errno));
err = errno;
struct nvme_virtual_mgmt_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.act = cfg.act,
.rt = cfg.rt,
.cntlid = cfg.cntlid,
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_identify_primary_ctrl(dev->fd, cfg.cntlid, &caps);
+ err = nvme_identify_primary_ctrl(dev_fd(dev), cfg.cntlid, &caps);
if (!err)
nvme_show_primary_ctrl_cap(&caps, flags);
else if (err > 0)
goto close_err;
}
- err = nvme_identify_secondary_ctrl_list(dev->fd, cfg.namespace_id,
+ err = nvme_identify_secondary_ctrl_list(dev_fd(dev), cfg.namespace_id,
cfg.cntid, sc_list);
if (!err)
nvme_show_list_secondary_ctrl(sc_list, cfg.num_entries, flags);
struct nvme_dev_self_test_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.stc = cfg.stc,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
if (cfg.verbose)
flags |= VERBOSE;
- err = nvme_get_log_device_self_test(dev->fd, &log);
+ err = nvme_get_log_device_self_test(dev_fd(dev), &log);
if (!err)
nvme_show_self_test_log(&log, cfg.dst_entries, 0,
dev->name, flags);
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
if (errno != ENOTTY) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
}
- err = get_feature_ids(dev->fd, cfg);
+ err = get_feature_ids(dev_fd(dev), cfg);
close_dev:
dev_close(dev);
struct nvme_fw_download_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.offset = cfg.offset,
.data_len = cfg.xfer,
.data = fw_buf,
struct nvme_fw_commit_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.slot = cfg.slot,
.action = cfg.action,
.bpid = cfg.bpid,
if (err < 0)
goto ret;
- err = nvme_subsystem_reset(dev->fd);
+ err = nvme_subsystem_reset(dev_fd(dev));
if (err < 0) {
if (errno == ENOTTY)
fprintf(stderr,
if (err < 0)
goto ret;
- err = nvme_ctrl_reset(dev->fd);
+ err = nvme_ctrl_reset(dev_fd(dev));
if (err < 0)
fprintf(stderr, "Reset: %s\n", nvme_strerror(errno));
if (err < 0)
goto ret;
- err = nvme_ns_rescan(dev->fd);
+ err = nvme_ns_rescan(dev_fd(dev));
if (err < 0)
fprintf(stderr, "Namespace Rescan");
struct nvme_sanitize_nvm_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.sanact = cfg.sanact,
.ause = cfg.ause,
.owpass = cfg.owpass,
if (cfg.human_readable)
flags |= VERBOSE;
- err = nvme_get_properties(dev->fd, &bar);
+ err = nvme_get_properties(dev_fd(dev), &bar);
if (err) {
bar = mmap_registers(r, dev);
fabrics = false;
struct nvme_get_property_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.offset = cfg.offset,
.value = &value,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
struct nvme_set_property_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.offset = cfg.offset,
.value = cfg.value,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
}
}
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err) {
fprintf(stderr, "identify-ctrl: %s\n", nvme_strerror(errno));
goto close_dev;
*/
cfg.namespace_id = NVME_NSID_ALL;
} else if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
}
if (cfg.namespace_id != NVME_NSID_ALL) {
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (err) {
if (err < 0)
fprintf(stderr, "identify-namespace: %s\n", nvme_strerror(errno));
struct nvme_format_nvm_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.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(dev)) {
- if (ioctl(dev->fd, NVME_IOCTL_RESCAN) < 0) {
+ if (ioctl(dev_fd(dev), NVME_IOCTL_RESCAN) < 0) {
fprintf(stderr, "failed to rescan namespaces\n");
err = -errno;
goto close_dev;
* to the given one because blkdev will not
* update by itself without re-opening fd.
*/
- if (ioctl(dev->fd, BLKBSZSET, &block_size) < 0) {
+ if (ioctl(dev_fd(dev), BLKBSZSET, &block_size) < 0) {
fprintf(stderr, "failed to set block size to %d\n",
block_size);
err = -errno;
goto close_dev;
}
- if (ioctl(dev->fd, BLKRRPART) < 0) {
+ if (ioctl(dev_fd(dev), BLKRRPART) < 0) {
fprintf(stderr, "failed to re-read partition table\n");
err = -errno;
goto close_dev;
}
}
if (cfg.reset && is_chardev(dev))
- nvme_ctrl_reset(dev->fd);
+ nvme_ctrl_reset(dev_fd(dev));
}
close_dev:
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
if (errno != ENOTTY) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = cfg.feature_id,
.nsid = cfg.namespace_id,
.cdw11 = cfg.value,
struct nvme_security_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.nssf = cfg.nssf,
.spsp0 = cfg.spsp & 0xff,
struct nvme_directive_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.dspec = cfg.dspec,
.doper = cfg.doper,
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
if (cfg.storage_tag_check)
control |= NVME_IO_STC;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
}
}
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
goto close_dev;
goto close_dev;
}
- err = nvme_identify_ns_csi(dev->fd, cfg.namespace_id, 0, NVME_CSI_NVM, &nvm_ns);
+ err = nvme_identify_ns_csi(dev_fd(dev), 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;
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
nvme_init_dsm_range(dsm, ctx_attrs, nlbs, slbas, nr);
struct nvme_dsm_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.attrs = cfg.cdw11,
.nr_ranges = nr,
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
struct nvme_copy_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.copy = copy.f0,
.sdlba = cfg.sdlba,
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
}
}
- err = nvme_flush(dev->fd, cfg.namespace_id);
+ err = nvme_flush(dev_fd(dev), cfg.namespace_id);
if (err < 0)
fprintf(stderr, "flush: %s\n", nvme_strerror(errno));
else if (err != 0)
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
struct nvme_resv_acquire_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.rtype = cfg.rtype,
.racqa = cfg.racqa,
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
struct nvme_resv_register_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.rrega = cfg.rrega,
.cptpl = cfg.cptpl,
goto ret;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
struct nvme_resv_release_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.rtype = cfg.rtype,
.rrela = cfg.rrela,
flags = BINARY;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
struct nvme_resv_report_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.eds = cfg.eds,
.len = size,
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
goto close_mfd;
}
- if (nvme_get_logical_block_size(dev->fd, cfg.namespace_id,
+ if (nvme_get_logical_block_size(dev_fd(dev), cfg.namespace_id,
&logical_block_size) < 0)
goto close_mfd;
}
if (cfg.metadata_size) {
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), 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(dev->fd, 1, 0, NVME_CSI_NVM, &nvm_ns);
+ err = nvme_identify_ns_csi(dev_fd(dev), 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 = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
control |= NVME_IO_STC;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
fprintf(stderr, "get-namespace-id: %s\n", nvme_strerror(errno));
goto close_dev;
}
}
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
goto close_dev;
goto close_dev;
}
- err = nvme_identify_ns_csi(dev->fd, cfg.namespace_id, 0, NVME_CSI_NVM, &nvm_ns);
+ err = nvme_identify_ns_csi(dev_fd(dev), 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;
struct nvme_io_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.start_block,
.nlb = cfg.block_count,
struct nvme_security_receive_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.nssf = cfg.nssf,
.spsp0 = cfg.spsp & 0xff,
struct nvme_get_lba_status_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.slba,
.mndw = cfg.mndw,
struct nvme_capacity_mgmt_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.op = cfg.operation,
.element_id = cfg.element_id,
.cdw11 = cfg.dw11,
struct nvme_directive_recv_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.dspec = cfg.dspec,
.doper = cfg.doper,
struct nvme_lockdown_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.scp = cfg.scp,
.prhbt = cfg.prhbt,
.ifc = cfg.ifc,
gettimeofday(&start_time, NULL);
if (admin)
- 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);
+ err = nvme_admin_passthru(dev_fd(dev), 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(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);
+ err = nvme_io_passthru(dev_fd(dev), 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);
gettimeofday(&end_time, NULL);
cmd_name = nvme_cmd_to_string(admin, cfg.opcode);
const char *name;
};
+static inline int dev_fd(struct nvme_dev *dev)
+{
+ return dev->fd;
+}
+
void register_extension(struct plugin *plugin);
/*
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, 0xc0, sizeof(log), &log);
+ err = nvme_get_log_simple(dev_fd(dev), 0xc0, sizeof(log), &log);
if (err) {
goto exit;
}
"Runtime Low",
};
- err = nvme_dera_get_device_status(dev->fd, &state);
+ err = nvme_dera_get_device_status(dev_fd(dev), &state);
if (!err){
if (state > 0 && state < 4){
printf("device_status : %s %d%% completed\n", dev_status[state], log.rebuild_percent);
if (err < 0)
return err;
- nvme_get_log_smart(dev->fd, cfg.namespace_id, false, &smart_log);
+ nvme_get_log_smart(dev_fd(dev), cfg.namespace_id, false, &smart_log);
nvme_show_smart_log(&smart_log, cfg.namespace_id, dev->name, NORMAL);
printf("DW0[0-1] Defect Cnt : %u\n", pvsc_smart->defect_cnt);
icount++;
memset(data, 0, 4096);
- ret = nvme_vucmd(dev->fd, NVME_VSC_GET_EVENT_LOG, 0, 0,
+ ret = nvme_vucmd(dev_fd(dev), NVME_VSC_GET_EVENT_LOG, 0, 0,
(SRB_SIGNATURE >> 32),
(SRB_SIGNATURE & 0xFFFFFFFF),
(char *)data, 4096);
if (cfg.clean_flg == 1) {
printf("Clean eventlog\n");
- nvme_vucmd(dev->fd, NVME_VSC_CLEAN_EVENT_LOG, 0, 0, (SRB_SIGNATURE >> 32),
- (SRB_SIGNATURE & 0xFFFFFFFF), (char *)NULL, 0);
+ nvme_vucmd(dev_fd(dev), NVME_VSC_CLEAN_EVENT_LOG, 0, 0,
+ (SRB_SIGNATURE >> 32),
+ (SRB_SIGNATURE & 0xFFFFFFFF), (char *)NULL, 0);
}
dev_close(dev);
ipackindex = 0;
memset(data, 0, 4096);
- if (nvme_vucmd(dev->fd, NVME_VSC_GET, VSC_FN_GET_CDUMP, 0x00,
+ if (nvme_vucmd(dev_fd(dev), 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 (busevsc == false) {
memset(data, 0, 4096);
- ret = nvme_get_nsid_log(dev->fd, true, 0x07, NVME_NSID_ALL,
+ ret = nvme_get_nsid_log(dev_fd(dev), 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(dev->fd, NVME_VSC_GET,
+ ret = nvme_vucmd(dev_fd(dev), NVME_VSC_GET,
VSC_FN_GET_CDUMP, 0x00,
(SRB_SIGNATURE >> 32),
(SRB_SIGNATURE & 0xFFFFFFFF),
(char *)data, 4096);
else
- ret = nvme_get_nsid_log(dev->fd, true, 0x07,
+ ret = nvme_get_nsid_log(dev_fd(dev), true,
+ 0x07,
NVME_NSID_ALL, 4096, data);
if (ret != 0)
return ret;
if (ipackindex != ipackcount) {
memset(data, 0, 4096);
if (busevsc)
- ret = nvme_vucmd(dev->fd, NVME_VSC_GET,
+ ret = nvme_vucmd(dev_fd(dev), NVME_VSC_GET,
VSC_FN_GET_CDUMP, 0x00,
(SRB_SIGNATURE >> 32),
(SRB_SIGNATURE & 0xFFFFFFFF),
(char *)data, 4096);
else
- ret = nvme_get_nsid_log(dev->fd, true, 0x07,
+ ret = nvme_get_nsid_log(dev_fd(dev), true,
+ 0x07,
NVME_NSID_ALL, 4096,
data);
if (ret != 0)
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, 0xca, sizeof(smart_log), &smart_log);
+ err = nvme_get_log_simple(dev_fd(dev), 0xca, sizeof(smart_log),
+ &smart_log);
if (!err) {
if (cfg.json)
show_intel_smart_log_jsn(&smart_log, cfg.namespace_id,
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, 0xdd, sizeof(log), log);
+ err = nvme_get_log_simple(dev_fd(dev), 0xdd, sizeof(log), log);
if (!err) {
if (!cfg.raw_binary)
printf("Intel Marketing Name Log:\n%s\n", log);
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, 0xc5, sizeof(stats), &stats);
+ err = nvme_get_log_simple(dev_fd(dev), 0xc5, sizeof(stats), &stats);
if (!err) {
if (!cfg.raw_binary)
show_temp_stats(&stats);
/* 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(dev->fd, cfg.write ? 0xc2 : 0xc1,
- sizeof(data), &data);
+ err = nvme_get_log_simple(dev_fd(dev), cfg.write ? 0xc2 : 0xc1,
+ sizeof(data), &data);
media_version[0] = (data[1] << 8) | data[0];
media_version[1] = (data[3] << 8) | data[2];
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = 0xf7,
.nsid = 0,
.sel = 0,
}
if (!cfg.file) {
- err = setup_file(f, cfg.file, dev->fd, cfg.log);
+ err = setup_file(f, cfg.file, dev_fd(dev), cfg.log);
if (err)
goto out_free;
cfg.file = f;
goto out_free;
}
- err = read_header(&cmd, buf, dev->fd, cdlog.u.entireDword, cfg.namespace_id);
+ err = read_header(&cmd, buf, dev_fd(dev), 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, dev->fd, &cmd);
+ err = get_internal_log_old(buf, output, dev_fd(dev), &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, dev->fd,
+ 0x400, output,
+ dev_fd(dev),
buf);
if (err)
goto out;
if (count > 1)
cdlog.u.fields.selectNlog = i;
- err = read_header(&cmd, buf, dev->fd,
+ err = read_header(&cmd, buf, dev_fd(dev),
cdlog.u.entireDword,
cfg.namespace_id);
if (err)
cmd.cdw10 = 0x400;
cmd.data_len = min(0x1000, intel_nlog->nlogbytesize);
err = read_entire_cmd(&cmd, intel_nlog->nlogbytesize / 4,
- 0x400, output, dev->fd,
+ 0x400, output,
+ dev_fd(dev),
buf);
if (err)
goto out;
cmd.cdw10 = 0x400;
cmd.data_len = 0x400;
err = read_entire_cmd(&cmd, ehdr->edumps[j].coresize,
- 0x400, output, dev->fd,
+ 0x400, output,
+ dev_fd(dev),
buf);
if (err)
goto out;
struct nvme_get_features_args args_get = {
.args_size = sizeof(args_get),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = nsid,
.sel = sel,
struct nvme_set_features_args args_set = {
.args_size = sizeof(args_set),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = nsid,
.cdw11 = option,
* valid buckets a user is allowed to modify. Read or write doesn't
* matter
*/
- err = nvme_get_log_simple(dev->fd, 0xc2,
- sizeof(media_version), media_version);
+ err = nvme_get_log_simple(dev_fd(dev), 0xc2,
+ sizeof(media_version), media_version);
if (err) {
fprintf(stderr, "Querying media version failed. ");
nvme_show_status(err);
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = nsid,
.cdw11 = cfg.write ? 0x1 : 0x0,
if (err < 0)
return err;
- err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
- sizeof(smart_log), &smart_log);
+ err = nvme_get_nsid_log(dev_fd(dev), false, 0xca, cfg.namespace_id,
+ sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
- err = show_memblaze_smart_log(dev->fd, cfg.namespace_id,
+ err = show_memblaze_smart_log(dev_fd(dev),
+ cfg.namespace_id,
dev->name, &smart_log);
else
d_raw((unsigned char *)&smart_log, sizeof(smart_log));
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = feature_id,
.nsid = 0,
.sel = 0,
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = cfg.feature_id,
.nsid = 0,
.cdw11 = cfg.value,
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = cfg.feature_id,
.nsid = 0,
.cdw11 = cfg.value,
fdi = fopen(FID_C3_LOG_FILENAME, "w+");
glp_high_latency_show_bar(fdi, DO_PRINT_FLAG);
- err = nvme_get_log_simple(dev->fd, GLP_ID_VU_GET_HIGH_LATENCY_LOG,
+ err = nvme_get_log_simple(dev_fd(dev), 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(dev->fd, GLP_ID_VU_GET_HIGH_LATENCY_LOG,
+ err = nvme_get_log_simple(dev_fd(dev), GLP_ID_VU_GET_HIGH_LATENCY_LOG,
sizeof(buf), &buf);
if ( err) {
nvme_show_status(err);
struct nvme_fw_download_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.offset = offset,
.data_len = xfer,
.data = fw_buf,
offset += xfer;
}
- err = memblaze_fw_commit(dev->fd, selectNo);
+ err = memblaze_fw_commit(dev_fd(dev), selectNo);
if(err == 0x10B || err == 0x20B) {
err = 0;
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, cfg.write ? 0xc2 : 0xc1,
+ err = nvme_get_log_simple(dev_fd(dev), cfg.write ? 0xc2 : 0xc1,
sizeof(stats), &stats);
if (!err)
io_latency_histogram(cfg.write ? f2 : f1, stats, DO_PRINT_FLAG,
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = cfg.feature_id,
.nsid = 0,
.cdw11 = cfg.value,
struct nvme_get_features_args args_get = {
.args_size = sizeof(args_get),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = nsid,
.sel = sel,
struct nvme_set_features_args args_set = {
.args_size = sizeof(args_set),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = nsid,
.cdw11 = option,
struct nvme_fw_download_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.offset = offset,
.data_len = xfer,
.data = fw_buf,
offset += xfer;
}
- err = micron_fw_commit(dev->fd, selectNo);
+ err = micron_fw_commit(dev_fd(dev), selectNo);
if (err == 0x10B || err == 0x20B) {
err = 0;
if (!strcmp(opt.option, "enable")) {
cdw11 = opt.value << 1 | 1;
- err = nvme_set_features_simple(dev->fd, fid, 1, cdw11, opt.save,
+ err = nvme_set_features_simple(dev_fd(dev), fid, 1, cdw11, opt.save,
&result);
if (err == 0) {
printf("successfully enabled SMBus on drive\n");
else if (!strcmp(opt.option, "status")) {
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = 1,
.sel = opt.value,
}
else if (!strcmp(opt.option, "disable")) {
cdw11 = opt.value << 1 | 0;
- err = nvme_set_features_simple(dev->fd, fid, 1, cdw11, opt.save,
+ err = nvme_set_features_simple(dev_fd(dev), fid, 1, cdw11, opt.save,
&result);
if (err == 0) {
printf("Successfully disabled SMBus on drive\n");
return -1;
}
- close(dev->fd);
+ close(dev_fd(dev));
return err;
}
if (strcmp(cfg.fmt, "json") == 0)
is_json = true;
- err = nvme_get_log_smart(dev->fd, 0xffffffff, false, &smart_log);
+ err = nvme_get_log_smart(dev_fd(dev), 0xffffffff, false, &smart_log);
if (!err) {
temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]);
temperature = temperature ? temperature - 273 : 0;
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(dev->fd, &admin_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
if (!err) {
counters = true;
correctable_errors = 10;
/* For M51CX models, PCIe errors are cleared using 0xC3 feature */
if (model == M51CX) {
- err = nvme_set_features_simple(dev->fd, fid, 0, (1 << 31), false,
+ err = nvme_set_features_simple(dev_fd(dev), fid, 0, (1 << 31), false,
&result);
if (err == 0 && (err = (int)result) == 0) {
printf("Device correctable errors are cleared!\n");
admin_cmd.opcode = 0xD6;
admin_cmd.addr = 0;
admin_cmd.cdw10 = 0;
- err = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
if (err == 0) {
printf("Device correctable error counters are cleared!\n");
goto out;
if (strcmp(cfg.fmt, "normal") == 0)
is_json = false;
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err) {
printf("Error %d retrieving controller identification data\n", err);
goto out;
goto out;
}
- err = nvme_get_log_simple(dev->fd, 0xD0, D0_log_size, extSmartLog);
+ err = nvme_get_log_simple(dev_fd(dev), 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(dev->fd, 0xFB, FB_log_size, logFB);
+ err = nvme_get_log_simple(dev_fd(dev), 0xFB, FB_log_size, logFB);
has_fb_log = (0 == err);
}
err = -1;
goto out;
}
- err = nvme_get_log_simple(dev->fd, 0xE1, E1_log_size, extSmartLog);
+ err = nvme_get_log_simple(dev_fd(dev), 0xE1, E1_log_size, extSmartLog);
if (!err) {
print_ext_smart_logs_e1((__u8 *)extSmartLog, is_json);
}
admin_cmd.addr = (__u64) (uintptr_t) &dinfo;
admin_cmd.data_len = (__u32)sizeof(dinfo);
admin_cmd.cdw12 = 3;
- err = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
if (err) {
fprintf(stderr, "ERROR : drive-info opcode failed with 0x%x\n", err);
dev_close(dev);
return -1;
}
} else {
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err) {
fprintf(stderr, "ERROR : identify_ctrl() failed with 0x%x\n", err);
dev_close(dev);
goto out;
}
- err = nvme_get_log_simple(dev->fd, 0xC2, C2_log_size, logC2);
+ err = nvme_get_log_simple(dev_fd(dev), 0xC2, C2_log_size, logC2);
if (err) {
fprintf(stderr, "Failed to retrieve fw activation history log, error: %x\n", err);
goto out;
struct nvme_get_features_args g_args = {
.args_size = sizeof(g_args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = 0,
.sel = 0,
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = MICRON_FID_LATENCY_MONITOR,
.nsid = 0,
.cdw11 = enable,
if (err)
return err;
memset(&log, 0, sizeof(log));
- err = nvme_get_log_simple(dev->fd, 0xD1, sizeof(log), &log);
+ err = nvme_get_log_simple(dev_fd(dev), 0xD1, sizeof(log), &log);
if (err) {
if (err < 0)
printf("Unable to retrieve latency stats log the drive\n");
}
memset(&log, 0, sizeof(log));
- err = nvme_get_log_simple(dev->fd, 0xD0, sizeof(log), &log);
+ err = nvme_get_log_simple(dev_fd(dev), 0xD0, sizeof(log), &log);
if (err) {
if (err < 0)
printf("Unable to retrieve latency stats log the drive\n");
__u8 spec = (eModel == M5410) ? 0 : 1;
__u8 nsze;
- if ((err = nvme_identify_ctrl(dev->fd, &ctrl)) == 0)
- err = nvme_get_log_simple(dev->fd, 0xFB,
- FB_log_size, logFB);
+ if ((err = nvme_identify_ctrl(dev_fd(dev), &ctrl)) == 0)
+ err = nvme_get_log_simple(dev_fd(dev), 0xFB,
+ FB_log_size, logFB);
if (err) {
if (err < 0)
printf("Unable to retrieve smart log 0xFB for the drive\n");
goto out;
}
- err = nvme_get_log_simple(dev->fd, 0xC0, C0_log_size, logC0);
+ err = nvme_get_log_simple(dev_fd(dev), 0xC0, C0_log_size, logC0);
if (err == 0) {
print_smart_cloud_health_log((__u8 *)logC0, is_json);
} else if (err < 0) {
return err;
}
- err = nvme_set_features_simple(dev->fd, fid, 1 << 31, 0, 0, &result);
+ err = nvme_set_features_simple(dev_fd(dev), 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);
if (err < 0)
return -1;
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if ((ctrl.lpa & 0x8) != 0x8) {
printf("drive doesn't support host/controller generated telemetry logs\n");
dev_close(dev);
if (!strcmp(opt.option, "enable")) {
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = 1,
.cdw11 = 1,
} else if (!strcmp(opt.option, "disable")) {
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = 1,
.cdw11 = 0,
} else if (!strcmp(opt.option, "status")) {
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = fid,
.nsid = 1,
.sel = opt.select & 0x3,
goto out;
}
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err)
goto out;
goto out;
}
int logSize = 0; __u8 *buffer = NULL; const char *dir = ".";
- err = micron_telemetry_log(dev->fd, cfg.log, &buffer, &logSize,
+ err = micron_telemetry_log(dev_fd(dev), cfg.log, &buffer, &logSize,
cfg.data_area);
if (err == 0 && logSize > 0 && buffer != NULL) {
sprintf(msg, "telemetry log: 0x%X", cfg.log);
GetDriveInfo(strOSDirName, ctrlIdx, &ctrl);
for (int i = 1; i <= ctrl.nn; i++)
- GetNSIDDInfo(dev->fd, strCtrlDirName, i);
+ GetNSIDDInfo(dev_fd(dev), strCtrlDirName, i);
- GetSmartlogData(dev->fd, strCtrlDirName);
- GetErrorlogData(dev->fd, ctrl.elpe, strCtrlDirName);
- GetGenericLogs(dev->fd, strCtrlDirName);
+ GetSmartlogData(dev_fd(dev), strCtrlDirName);
+ GetErrorlogData(dev_fd(dev), ctrl.elpe, strCtrlDirName);
+ GetGenericLogs(dev_fd(dev), strCtrlDirName);
/* pull if telemetry log data is supported */
if ((ctrl.lpa & 0x8) == 0x8)
- GetTelemetryData(dev->fd, strCtrlDirName);
+ GetTelemetryData(dev_fd(dev), strCtrlDirName);
- GetFeatureSettings(dev->fd, strCtrlDirName);
+ GetFeatureSettings(dev_fd(dev), strCtrlDirName);
if (eModel != M5410 && eModel != M5407) {
memcpy(&aVendorLogs[c_logs_index], aM51XXLogs, sizeof(aM51XXLogs));
case 0xE4:
case 0xE8:
case 0xEA:
- err = get_common_log(dev->fd, aVendorLogs[i].ucLogPage,
+ err = get_common_log(dev_fd(dev), aVendorLogs[i].ucLogPage,
&dataBuffer, &bSize);
break;
case 0xC1:
case 0xC2:
case 0xC4:
- err = GetLogPageSize(dev->fd, aVendorLogs[i].ucLogPage, &bSize);
+ err = GetLogPageSize(dev_fd(dev), aVendorLogs[i].ucLogPage,
+ &bSize);
if (err == 0 && bSize > 0)
- err = GetCommonLogPage(dev->fd, aVendorLogs[i].ucLogPage, &dataBuffer, bSize);
+ err = GetCommonLogPage(dev_fd(dev), 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(dev->fd, aVendorLogs[i].ucLogPage, dataBuffer, bSize);
+ err = NVMEGetLogPage(dev_fd(dev),
+ aVendorLogs[i].ucLogPage, dataBuffer,
+ bSize);
else
- err = nvme_get_log_simple(dev->fd, aVendorLogs[i].ucLogPage,
+ err = nvme_get_log_simple(dev_fd(dev),
+ aVendorLogs[i].ucLogPage,
bSize, dataBuffer);
}
break;
case 0xFC:
case 0xFD:
if (eModel == M51BX) {
- (void)NVMEResetLog(dev->fd, aVendorLogs[i].ucLogPage,
+ (void)NVMEResetLog(dev_fd(dev), aVendorLogs[i].ucLogPage,
aVendorLogs[i].nLogSize, aVendorLogs[i].nMaxSize);
}
/* fallthrough */
break;
}
memset(dataBuffer, 0, bSize);
- err = nvme_get_log_simple(dev->fd, aVendorLogs[i].ucLogPage,
+ err = nvme_get_log_simple(dev_fd(dev), 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(dev->fd, aVendorLogs[i].ucLogPage,
+ err = nvme_get_log_simple(dev_fd(dev),
+ aVendorLogs[i].ucLogPage,
bSize, dataBuffer);
if (err || (((unsigned int *)dataBuffer)[0] == 0xdeadbeef))
break;
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(dev->fd, log_list[i].log_id,
+ err = nvme_get_log_simple(dev_fd(dev), 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);
if (ret < 0)
return ret;
- ret = get_c0_log_page(dev->fd, cfg.output_format);
+ ret = get_c0_log_page(dev_fd(dev), cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : OCP : Failure reading the C0 Log Page, ret = %d\n",
ret);
}
memset(data, 0, sizeof (__u8) * C3_LATENCY_MON_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, C3_LATENCY_MON_OPCODE,
- C3_LATENCY_MON_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), C3_LATENCY_MON_OPCODE,
+ C3_LATENCY_MON_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr,
if (err < 0)
return err;
- err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
- sizeof(smart_log), (void *)&smart_log);
+ err = nvme_get_nsid_log(dev_fd(dev), false, 0xca, cfg.namespace_id,
+ sizeof(smart_log), (void *)&smart_log);
if (!err) {
if (cfg.json)
show_sfx_smart_log_jsn(&smart_log, cfg.namespace_id,
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, cfg.write ? 0xc3 : 0xc1,
+ err = nvme_get_log_simple(dev_fd(dev), cfg.write ? 0xc3 : 0xc1,
sizeof(stats), (void *)&stats);
if (!err) {
if ((stats.ver.maj == VANDA_MAJOR_IDX) && (stats.ver.min == VANDA_MINOR_IDX)) {
return -1;
}
- err = get_bb_table(dev->fd, 0xffffffff, data_buf, buf_size);
+ err = get_bb_table(dev_fd(dev), 0xffffffff, data_buf, buf_size);
if (err < 0) {
perror("get-bad-block");
} else if (err != 0) {
if (err < 0)
return err;
- if (nvme_query_cap(dev->fd, 0xffffffff, sizeof(ctx), &ctx)) {
+ if (nvme_query_cap(dev_fd(dev), 0xffffffff, sizeof(ctx), &ctx)) {
perror("sfx-query-cap");
err = -1;
}
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(dev->fd, cap_in_4k, &shrink)) {
+ if (change_sanity_check(dev_fd(dev), cap_in_4k, &shrink)) {
printf("ScaleFlux change-capacity: fail\n");
dev_close(dev);
return err;
return 0;
}
- err = nvme_change_cap(dev->fd, 0xffffffff, cap_in_4k);
+ err = nvme_change_cap(dev_fd(dev), 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(dev->fd, BLKRRPART);
+ ioctl(dev_fd(dev), BLKRRPART);
}
dev_close(dev);
return err;
dev_close(dev);
return 0;
} else {
- return sfx_clean_card(dev->fd);
+ return sfx_clean_card(dev_fd(dev));
}
}
if (cfg.feature_id == SFX_FEAT_ATOMIC && cfg.value != 0) {
if (cfg.namespace_id != 0xffffffff) {
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id,
+ &ns);
if (err) {
if (err < 0)
perror("identify-namespace");
}
}
- err = nvme_sfx_set_features(dev->fd, cfg.namespace_id, cfg.feature_id,
+ err = nvme_sfx_set_features(dev_fd(dev), cfg.namespace_id,
+ cfg.feature_id,
cfg.value);
if (err < 0) {
return EINVAL;
}
- err = nvme_sfx_get_features(dev->fd, cfg.namespace_id, cfg.feature_id, &result);
+ err = nvme_sfx_get_features(dev_fd(dev), cfg.namespace_id,
+ cfg.feature_id, &result);
if (err < 0) {
perror("ScaleFlux-get-feature");
dev_close(dev);
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err < 0)
return err;
- err = nvme_get_log_simple(dev->fd, 0xc5,
+ err = nvme_get_log_simple(dev_fd(dev), 0xc5,
sizeof(logPageMap), &logPageMap);
if (!err) {
if (strcmp(cfg.output_format,"json")) {
if (strcmp(cfg.output_format,"json"))
printf("Seagate Extended SMART Information :\n");
- err = nvme_get_log_simple(dev->fd, 0xC4,
+ err = nvme_get_log_simple(dev_fd(dev), 0xC4,
sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
if (!err) {
if (strcmp(cfg.output_format,"json")) {
* Next get Log Page 0xCF
*/
- err = nvme_get_log_simple(dev->fd, 0xCF,
+ err = nvme_get_log_simple(dev_fd(dev), 0xCF,
sizeof(logPageCF), &logPageCF);
if (!err) {
if(strcmp(cfg.output_format,"json")) {
if(strcmp(cfg.output_format,"json"))
printf("Seagate Temperature Stats Information :\n");
/*STEP-1 : Get Current Temperature from SMART */
- err = nvme_get_log_smart(dev->fd, 0xffffffff, false, &smart_log);
+ err = nvme_get_log_smart(dev_fd(dev), 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(dev->fd, 0xC4,
+ err = nvme_get_log_simple(dev_fd(dev), 0xC4,
sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
if (!err) {
for(index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++) {
else if (err > 0)
nvme_show_status(err);
- cf_err = nvme_get_log_simple(dev->fd, 0xCF,
+ cf_err = nvme_get_log_simple(dev_fd(dev), 0xCF,
sizeof(ExtdSMARTInfo), &logPageCF);
if(!cf_err) {
if(strcmp(cfg.output_format,"json"))
printf("Seagate PCIe error counters Information :\n");
- err = nvme_get_log_simple(dev->fd, 0xCB,
+ err = nvme_get_log_simple(dev_fd(dev), 0xCB,
sizeof(pcieErrorLog), &pcieErrorLog);
if (!err) {
if(strcmp(cfg.output_format,"json")) {
return -1;
}
- err = nvme_set_features_simple(dev->fd, 0xE1, 0, 0xCB, cfg.save,
+ err = nvme_set_features_simple(dev_fd(dev), 0xE1, 0, 0xCB, cfg.save,
&result);
if (err < 0) {
dump_fd = STDOUT_FILENO;
cfg.log_id = (cfg.log_id << 8) | 0x07;
- err = nvme_get_nsid_log(dev->fd, false, cfg.log_id, cfg.namespace_id,
- sizeof(tele_log), (void *)(&tele_log));
+ err = nvme_get_nsid_log(dev_fd(dev), false, cfg.log_id,
+ cfg.namespace_id,
+ sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
offset += 512;
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = cfg.log_id,
.nsid = cfg.namespace_id,
.lpo = offset,
dump_fd = STDOUT_FILENO;
log_id = 0x08;
- err = nvme_get_nsid_log(dev->fd, false, log_id, cfg.namespace_id,
- sizeof(tele_log), (void *)(&tele_log));
+ err = nvme_get_nsid_log(dev_fd(dev), false, log_id, cfg.namespace_id,
+ sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
offset += 512;
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = log_id,
.nsid = cfg.namespace_id,
.lpo = offset,
}
log_id = 0x08;
- err = nvme_get_nsid_log(dev->fd, false, log_id, cfg.namespace_id,
- sizeof(tele_log), (void *)(&tele_log));
+ err = nvme_get_nsid_log(dev_fd(dev), false, log_id, cfg.namespace_id,
+ sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
offset += 512;
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = log_id,
.nsid = cfg.namespace_id,
.lpo = offset,
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);
+ err = nvme_get_nsid_log(dev_fd(dev), false, 0xca, cfg.namespace_id,
+ sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
show_shannon_smart_log(&smart_log, cfg.namespace_id,
struct nvme_get_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = cfg.feature_id,
.nsid = cfg.namespace_id,
.sel = cfg.sel,
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = cfg.feature_id,
.nsid = cfg.namespace_id,
.cdw11 = cfg.value,
garbage_control_collection_log_t gc_log;
const int solidigm_vu_gc_log_id = 0xfd;
- err = nvme_get_log_simple(dev->fd, solidigm_vu_gc_log_id,
+ err = nvme_get_log_simple(dev_fd(dev), solidigm_vu_gc_log_id,
sizeof(gc_log), &gc_log);
if (!err) {
if (flags & BINARY) {
if (err < 0)
return err;
- lt.fd = dev->fd;
+ lt.fd = dev_fd(dev);
lt.print_flags = validate_output_format(lt.cfg.output_format);
if (lt.print_flags == -EINVAL) {
return flags;
}
- err = nvme_get_log_simple(dev->fd, solidigm_vu_smart_log_id,
+ err = nvme_get_log_simple(dev_fd(dev), solidigm_vu_smart_log_id,
sizeof(smart_log_payload), &smart_log_payload);
if (!err) {
if (flags & JSON) {
}
/* Check device supported */
- err = nvme_get_sct_status(dev->fd, MASK_0 | MASK_1);
+ err = nvme_get_sct_status(dev_fd(dev), MASK_0 | MASK_1);
if (err) {
goto end;
}
- err = nvme_get_nsid_log(dev->fd, false, log_page, namespace_id, log_len, log);
+ err = nvme_get_nsid_log(dev_fd(dev), false, log_page, namespace_id,
+ log_len, log);
if (err) {
fprintf(stderr, "%s: couldn't get log 0x%x\n", __func__,
log_page);
else
printf("Getting current log\n");
- err = nvme_get_internal_log_file(dev->fd, cfg.output_file,
+ err = nvme_get_internal_log_file(dev_fd(dev), cfg.output_file,
!cfg.prev_log);
if (err < 0)
fprintf(stderr, "%s: couldn't get fw log \n", __func__);
}
/* Check device supported */
- err = nvme_get_sct_status(dev->fd, MASK_0 | MASK_1);
+ err = nvme_get_sct_status(dev_fd(dev), MASK_0 | MASK_1);
if (err)
goto end;
struct nvme_set_features_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.fid = feature_id,
.nsid = namespace_id,
.cdw11 = value,
printf("\nDevice not found \n");;
return -1;
}
- result = nvme_get_log_smart(dev->fd, 0xffffffff, false, &smart_log);
+ result = nvme_get_log_smart(dev_fd(dev), 0xffffffff, false, &smart_log);
if (!result) {
printf("Transcend NVME heath value: ");
percent_used =smart_log.percent_used;
nvmecmd.cdw12=DW12_BAD_BLOCK;
nvmecmd.addr = (__u64)(uintptr_t)data;
nvmecmd.data_len = 0x1;
- result = nvme_submit_admin_passthru(dev->fd, &nvmecmd, NULL);
+ result = nvme_submit_admin_passthru(dev_fd(dev), &nvmecmd, NULL);
if(!result) {
int badblock = data[0];
printf("Transcend NVME badblock count: %d\n",badblock);
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(dev->fd, path, &cfg);
+ ret = vt_update_vtview_log_header(dev_fd(dev), path, &cfg);
if (ret) {
err = EINVAL;
dev_close(dev);
if(cur_time >= end_time)
break;
- ret = vt_add_entry_to_log(dev->fd, path, &cfg);
+ ret = vt_add_entry_to_log(dev_fd(dev), path, &cfg);
if (ret) {
printf("Cannot update driver log\n");
break;
return err;
}
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
printf("Cannot read identify device\n");
dev_close(dev);
struct nvme_id_ctrl ctrl;
memset(&ctrl, 0, sizeof(struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
struct nvme_id_ctrl ctrl;
memset(&ctrl, 0, sizeof(struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
strncpy(orig, file, PATH_MAX - 1);
memset(file, 0, len);
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
/* get the log page length */
struct nvme_get_log_args args_len = {
.args_size = sizeof(args_len),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
/* get the log page data */
struct nvme_get_log_args args_data = {
.args_size = sizeof(args_data),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
/* get the log page data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
memset(&admin_cmd, 0, sizeof (struct nvme_passthru_cmd));
admin_cmd.opcode = opcode;
admin_cmd.cdw12 = cdw12;
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
if (ret != 0) {
fprintf(stdout, "ERROR : WDC : Crash dump erase failed\n");
}
admin_cmd.cdw13 = curr_data_offset;
while (curr_data_offset < data_len) {
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
if (ret != 0) {
nvme_show_status(ret);
fprintf(stderr, "%s: ERROR : WDC : Get chunk %d, size = 0x%x, offset = 0x%x, addr = 0x%lx\n",
nvme_root_t r;
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", err);
} else if (type == WDC_TELEMETRY_TYPE_CONTROLLER) {
if ((capabilities & WDC_DRIVE_CAP_INTERNAL_LOG) == WDC_DRIVE_CAP_INTERNAL_LOG) {
/* Verify the Controller Initiated Option is enabled */
- err = nvme_get_features_data(dev->fd,
+ err = nvme_get_features_data(dev_fd(dev),
WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
0, 4, buf, &result);
if (err == 0) {
}
if (ctrl_init)
- err = nvme_get_ctrl_telemetry(dev->fd, true, &log, data_area, &full_size);
+ err = nvme_get_ctrl_telemetry(dev_fd(dev), true, &log,
+ data_area, &full_size);
else if (host_gen)
- err = nvme_get_new_host_telemetry(dev->fd, &log, data_area, &full_size);
+ err = nvme_get_new_host_telemetry(dev_fd(dev), &log,
+ data_area, &full_size);
else
- err = nvme_get_host_telemetry(dev->fd, &log, data_area, &full_size);
+ err = nvme_get_host_telemetry(dev_fd(dev), &log, data_area,
+ &full_size);
if (err < 0) {
perror("get-telemetry-log");
memset(log_hdr, 0, e6_log_hdr_size);
if (type == WDC_TELEMETRY_TYPE_NONE) {
- ret = wdc_dump_length_e6(dev->fd, WDC_NVME_CAP_DIAG_OPCODE,
+ ret = wdc_dump_length_e6(dev_fd(dev),
+ WDC_NVME_CAP_DIAG_OPCODE,
WDC_NVME_CAP_DIAG_HEADER_TOC_SIZE>>2,
0x00,
log_hdr);
if (cap_diag_length == 0) {
fprintf(stderr, "INFO : WDC : Capture Diagnostics log is empty\n");
} else {
- ret = wdc_do_dump_e6(dev->fd, WDC_NVME_CAP_DIAG_OPCODE, cap_diag_length,
+ ret = wdc_do_dump_e6(dev_fd(dev),
+ WDC_NVME_CAP_DIAG_OPCODE,
+ cap_diag_length,
(WDC_NVME_CAP_DIAG_SUBCMD << WDC_NVME_SUBCMD_SHIFT) | WDC_NVME_CAP_DIAG_CMD,
file, xfer_size, (__u8 *)log_hdr);
/* FW requirement - xfer size must be 256k for data area 4 */
if (cfg.data_area >= 4)
xfer_size = 0x40000;
- ret = wdc_do_cap_dui(dev->fd, f, xfer_size, cfg.data_area,
+ ret = wdc_do_cap_dui(dev_fd(dev), f, xfer_size,
+ cfg.data_area,
cfg.verbose, cfg.file_size,
cfg.offset);
goto out;
telemetry_type, telemetry_data_area);
goto out;
} else {
- ret = wdc_do_cap_dui(dev->fd, f, xfer_size,
+ ret = wdc_do_cap_dui(dev_fd(dev), 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(dev->fd, f);
+ ret = wdc_do_sn730_get_and_tar(dev_fd(dev), f);
else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
WDC_NVME_CLEAR_CRASH_DUMP_CMD);
}
- ret = wdc_dump_length(dev->fd,
- opcode,
- cdw10_size,
- cdw12_size,
- &crash_dump_length);
+ ret = wdc_dump_length(dev_fd(dev),
+ opcode,
+ cdw10_size,
+ cdw12_size,
+ &crash_dump_length);
if (ret == -1) {
if (type == WDC_NVME_PFAIL_DUMP_TYPE)
__u32 drive_log_length;
struct nvme_passthru_cmd admin_cmd;
- ret = wdc_dump_length(dev->fd, WDC_NVME_DRIVE_LOG_SIZE_OPCODE,
- WDC_NVME_DRIVE_LOG_SIZE_NDT,
- (WDC_NVME_DRIVE_LOG_SIZE_SUBCMD <<
- WDC_NVME_SUBCMD_SHIFT | WDC_NVME_DRIVE_LOG_SIZE_CMD),
- &drive_log_length);
+ ret = wdc_dump_length(dev_fd(dev), WDC_NVME_DRIVE_LOG_SIZE_OPCODE,
+ WDC_NVME_DRIVE_LOG_SIZE_NDT,
+ (WDC_NVME_DRIVE_LOG_SIZE_SUBCMD <<
+ WDC_NVME_SUBCMD_SHIFT | WDC_NVME_DRIVE_LOG_SIZE_CMD),
+ &drive_log_length);
if (ret == -1) {
return -1;
}
admin_cmd.cdw12 = ((WDC_NVME_DRIVE_LOG_SUBCMD <<
WDC_NVME_SUBCMD_SHIFT) | WDC_NVME_DRIVE_LOG_SIZE_CMD);
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
nvme_show_status(ret);
if (ret == 0) {
ret = wdc_create_log_file(file, drive_log_data, drive_log_length);
memset(&admin_cmd, 0, sizeof (admin_cmd));
admin_cmd.opcode = WDC_NVME_PURGE_CMD_OPCODE;
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
if (ret > 0) {
switch (ret) {
case WDC_NVME_PURGE_CMD_SEQ_ERR:
admin_cmd.cdw10 = WDC_NVME_PURGE_MONITOR_CMD_CDW10;
admin_cmd.timeout_ms = WDC_NVME_PURGE_MONITOR_TIMEOUT;
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
if (ret == 0) {
mon = (struct wdc_nvme_purge_monitor_data *) output;
printf("Purge state = 0x%0x\n", admin_cmd.result);
struct nvme_id_ctrl ctrl;
char ts_buf[128];
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (!err)
printf(" Serial Number: %-.*s\n", (int)sizeof(ctrl.sn), ctrl.sn);
else {
}
if (namespace_id == NVME_NSID_ALL) {
- ret = nvme_get_nsid(dev->fd, &namespace_id);
+ ret = nvme_get_nsid(dev_fd(dev),
+ &namespace_id);
if (ret < 0) {
namespace_id = NVME_NSID_ALL;
}
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
.nsid = namespace_id,
.lpo = 0,
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
.nsid = NVME_NSID_ALL,
.lpo = 0,
}
/* Get the 0xC0 log data */
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
- WDC_NVME_EOL_STATUS_LOG_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ WDC_NVME_EOL_STATUS_LOG_LEN,
+ data);
if (strcmp(format, "json"))
nvme_show_status(ret);
}
/* Get the 0xC0 log data */
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
- WDC_NVME_SMART_CLOUD_ATTR_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
+ WDC_NVME_SMART_CLOUD_ATTR_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
case WDC_NVME_SN820CL_DEV_ID:
/* Get the 0xC0 Extended Smart Cloud Attribute log data */
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, uuid_index, namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data,
+ uuid_index, namespace_id);
if (strcmp(format, "json"))
nvme_show_status(ret);
memset(data, 0, sizeof (__u8) * WDC_FB_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_FB_CA_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ WDC_FB_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
memset(data, 0, sizeof (__u8) * WDC_FB_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_FB_CA_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ WDC_FB_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
}
memset(data, 0, sizeof (__u8) * WDC_BD_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_BD_CA_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ WDC_BD_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
}
memset(data, 0, sizeof (__u8) * WDC_ADD_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_ADD_LOG_OPCODE,
- WDC_ADD_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_NVME_ADD_LOG_OPCODE,
+ WDC_ADD_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
if (ret == 0) {
}
memset(data, 0, sizeof (__u8) * WDC_LATENCY_MON_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_LATENCY_MON_OPCODE,
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_LATENCY_MON_OPCODE,
WDC_LATENCY_MON_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
}
memset(data, 0, sizeof (__u8) * WDC_ERROR_REC_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_ERROR_REC_LOG_ID,
- WDC_ERROR_REC_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_ERROR_REC_LOG_ID,
+ WDC_ERROR_REC_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret, false), ret);
}
memset(data, 0, sizeof (__u8) * WDC_DEV_CAP_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_DEV_CAP_LOG_ID,
- WDC_DEV_CAP_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_DEV_CAP_LOG_ID,
+ WDC_DEV_CAP_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret, false), ret);
}
memset(data, 0, sizeof (__u8) * WDC_UNSUPPORTED_REQS_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_UNSUPPORTED_REQS_LOG_ID,
- WDC_UNSUPPORTED_REQS_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_UNSUPPORTED_REQS_LOG_ID,
+ WDC_UNSUPPORTED_REQS_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret, false), ret);
}
memset(data, 0, sizeof (__u8) * WDC_NVME_VU_SMART_LOG_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE,
- WDC_NVME_VU_SMART_LOG_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_VU_SMART_LOG_OPCODE,
+ WDC_NVME_VU_SMART_LOG_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
}
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
+ cfg.namespace_id);
if (strcmp(cfg.output_format, "json"))
nvme_show_status(ret);
goto out;
}
- ret = nvme_get_hw_rev_log(dev->fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_hw_rev_log(dev_fd(dev), &data, 0, cfg.namespace_id);
if (strcmp(cfg.output_format, "json"))
nvme_show_status(ret);
}
/* get data units written from the smart log page */
- ret = nvme_get_log_smart(dev->fd, cfg.namespace_id, false, &smart_log);
+ ret = nvme_get_log_smart(dev_fd(dev), 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(dev->fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
+ cfg.namespace_id);
if (ret == 0) {
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
}
if (capabilities & WDC_DRIVE_CAP_CLEAR_PCIE) {
- ret = wdc_do_clear_pcie_correctable_errors(dev->fd);
+ ret = wdc_do_clear_pcie_correctable_errors(dev_fd(dev));
}
else if (capabilities & WDC_DRIVE_CAP_VUC_CLEAR_PCIE) {
- ret = wdc_do_clear_pcie_correctable_errors_vuc(dev->fd);
+ ret = wdc_do_clear_pcie_correctable_errors_vuc(dev_fd(dev));
}
else {
- ret = wdc_do_clear_pcie_correctable_errors_fid(dev->fd);
+ ret = wdc_do_clear_pcie_correctable_errors_fid(dev_fd(dev));
}
out:
admin_cmd.cdw12 = ((WDC_NVME_CLEAR_ASSERT_DUMP_SUBCMD << WDC_NVME_SUBCMD_SHIFT) |
WDC_NVME_CLEAR_ASSERT_DUMP_CMD);
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
nvme_show_status(ret);
} else
fprintf(stderr, "INFO : WDC : No Assert Dump Present\n");
memset(data, 0, sizeof (__u8) * WDC_FW_ACT_HISTORY_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID,
- WDC_FW_ACT_HISTORY_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID,
+ WDC_FW_ACT_HISTORY_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
memset(data, 0, sizeof (__u8) * WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN);
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_FW_ACT_HISTORY_C2_LOG_ID,
- WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_FW_ACT_HISTORY_C2_LOG_ID,
+ WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
.nsid = 0xFFFFFFFF,
.lpo = 0,
}
if (capabilities & WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY)
- ret = wdc_do_clear_fw_activate_history_vuc(dev->fd);
+ ret = wdc_do_clear_fw_activate_history_vuc(dev_fd(dev));
else
- ret = wdc_do_clear_fw_activate_history_fid(dev->fd);
+ ret = wdc_do_clear_fw_activate_history_fid(dev_fd(dev));
out:
nvme_free_tree(r);
}
if (cfg.disable) {
- ret = nvme_set_features_simple(dev->fd,
+ ret = nvme_set_features_simple(dev_fd(dev),
WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
0, 1, false, &result);
}
else {
if (cfg.enable) {
- ret = nvme_set_features_simple(dev->fd,
+ ret = nvme_set_features_simple(dev_fd(dev),
WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
0, 0, false, &result);
}
else if (cfg.status) {
- ret = nvme_get_features_simple(dev->fd,
+ ret = nvme_get_features_simple(dev_fd(dev),
WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
0, &result);
if (ret == 0) {
memset(sn, 0, WDC_SERIAL_NO_LEN);
memset(fw_rev, 0, WDC_NVME_FIRMWARE_REV_LEN);
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
__u32 maxTransferLenDevice = 0;
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed 0x%x\n", ret);
return -1;
cmd.cdw13 = fileId<<16;
cmd.cdw14 = spiDestn;
- ret = nvme_submit_admin_passthru(dev->fd, &cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &cmd, NULL);
if (!ret && logSize)
*logSize = cmd.result;
cmd.addr = (__u64)(__u64)(uintptr_t)dataBuffer;
cmd.data_len = *bufferSize;
- ret = nvme_submit_admin_passthru(dev->fd, &cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &cmd, NULL);
if( ret != WDC_STATUS_SUCCESS) {
fprintf(stderr, "ERROR : WDC : VUReadBuffer() failed, ");
/* Get Identify Controller Data */
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed, ret = %d\n", ret);
return -1;
}
memset(&ns, 0, sizeof (struct nvme_id_ns));
- ret = nvme_identify_ns(dev->fd, 1, &ns);
+ ret = nvme_identify_ns(dev_fd(dev), 1, &ns);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ns() failed, ret = %d\n", ret);
} else {
dataBuffer = calloc(1, elogBufferSize);
elogBuffer = (struct nvme_error_log_page *)dataBuffer;
- ret = nvme_get_log_error(dev->fd, elogNumEntries, false, elogBuffer);
+ ret = nvme_get_log_error(dev_fd(dev), elogNumEntries, false,
+ elogBuffer);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_error_log() failed, ret = %d\n", ret);
} else {
/* Get Smart log page */
memset(&smart_log, 0, sizeof (struct nvme_smart_log));
- ret = nvme_get_log_smart(dev->fd, NVME_NSID_ALL, false, &smart_log);
+ ret = nvme_get_log_smart(dev_fd(dev), NVME_NSID_ALL, false,
+ &smart_log);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_smart_log() failed, ret = %d\n", ret);
} else {
/* Get FW Slot log page */
memset(&fw_log, 0, sizeof (struct nvme_firmware_slot));
- ret = nvme_get_log_fw_slot(dev->fd, false, &fw_log);
+ ret = nvme_get_log_fw_slot(dev_fd(dev), false, &fw_log);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_fw_log() failed, ret = %d\n", ret);
} else {
dataBuffer = calloc(1, dataBufferSize);
memset(dataBuffer, 0, dataBufferSize);
- ret = nvme_get_log_simple(dev->fd, deVULogPagesList[vuLogIdx].logPageId,
- dataBufferSize, dataBuffer);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ deVULogPagesList[vuLogIdx].logPageId,
+ dataBufferSize, dataBuffer);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_get_log() for log page 0x%x failed, ret = %d\n",
deVULogPagesList[vuLogIdx].logPageId, ret);
/* skipping LbaRangeType as it is an optional nvme command and not supported */
if (deFeatureIdList[listIdx].featureId == FID_LBA_RANGE_TYPE)
continue;
- ret = nvme_get_features_data(dev->fd,
+ ret = nvme_get_features_data(dev_fd(dev),
deFeatureIdList[listIdx].featureId,
WDC_DE_GLOBAL_NSID,
sizeof(featureIdBuff),
WDC_NVME_DRIVE_RESIZE_CMD);
admin_cmd.cdw13 = new_size;
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
return ret;
}
admin_cmd.nsid = nsid;
admin_cmd.cdw10 = op_option;
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
return ret;
}
admin_cmd.cdw12 = ((WDC_NVME_DRIVE_INFO_SUBCMD << WDC_NVME_SUBCMD_SHIFT) |
WDC_NVME_DRIVE_INFO_CMD);
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
if (!ret && result)
*result = admin_cmd.result;
j = sizeof (ctrl.mn) - 1;
memset(drive_reason_id, 0, len);
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
int ret = 0;
if (log_id == NVME_LOG_LID_TELEMETRY_HOST)
- ret = nvme_get_log_create_telemetry_host(dev->fd, log_hdr);
+ ret = nvme_get_log_create_telemetry_host(dev_fd(dev), log_hdr);
else
- ret = nvme_get_log_telemetry_ctrl(dev->fd, false, 0, 512,
+ ret = nvme_get_log_telemetry_ctrl(dev_fd(dev), false, 0, 512,
(void *)log_hdr);
if (ret < 0)
uint8_t *data = NULL;
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
+ NVME_NSID_ALL);
if (ret) {
fprintf(stderr, "ERROR : WDC : %s : Failed to retreive NAND stats\n", __func__);
goto out;
}
- ret = nvme_get_log_simple(dev->fd, WDC_NVME_NAND_STATS_LOG_ID,
- WDC_NVME_NAND_STATS_SIZE, (void*)output);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_NVME_NAND_STATS_LOG_ID,
+ WDC_NVME_NAND_STATS_SIZE, (void*)output);
if (ret) {
fprintf(stderr, "ERROR : WDC : %s : Failed to retreive NAND stats\n", __func__);
goto out;
admin_cmd.addr = (__u64)(uintptr_t)pcieStatsPtr;
admin_cmd.data_len = pcie_stats_size;
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd, NULL);
return ret;
}
}
/* get the id ctrl data used to fill in drive info below */
- ret = nvme_identify_ctrl(dev->fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC %s: Identify Controller failed\n", __func__);
break;
case WDC_NVME_SN820CL_DEV_ID:
/* Get the Drive HW Rev from the C6 Log page */
- ret = nvme_get_hw_rev_log(dev->fd, &data, 0,
+ ret = nvme_get_hw_rev_log(dev_fd(dev), &data, 0,
NVME_NSID_ALL);
if (ret == 0) {
wdc_nvme_hw_rev_log *log_data = (wdc_nvme_hw_rev_log *)data;
goto out;
}
- ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data,
+ 0, NVME_NSID_ALL);
if (ret == 0) {
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
}
/* get the temperature stats or report errors */
- ret = nvme_identify_ctrl(dev->fd, &id_ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &id_ctrl);
if (ret != 0)
goto out;
- ret = nvme_get_log_smart(dev->fd, NVME_NSID_ALL, false, &smart_log);
+ ret = nvme_get_log_smart(dev_fd(dev), 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(dev->fd, 0x10, 0, &hctm_tmt);
+ nvme_get_features_simple(dev_fd(dev), 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;
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(dev->fd, &data, 0,
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
cfg.namespace_id);
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
d);
#endif
nvme_cmd.result = 0;
- err = nvme_submit_admin_passthru(dev->fd, &nvme_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev_fd(dev), &nvme_cmd, NULL);
if (err == NVME_SC_INTERNAL) {
fprintf(stderr, "%s: WARNING : WDC : No log ID:x%x available\n",
__func__, log_id);
nvme_cmd.cdw14 = cdw14;
nvme_cmd.cdw15 = cdw15;
nvme_cmd.result = 0; /* returned result !=0 indicates more data available */
- err = nvme_submit_admin_passthru(dev->fd, &nvme_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev_fd(dev),
+ &nvme_cmd, NULL);
if (err != 0) {
more = 0;
fprintf(stderr, "%s: ERROR : WDC : NVMe Rcv Mgmt ", __func__);
#ifdef WDC_NVME_CLI_DEBUG
fprintf(stderr, "nsid 0x%08x addr 0x%08llx, data_len 0x%08x, cdw10 0x%08x, cdw11 0x%08x, cdw12 0x%08x, cdw13 0x%08x, cdw14 0x%08x \n", admin_cmd.nsid, admin_cmd.addr, admin_cmd.data_len, admin_cmd.cdw10, admin_cmd.cdw11, admin_cmd.cdw12, admin_cmd.cdw13, admin_cmd.cdw14);
#endif
- ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
if (ret != 0) {
nvme_show_status(ret);
fprintf(stderr, "%s: ERROR : WDC : Get chunk %d, size = 0x%x, offset = 0x%x, addr = 0x%lx\n",
free(nm);
return -1;
}
- err = nvme_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err) {
free(nm);
free(raw);
if (err < 0)
return err;
- err = nvme_get_nsid_log(dev->fd, false, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(dev_fd(dev), false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
if (flags < 0)
goto close_fd;
- err = nvme_zns_identify_ctrl(dev->fd, &ctrl);
+ err = nvme_zns_identify_ctrl(dev_fd(dev), &ctrl);
if (!err)
nvme_show_zns_id_ctrl(&ctrl, flags);
else if (err > 0)
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_fd;
}
}
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &id_ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &id_ns);
if (err) {
nvme_show_status(err);
goto close_fd;
}
- err = nvme_zns_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_zns_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (!err)
nvme_show_zns_id_ns(&ns, &id_ns, flags);
else if (err > 0)
goto close_dev;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto free;
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = zsa,
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
if (cfg.zsa == NVME_ZNS_ZSA_SET_DESC_EXT) {
if(!cfg.data_len) {
- int data_len = get_zdes_bytes(dev->fd, cfg.namespace_id);
+ int data_len = get_zdes_bytes(dev_fd(dev),
+ cfg.namespace_id);
if (data_len == 0) {
fprintf(stderr,
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = cfg.zsa,
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = NVME_ZNS_ZSA_OPEN,
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
}
}
- data_len = get_zdes_bytes(dev->fd, cfg.namespace_id);
+ data_len = get_zdes_bytes(dev_fd(dev), cfg.namespace_id);
if (!data_len || data_len < 0) {
fprintf(stderr,
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zsa = NVME_ZNS_ZSA_SET_DESC_EXT,
return errno;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
struct nvme_zns_mgmt_send_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.lba,
.zsa = NVME_ZNS_ZSA_ZRWA_FLUSH,
goto close_dev;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
struct nvme_zns_mgmt_recv_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.slba = cfg.zslba,
.zra = cfg.zra,
flags |= VERBOSE;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
}
if (cfg.extended) {
- zdes = get_zdes_bytes(dev->fd, cfg.namespace_id);
+ zdes = get_zdes_bytes(dev_fd(dev), cfg.namespace_id);
if (zdes < 0) {
err = zdes;
goto close_dev;
}
}
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &id_ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &id_ns);
if (err) {
nvme_show_status(err);
goto close_dev;
}
- err = nvme_zns_identify_ns(dev->fd, cfg.namespace_id, &id_zns);
+ err = nvme_zns_identify_ns(dev_fd(dev), 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);
goto close_dev;
}
- err = nvme_zns_report_zones(dev->fd, cfg.namespace_id, 0,
+ err = nvme_zns_report_zones(dev_fd(dev), cfg.namespace_id, 0,
cfg.state, false, false,
log_len, buff,
NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
log_len = sizeof(struct nvme_zone_report) + ((sizeof(struct nvme_zns_desc) * nr_zones_chunks) + (nr_zones_chunks * zdes));
}
- err = nvme_zns_report_zones(dev->fd, cfg.namespace_id, offset,
+ err = nvme_zns_report_zones(dev_fd(dev), cfg.namespace_id,
+ offset,
cfg.state, cfg.extended,
cfg.partial, log_len, report,
NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
}
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_dev;
}
}
- err = nvme_identify_ns(dev->fd, cfg.namespace_id, &ns);
+ err = nvme_identify_ns(dev_fd(dev), cfg.namespace_id, &ns);
if (err) {
nvme_show_status(err);
goto close_dev;
struct nvme_zns_append_args args = {
.args_size = sizeof(args),
- .fd = dev->fd,
+ .fd = dev_fd(dev),
.nsid = cfg.namespace_id,
.zslba = cfg.zslba,
.nlb = nblocks,
goto close_fd;
if (!cfg.namespace_id) {
- err = nvme_get_nsid(dev->fd, &cfg.namespace_id);
+ err = nvme_get_nsid(dev_fd(dev), &cfg.namespace_id);
if (err < 0) {
perror("get-namespace-id");
goto close_fd;
}
}
- err = nvme_get_log_zns_changed_zones(dev->fd, cfg.namespace_id,
+ err = nvme_get_log_zns_changed_zones(dev_fd(dev), cfg.namespace_id,
cfg.rae, &log);
if (!err)
nvme_show_zns_changed(&log, flags);
projects / users / sagi / nvme-cli.git / commitdiff