#define RPMB_NVME_SECP 0xEA
#define RPMB_NVME_SPSP 0x0001
-#define SEND_RPMB_REQ(tgt, size, req) \
-nvme_security_send(fd, 0, tgt, RPMB_NVME_SPSP, 0, RPMB_NVME_SECP, 0, size, \
- (unsigned char *)(req), NVME_DEFAULT_IOCTL_TIMEOUT, NULL)
-
-#define RECV_RPMB_RSP(tgt, size, rsp) \
-nvme_security_receive(fd, 0, tgt, RPMB_NVME_SPSP, 0, RPMB_NVME_SECP, 0, size, \
- (unsigned char *)(rsp), NVME_DEFAULT_IOCTL_TIMEOUT, NULL)
-
+static int send_rpmb_req(int fd, unsigned char tgt, int size,
+ struct rpmb_data_frame_t *req)
+{
+ struct nvme_security_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = 0,
+ .nssf = tgt,
+ .spsp0 = RPMB_NVME_SPSP,
+ .spsp1 = 0,
+ .secp = RPMB_NVME_SECP,
+ .tl = 0,
+ .data_len = size,
+ .data = (void *)req,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+
+ return nvme_security_send(&args);
+}
+
+static int recv_rpmb_rsp(int fd, int tgt, int size,
+ struct rpmb_data_frame_t *rsp)
+{
+
+ struct nvme_security_receive_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = 0,
+ .nssf = tgt,
+ .spsp0 = RPMB_NVME_SPSP,
+ .spsp1 = 0,
+ .secp = RPMB_NVME_SECP,
+ .al = 0,
+ .data_len = size,
+ .data = (void *)rsp,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+
+ return nvme_security_receive(&args);
+}
+
/* Initialize nonce value in rpmb request frame */
static void rpmb_nonce_init(struct rpmb_data_frame_t *req)
{
sprintf((char *)msg, "RPMB request 0x%04x to target 0x%x",
req->type, req->target);
- error = SEND_RPMB_REQ(req->target, req_size, req);
+ error = send_rpmb_req(fd, req->target, req_size, req);
if (error != 0) {
fprintf(stderr, "%s failed with error = 0x%x\n",
msg, error);
}
/* Read result of previous request */
- error = RECV_RPMB_RSP(req->target, rsp_size, rsp);
+ error = recv_rpmb_rsp(fd, req->target, rsp_size, rsp);
if (error) {
fprintf(stderr, "error 0x%x receiving response for %s\n",
error, msg);
/* re-use response buffer */
memset(rsp, 0, rsp_size);
- err = RECV_RPMB_RSP(req->target, rsp_size, (unsigned char *)rsp);
+ err = recv_rpmb_rsp(fd, req->target, rsp_size, rsp);
if (err != 0) {
err = check_rpmb_response(req, rsp, "Failed to Program Key");
}
memcpy(req->mac, mac, 32);
/* send the request and get response */
- error = SEND_RPMB_REQ(tgt, req_size, (unsigned char *)req);
+ error = send_rpmb_req(fd, tgt, req_size, req);
if (error != 0) {
fprintf(stderr, "RPMB request 0x%04x for 0x%x, error: %d\n",
req->type, tgt, error);
rsp = (struct rpmb_data_frame_t *)calloc(rsp_size, 1);
rsp->target = req->target;
rsp->type = RPMB_REQ_READ_RESULT;
- error = SEND_RPMB_REQ(tgt, rsp_size, (unsigned char *)rsp);
+ error = send_rpmb_req(fd, tgt, rsp_size, rsp);
if (error != 0 || rsp->result != 0) {
fprintf(stderr, "Write-data read result 0x%x, error = 0x%x\n",
rsp->result, error);
/* Read final response */
memset(rsp, 0, rsp_size);
- error = RECV_RPMB_RSP(tgt, rsp_size, (unsigned char *)rsp);
+ error = recv_rpmb_rsp(fd, tgt, rsp_size, rsp);
if (error != 0)
fprintf(stderr, "Auth data write recv error = 0x%x\n", error);
else
memcpy(req->mac, mac, sizeof(req->mac));
- error = SEND_RPMB_REQ(0, req_size, (unsigned char *)req);
+ error = send_rpmb_req(fd, 0, req_size, req);
if (error != 0) {
fprintf(stderr, "Write-config RPMB request, error = 0x%x\n",
error);
rsp->target = req->target;
rsp->type = RPMB_REQ_READ_RESULT;
/* get the response and validate */
- error = RECV_RPMB_RSP(req->target, rsp_size, rsp);
+ error = recv_rpmb_rsp(fd, req->target, rsp_size, rsp);
if (error != 0) {
fprintf(stderr,"Failed getting write-config response\
error = 0x%x\n", error);
}
memset(buf, 0, len);
- err = nvme_get_features(fd, NVME_NSID_ALL,
- NVME_FEAT_FID_HOST_BEHAVIOR, 0, 0, 0,
- len, buf, NVME_DEFAULT_IOCTL_TIMEOUT,
- &result);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = NVME_FEAT_FID_HOST_BEHAVIOR,
+ .nsid = NVME_NSID_ALL,
+ .sel = 0,
+ .cdw11 = 0,
+ .uuidx = 0,
+ .data_len = len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_get_features(&args);
if (err > 0) {
nvme_show_status(err);
} else if (err < 0) {
goto close_fd;
}
- err = nvme_get_log(fd, cfg.log_id, cfg.namespace_id,
- cfg.lpo, cfg.lsp, cfg.lsi, cfg.rae,
- cfg.uuid_index, cfg.csi, cfg.ot,
- cfg.log_len, log, NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = cfg.log_id,
+ .nsid = cfg.namespace_id,
+ .lpo = cfg.lpo,
+ .lsp = cfg.lsp,
+ .lsi = cfg.lsi,
+ .rae = cfg.rae,
+ .uuidx = cfg.uuid_index,
+ .csi = cfg.csi,
+ .ot = cfg.ot,
+ .len = cfg.log_len,
+ .log = log,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_get_log(&args);
if (!err) {
if (!cfg.raw_binary) {
printf("Device:%s log-id:%d namespace-id:%#x\n",
if (fd < 0)
goto ret;
- err = nvme_virtual_mgmt(fd, cfg.act, cfg.rt, cfg.cntlid, cfg.nr, &result);
+ struct nvme_virtual_mgmt_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .act = cfg.act,
+ .rt = cfg.rt,
+ .cntlid = cfg.cntlid,
+ .nr = cfg.nr,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_virtual_mgmt(&args);
if (!err) {
printf("success, Number of Controller Resources Modified "\
"(NRM):%#x\n", result);
if (fd < 0)
goto ret;
- err = nvme_dev_self_test(fd, cfg.namespace_id, cfg.stc);
+ struct nvme_dev_self_test_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .stc = cfg.stc,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_dev_self_test(&args);
if (!err) {
if (cfg.stc == 0xf)
printf("Aborting device self-test operation\n");
memset(*buf, 0, cfg->data_len);
}
- return nvme_get_features(fd, cfg->feature_id, cfg->namespace_id,
- cfg->sel, cfg->cdw11, cfg->uuid_index,
- cfg->data_len, *buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, result);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg->feature_id,
+ .nsid = cfg->namespace_id,
+ .sel = cfg->sel,
+ .cdw11 = cfg->cdw11,
+ .uuidx = cfg->uuid_index,
+ .data_len = cfg->data_len,
+ .data = *buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = result,
+ };
+ return nvme_get_features(&args);
}
static void get_feature_id_print(struct feat_cfg cfg, int err, __u32 result,
while (fw_size > 0) {
cfg.xfer = min(cfg.xfer, fw_size);
- err = nvme_fw_download(fd, cfg.offset, cfg.xfer, fw_buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_fw_download_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .offset = cfg.offset,
+ .data_len = cfg.xfer,
+ .data = fw_buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_fw_download(&args);
if (err < 0) {
perror("fw-download");
break;
goto close_fd;
}
- err = nvme_fw_commit(fd, cfg.slot, cfg.action, cfg.bpid, &result);
+ struct nvme_fw_commit_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .slot = cfg.slot,
+ .action = cfg.action,
+ .bpid = cfg.bpid,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_fw_commit(&args);
if (err < 0)
perror("fw-commit");
else if (err != 0)
}
}
- ret = nvme_sanitize_nvm(fd, cfg.sanact, cfg.ause, cfg.owpass, cfg.oipbp,
- cfg.no_dealloc, cfg.ovrpat,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_sanitize_nvm_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .sanact = cfg.sanact,
+ .ause = cfg.ause,
+ .owpass = cfg.owpass,
+ .oipbp = cfg.oipbp,
+ .nodas = cfg.no_dealloc,
+ .ovrpat = cfg.ovrpat,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_sanitize_nvm(&args);
if (ret < 0)
perror("sanitize");
else if (ret > 0)
memset(*pbar, 0xff, size);
for (offset = NVME_REG_CAP; offset <= NVME_REG_CMBSZ;) {
- err = nvme_get_property(fd, offset, &value,
- NVME_DEFAULT_IOCTL_TIMEOUT);
+ struct nvme_get_property_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .offset = offset,
+ .value = &value,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ };
+ err = nvme_get_property(&args);
if (err > 0 && (err & 0xff) == NVME_SC_INVALID_FIELD) {
err = 0;
value = -1;
goto close_fd;
}
- err = nvme_get_property(fd, cfg.offset, &value,
- NVME_DEFAULT_IOCTL_TIMEOUT);
+ struct nvme_get_property_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .offset = cfg.offset,
+ .value = &value,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ };
+ err = nvme_get_property(&args);
if (err < 0) {
perror("get-property");
} else if (!err) {
goto close_fd;
}
- err = nvme_set_property(fd, cfg.offset, cfg.value,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_set_property_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .offset = cfg.offset,
+ .value = cfg.value,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_set_property(&args);
if (err < 0) {
perror("set-property");
} else if (!err) {
fprintf(stderr, "Sending format operation ... \n");
}
- err = nvme_format_nvm(fd, cfg.namespace_id, cfg.lbaf, cfg.ms, cfg.pi,
- cfg.pil, cfg.ses, cfg.timeout, NULL);
+ struct nvme_format_nvm_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .lbaf = cfg.lbaf,
+ .mset = cfg.ms,
+ .pi = cfg.pi,
+ .pil = cfg.pil,
+ .ses = cfg.ses,
+ .timeout = cfg.timeout,
+ .result = NULL,
+ };
+ err = nvme_format_nvm(&args);
if (err < 0)
perror("format");
else if (err != 0)
}
}
- err = nvme_set_features(fd, cfg.feature_id, cfg.namespace_id, cfg.value,
- cfg.cdw12, cfg.save, cfg.uuid_index, 0,
- cfg.data_len, buf, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg.feature_id,
+ .nsid = cfg.namespace_id,
+ .cdw11 = cfg.value,
+ .cdw12 = cfg.cdw12,
+ .save = cfg.save,
+ .uuidx = cfg.uuid_index,
+ .cdw15 = 0,
+ .data_len = cfg.data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err < 0) {
perror("set-feature");
} else if (!err) {
goto free;
}
- err = nvme_security_send(fd, cfg.namespace_id, cfg.nssf,
- cfg.spsp & 0xff, cfg.spsp >> 8, cfg.secp,
- cfg.tl, cfg.tl, sec_buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_security_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .nssf = cfg.nssf,
+ .spsp0 = cfg.spsp & 0xff,
+ .spsp1 = cfg.spsp >> 8,
+ .secp = cfg.secp,
+ .tl = cfg.tl,
+ .data_len = cfg.tl,
+ .data = sec_buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_security_send(&args);
if (err < 0)
perror("security-send");
else if (err != 0)
}
}
- err = nvme_directive_send(fd, cfg.namespace_id, cfg.dspec, cfg.doper,
- cfg.dtype, dw12, cfg.data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_directive_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .dspec = cfg.dspec,
+ .doper = cfg.doper,
+ .dtype = cfg.dtype,
+ .cdw12 = dw12,
+ .data_len = cfg.data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_directive_send(&args);
if (err < 0) {
perror("dir-send");
goto close_ffd;
}
}
- err = nvme_write_uncorrectable(fd, cfg.namespace_id, cfg.start_block,
- cfg.block_count, NVME_DEFAULT_IOCTL_TIMEOUT);
+ struct nvme_io_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.start_block,
+ .nlb = cfg.block_count,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_write_uncorrectable(&args);
if (err < 0)
perror("write uncorrectable");
else if (err != 0)
}
}
- err = nvme_write_zeros(fd, cfg.namespace_id, cfg.start_block,
- cfg.block_count, control, cfg.ref_tag,
- cfg.app_tag, cfg.app_tag_mask, cfg.storage_tag,
- NVME_DEFAULT_IOCTL_TIMEOUT);
+ struct nvme_io_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.start_block,
+ .nlb = cfg.block_count,
+ .control = control,
+ .reftag = cfg.ref_tag,
+ .apptag = cfg.app_tag,
+ .appmask = cfg.app_tag_mask,
+ .storage_tag = cfg.storage_tag,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_write_zeros(&args);
if (err < 0)
perror("write-zeroes");
else if (err != 0)
cfg.cdw11 = (cfg.ad << 2) | (cfg.idw << 1) | (cfg.idr << 0);
nvme_init_dsm_range(dsm, ctx_attrs, nlbs, slbas, nr);
- err = nvme_dsm(fd, cfg.namespace_id, cfg.cdw11, nr, dsm,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_dsm_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .attrs = cfg.cdw11,
+ .nr_ranges = nr,
+ .dsm = dsm,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_dsm(&args);
if (err < 0)
perror("data-set management");
else if (err != 0)
nvme_init_copy_range(copy, nlbs, (__u64 *)slbas, eilbrts, elbatms, elbats, nr);
- err = nvme_copy(fd, cfg.namespace_id, copy, cfg.sdlba, nr, cfg.prinfor,
- cfg.prinfow, cfg.dtype, cfg.dspec, cfg.format, cfg.lr,
- cfg.fua, cfg.ilbrt, cfg.lbatm, cfg.lbat,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_copy_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .copy = copy,
+ .sdlba = cfg.sdlba,
+ .nr = nr,
+ .prinfor = cfg.prinfor,
+ .dtype = cfg.dtype,
+ .dspec = cfg.dspec,
+ .format = cfg.format,
+ .lr = cfg.lr,
+ .fua = cfg.fua,
+ .ilbrt = cfg.ilbrt,
+ .lbatm = cfg.lbatm,
+ .lbat = cfg.lbat,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_copy(&args);
if (err < 0)
perror("NVMe Copy");
else if (err != 0)
goto close_fd;
}
- err = nvme_resv_acquire(fd, cfg.namespace_id, cfg.rtype, cfg.racqa,
- !!cfg.iekey, cfg.crkey, cfg.prkey,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_resv_acquire_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .rtype = cfg.rtype,
+ .racqa = cfg.racqa,
+ .iekey = !!cfg.iekey,
+ .crkey = cfg.crkey,
+ .nrkey = cfg.prkey,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_resv_acquire(&args);
if (err < 0)
perror("reservation acquire");
else if (err != 0)
goto close_fd;
}
- err = nvme_resv_register(fd, cfg.namespace_id, cfg.rrega, cfg.cptpl,
- !!cfg.iekey, cfg.crkey, cfg.nrkey,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_resv_register_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .rrega = cfg.rrega,
+ .cptpl = cfg.cptpl,
+ .iekey = !!cfg.iekey,
+ .crkey = cfg.crkey,
+ .nrkey = cfg.nrkey,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_resv_register(&args);
if (err < 0)
perror("reservation register");
else if (err != 0)
goto close_fd;
}
- err = nvme_resv_release(fd, cfg.namespace_id, cfg.rtype, cfg.rrela,
- !!cfg.iekey, cfg.crkey,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_resv_release_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .rtype = cfg.rtype,
+ .rrela = cfg.rrela,
+ .iekey = !!cfg.iekey,
+ .crkey = cfg.crkey,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_resv_release(&args);
if (err < 0)
perror("reservation release");
else if (err != 0)
}
memset(status, 0, size);
- err = nvme_resv_report(fd, cfg.namespace_id, cfg.eds, size, status,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_resv_report_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .eds = cfg.eds,
+ .len = size,
+ .report = status,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_resv_report(&args);
if (!err)
nvme_show_resv_report(status, size, cfg.eds, flags);
else if (err > 0)
if (cfg.dry_run)
goto free_mbuffer;
+ struct nvme_io_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.start_block,
+ .nlb = cfg.block_count,
+ .control = control,
+ .dsm = dsmgmt,
+ .dspec = 0,
+ .reftag = cfg.ref_tag,
+ .apptag = cfg.app_tag,
+ .appmask = cfg.app_tag_mask,
+ .storage_tag = cfg.storage_tag,
+ .data_len = buffer_size,
+ .data = buffer,
+ .metadata_len = cfg.metadata_size,
+ .metadata = mbuffer,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
gettimeofday(&start_time, NULL);
if (opcode & 1)
- err = nvme_write(fd, cfg.namespace_id, cfg.start_block,
- cfg.block_count, control, dsmgmt, 0, cfg.ref_tag,
- cfg.app_tag, cfg.app_tag_mask, cfg.storage_tag,
- buffer_size, buffer, cfg.metadata_size, mbuffer,
- NVME_DEFAULT_IOCTL_TIMEOUT);
+ err = nvme_write(&args);
else
- err = nvme_read(fd, cfg.namespace_id, cfg.start_block,
- cfg.block_count, control, dsmgmt, cfg.ref_tag,
- cfg.app_tag, cfg.app_tag_mask, cfg.storage_tag,
- buffer_size, buffer, cfg.metadata_size, mbuffer,
- NVME_DEFAULT_IOCTL_TIMEOUT);
+ err = nvme_read(&args);
gettimeofday(&end_time, NULL);
if (cfg.latency)
printf(" latency: %s: %llu us\n",
}
}
- err = nvme_verify(fd, cfg.namespace_id, cfg.start_block,
- cfg.block_count, control, cfg.ref_tag,
- cfg.app_tag, cfg.app_tag_mask, cfg.storage_tag,
- NVME_DEFAULT_IOCTL_TIMEOUT);
+ struct nvme_io_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.start_block,
+ .nlb = cfg.block_count,
+ .control = control,
+ .reftag = cfg.ref_tag,
+ .apptag = cfg.app_tag,
+ .appmask = cfg.app_tag_mask,
+ .storage_tag = cfg.storage_tag,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_verify(&args);
if (err < 0)
perror("verify");
else if (err != 0)
}
}
- err = nvme_security_receive(fd, cfg.namespace_id, cfg.nssf,
- cfg.spsp & 0xff, cfg.spsp >> 8,
- cfg.secp, cfg.al, cfg.size, sec_buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_security_receive_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .nssf = cfg.nssf,
+ .spsp0 = cfg.spsp & 0xff,
+ .spsp1 = cfg.spsp >> 8,
+ .secp = cfg.secp,
+ .al = cfg.al,
+ .data_len = cfg.size,
+ .data = sec_buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_security_receive(&args);
if (err < 0)
perror("security receive");
else if (err != 0)
goto close_fd;
}
- err = nvme_get_lba_status(fd, cfg.namespace_id, cfg.slba, cfg.mndw,
- cfg.atype, cfg.rl, NVME_DEFAULT_IOCTL_TIMEOUT,
- buf, NULL);
+ struct nvme_get_lba_status_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.slba,
+ .mndw = cfg.mndw,
+ .rl = cfg.rl,
+ .atype = cfg.atype,
+ .lbas = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_get_lba_status(&args);
if (!err)
nvme_show_lba_status(buf, buf_len, flags);
else if (err > 0)
goto close_fd;
}
- err = nvme_capacity_mgmt(fd, cfg.operation, cfg.element_id, cfg.dw11,
- cfg.dw12, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_capacity_mgmt_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .op = cfg.operation,
+ .element_id = cfg.element_id,
+ .cdw11 = cfg.dw11,
+ .cdw12 = cfg.dw12,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_capacity_mgmt(&args);
if (!err) {
printf("Capacity Management Command is Success\n");
if (cfg.operation == 1) {
memset(buf, 0, cfg.data_len);
}
- err = nvme_directive_recv(fd, cfg.namespace_id, cfg.dspec, cfg.doper,
- cfg.dtype, dw12, cfg.data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_directive_recv_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .dspec = cfg.dspec,
+ .doper = cfg.doper,
+ .dtype = cfg.dtype,
+ .cdw12 = dw12,
+ .data_len = cfg.data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_directive_recv(&args);
if (!err)
nvme_directive_show(cfg.dtype, cfg.doper, cfg.dspec,
cfg.namespace_id, result, buf, cfg.data_len,
goto close_fd;
}
- err = nvme_lockdown(fd, cfg.scp,cfg.prhbt,cfg.ifc,cfg.ofi,
- cfg.uuid);
-
+ struct nvme_lockdown_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .scp = cfg.scp,
+ .prhbt = cfg.prhbt,
+ .ifc = cfg.ifc,
+ .ofi = cfg.ofi,
+ .uuidx = cfg.uuid,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_lockdown(&args);
if (err < 0)
perror("lockdown");
else if (err > 0)
__u32 thresholds[OPTANE_V1000_BUCKET_LEN] = {0};
__u32 result;
- err = nvme_get_features(fd, 0xf7, 0, 0, cfg.write ? 0x1 : 0x0, 0,
- sizeof(thresholds), thresholds,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = 0xf7,
+ .nsid = 0,
+ .sel = 0,
+ .cdw11 = cfg.write ? 0x1 : 0x0,
+ .uuidx = 0,
+ .data_len = sizeof(thresholds),
+ .data = thresholds,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_get_features(&args);
if (err) {
fprintf(stderr, "Quering thresholds failed. ");
nvme_show_status(err);
if (fd < 0)
return fd;
+
+ struct nvme_get_features_args args_get = {
+ .args_size = sizeof(args_get),
+ .fd = fd,
+ .fid = fid,
+ .nsid = nsid,
+ .sel = sel,
+ .cdw11 = cdw11,
+ .uuidx = 0,
+ .data_len = data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+
+ struct nvme_set_features_args args_set = {
+ .args_size = sizeof(args_set),
+ .fd = fd,
+ .fid = fid,
+ .nsid = nsid,
+ .cdw11 = option,
+ .cdw12 = cdw12,
+ .save = save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+
switch (option) {
case None:
- err = nvme_get_features(fd, fid, nsid, sel, cdw11, 0, data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ err = nvme_get_features(&args_get);
if (!err) {
printf(
"Latency Statistics Tracking (FID 0x%X) is currently (%i).\n",
break;
case True:
case False:
- err = nvme_set_features(fd, fid, nsid, option, cdw12, save, 0,
- 0, data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ err = nvme_set_features(&args_set);
if (err > 0) {
nvme_show_status(err);
} else if (err < 0) {
}
- err = nvme_set_features(fd, fid, nsid, cfg.write ? 0x1 : 0x0,
- cdw12, save, 0, 0, sizeof(thresholds),
- thresholds, NVME_DEFAULT_IOCTL_TIMEOUT,
- &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = fid,
+ .nsid = nsid,
+ .cdw11 = cfg.write ? 0x1 : 0x0,
+ .cdw12 = cdw12,
+ .save = save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = sizeof(thresholds),
+ .data = thresholds,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err > 0) {
nvme_show_status(err);
if (fd < 0)
return fd;
- err = nvme_get_nsid_log(fd, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
fd = parse_and_open(argc, argv, desc, opts);
if (fd < 0) return fd;
- err = nvme_get_features(fd, feature_id, 0, 0, 0, 0, 0, NULL,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = feature_id,
+ .nsid = 0,
+ .sel = 0,
+ .cdw11 = 0,
+ .uuidx = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_get_features(&args);
if (err < 0) {
perror("get-feature");
}
fd = parse_and_open(argc, argv, desc, opts);
if (fd < 0) return fd;
- err = nvme_set_features(fd, cfg.feature_id, 0, cfg.value, 0, cfg.save,
- 0, 0, 0, NULL, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg.feature_id,
+ .nsid = 0,
+ .cdw11 = cfg.value,
+ .cdw12 = 0,
+ .save = cfg.save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err < 0) {
perror("set-feature");
}
}
cfg.value = (param1 << MB_FEAT_HIGH_LATENCY_VALUE_SHIFT) | param2;
- err = nvme_set_features(fd, cfg.feature_id, 0, cfg.value, 0, 0, 0, 0, 0,
- NULL, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg.feature_id,
+ .nsid = 0,
+ .cdw11 = cfg.value,
+ .cdw12 = 0,
+ .save = false,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err < 0) {
perror("set-feature");
}
while (fw_size > 0) {
xfer = min(xfer, fw_size);
- err = nvme_fw_download(fd, offset, xfer, fw_buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_fw_download_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .offset = offset,
+ .data_len = xfer,
+ .data = fw_buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_fw_download(&args);
if (err < 0) {
perror("fw-download");
goto out;
if (fd < 0)
return fd;
-
-
- err = nvme_set_features(fd, cfg.feature_id, 0, cfg.value, 0, cfg.save,
- 0, 0, 0, NULL, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg.feature_id,
+ .nsid = 0,
+ .cdw11 = cfg.value,
+ .cdw12 = 0,
+ .save = cfg.save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err < 0) {
perror("set-feature");
}
else if (cfg.enable || cfg.disable)
option = cfg.enable;
+ struct nvme_get_features_args args_get = {
+ .args_size = sizeof(args_get),
+ .fd = fd,
+ .fid = fid,
+ .nsid = nsid,
+ .sel = sel,
+ .cdw11 = cdw11,
+ .uuidx = 0,
+ .data_len = data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+
+ struct nvme_set_features_args args_set = {
+ .args_size = sizeof(args_set),
+ .fd = fd,
+ .fid = fid,
+ .nsid = nsid,
+ .cdw11 = option,
+ .cdw12 = cdw12,
+ .save = save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+
if (fd < 0)
return fd;
switch (option) {
case None:
- err = nvme_get_features(fd, nsid, fid, sel, cdw11, 0,
- data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ err = nvme_get_features(&args_get);
if (!err) {
printf(
"Latency Statistics Tracking (FID 0x%X) is currently (%i).\n",
break;
case True:
case False:
- err = nvme_set_features(fd, fid, nsid, option, cdw12, save,
- 0, 0, data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ err = nvme_set_features(&args_set);
if (err > 0) {
nvme_show_status(err);
} else if (err < 0) {
while (fw_size > 0) {
xfer = min(xfer, fw_size);
- err = nvme_fw_download(fd, offset, xfer, fw_buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_fw_download_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .offset = offset,
+ .data_len = xfer,
+ .data = fw_buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_fw_download(&args);
if (err < 0) {
perror("fw-download");
goto out;
struct command *cmd, struct plugin *plugin)
{
__u32 result = 0;
- __u32 cdw10 = 0;
__u32 cdw11 = 0;
const char *desc = "Enable/Disable/Get status of SMBUS option on controller";
const char *option = "enable or disable or status";
}
}
else if (!strcmp(opt.option, "status")) {
- cdw10 = opt.value;
- err = nvme_get_features(fd, fid, 1, 0, cdw10, 0, 0, NULL,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = fid,
+ .nsid = 1,
+ .sel = opt.value,
+ .cdw11 = 0,
+ .uuidx = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_get_features(&args);
if (err == 0) {
printf("SMBus status on the drive: %s (returns %s temperature) \n",
(result & 1) ? "enabled" : "disabled",
bufp = NULL;
}
- err = nvme_get_features(fd, fmap[i].id, 1, 0, 0x0, 0, len, bufp,
- NVME_DEFAULT_IOCTL_TIMEOUT, &attrVal);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = fmap[i].id,
+ .nsid = 1,
+ .sel = 0,
+ .cdw11 = 0x0,
+ .uuidx = 0,
+ .data_len = len,
+ .data = bufp,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &attrVal,
+ };
+ err = nvme_get_features(&args);
if (err == 0) {
sprintf(msg, "feature: 0x%X", fmap[i].id);
WriteData((__u8*)&attrVal, sizeof(attrVal), dir, fmap[i].file, msg);
}
if (!strcmp(opt.option, "enable")) {
- err = nvme_set_features(fd, fid, 1, 1, 0, (opt.select & 0x1),
- 0, 0, 0, 0, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = fid,
+ .nsid = 1,
+ .cdw11 = 1,
+ .cdw12 = 0,
+ .save = (opt.select & 0x1),
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err == 0) {
printf("successfully set controller telemetry option\n");
} else {
printf("Failed to set controller telemetry option\n");
}
} else if (!strcmp(opt.option, "disable")) {
- err = nvme_set_features(fd, fid, 1, 0, 0, (opt.select & 0x1),
- 0, 0, 0, 0, NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = fid,
+ .nsid = 1,
+ .cdw11 = 0,
+ .cdw12 = 0,
+ .save = (opt.select & 0x1),
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err == 0) {
printf("successfully disabled controller telemetry option\n");
} else {
printf("Failed to disable controller telemetry option\n");
}
} else if (!strcmp(opt.option, "status")) {
- opt.select &= 0x3;
- err = nvme_get_features(fd, fid, 1, opt.select, 0, 0, 0, 0,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ ;
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = fid,
+ .nsid = 1,
+ .sel = opt.select & 0x3,
+ .cdw11 = 0,
+ .uuidx = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_get_features(&args);
if (err == 0) {
printf("Controller telemetry option : %s\n",
(result) ? "enabled" : "disabled");
fd = parse_and_open(argc, argv, desc, opts);
- err = nvme_get_nsid_log(fd, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), (void *)&smart_log);
if (!err) {
if (cfg.json)
dump_fd = STDOUT_FILENO;
cfg.log_id = (cfg.log_id << 8) | 0x07;
- err = nvme_get_nsid_log(fd, cfg.log_id, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, cfg.log_id, cfg.namespace_id,
sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
memset(log, 0, blksToGet * 512);
- err = nvme_get_log(fd, cfg.log_id, cfg.namespace_id, offset,
- 0, 0, true, 0, NVME_CSI_NVM, false,
- blksToGet * 512, (void *)log,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = cfg.log_id,
+ .nsid = cfg.namespace_id,
+ .lpo = offset,
+ .lsp = 0,
+ .lsi = 0,
+ .rae = true,
+ .uuidx = 0,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = blksToGet * 512,
+ .log = (void *)log,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_get_log(&args);
if (!err) {
offset += blksToGet * 512;
dump_fd = STDOUT_FILENO;
log_id = 0x08;
- err = nvme_get_nsid_log(fd, log_id, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, log_id, cfg.namespace_id,
sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
memset(log, 0, blksToGet * 512);
- err = nvme_get_log(fd, log_id, cfg.namespace_id, offset, 0, 0,
- true, 0, NVME_CSI_NVM, false,
- blksToGet * 512, (void *)log,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = log_id,
+ .nsid = cfg.namespace_id,
+ .lpo = offset,
+ .lsp = 0,
+ .lsi = 0,
+ .rae = true,
+ .uuidx = 0,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = blksToGet * 512,
+ .log = (void *)log,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_get_log(&args);
if (!err) {
offset += blksToGet * 512;
}
log_id = 0x08;
- err = nvme_get_nsid_log(fd, log_id, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, log_id, cfg.namespace_id,
sizeof(tele_log), (void *)(&tele_log));
if (!err) {
maxBlk = tele_log.tele_data_area3;
memset(log, 0, blksToGet * 512);
- err = nvme_get_log(fd, log_id, cfg.namespace_id, offset, 0, 0,
- true, 0, NVME_CSI_NVM, false,
- blksToGet * 512, (void *)log,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = log_id,
+ .nsid = cfg.namespace_id,
+ .lpo = offset,
+ .lsp = 0,
+ .lsi = 0,
+ .rae = true,
+ .uuidx = 0,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = blksToGet * 512,
+ .log = (void *)log,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_get_log(&args);
if (!err) {
offset += blksToGet * 512;
};
fd = parse_and_open(argc, argv, desc, opts);
- err = nvme_get_nsid_log(fd, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
memset(buf, 0, cfg.data_len);
}
- err = nvme_get_features(fd, cfg.feature_id, cfg.namespace_id, cfg.sel,
- cfg.cdw11, 0, cfg.data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg.feature_id,
+ .nsid = cfg.namespace_id,
+ .sel = cfg.sel,
+ .cdw11 = cfg.cdw11,
+ .uuidx = 0,
+ .data_len = cfg.data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_get_features(&args);
if (!err) {
#if 0
printf("get-feature:0x%02x (%s), %s value: %#08x\n", cfg.feature_id,
}
}
- err = nvme_set_features(fd, cfg.feature_id, cfg.namespace_id, cfg.value,
- 0, cfg.save, 0, 0, cfg.data_len, buf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = cfg.feature_id,
+ .nsid = cfg.namespace_id,
+ .cdw11 = cfg.value,
+ .cdw12 = 0,
+ .save = cfg.save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = cfg.data_len,
+ .data = buf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err < 0) {
perror("set-feature");
goto free;
if (err) {
goto end;
}
- err = nvme_get_nsid_log(fd, log_page, namespace_id, log_len, log);
+ err = nvme_get_nsid_log(fd, false, log_page, namespace_id, log_len, log);
if (err) {
fprintf(stderr, "%s: couldn't get log 0x%x\n", __func__,
log_page);
if (err)
goto end;
- err = nvme_set_features(fd, feature_id, namespace_id, value, cdw12,
- save, 0, 0, 0, NULL,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ struct nvme_set_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = feature_id,
+ .nsid = namespace_id,
+ .cdw11 = value,
+ .cdw12 = cdw12,
+ .save = save,
+ .uuidx = 0,
+ .cdw15 = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+ err = nvme_set_features(&args);
if (err)
fprintf(stderr, "%s: couldn't clear PCIe correctable errors \n",
__func__);
memset(data, 0, sizeof (__u8) * WDC_C2_LOG_BUF_LEN);
/* get the log page length */
- ret = nvme_get_log(fd, lid, 0xFFFFFFFF, NVME_LOG_LSP_NONE, 0, 0,
- false, uuid_ix, NVME_CSI_NVM, false,
- WDC_C2_LOG_BUF_LEN, data,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args_len = {
+ .args_size = sizeof(args_len),
+ .fd = fd,
+ .lid = lid,
+ .nsid = 0xFFFFFFFF,
+ .lpo = 0,
+ .lsp = NVME_LOG_LSP_NONE,
+ .lsi = 0,
+ .rae = false,
+ .uuidx = uuid_ix,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = WDC_C2_LOG_BUF_LEN,
+ .log = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_get_log(&args_len);
if (ret) {
fprintf(stderr, "ERROR : WDC : Unable to get 0x%x Log Page length, ret = 0x%x\n", lid, ret);
goto end;
}
/* get the log page data */
- ret = nvme_get_log(fd, lid, 0xFFFFFFFF, 0, NVME_LOG_LSP_NONE, 0, false,
- uuid_ix, NVME_CSI_NVM, false,
- le32_to_cpu(hdr_ptr->length), data,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args_data = {
+ .args_size = sizeof(args_data),
+ .fd = fd,
+ .lid = lid,
+ .nsid = 0xFFFFFFFF,
+ .lpo = 0,
+ .lsp = NVME_LOG_LSP_NONE,
+ .lsi = 0,
+ .rae = false,
+ .uuidx = uuid_ix,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = le32_to_cpu(hdr_ptr->length),
+ .log = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_get_log(&args_data);
if (ret) {
fprintf(stderr, "ERROR : WDC : Unable to read 0x%x Log Page data, ret = 0x%x\n", lid, ret);
/* not found with uuid = 1 try with uuid = 0 */
uuid_ix = 0;
/* get the log page data */
- ret = nvme_get_log(fd, lid, 0xFFFFFFFF, 0, NVME_LOG_LSP_NONE, 0, false,
- uuid_ix, NVME_CSI_NVM, false,
- le32_to_cpu(hdr_ptr->length),
- data, NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = lid,
+ .nsid = 0xFFFFFFFF,
+ .lpo = 0,
+ .lsp = NVME_LOG_LSP_NONE,
+ .lsi = 0,
+ .rae = false,
+ .uuidx = uuid_ix,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = le32_to_cpu(hdr_ptr->length),
+ .log = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_get_log(&args);
hdr_ptr = (struct wdc_c2_log_page_header *)data;
sph = (struct wdc_c2_log_subpage_header *)(data + length);
goto close_output;
}
+ struct nvme_get_features_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .fid = NVME_FEAT_FID_HOST_BEHAVIOR,
+ .nsid = NVME_NSID_ALL,
+ .sel = 0,
+ .cdw11 = 0,
+ .uuidx = 0,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+
switch (data_area) {
case 1:
full_size = (le16_to_cpu(hdr->dalb1) * WDC_TELEMETRY_BLOCK_SIZE) + WDC_TELEMETRY_HEADER_LENGTH;
}
memset(buf, 0, len);
- err = nvme_get_features(fd, NVME_NSID_ALL,
- NVME_FEAT_FID_HOST_BEHAVIOR, 0, 0, 0,
- len, buf, NVME_DEFAULT_IOCTL_TIMEOUT,
- &result);
+ args.data_len = len;
+ args.data = buf;
+ err = nvme_get_features(&args);
if (err > 0) {
nvme_show_status(err);
} else if (err < 0) {
}
/* Get the 0xC0 log data */
- ret = nvme_get_log(fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE, namespace_id, 0,
- NVME_LOG_LSP_NONE, 0, false, uuid_index, NVME_CSI_NVM,
- false, WDC_NVME_SMART_CLOUD_ATTR_LEN, data,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ .nsid = namespace_id,
+ .lpo = 0,
+ .lsp = NVME_LOG_LSP_NONE,
+ .lsi = 0,
+ .rae = false,
+ .uuidx = uuid_index,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = WDC_NVME_SMART_CLOUD_ATTR_LEN,
+ .log = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_get_log(&args);
if (strcmp(format, "json"))
nvme_show_status(ret);
}
/* Get the 0xC0 log data */
- ret = nvme_get_log(fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE, NVME_NSID_ALL, 0,
- NVME_LOG_LSP_NONE, 0, false, uuid_index,
- NVME_CSI_NVM, false,
- WDC_NVME_EOL_STATUS_LOG_LEN, data,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ .nsid = NVME_NSID_ALL,
+ .lpo = 0,
+ .lsp = NVME_LOG_LSP_NONE,
+ .lsi = 0,
+ .rae = false,
+ .uuidx = uuid_index,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = WDC_NVME_EOL_STATUS_LOG_LEN,
+ .log = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_get_log(&args);
if (strcmp(format, "json"))
nvme_show_status(ret);
}
/* Get the 0xC0 log data */
- ret = nvme_get_log(fd, WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
- 0xFFFFFFFF, 0, NVME_LOG_LSP_NONE, 0, false,
- uuid_index, NVME_CSI_NVM, false,
- WDC_NVME_SMART_CLOUD_ATTR_LEN, data,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_get_log_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
+ .nsid = 0xFFFFFFFF,
+ .lpo = 0,
+ .lsp = NVME_LOG_LSP_NONE,
+ .lsi = 0,
+ .rae = false,
+ .uuidx = uuid_index,
+ .csi = NVME_CSI_NVM,
+ .ot = false,
+ .len = WDC_NVME_SMART_CLOUD_ATTR_LEN,
+ .log = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ ret = nvme_get_log(&args);
if (ret == 0) {
/* Verify GUID matches */
if (fd < 0)
return fd;
- err = nvme_get_nsid_log(fd, 0xca, cfg.namespace_id,
+ err = nvme_get_nsid_log(fd, false, 0xca, cfg.namespace_id,
sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
}
}
- err = nvme_zns_mgmt_send(fd, cfg.namespace_id, cfg.zslba, zsa,
- cfg.select_all, 0, 0, NULL, cfg.timeout, &result);
+ struct nvme_zns_mgmt_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.zslba,
+ .zsa = zsa,
+ .select_all = cfg.select_all,
+ .zsaso = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = cfg.timeout,
+ .result = &result,
+ };
+ err = nvme_zns_mgmt_send(&args);
if (!err) {
if (zsa == NVME_ZNS_ZSA_RESET)
zcapc = result & 0x1;
}
}
- err = nvme_zns_mgmt_send(fd, cfg.namespace_id, cfg.zslba, cfg.zsa,
- cfg.select_all, cfg.zsaso, cfg.data_len, buf, cfg.timeout, NULL);
+ struct nvme_zns_mgmt_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.zslba,
+ .zsa = cfg.zsa,
+ .select_all = cfg.select_all,
+ .zsaso = cfg.zsaso,
+ .data_len = cfg.data_len,
+ .data = buf,
+ .timeout = cfg.timeout,
+ .result = NULL,
+ };
+ err = nvme_zns_mgmt_send(&args);
if (!err)
printf("zone-mgmt-send: Success, action:%d zone:%"PRIx64" "
"all:%d nsid:%d\n",
}
}
- err = nvme_zns_mgmt_send(fd, cfg.namespace_id, cfg.zslba, NVME_ZNS_ZSA_OPEN,
- cfg.select_all, cfg.zrwaa, 0, NULL, cfg.timeout, NULL);
+ struct nvme_zns_mgmt_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.zslba,
+ .zsa = NVME_ZNS_ZSA_OPEN,
+ .select_all = cfg.select_all,
+ .zsaso = cfg.zrwaa,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = cfg.timeout,
+ .result = NULL,
+ };
+ err = nvme_zns_mgmt_send(&args);
if (!err)
printf("zns-open-zone: Success zone slba:%"PRIx64" nsid:%d\n",
(uint64_t)cfg.zslba, cfg.namespace_id);
goto close_ffd;
}
- err = nvme_zns_mgmt_send(fd, cfg.namespace_id, cfg.zslba,
- NVME_ZNS_ZSA_SET_DESC_EXT, 0, cfg.zrwaa, data_len, buf,
- cfg.timeout, NULL);
+ struct nvme_zns_mgmt_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.zslba,
+ .zsa = NVME_ZNS_ZSA_SET_DESC_EXT,
+ .select_all = 0,
+ .zsaso = cfg.zrwaa,
+ .data_len = data_len,
+ .data = buf,
+ .timeout = cfg.timeout,
+ .result = NULL,
+ };
+ err = nvme_zns_mgmt_send(&args);
if (!err)
printf("set-zone-desc: Success, zone:%"PRIx64" nsid:%d\n",
(uint64_t)cfg.zslba, cfg.namespace_id);
}
}
- err = nvme_zns_mgmt_send(fd, cfg.namespace_id, cfg.lba,
- NVME_ZNS_ZSA_ZRWA_FLUSH, 0, 0, 0, NULL, cfg.timeout, NULL);
+ struct nvme_zns_mgmt_send_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.lba,
+ .zsa = NVME_ZNS_ZSA_ZRWA_FLUSH,
+ .select_all = 0,
+ .zsaso = 0,
+ .data_len = 0,
+ .data = NULL,
+ .timeout = cfg.timeout,
+ .result = NULL,
+ };
+ err = nvme_zns_mgmt_send(&args);
if (!err)
printf("zrwa-flush-zone: Success, lba:%"PRIx64" nsid:%d\n",
(uint64_t)cfg.lba, cfg.namespace_id);
}
}
- err = nvme_zns_mgmt_recv(fd, cfg.namespace_id, cfg.zslba, cfg.zra,
- cfg.zrasf, cfg.partial, cfg.data_len, data,
- NVME_DEFAULT_IOCTL_TIMEOUT, NULL);
+ struct nvme_zns_mgmt_recv_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .slba = cfg.zslba,
+ .zra = cfg.zra,
+ .zrasf = cfg.zrasf,
+ .zras_feat = cfg.partial,
+ .data_len = cfg.data_len,
+ .data = data,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = NULL,
+ };
+ err = nvme_zns_mgmt_recv(&args);
if (!err)
printf("zone-mgmt-recv: Success, action:%d zone:%"PRIx64" nsid:%d\n",
cfg.zra, (uint64_t)cfg.zslba, cfg.namespace_id);
if (cfg.piremap)
control |= NVME_IO_ZNS_APPEND_PIREMAP;
+ struct nvme_zns_append_args args = {
+ .args_size = sizeof(args),
+ .fd = fd,
+ .nsid = cfg.namespace_id,
+ .zslba = cfg.zslba,
+ .nlb = nblocks,
+ .control = control,
+ .ilbrt = cfg.ref_tag,
+ .lbat = cfg.lbat,
+ .lbatm = cfg.lbatm,
+ .data_len = cfg.data_size,
+ .data = buf,
+ .metadata_len = cfg.metadata_size,
+ .metadata = mbuf,
+ .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+ .result = &result,
+ };
+
gettimeofday(&start_time, NULL);
- err = nvme_zns_append(fd, cfg.namespace_id, cfg.zslba, nblocks,
- control, cfg.ref_tag, cfg.lbat, cfg.lbatm,
- cfg.data_size, buf, cfg.metadata_size, mbuf,
- NVME_DEFAULT_IOCTL_TIMEOUT, &result);
+ err = nvme_zns_append(&args);
gettimeofday(&end_time, NULL);
if (cfg.latency)
printf(" latency: zone append: %llu us\n",
[wrap-git]
url = https://github.com/linux-nvme/libnvme.git
-revision = 35936185e376082cb26da205fd923c0f1c417c12
+revision = c921be9f1be46a2dea78bcd8d32c0a9df6f17b4e
[provide]
libnvme = libnvme_dep
projects / users / sagi / nvme-cli.git / commitdiff