#include <assert.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <errno.h>
#include <getopt.h>
#include <fcntl.h>
#include <inttypes.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include "nvme-ioctl.h"
static int nvme_verify_chr(int fd)
{
static struct stat nvme_stat;
int err = fstat(fd, &nvme_stat);
if (err < 0) {
perror("fstat");
return errno;
}
if (!S_ISCHR(nvme_stat.st_mode)) {
fprintf(stderr,
"Error: requesting reset on non-controller handle\n");
return ENOTBLK;
}
return 0;
}
int nvme_subsystem_reset(int fd)
{
int ret;
ret = nvme_verify_chr(fd);
if (ret)
return ret;
return ioctl(fd, NVME_IOCTL_SUBSYS_RESET);
}
int nvme_reset_controller(int fd)
{
int ret;
ret = nvme_verify_chr(fd);
if (ret)
return ret;
return ioctl(fd, NVME_IOCTL_RESET);
}
int nvme_ns_rescan(int fd)
{
int ret;
ret = nvme_verify_chr(fd);
if (ret)
return ret;
return ioctl(fd, NVME_IOCTL_RESCAN);
}
int nvme_get_nsid(int fd)
{
static struct stat nvme_stat;
int err = fstat(fd, &nvme_stat);
if (err < 0)
return -errno;
return ioctl(fd, NVME_IOCTL_ID);
}
int nvme_submit_passthru(int fd, unsigned long ioctl_cmd,
struct nvme_passthru_cmd *cmd)
{
return ioctl(fd, ioctl_cmd, cmd);
}
int nvme_submit_admin_passthru(int fd, struct nvme_passthru_cmd *cmd)
{
return ioctl(fd, NVME_IOCTL_ADMIN_CMD, cmd);
}
int nvme_submit_io_passthru(int fd, struct nvme_passthru_cmd *cmd)
{
return ioctl(fd, NVME_IOCTL_IO_CMD, cmd);
}
int nvme_passthru(int fd, unsigned long ioctl_cmd, __u8 opcode,
__u8 flags, __u16 rsvd,
__u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10, __u32 cdw11,
__u32 cdw12, __u32 cdw13, __u32 cdw14, __u32 cdw15,
__u32 data_len, void *data, __u32 metadata_len,
void *metadata, __u32 timeout_ms, __u32 *result)
{
struct nvme_passthru_cmd cmd = {
.opcode = opcode,
.flags = flags,
.rsvd1 = rsvd,
.nsid = nsid,
.cdw2 = cdw2,
.cdw3 = cdw3,
.metadata = (__u64)(uintptr_t) metadata,
.addr = (__u64)(uintptr_t) data,
.metadata_len = metadata_len,
.data_len = data_len,
.cdw10 = cdw10,
.cdw11 = cdw11,
.cdw12 = cdw12,
.cdw13 = cdw13,
.cdw14 = cdw14,
.cdw15 = cdw15,
.timeout_ms = timeout_ms,
.result = 0,
};
int err;
err = nvme_submit_passthru(fd, ioctl_cmd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_io(int fd, __u8 opcode, __u64 slba, __u16 nblocks, __u16 control,
__u32 dsmgmt, __u32 reftag, __u16 apptag, __u16 appmask, void *data,
void *metadata)
{
struct nvme_user_io io = {
.opcode = opcode,
.flags = 0,
.control = control,
.nblocks = nblocks,
.rsvd = 0,
.metadata = (__u64)(uintptr_t) metadata,
.addr = (__u64)(uintptr_t) data,
.slba = slba,
.dsmgmt = dsmgmt,
.reftag = reftag,
.appmask = appmask,
.apptag = apptag,
};
return ioctl(fd, NVME_IOCTL_SUBMIT_IO, &io);
}
int nvme_read(int fd, __u64 slba, __u16 nblocks, __u16 control, __u32 dsmgmt,
__u32 reftag, __u16 apptag, __u16 appmask, void *data,
void *metadata)
{
return nvme_io(fd, nvme_cmd_read, slba, nblocks, control, dsmgmt,
reftag, apptag, appmask, data, metadata);
}
int nvme_write(int fd, __u64 slba, __u16 nblocks, __u16 control, __u32 dsmgmt,
__u32 reftag, __u16 apptag, __u16 appmask, void *data,
void *metadata)
{
return nvme_io(fd, nvme_cmd_write, slba, nblocks, control, dsmgmt,
reftag, apptag, appmask, data, metadata);
}
int nvme_compare(int fd, __u64 slba, __u16 nblocks, __u16 control, __u32 dsmgmt,
__u32 reftag, __u16 apptag, __u16 appmask, void *data,
void *metadata)
{
return nvme_io(fd, nvme_cmd_compare, slba, nblocks, control, dsmgmt,
reftag, apptag, appmask, data, metadata);
}
int nvme_verify(int fd, __u32 nsid, __u64 slba, __u16 nblocks,
__u16 control, __u32 reftag, __u16 apptag, __u16 appmask)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_verify,
.nsid = nsid,
.cdw10 = slba & 0xffffffff,
.cdw11 = slba >> 32,
.cdw12 = nblocks | (control << 16),
.cdw14 = reftag,
.cdw15 = apptag | (appmask << 16),
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_passthru_io(int fd, __u8 opcode, __u8 flags, __u16 rsvd,
__u32 nsid, __u32 cdw2, __u32 cdw3, __u32 cdw10,
__u32 cdw11, __u32 cdw12, __u32 cdw13, __u32 cdw14,
__u32 cdw15, __u32 data_len, void *data,
__u32 metadata_len, void *metadata, __u32 timeout_ms)
{
return nvme_passthru(fd, NVME_IOCTL_IO_CMD, opcode, flags, rsvd, nsid,
cdw2, cdw3, cdw10, cdw11, cdw12, cdw13, cdw14,
cdw15, data_len, data, metadata_len, metadata,
timeout_ms, NULL);
}
int nvme_write_zeros(int fd, __u32 nsid, __u64 slba, __u16 nlb,
__u16 control, __u32 reftag, __u16 apptag, __u16 appmask)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_write_zeroes,
.nsid = nsid,
.cdw10 = slba & 0xffffffff,
.cdw11 = slba >> 32,
.cdw12 = nlb | (control << 16),
.cdw14 = reftag,
.cdw15 = apptag | (appmask << 16),
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_write_uncorrectable(int fd, __u32 nsid, __u64 slba, __u16 nlb)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_write_uncor,
.nsid = nsid,
.cdw10 = slba & 0xffffffff,
.cdw11 = slba >> 32,
.cdw12 = nlb,
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_flush(int fd, __u32 nsid)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_flush,
.nsid = nsid,
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_dsm(int fd, __u32 nsid, __u32 cdw11, struct nvme_dsm_range *dsm,
__u16 nr_ranges)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_dsm,
.nsid = nsid,
.addr = (__u64)(uintptr_t) dsm,
.data_len = nr_ranges * sizeof(*dsm),
.cdw10 = nr_ranges - 1,
.cdw11 = cdw11,
};
return nvme_submit_io_passthru(fd, &cmd);
}
struct nvme_dsm_range *nvme_setup_dsm_range(__u32 *ctx_attrs, __u32 *llbas,
__u64 *slbas, __u16 nr_ranges)
{
int i;
struct nvme_dsm_range *dsm = malloc(nr_ranges * sizeof(*dsm));
if (!dsm) {
fprintf(stderr, "malloc: %s\n", strerror(errno));
return NULL;
}
for (i = 0; i < nr_ranges; i++) {
dsm[i].cattr = cpu_to_le32(ctx_attrs[i]);
dsm[i].nlb = cpu_to_le32(llbas[i]);
dsm[i].slba = cpu_to_le64(slbas[i]);
}
return dsm;
}
int nvme_resv_acquire(int fd, __u32 nsid, __u8 rtype, __u8 racqa,
bool iekey, __u64 crkey, __u64 nrkey)
{
__le64 payload[2] = { cpu_to_le64(crkey), cpu_to_le64(nrkey) };
__u32 cdw10 = (racqa & 0x7) | (iekey ? 1 << 3 : 0) | rtype << 8;
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_resv_acquire,
.nsid = nsid,
.cdw10 = cdw10,
.addr = (__u64)(uintptr_t) (payload),
.data_len = sizeof(payload),
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_resv_register(int fd, __u32 nsid, __u8 rrega, __u8 cptpl,
bool iekey, __u64 crkey, __u64 nrkey)
{
__le64 payload[2] = { cpu_to_le64(crkey), cpu_to_le64(nrkey) };
__u32 cdw10 = (rrega & 0x7) | (iekey ? 1 << 3 : 0) | cptpl << 30;
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_resv_register,
.nsid = nsid,
.cdw10 = cdw10,
.addr = (__u64)(uintptr_t) (payload),
.data_len = sizeof(payload),
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_resv_release(int fd, __u32 nsid, __u8 rtype, __u8 rrela,
bool iekey, __u64 crkey)
{
__le64 payload[1] = { cpu_to_le64(crkey) };
__u32 cdw10 = (rrela & 0x7) | (iekey ? 1 << 3 : 0) | rtype << 8;
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_resv_release,
.nsid = nsid,
.cdw10 = cdw10,
.addr = (__u64)(uintptr_t) (payload),
.data_len = sizeof(payload),
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_resv_report(int fd, __u32 nsid, __u32 numd, __u32 cdw11, void *data)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_cmd_resv_report,
.nsid = nsid,
.cdw10 = numd,
.cdw11 = cdw11,
.addr = (__u64)(uintptr_t) data,
.data_len = (numd + 1) << 2,
};
return nvme_submit_io_passthru(fd, &cmd);
}
int nvme_identify13(int fd, __u32 nsid, __u32 cdw10, __u32 cdw11, void *data)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_identify,
.nsid = nsid,
.addr = (__u64)(uintptr_t) data,
.data_len = NVME_IDENTIFY_DATA_SIZE,
.cdw10 = cdw10,
.cdw11 = cdw11,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_identify(int fd, __u32 nsid, __u32 cdw10, void *data)
{
return nvme_identify13(fd, nsid, cdw10, 0, data);
}
int nvme_identify_ctrl(int fd, void *data)
{
memset(data, 0, sizeof(struct nvme_id_ctrl));
return nvme_identify(fd, 0, 1, data);
}
int nvme_identify_ns(int fd, __u32 nsid, bool present, void *data)
{
int cns = present ? NVME_ID_CNS_NS_PRESENT : NVME_ID_CNS_NS;
return nvme_identify(fd, nsid, cns, data);
}
int nvme_identify_ns_list(int fd, __u32 nsid, bool all, void *data)
{
int cns = all ? NVME_ID_CNS_NS_PRESENT_LIST : NVME_ID_CNS_NS_ACTIVE_LIST;
return nvme_identify(fd, nsid, cns, data);
}
int nvme_identify_ctrl_list(int fd, __u32 nsid, __u16 cntid, void *data)
{
int cns = nsid ? NVME_ID_CNS_CTRL_NS_LIST : NVME_ID_CNS_CTRL_LIST;
return nvme_identify(fd, nsid, (cntid << 16) | cns, data);
}
int nvme_identify_secondary_ctrl_list(int fd, __u32 nsid, __u16 cntid, void *data)
{
return nvme_identify(fd, nsid, (cntid << 16) | NVME_ID_CNS_SCNDRY_CTRL_LIST, data);
}
int nvme_identify_ns_descs(int fd, __u32 nsid, void *data)
{
return nvme_identify(fd, nsid, NVME_ID_CNS_NS_DESC_LIST, data);
}
int nvme_identify_nvmset(int fd, __u16 nvmset_id, void *data)
{
return nvme_identify13(fd, 0, NVME_ID_CNS_NVMSET_LIST, nvmset_id, data);
}
int nvme_identify_ns_granularity(int fd, void *data)
{
return nvme_identify13(fd, 0, NVME_ID_CNS_NS_GRANULARITY, 0, data);
}
int nvme_identify_uuid(int fd, void *data)
{
return nvme_identify(fd, 0, NVME_ID_CNS_UUID_LIST, data);
}
int nvme_get_log14(int fd, __u32 nsid, __u8 log_id, __u8 lsp, __u64 lpo,
__u16 lsi, bool rae, __u8 uuid_ix, __u32 data_len, void *data)
{
__u32 numd = (data_len >> 2) - 1;
__u16 numdu = numd >> 16, numdl = numd & 0xffff;
__u32 cdw10 = log_id | (numdl << 16) | (rae ? 1 << 15 : 0) | lsp << 8;
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_get_log_page,
.nsid = nsid,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
.cdw10 = cdw10,
.cdw11 = numdu | (lsi << 16),
.cdw12 = lpo & 0xffffffff,
.cdw13 = lpo >> 32,
.cdw14 = uuid_ix,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_get_log13(int fd, __u32 nsid, __u8 log_id, __u8 lsp,
__u64 lpo, __u16 lsi, bool rae, __u32 data_len,
void *data)
{
return nvme_get_log14(fd, nsid, log_id, lsp, lpo, lsi, rae, 0,
data_len, data);
}
int nvme_get_log(int fd, __u32 nsid, __u8 log_id, bool rae,
__u32 data_len, void *data)
{
__u32 offset = 0, xfer_len = data_len;
void *ptr = data;
int ret;
/*
* 4k is the smallest possible transfer unit, so by
* restricting ourselves for 4k transfers we avoid having
* to check the MDTS value of the controller.
*/
do {
xfer_len = data_len - offset;
if (xfer_len > 4096)
xfer_len = 4096;
ret = nvme_get_log13(fd, nsid, log_id, NVME_NO_LOG_LSP,
offset, 0, rae, xfer_len, ptr);
if (ret)
return ret;
offset += xfer_len;
ptr += xfer_len;
} while (offset < data_len);
return 0;
}
int nvme_get_telemetry_log(int fd, void *lp, int generate_report,
int ctrl_init, size_t log_page_size, __u64 offset)
{
if (ctrl_init)
return nvme_get_log13(fd, NVME_NSID_ALL, NVME_LOG_TELEMETRY_CTRL,
NVME_NO_LOG_LSP, offset,
0, 1, log_page_size, lp);
if (generate_report)
return nvme_get_log13(fd, NVME_NSID_ALL, NVME_LOG_TELEMETRY_HOST,
NVME_TELEM_LSP_CREATE, offset,
0, 1, log_page_size, lp);
else
return nvme_get_log13(fd, NVME_NSID_ALL, NVME_LOG_TELEMETRY_HOST,
NVME_NO_LOG_LSP, offset,
0, 1, log_page_size, lp);
}
int nvme_fw_log(int fd, struct nvme_firmware_log_page *fw_log)
{
return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_FW_SLOT, true,
sizeof(*fw_log), fw_log);
}
int nvme_changed_ns_list_log(int fd, struct nvme_changed_ns_list_log *changed_ns_list_log)
{
return nvme_get_log(fd, 0, NVME_LOG_CHANGED_NS, true,
sizeof(changed_ns_list_log->log),
changed_ns_list_log->log);
}
int nvme_error_log(int fd, int entries, struct nvme_error_log_page *err_log)
{
return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_ERROR, false,
entries * sizeof(*err_log), err_log);
}
int nvme_endurance_log(int fd, __u16 group_id, struct nvme_endurance_group_log *endurance_log)
{
return nvme_get_log13(fd, 0, NVME_LOG_ENDURANCE_GROUP, 0, 0, group_id, 0,
sizeof(*endurance_log), endurance_log);
}
int nvme_smart_log(int fd, __u32 nsid, struct nvme_smart_log *smart_log)
{
return nvme_get_log(fd, nsid, NVME_LOG_SMART, false,
sizeof(*smart_log), smart_log);
}
int nvme_ana_log(int fd, void *ana_log, size_t ana_log_len, int rgo)
{
return nvme_get_log13(fd, NVME_NSID_ALL, NVME_LOG_ANA, rgo, 0, 0,
true, ana_log_len, ana_log);
}
int nvme_self_test_log(int fd, __u32 nsid, struct nvme_self_test_log *self_test_log)
{
return nvme_get_log(fd, nsid, NVME_LOG_DEVICE_SELF_TEST, false,
sizeof(*self_test_log), self_test_log);
}
int nvme_effects_log(int fd, struct nvme_effects_log_page *effects_log)
{
return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_CMD_EFFECTS, false,
sizeof(*effects_log), effects_log);
}
int nvme_discovery_log(int fd, struct nvmf_disc_rsp_page_hdr *log, __u32 size)
{
return nvme_get_log(fd, 0, NVME_LOG_DISC, false, size, log);
}
int nvme_sanitize_log(int fd, struct nvme_sanitize_log_page *sanitize_log)
{
return nvme_get_log(fd, 0, NVME_LOG_SANITIZE, false,
sizeof(*sanitize_log), sanitize_log);
}
int nvme_feature(int fd, __u8 opcode, __u32 nsid, __u32 cdw10, __u32 cdw11,
__u32 cdw12, __u32 data_len, void *data, __u32 *result)
{
struct nvme_admin_cmd cmd = {
.opcode = opcode,
.nsid = nsid,
.cdw10 = cdw10,
.cdw11 = cdw11,
.cdw12 = cdw12,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_set_feature(int fd, __u32 nsid, __u8 fid, __u32 value, __u32 cdw12,
bool save, __u32 data_len, void *data, __u32 *result)
{
__u32 cdw10 = fid | (save ? 1 << 31 : 0);
return nvme_feature(fd, nvme_admin_set_features, nsid, cdw10, value,
cdw12, data_len, data, result);
}
int nvme_get_property(int fd, int offset, uint64_t *value)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_fabrics_command,
.nsid = nvme_fabrics_type_property_get,
.cdw10 = is_64bit_reg(offset),
.cdw11 = offset,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && value)
*value = cmd.result;
return err;
}
int nvme_get_properties(int fd, void **pbar)
{
int offset;
uint64_t value;
int err, size = getpagesize();
*pbar = malloc(size);
if (!*pbar) {
fprintf(stderr, "malloc: %s\n", strerror(errno));
return -ENOMEM;
}
memset(*pbar, 0xff, size);
for (offset = NVME_REG_CAP; offset <= NVME_REG_CMBSZ;) {
err = nvme_get_property(fd, offset, &value);
if (err > 0 && (err & 0xff) == NVME_SC_INVALID_FIELD) {
err = 0;
value = -1;
} else if (err) {
free(*pbar);
break;
}
if (is_64bit_reg(offset)) {
*(uint64_t *)(*pbar + offset) = value;
offset += 8;
} else {
*(uint32_t *)(*pbar + offset) = value;
offset += 4;
}
}
return err;
}
int nvme_set_property(int fd, int offset, uint64_t value)
{
struct nvme_passthru_cmd cmd = {
.opcode = nvme_fabrics_command,
.nsid = nvme_fabrics_type_property_set,
.cdw10 = is_64bit_reg(offset),
.cdw11 = offset,
.cdw12 = value & 0xffffffff,
.cdw13 = value >> 32,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_get_feature(int fd, __u32 nsid, __u8 fid, __u8 sel, __u32 cdw11,
__u32 data_len, void *data, __u32 *result)
{
__u32 cdw10 = fid | sel << 8;
return nvme_feature(fd, nvme_admin_get_features, nsid, cdw10, cdw11,
0, data_len, data, result);
}
int nvme_format(int fd, __u32 nsid, __u8 lbaf, __u8 ses, __u8 pi,
__u8 pil, __u8 ms, __u32 timeout)
{
__u32 cdw10 = lbaf | ms << 4 | pi << 5 | pil << 8 | ses << 9;
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_format_nvm,
.nsid = nsid,
.cdw10 = cdw10,
.timeout_ms = timeout,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_ns_create(int fd, __u64 nsze, __u64 ncap, __u8 flbas, __u8 dps,
__u8 nmic, __u32 anagrpid, __u16 nvmsetid, __u32 timeout,
__u32 *result)
{
struct nvme_id_ns ns = {
.nsze = cpu_to_le64(nsze),
.ncap = cpu_to_le64(ncap),
.flbas = flbas,
.dps = dps,
.nmic = nmic,
.anagrpid = anagrpid,
.nvmsetid = nvmsetid,
};
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_ns_mgmt,
.addr = (__u64)(uintptr_t) ((void *)&ns),
.cdw10 = 0,
.data_len = 0x1000,
.timeout_ms = timeout,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_ns_delete(int fd, __u32 nsid, __u32 timeout)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_ns_mgmt,
.nsid = nsid,
.cdw10 = 1,
.timeout_ms = timeout,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_ns_attachment(int fd, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist,
bool attach)
{
struct nvme_controller_list cntlist = {
.num = cpu_to_le16(num_ctrls),
};
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_ns_attach,
.nsid = nsid,
.addr = (__u64)(uintptr_t)&cntlist,
.cdw10 = attach ? 0 : 1,
.data_len = 0x1000,
};
int i;
for (i = 0; i < num_ctrls; i++)
cntlist.identifier[i] = cpu_to_le16(ctrlist[i]);
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_fw_download(int fd, __u32 offset, __u32 data_len, void *data)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_download_fw,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
.cdw10 = (data_len >> 2) - 1,
.cdw11 = offset >> 2,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_fw_commit(int fd, __u8 slot, __u8 action, __u8 bpid)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_activate_fw,
.cdw10 = (bpid << 31) | (action << 3) | slot,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_sec_send(int fd, __u32 nsid, __u8 nssf, __u16 spsp,
__u8 secp, __u32 tl, __u32 data_len, void *data, __u32 *result)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_security_send,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
.nsid = nsid,
.cdw10 = secp << 24 | spsp << 8 | nssf,
.cdw11 = tl,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_sec_recv(int fd, __u32 nsid, __u8 nssf, __u16 spsp,
__u8 secp, __u32 al, __u32 data_len, void *data, __u32 *result)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_security_recv,
.nsid = nsid,
.cdw10 = secp << 24 | spsp << 8 | nssf,
.cdw11 = al,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_get_lba_status(int fd, __u64 slba, __u32 mndw, __u8 atype, __u16 rl,
void *data)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_get_lba_status,
.addr = (__u64)(uintptr_t) data,
.cdw10 = slba & 0xffffffff,
.cdw11 = slba >> 32,
.cdw12 = mndw,
.cdw13 = (atype << 24) | rl,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_dir_send(int fd, __u32 nsid, __u16 dspec, __u8 dtype, __u8 doper,
__u32 data_len, __u32 dw12, void *data, __u32 *result)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_directive_send,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
.nsid = nsid,
.cdw10 = data_len? (data_len >> 2) - 1 : 0,
.cdw11 = dspec << 16 | dtype << 8 | doper,
.cdw12 = dw12,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_dir_recv(int fd, __u32 nsid, __u16 dspec, __u8 dtype, __u8 doper,
__u32 data_len, __u32 dw12, void *data, __u32 *result)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_directive_recv,
.addr = (__u64)(uintptr_t) data,
.data_len = data_len,
.nsid = nsid,
.cdw10 = data_len? (data_len >> 2) - 1 : 0,
.cdw11 = dspec << 16 | dtype << 8 | doper,
.cdw12 = dw12,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}
int nvme_sanitize(int fd, __u8 sanact, __u8 ause, __u8 owpass, __u8 oipbp,
__u8 no_dealloc, __u32 ovrpat)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_sanitize_nvm,
.cdw10 = no_dealloc << 9 | oipbp << 8 |
owpass << NVME_SANITIZE_OWPASS_SHIFT |
ause << 3 | sanact,
.cdw11 = ovrpat,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_self_test_start(int fd, __u32 nsid, __u32 cdw10)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_dev_self_test,
.nsid = nsid,
.cdw10 = cdw10,
};
return nvme_submit_admin_passthru(fd, &cmd);
}
int nvme_virtual_mgmt(int fd, __u32 cdw10, __u32 cdw11, __u32 *result)
{
struct nvme_admin_cmd cmd = {
.opcode = nvme_admin_virtual_mgmt,
.cdw10 = cdw10,
.cdw11 = cdw11,
};
int err;
err = nvme_submit_admin_passthru(fd, &cmd);
if (!err && result)
*result = cmd.result;
return err;
}