{ NVME_DE_LOGPAGE_C0, 0xC0, 512, "0xc0"}
};
-static int wdc_get_serial_name(int fd, char *file, size_t len, const char *suffix);
+static int wdc_get_serial_name(struct nvme_dev *dev, char *file, size_t len,
+ const char *suffix);
static int wdc_create_log_file(char *file, __u8 *drive_log_data,
__u32 drive_log_length);
-static int wdc_do_clear_dump(int fd, __u8 opcode, __u32 cdw12);
-static int wdc_do_dump(int fd, __u32 opcode,__u32 data_len,
+static int wdc_do_clear_dump(struct nvme_dev *dev, __u8 opcode, __u32 cdw12);
+static int wdc_do_dump(struct nvme_dev *dev, __u32 opcode,__u32 data_len,
__u32 cdw12, char *file, __u32 xfer_size);
-static int wdc_do_crash_dump(int fd, char *file, int type);
-static int wdc_crash_dump(int fd, char *file, int type);
+static int wdc_do_crash_dump(struct nvme_dev *dev, char *file, int type);
+static int wdc_crash_dump(struct nvme_dev *dev, char *file, int type);
static int wdc_get_crash_dump(int argc, char **argv, struct command *command,
struct plugin *plugin);
-static int wdc_do_drive_log(int fd, char *file);
+static int wdc_do_drive_log(struct nvme_dev *dev, char *file);
static int wdc_drive_log(int argc, char **argv, struct command *command,
struct plugin *plugin);
static const char* wdc_purge_mon_status_to_string(__u32 status);
struct command *command, struct plugin *plugin);
static int wdc_purge_monitor(int argc, char **argv,
struct command *command, struct plugin *plugin);
-static bool wdc_nvme_check_supported_log_page(nvme_root_t r, int fd, __u8 log_id);
+static bool wdc_nvme_check_supported_log_page(nvme_root_t r,
+ struct nvme_dev *dev, __u8 log_id);
static int wdc_clear_pcie_correctable_errors(int argc, char **argv, struct command *command,
struct plugin *plugin);
-static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key);
+static int wdc_do_drive_essentials(nvme_root_t r, struct nvme_dev *dev, char *dir, char *key);
static int wdc_drive_essentials(int argc, char **argv, struct command *command,
struct plugin *plugin);
static int wdc_drive_status(int argc, char **argv, struct command *command,
struct plugin *plugin);
static int wdc_drive_resize(int argc, char **argv,
struct command *command, struct plugin *plugin);
-static int wdc_do_drive_resize(int fd, uint64_t new_size);
+static int wdc_do_drive_resize(struct nvme_dev *dev, uint64_t new_size);
static int wdc_namespace_resize(int argc, char **argv,
struct command *command, struct plugin *plugin);
-static int wdc_do_namespace_resize(int fd, __u32 nsid, __u32 op_option);
+static int wdc_do_namespace_resize(struct nvme_dev *dev, __u32 nsid,
+ __u32 op_option);
static int wdc_reason_identifier(int argc, char **argv,
struct command *command, struct plugin *plugin);
-static int wdc_do_get_reason_id(int fd, char *file, int log_id);
-static int wdc_save_reason_id(int fd, __u8 *rsn_ident, int size);
-static int wdc_clear_reason_id(int fd);
+static int wdc_do_get_reason_id(struct nvme_dev *dev, char *file, int log_id);
+static int wdc_save_reason_id(struct nvme_dev *dev, __u8 *rsn_ident, int size);
+static int wdc_clear_reason_id(struct nvme_dev *dev);
static int wdc_log_page_directory(int argc, char **argv, struct command *command,
struct plugin *plugin);
-static int wdc_do_drive_info(int fd, __u32 *result);
+static int wdc_do_drive_info(struct nvme_dev *dev, __u32 *result);
static int wdc_vs_drive_info(int argc, char **argv, struct command *command,
struct plugin *plugin);
static int wdc_vs_temperature_stats(int argc, char **argv, struct command *command,
struct plugin *plugin);
-static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r, int fd);
-static int wdc_enc_get_nic_log(int fd, __u8 log_id, __u32 xfer_size, __u32 data_len, FILE *out);
-static int wdc_enc_submit_move_data(int fd, char *cmd, int len, int xfer_size, FILE *out, int data_id, int cdw14, int cdw15);
-static bool get_dev_mgment_cbs_data(nvme_root_t r, int fd, __u8 log_id, void **cbs_data);
-static __u32 wdc_get_fw_cust_id(nvme_root_t r, int fd);
+static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r, struct nvme_dev *dev);
+static int wdc_enc_get_nic_log(struct nvme_dev *dev, __u8 log_id,
+ __u32 xfer_size, __u32 data_len, FILE *out);
+static int wdc_enc_submit_move_data(struct nvme_dev *dev, char *cmd, int len,
+ int xfer_size, FILE *out, int data_id, int cdw14, int cdw15);
+static bool get_dev_mgment_cbs_data(nvme_root_t r, struct nvme_dev *dev,
+ __u8 log_id, void **cbs_data);
+static __u32 wdc_get_fw_cust_id(nvme_root_t r, struct nvme_dev *dev);
/* Drive log data size */
struct wdc_log_size {
return result;
}
-static int wdc_get_pci_ids(nvme_root_t r, uint32_t *device_id,
- uint32_t *vendor_id)
+static int wdc_get_pci_ids(nvme_root_t r, struct nvme_dev *dev,
+ uint32_t *device_id, uint32_t *vendor_id)
{
char vid[256], did[256], id[32];
nvme_ctrl_t c = NULL;
nvme_ns_t n = NULL;
int fd, ret;
- c = nvme_scan_ctrl(r, nvme_dev->name);
+ c = nvme_scan_ctrl(r, dev->name);
if (c) {
snprintf(vid, sizeof(vid), "%s/device/vendor",
nvme_ctrl_get_sysfs_dir(c));
nvme_ctrl_get_sysfs_dir(c));
nvme_free_ctrl(c);
} else {
- n = nvme_scan_namespace(nvme_dev->name);
+ n = nvme_scan_namespace(dev->name);
if (!n) {
- fprintf(stderr, "Unable to find %s\n", nvme_dev->name);
+ fprintf(stderr, "Unable to find %s\n", dev->name);
return -1;
}
return 0;
}
-static int wdc_get_vendor_id(int fd, uint32_t *vendor_id)
+static int wdc_get_vendor_id(struct nvme_dev *dev, uint32_t *vendor_id)
{
int ret;
struct nvme_id_ctrl ctrl;
memset(&ctrl, 0, sizeof(struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
return (num && ( !(num & (num-1))));
}
-static int wdc_get_model_number(int fd, char *model)
+static int wdc_get_model_number(struct nvme_dev *dev, char *model)
{
int ret,i;
struct nvme_id_ctrl ctrl;
memset(&ctrl, 0, sizeof(struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
return ret;
}
-static bool wdc_check_device(nvme_root_t r, int fd)
+static bool wdc_check_device(nvme_root_t r, struct nvme_dev *dev)
{
int ret;
bool supported;
uint32_t read_device_id = -1, read_vendor_id = -1;
- ret = wdc_get_pci_ids(r, &read_device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &read_device_id, &read_vendor_id);
if (ret < 0) {
/* Use the identify nvme command to get vendor id due to NVMeOF device. */
- if (wdc_get_vendor_id(fd, &read_vendor_id) < 0)
+ if (wdc_get_vendor_id(dev, &read_vendor_id) < 0)
return false;
}
return supported;
}
-static bool wdc_enc_check_model(int fd)
+static bool wdc_enc_check_model(struct nvme_dev *dev)
{
int ret;
bool supported;
char model[NVME_ID_CTRL_MODEL_NUMBER_SIZE+1];
- ret = wdc_get_model_number(fd, model);
+ ret = wdc_get_model_number(dev, model);
if (ret < 0)
return false;
return supported;
}
-static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
+static __u64 wdc_get_drive_capabilities(nvme_root_t r, struct nvme_dev *dev)
+{
int ret;
uint32_t read_device_id = -1, read_vendor_id = -1;
__u64 capabilities = 0;
__u32 cust_id;
- ret = wdc_get_pci_ids(r, &read_device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &read_device_id, &read_vendor_id);
if (ret < 0)
{
- if (wdc_get_vendor_id(fd, &read_vendor_id) < 0)
+ if (wdc_get_vendor_id(dev, &read_vendor_id) < 0)
return capabilities;
}
/* below check condition is added due in NVMeOF device we dont have device_id so we need to use only vendor_id*/
if (read_device_id == -1 && read_vendor_id != -1)
{
- capabilities = wdc_get_enc_drive_capabilities(r, fd);
+ capabilities = wdc_get_enc_drive_capabilities(r, dev);
return capabilities;
}
WDC_DRIVE_CAP_PURGE);
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_CA_LOG_PAGE;
/* verify the 0xC1 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_ADD_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_ADD_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_C1_LOG_PAGE;
break;
default:
WDC_DRIVE_CAP_DRIVE_STATUS | WDC_DRIVE_CAP_CLEAR_ASSERT |
WDC_DRIVE_CAP_RESIZE | WDC_DRIVE_CAP_CLEAR_PCIE);
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_CA_LOG_PAGE;
/* verify the 0xD0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_VU_SMART_LOG_OPCODE)
+ == true)
capabilities |= WDC_DRIVE_CAP_D0_LOG_PAGE;
break;
case WDC_NVME_SN640_DEV_ID:
/* FALLTHRU */
case WDC_NVME_SN560_DEV_ID_3:
/* verify the 0xC0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE) == true) {
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_EOL_STATUS_LOG_OPCODE)
+ == true) {
capabilities |= WDC_DRIVE_CAP_C0_LOG_PAGE;
}
WDC_DRIVE_CAP_LOG_PAGE_DIR);
/* verify the 0xC1 (OCP Error Recovery) log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_ERROR_REC_LOG_ID) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_ERROR_REC_LOG_ID))
capabilities |= WDC_DRIVE_CAP_OCP_C1_LOG_PAGE;
/* verify the 0xC3 (OCP Latency Monitor) log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_LATENCY_MON_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_LATENCY_MON_OPCODE))
capabilities |= WDC_DRIVE_CAP_C3_LOG_PAGE;
/* verify the 0xC4 (OCP Device Capabilities) log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_DEV_CAP_LOG_ID) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_DEV_CAP_LOG_ID))
capabilities |= WDC_DRIVE_CAP_OCP_C4_LOG_PAGE;
/* verify the 0xC5 (OCP Unsupported Requirments) log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_UNSUPPORTED_REQS_LOG_ID) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_UNSUPPORTED_REQS_LOG_ID))
capabilities |= WDC_DRIVE_CAP_OCP_C5_LOG_PAGE;
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_CA_LOG_PAGE;
/* verify the 0xD0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_VU_SMART_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_D0_LOG_PAGE;
- cust_id = wdc_get_fw_cust_id(r, fd);
+ cust_id = wdc_get_fw_cust_id(r, dev);
if (cust_id == WDC_INVALID_CUSTOMER_ID) {
fprintf(stderr, "%s: ERROR : WDC : invalid customer id\n", __func__);
return -1;
/* FALLTHRU */
case WDC_NVME_SN860_DEV_ID:
/* verify the 0xC0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE) == true) {
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_EOL_STATUS_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_C0_LOG_PAGE;
- }
/* FALLTHRU */
case WDC_NVME_ZN540_DEV_ID:
/* FALLTHRU */
WDC_DRIVE_CAP_LOG_PAGE_DIR );
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_CA_LOG_PAGE;
/* verify the 0xD0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_VU_SMART_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_D0_LOG_PAGE;
break;
case WDC_NVME_SN650_DEV_ID:
case WDC_NVME_SN655_DEV_ID:
case WDC_NVME_SN550_DEV_ID:
/* verify the 0xC0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE) == true) {
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_EOL_STATUS_LOG_OPCODE))
capabilities |= WDC_DRIVE_CAP_C0_LOG_PAGE;
- }
capabilities |= (WDC_DRIVE_CAP_CAP_DIAG | WDC_DRIVE_CAP_INTERNAL_LOG |
WDC_DRIVE_CAP_DRIVE_STATUS | WDC_DRIVE_CAP_CLEAR_ASSERT |
return capabilities;
}
-static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r, int fd) {
+static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r,
+ struct nvme_dev *dev)
+{
int ret;
uint32_t read_vendor_id;
__u64 capabilities = 0;
__u32 cust_id;
- ret = wdc_get_vendor_id(fd, &read_vendor_id);
+ ret = wdc_get_vendor_id(dev, &read_vendor_id);
if (ret < 0)
return capabilities;
WDC_DRIVE_CAP_DRIVE_LOG | WDC_DRIVE_CAP_CRASH_DUMP | WDC_DRIVE_CAP_PFAIL_DUMP);
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
capabilities |= WDC_DRIVE_CAP_CA_LOG_PAGE;
/* verify the 0xC1 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_ADD_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_ADD_LOG_OPCODE) == true)
capabilities |= WDC_DRIVE_CAP_C1_LOG_PAGE;
break;
case WDC_NVME_VID_2:
WDC_DRIVE_CAP_RESIZE);
/* verify the 0xC3 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_LATENCY_MON_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_LATENCY_MON_OPCODE) == true)
capabilities |= WDC_DRIVE_CAP_C3_LOG_PAGE;
/* verify the 0xCB log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID) == true)
capabilities |= WDC_DRIVE_CAP_FW_ACTIVATE_HISTORY;
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == true)
capabilities |= WDC_DRIVE_CAP_CA_LOG_PAGE;
/* verify the 0xD0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == true)
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == true)
capabilities |= WDC_DRIVE_CAP_D0_LOG_PAGE;
- cust_id = wdc_get_fw_cust_id(r, fd);
+ cust_id = wdc_get_fw_cust_id(r, dev);
if (cust_id == WDC_INVALID_CUSTOMER_ID) {
fprintf(stderr, "%s: ERROR : WDC : invalid customer id\n", __func__);
return -1;
return capabilities;
}
-static int wdc_get_serial_name(int fd, char *file, size_t len, const char *suffix)
+static int wdc_get_serial_name(struct nvme_dev *dev, char *file, size_t len,
+ const char *suffix)
{
int i;
int ret;
strncpy(orig, file, PATH_MAX - 1);
memset(file, 0, len);
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
return valid_log;
}
-static bool get_dev_mgment_cbs_data(nvme_root_t r, int fd, __u8 log_id, void **cbs_data)
+static bool get_dev_mgment_cbs_data(nvme_root_t r, struct nvme_dev *dev,
+ __u8 log_id, void **cbs_data)
{
int ret = -1;
void* data;
*cbs_data = NULL;
__u32 device_id, read_vendor_id;
- ret = wdc_get_pci_ids(r, &device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &device_id, &read_vendor_id);
if(device_id == WDC_NVME_ZN350_DEV_ID || device_id == WDC_NVME_ZN350_DEV_ID_1) {
lid = WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE_C8;
uuid_ix = 0;
/* get the log page length */
struct nvme_get_log_args args_len = {
.args_size = sizeof(args_len),
- .fd = fd,
+ .fd = dev->fd,
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
/* get the log page data */
struct nvme_get_log_args args_data = {
.args_size = sizeof(args_data),
- .fd = fd,
+ .fd = dev->fd,
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
/* get the log page data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev->fd,
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
return found;
}
-static bool wdc_nvme_check_supported_log_page(nvme_root_t r, int fd, __u8 log_id)
+static bool wdc_nvme_check_supported_log_page(nvme_root_t r,
+ struct nvme_dev *dev,
+ __u8 log_id)
{
int i;
bool found = false;
struct wdc_c2_cbs_data *cbs_data = NULL;
- if (get_dev_mgment_cbs_data(r, fd, WDC_C2_LOG_PAGES_SUPPORTED_ID, (void *)&cbs_data)) {
+ if (get_dev_mgment_cbs_data(r, dev, WDC_C2_LOG_PAGES_SUPPORTED_ID, (void *)&cbs_data)) {
if (cbs_data != NULL) {
for (i = 0; i < le32_to_cpu(cbs_data->length); i++) {
if (log_id == cbs_data->data[i]) {
return found;
}
-static bool wdc_nvme_get_dev_status_log_data(nvme_root_t r, int fd, __le32 *ret_data,
+static bool wdc_nvme_get_dev_status_log_data(nvme_root_t r,
+ struct nvme_dev *dev,
+ __le32 *ret_data,
__u8 log_id)
{
__u32 *cbs_data = NULL;
- if (get_dev_mgment_cbs_data(r, fd, log_id, (void *)&cbs_data)) {
+ if (get_dev_mgment_cbs_data(r, dev, log_id, (void *)&cbs_data)) {
if (cbs_data != NULL) {
memcpy((void *)ret_data, (void *)cbs_data, 4);
free(cbs_data);
return false;
}
-static int wdc_do_clear_dump(int fd, __u8 opcode, __u32 cdw12)
+static int wdc_do_clear_dump(struct nvme_dev *dev, __u8 opcode, __u32 cdw12)
{
int ret;
struct nvme_passthru_cmd admin_cmd;
memset(&admin_cmd, 0, sizeof (struct nvme_passthru_cmd));
admin_cmd.opcode = opcode;
admin_cmd.cdw12 = cdw12;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (ret != 0) {
fprintf(stdout, "ERROR : WDC : Crash dump erase failed\n");
}
return ret;
}
-static int wdc_do_dump(int fd, __u32 opcode,__u32 data_len,
+static int wdc_do_dump(struct nvme_dev *dev, __u32 opcode,__u32 data_len,
__u32 cdw12, char *file, __u32 xfer_size)
{
int ret = 0;
admin_cmd.cdw13 = curr_data_offset;
while (curr_data_offset < data_len) {
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &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",
return ret;
}
-static int wdc_do_cap_telemetry_log(int fd, char *file, __u32 bs, int type, int data_area)
+static int wdc_do_cap_telemetry_log(struct nvme_dev *dev, char *file,
+ __u32 bs, int type, int data_area)
{
struct nvme_telemetry_log *log;
size_t full_size = 0;
nvme_root_t r;
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (err) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", err);
}
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if (type == WDC_TELEMETRY_TYPE_HOST) {
host_gen = 1;
} 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(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0,
- 4, buf, &result);
+ err = nvme_get_features_data(dev->fd,
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, 4, buf, &result);
if (err == 0) {
if (result == 0) {
/* enabled */
}
if (ctrl_init)
- err = nvme_get_ctrl_telemetry(fd, true, &log, data_area, &full_size);
+ err = nvme_get_ctrl_telemetry(dev->fd, true, &log, data_area, &full_size);
else if (host_gen)
- err = nvme_get_new_host_telemetry(fd, &log, data_area, &full_size);
+ err = nvme_get_new_host_telemetry(dev->fd, &log, data_area, &full_size);
else
- err = nvme_get_host_telemetry(fd, &log, data_area, &full_size);
+ err = nvme_get_host_telemetry(dev->fd, &log, data_area, &full_size);
if (err < 0) {
perror("get-telemetry-log");
return err;
}
-static int wdc_do_cap_diag(nvme_root_t r, int fd, char *file,
+static int wdc_do_cap_diag(nvme_root_t r, struct nvme_dev *dev, char *file,
__u32 xfer_size, int type, int data_area)
{
int ret = -1;
memset(log_hdr, 0, e6_log_hdr_size);
if (type == WDC_TELEMETRY_TYPE_NONE) {
- ret = wdc_dump_length_e6(fd, WDC_NVME_CAP_DIAG_OPCODE,
+ ret = wdc_dump_length_e6(dev->fd, 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(fd, WDC_NVME_CAP_DIAG_OPCODE, cap_diag_length,
+ ret = wdc_do_dump_e6(dev->fd, 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);
} else if ((type == WDC_TELEMETRY_TYPE_HOST) ||
(type == WDC_TELEMETRY_TYPE_CONTROLLER)) {
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(fd, file, xfer_size, type, data_area);
+ ret = wdc_do_cap_telemetry_log(dev, file, xfer_size, type, data_area);
} else
fprintf(stderr, "%s: ERROR : Invalid type : %d\n", __func__, type);
strncpy(f, cfg.file, PATH_MAX - 1);
if (cfg.xfer_size != 0)
xfer_size = cfg.xfer_size;
- ret = wdc_get_serial_name(dev->fd, f, PATH_MAX, "cap_diag");
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, "cap_diag");
if (ret) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
goto out;
strcat(f, ".bin");
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CAP_DIAG) == WDC_DRIVE_CAP_CAP_DIAG)
- ret = wdc_do_cap_diag(r, dev->fd, f, xfer_size, 0, 0);
+ ret = wdc_do_cap_diag(r, dev, f, xfer_size, 0, 0);
else
fprintf(stderr,
"ERROR : WDC: unsupported device for this command\n");
return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd))
+ if (!wdc_check_device(r, dev))
goto out;
if (cfg.xfer_size != 0)
timeInfo.hour, timeInfo.minute, timeInfo.second);
snprintf(fileSuffix, PATH_MAX, "_internal_fw_log_%s", (char*)timeStamp);
- ret = wdc_get_serial_name(dev->fd, f, PATH_MAX, fileSuffix);
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, fileSuffix);
if (ret) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
goto out;
goto out;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_INTERNAL_LOG) == WDC_DRIVE_CAP_INTERNAL_LOG) {
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
- ret = wdc_do_cap_diag(r, dev->fd, f, xfer_size,
+ ret = wdc_do_cap_diag(r, dev, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
}
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(dev->fd, f, xfer_size,
+ ret = wdc_do_cap_telemetry_log(dev, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
} else {
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(dev->fd, f, xfer_size,
+ ret = wdc_do_cap_telemetry_log(dev, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
} else {
return ret;
}
-static int wdc_do_crash_dump(int fd, char *file, int type)
+static int wdc_do_crash_dump(struct nvme_dev *dev, char *file, int type)
{
int ret;
__u32 crash_dump_length;
WDC_NVME_CLEAR_CRASH_DUMP_CMD);
}
- ret = wdc_dump_length(fd,
+ ret = wdc_dump_length(dev->fd,
opcode,
cdw10_size,
cdw12_size,
else
fprintf(stderr, "INFO : WDC: Crash dump is empty\n");
} else {
- ret = wdc_do_dump(fd,
+ ret = wdc_do_dump(dev,
opcode,
crash_dump_length,
cdw12,
crash_dump_length);
if (ret == 0)
- ret = wdc_do_clear_dump(fd, WDC_NVME_CLEAR_DUMP_OPCODE, cdw12_clear);
+ ret = wdc_do_clear_dump(dev, WDC_NVME_CLEAR_DUMP_OPCODE,
+ cdw12_clear);
}
return ret;
}
-static int wdc_crash_dump(int fd, char *file, int type)
+static int wdc_crash_dump(struct nvme_dev *dev, char *file, int type)
{
char f[PATH_MAX] = {0};
const char *dump_type;
else
dump_type = "_crash_dump";
- ret = wdc_get_serial_name(fd, f, PATH_MAX, dump_type);
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, dump_type);
if (ret)
fprintf(stderr, "ERROR : WDC : failed to generate file name\n");
else
- ret = wdc_do_crash_dump(fd, f, type);
+ ret = wdc_do_crash_dump(dev, f, type);
return ret;
}
-static int wdc_do_drive_log(int fd, char *file)
+static int wdc_do_drive_log(struct nvme_dev *dev, char *file)
{
int ret;
__u8 *drive_log_data;
__u32 drive_log_length;
struct nvme_passthru_cmd admin_cmd;
- ret = wdc_dump_length(fd, WDC_NVME_DRIVE_LOG_SIZE_OPCODE,
+ 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),
admin_cmd.cdw12 = ((WDC_NVME_DRIVE_LOG_SUBCMD <<
WDC_NVME_SUBCMD_SHIFT) | WDC_NVME_DRIVE_LOG_SIZE_CMD);
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
nvme_show_status(ret);
if (ret == 0) {
ret = wdc_create_log_file(file, drive_log_data, drive_log_length);
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_LOG) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
if (cfg.file != NULL) {
strncpy(f, cfg.file, PATH_MAX - 1);
}
- ret = wdc_get_serial_name(dev->fd, f, PATH_MAX, "drive_log");
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, "drive_log");
if (ret)
fprintf(stderr, "ERROR : WDC : failed to generate file name\n");
else
- ret = wdc_do_drive_log(dev->fd, f);
+ ret = wdc_do_drive_log(dev, f);
}
nvme_free_tree(r);
dev_close(dev);
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CRASH_DUMP) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_crash_dump(dev->fd, cfg.file, WDC_NVME_CRASH_DUMP_TYPE);
+ ret = wdc_crash_dump(dev, cfg.file, WDC_NVME_CRASH_DUMP_TYPE);
if (ret != 0) {
fprintf(stderr, "ERROR : WDC : failed to read crash dump\n");
}
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_PFAIL_DUMP) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_crash_dump(dev->fd, cfg.file, WDC_NVME_PFAIL_DUMP_TYPE);
+ ret = wdc_crash_dump(dev, cfg.file, WDC_NVME_PFAIL_DUMP_TYPE);
if (ret != 0) {
fprintf(stderr, "ERROR : WDC : failed to read pfail crash dump\n");
}
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if((capabilities & WDC_DRIVE_CAP_PURGE) == 0) {
ret = -1;
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if((capabilities & WDC_DRIVE_CAP_PURGE) == 0) {
ret = -1;
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
return 0;
}
-static int wdc_print_latency_monitor_log_normal(int fd, struct wdc_ssd_latency_monitor_log *log_data)
+static int wdc_print_latency_monitor_log_normal(struct nvme_dev *dev,
+ struct wdc_ssd_latency_monitor_log *log_data)
{
printf("Latency Monitor/C3 Log Page Data \n");
- printf(" Controller : %s\n", nvme_dev->name);
+ printf(" Controller : %s\n", dev->name);
int err = -1, i, j;
struct nvme_id_ctrl ctrl;
char ts_buf[128];
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev->fd, &ctrl);
if (!err)
printf(" Serial Number: %-.*s\n", (int)sizeof(ctrl.sn), ctrl.sn);
else {
return 0;
}
-static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
+static int wdc_get_c0_log_page(nvme_root_t r, struct nvme_dev *dev, char *format,
int uuid_index, __u32 namespace_id)
{
int ret = 0;
__u32 cust_id;
uint32_t device_id, read_vendor_id;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
return fmt;
}
- ret = wdc_get_pci_ids(r, &device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &device_id, &read_vendor_id);
switch (device_id) {
case WDC_NVME_SN560_DEV_ID_1:
case WDC_NVME_SN560_DEV_ID_2:
case WDC_NVME_SN560_DEV_ID_3:
- cust_id = wdc_get_fw_cust_id(r, fd);
+ cust_id = wdc_get_fw_cust_id(r, dev);
if (cust_id == WDC_INVALID_CUSTOMER_ID) {
fprintf(stderr, "%s: ERROR : WDC : invalid customer id\n", __func__);
return -1;
}
if (namespace_id == NVME_NSID_ALL) {
- ret = nvme_get_nsid(fd, &namespace_id);
+ ret = nvme_get_nsid(dev->fd, &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 = fd,
+ .fd = dev->fd,
.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 = fd,
+ .fd = dev->fd,
.lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
.nsid = NVME_NSID_ALL,
.lpo = 0,
}
/* Get the 0xC0 log data */
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
WDC_NVME_EOL_STATUS_LOG_LEN, data);
if (strcmp(format, "json"))
}
/* Get the 0xC0 log data */
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
WDC_NVME_SMART_CLOUD_ATTR_LEN, data);
if (strcmp(format, "json"))
case WDC_NVME_SN820CL_DEV_ID:
/* Get the 0xC0 Extended Smart Cloud Attribute log data */
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(fd, &data, uuid_index, namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, uuid_index, namespace_id);
if (strcmp(format, "json"))
nvme_show_status(ret);
return ret;
}
-static int wdc_print_latency_monitor_log(int fd, struct wdc_ssd_latency_monitor_log *log_data, int fmt)
+static int wdc_print_latency_monitor_log(struct nvme_dev *dev,
+ struct wdc_ssd_latency_monitor_log *log_data,
+ int fmt)
{
if (!log_data) {
fprintf(stderr, "ERROR : WDC : Invalid C3 log data buffer\n");
}
switch (fmt) {
case NORMAL:
- wdc_print_latency_monitor_log_normal(fd, log_data);
+ wdc_print_latency_monitor_log_normal(dev, log_data);
break;
case JSON:
wdc_print_latency_monitor_log_json(log_data);
return 0;
}
-static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
+static int wdc_get_ca_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
{
int ret = 0;
int fmt = -1;
uint32_t read_device_id, read_vendor_id;
__u32 cust_id;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
/* verify the 0xCA log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE) == false) {
fprintf(stderr, "ERROR : WDC : 0xCA Log Page not supported\n");
return -1;
}
/* get the FW customer id */
- cust_id = wdc_get_fw_cust_id(r, fd);
+ cust_id = wdc_get_fw_cust_id(r, dev);
if (cust_id == WDC_INVALID_CUSTOMER_ID) {
fprintf(stderr, "%s: ERROR : WDC : invalid customer id\n", __func__);
return -1;
}
- ret = wdc_get_pci_ids(r, &read_device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &read_device_id, &read_vendor_id);
switch (read_device_id) {
memset(data, 0, sizeof (__u8) * WDC_FB_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, 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(fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, 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(fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
WDC_BD_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
return ret;
}
-static int wdc_get_c1_log_page(nvme_root_t r, int fd,
+static int wdc_get_c1_log_page(nvme_root_t r, struct nvme_dev *dev,
char *format, uint8_t interval)
{
int ret = 0;
struct wdc_log_page_subpage_header *sph;
struct wdc_ssd_perf_stats *perf;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
memset(data, 0, sizeof (__u8) * WDC_ADD_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_ADD_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, WDC_NVME_ADD_LOG_OPCODE,
WDC_ADD_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
return ret;
}
-static int wdc_get_c3_log_page(nvme_root_t r, int fd, char *format)
+static int wdc_get_c3_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
{
int ret = 0;
int fmt = -1;
int i;
struct wdc_ssd_latency_monitor_log *log_data;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
memset(data, 0, sizeof (__u8) * WDC_LATENCY_MON_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_LATENCY_MON_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, WDC_LATENCY_MON_OPCODE,
WDC_LATENCY_MON_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
}
/* parse the data */
- wdc_print_latency_monitor_log(fd, log_data, fmt);
+ wdc_print_latency_monitor_log(dev, log_data, fmt);
} else {
fprintf(stderr, "ERROR : WDC : Unable to read C3 data from buffer\n");
}
}
-static int wdc_get_ocp_c1_log_page(nvme_root_t r, int fd, char *format)
+static int wdc_get_ocp_c1_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
{
int ret = 0;
int fmt = -1;
int i;
struct wdc_ocp_c1_error_recovery_log *log_data;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
memset(data, 0, sizeof (__u8) * WDC_ERROR_REC_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_ERROR_REC_LOG_ID,
+ ret = nvme_get_log_simple(dev->fd, WDC_ERROR_REC_LOG_ID,
WDC_ERROR_REC_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
return ret;
}
-static int wdc_get_ocp_c4_log_page(nvme_root_t r, int fd, char *format)
+static int wdc_get_ocp_c4_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
{
int ret = 0;
int fmt = -1;
int i;
struct wdc_ocp_C4_dev_cap_log *log_data;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
memset(data, 0, sizeof (__u8) * WDC_DEV_CAP_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_DEV_CAP_LOG_ID,
+ ret = nvme_get_log_simple(dev->fd, WDC_DEV_CAP_LOG_ID,
WDC_DEV_CAP_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
return ret;
}
-static int wdc_get_ocp_c5_log_page(nvme_root_t r, int fd, char *format)
+static int wdc_get_ocp_c5_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
{
int ret = 0;
int fmt = -1;
int i;
struct wdc_ocp_C5_unsupported_reqs *log_data;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
memset(data, 0, sizeof (__u8) * WDC_UNSUPPORTED_REQS_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_UNSUPPORTED_REQS_LOG_ID,
+ ret = nvme_get_log_simple(dev->fd, WDC_UNSUPPORTED_REQS_LOG_ID,
WDC_UNSUPPORTED_REQS_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
return ret;
}
-static int wdc_get_d0_log_page(nvme_root_t r, int fd, char *format)
+static int wdc_get_d0_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
{
int ret = 0;
int fmt = -1;
__u8 *data;
struct wdc_ssd_d0_smart_log *perf;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
if (fmt < 0) {
}
/* verify the 0xD0 log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_VU_SMART_LOG_OPCODE) == false) {
fprintf(stderr, "ERROR : WDC : 0xD0 Log Page not supported\n");
return -1;
}
}
memset(data, 0, sizeof (__u8) * WDC_NVME_VU_SMART_LOG_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE,
+ ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE,
WDC_NVME_VU_SMART_LOG_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
fprintf(stderr, "ERROR : WDC: Unknown log page mask - %s\n", cfg.log_page_mask);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_SMART_LOG_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
if (((capabilities & WDC_DRIVE_CAP_C0_LOG_PAGE) == WDC_DRIVE_CAP_C0_LOG_PAGE) &&
(page_mask & WDC_C0_PAGE_MASK)) {
/* Get 0xC0 log page if possible. */
- ret = wdc_get_c0_log_page(r, dev->fd, cfg.output_format,
+ ret = wdc_get_c0_log_page(r, dev, cfg.output_format,
uuid_index, cfg.namespace_id);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the C0 Log Page, ret = %d\n", ret);
if (((capabilities & (WDC_DRIVE_CAP_CA_LOG_PAGE)) == (WDC_DRIVE_CAP_CA_LOG_PAGE)) &&
(page_mask & WDC_CA_PAGE_MASK)) {
/* Get the CA Log Page */
- ret = wdc_get_ca_log_page(r, dev->fd, cfg.output_format);
+ ret = wdc_get_ca_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the CA Log Page, ret = %d\n", ret);
}
if (((capabilities & WDC_DRIVE_CAP_C1_LOG_PAGE) == WDC_DRIVE_CAP_C1_LOG_PAGE) &&
(page_mask & WDC_C1_PAGE_MASK)) {
/* Get the C1 Log Page */
- ret = wdc_get_c1_log_page(r, dev->fd, cfg.output_format,
+ ret = wdc_get_c1_log_page(r, dev, cfg.output_format,
cfg.interval);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the C1 Log Page, ret = %d\n", ret);
if (((capabilities & WDC_DRIVE_CAP_D0_LOG_PAGE) == WDC_DRIVE_CAP_D0_LOG_PAGE) &&
(page_mask & WDC_D0_PAGE_MASK)) {
/* Get the D0 Log Page */
- ret = wdc_get_d0_log_page(r, dev->fd, cfg.output_format);
+ ret = wdc_get_d0_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the D0 Log Page, ret = %d\n", ret);
}
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CLOUD_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_HW_REV_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_DEVICE_WAF) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_C3_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_c3_log_page(r, dev->fd, cfg.output_format);
+ ret = wdc_get_c3_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Latency Monitor (C3) Log Page, ret = %d\n", ret);
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_OCP_C1_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_ocp_c1_log_page(r, dev->fd, cfg.output_format);
+ ret = wdc_get_ocp_c1_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Error Recovery (C1) Log Page, ret = 0x%x\n", ret);
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_OCP_C4_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_ocp_c4_log_page(r, dev->fd, cfg.output_format);
+ ret = wdc_get_ocp_c4_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Device Capabilities (C4) Log Page, ret = 0x%x\n", ret);
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_OCP_C5_LOG_PAGE) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
goto out;
}
- ret = wdc_get_ocp_c5_log_page(r, dev->fd, cfg.output_format);
+ ret = wdc_get_ocp_c5_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the Unsupported Requirements (C5) Log Page, ret = 0x%x\n", ret);
return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, dev->fd)) {
+ if (!wdc_check_device(r, dev)) {
ret = -1;
goto out;
}
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CLEAR_PCIE_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_STATUS) != WDC_DRIVE_CAP_DRIVE_STATUS) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
/* verify the 0xC2 Device Manageability log page is supported */
- if (wdc_nvme_check_supported_log_page(r, dev->fd,
+ if (wdc_nvme_check_supported_log_page(r, dev,
WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE) == false) {
fprintf(stderr, "ERROR : WDC : 0xC2 Log Page not supported\n");
ret = -1;
}
/* Get the assert dump present status */
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &assert_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &assert_status,
WDC_C2_ASSERT_DUMP_PRESENT_ID))
fprintf(stderr, "ERROR : WDC : Get Assert Status Failed\n");
/* Get the thermal throttling status */
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &thermal_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &thermal_status,
WDC_C2_THERMAL_THROTTLE_STATUS_ID))
fprintf(stderr, "ERROR : WDC : Get Thermal Throttling Status Failed\n");
/* Get EOL status */
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &eol_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &eol_status,
WDC_C2_USER_EOL_STATUS_ID)) {
fprintf(stderr, "ERROR : WDC : Get User EOL Status Failed\n");
eol_status = cpu_to_le32(-1);
}
/* Get Customer EOL state */
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &user_eol_state,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &user_eol_state,
WDC_C2_USER_EOL_STATE_ID))
fprintf(stderr, "ERROR : WDC : Get User EOL State Failed\n");
/* Get System EOL state*/
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &system_eol_state,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &system_eol_state,
WDC_C2_SYSTEM_EOL_STATE_ID))
fprintf(stderr, "ERROR : WDC : Get System EOL State Failed\n");
/* Get format corrupt reason*/
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &format_corrupt_reason,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &format_corrupt_reason,
WDC_C2_FORMAT_CORRUPT_REASON_ID))
fprintf(stderr, "ERROR : WDC : Get Format Corrupt Reason Failed\n");
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CLEAR_ASSERT) != WDC_DRIVE_CAP_CLEAR_ASSERT) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
goto out;
}
- if (!wdc_nvme_get_dev_status_log_data(r, dev->fd, &assert_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &assert_status,
WDC_C2_ASSERT_DUMP_PRESENT_ID)) {
fprintf(stderr, "ERROR : WDC : Get Assert Status Failed\n");
ret = -1;
return ret;
}
-static int wdc_get_fw_act_history(nvme_root_t r, int fd, char *format)
+static int wdc_get_fw_act_history(nvme_root_t r, struct nvme_dev *dev,
+ char *format)
{
int ret = 0;
int fmt = -1;
__u8 *data;
struct wdc_fw_act_history_log_hdr *fw_act_history_hdr;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
}
/* verify the FW Activate History log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID) == false) {
fprintf(stderr, "ERROR : WDC : %d Log Page not supported\n", WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID);
return -1;
}
memset(data, 0, sizeof (__u8) * WDC_FW_ACT_HISTORY_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID,
+ ret = nvme_get_log_simple(dev->fd, WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID,
WDC_FW_ACT_HISTORY_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
return ret;
}
-static __u32 wdc_get_fw_cust_id(nvme_root_t r, int fd)
+static __u32 wdc_get_fw_cust_id(nvme_root_t r, struct nvme_dev *dev)
{
__u32 cust_id = WDC_INVALID_CUSTOMER_ID;
__u32 *cust_id_ptr = NULL;
- if (!(get_dev_mgment_cbs_data(r, fd, WDC_C2_CUSTOMER_ID_ID, (void*)&cust_id_ptr))) {
+ if (!(get_dev_mgment_cbs_data(r, dev, WDC_C2_CUSTOMER_ID_ID, (void*)&cust_id_ptr))) {
fprintf(stderr, "%s: ERROR : WDC : 0xC2 Log Page entry ID 0x%x not found\n", __func__, WDC_C2_CUSTOMER_ID_ID);
} else {
cust_id = *cust_id_ptr;
return cust_id;
}
-static int wdc_get_fw_act_history_C2(nvme_root_t r, int fd, char *format)
+static int wdc_get_fw_act_history_C2(nvme_root_t r, struct nvme_dev *dev,
+ char *format)
{
int ret = 0;
int fmt = -1;
__u32 tot_entries = 0, num_entries = 0;
__u32 vendor_id = 0, device_id = 0;
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
return -1;
fmt = validate_output_format(format);
return fmt;
}
- ret = wdc_get_pci_ids(r, &device_id, &vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &device_id, &vendor_id);
if ((data = (__u8*) malloc(sizeof (__u8) * WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN)) == NULL) {
fprintf(stderr, "ERROR : WDC : malloc : %s\n", strerror(errno));
memset(data, 0, sizeof (__u8) * WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_FW_ACT_HISTORY_C2_LOG_ID,
+ 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);
if (strcmp(format, "json"))
if (tot_entries > 0) {
/* get the FW customer id */
- cust_id = wdc_get_fw_cust_id(r, fd);
+ cust_id = wdc_get_fw_cust_id(r, dev);
if (cust_id == WDC_INVALID_CUSTOMER_ID) {
fprintf(stderr, "%s: ERROR : WDC : invalid customer id\n", __func__);
ret = -1;
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_FW_ACTIVATE_HISTORY_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
free(data);
if (c0GuidMatch) {
- ret = wdc_get_fw_act_history_C2(r, dev->fd,
+ ret = wdc_get_fw_act_history_C2(r, dev,
cfg.output_format);
}
else {
- ret = wdc_get_fw_act_history(r, dev->fd,
+ ret = wdc_get_fw_act_history(r, dev,
cfg.output_format);
}
} else {
- ret = wdc_get_fw_act_history_C2(r, dev->fd, cfg.output_format);
+ ret = wdc_get_fw_act_history_C2(r, dev, cfg.output_format);
}
if (ret)
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRVIE_CAP_DISABLE_CTLR_TELE_LOG) != WDC_DRVIE_CAP_DISABLE_CTLR_TELE_LOG) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
0, 1, false, &result);
- wdc_clear_reason_id(dev->fd);
+ wdc_clear_reason_id(dev);
}
else {
if (cfg.enable) {
}
-static int wdc_get_serial_and_fw_rev(int fd, char *sn, char *fw_rev)
+static int wdc_get_serial_and_fw_rev(struct nvme_dev *dev, char *sn, char *fw_rev)
{
int i;
int ret;
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(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
return 0;
}
-static int wdc_get_max_transfer_len(int fd, __u32 *maxTransferLen)
+static int wdc_get_max_transfer_len(struct nvme_dev *dev, __u32 *maxTransferLen)
{
int ret = 0;
struct nvme_id_ctrl ctrl;
__u32 maxTransferLenDevice = 0;
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed 0x%x\n", ret);
return -1;
return ret;
}
-static int wdc_de_VU_read_size(int fd, __u32 fileId, __u16 spiDestn, __u32* logSize)
+static int wdc_de_VU_read_size(struct nvme_dev *dev, __u32 fileId,
+ __u16 spiDestn, __u32* logSize)
{
int ret = WDC_STATUS_FAILURE;
struct nvme_passthru_cmd cmd;
- if(!fd || !logSize )
+ if(!dev || !logSize )
{
ret = WDC_STATUS_INVALID_PARAMETER;
goto end;
cmd.cdw13 = fileId<<16;
cmd.cdw14 = spiDestn;
- ret = nvme_submit_admin_passthru(fd, &cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &cmd, NULL);
if (!ret && logSize)
*logSize = cmd.result;
return ret;
}
-static int wdc_de_VU_read_buffer(int fd, __u32 fileId, __u16 spiDestn, __u32 offsetInDwords, __u8* dataBuffer, __u32* bufferSize)
+static int wdc_de_VU_read_buffer(struct nvme_dev *dev, __u32 fileId,
+ __u16 spiDestn, __u32 offsetInDwords,
+ __u8* dataBuffer, __u32* bufferSize)
{
int ret = WDC_STATUS_FAILURE;
struct nvme_passthru_cmd cmd;
__u32 noOfDwordExpected = 0;
- if(!fd || !dataBuffer || !bufferSize)
+ if(!dev || !dataBuffer || !bufferSize)
{
ret = WDC_STATUS_INVALID_PARAMETER;
goto end;
cmd.addr = (__u64)(__u64)(uintptr_t)dataBuffer;
cmd.data_len = *bufferSize;
- ret = nvme_submit_admin_passthru(fd, &cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &cmd, NULL);
if( ret != WDC_STATUS_SUCCESS) {
fprintf(stderr, "ERROR : WDC : VUReadBuffer() failed, ");
return ret;
}
-static int wdc_get_log_dir_max_entries(int fd, __u32* maxNumOfEntries)
+static int wdc_get_log_dir_max_entries(struct nvme_dev *dev, __u32* maxNumOfEntries)
{
int ret = WDC_STATUS_FAILURE;
__u32 headerPayloadSize = 0;
__u16 fileOffset = 0;
- if (!fd || !maxNumOfEntries)
+ if (!dev || !maxNumOfEntries)
{
ret = WDC_STATUS_INVALID_PARAMETER;
return ret;
}
/* 1.Get log directory first four bytes */
- if (WDC_STATUS_SUCCESS != (ret = wdc_de_VU_read_size(fd, 0, 5, (__u32*)&headerPayloadSize)))
+ if (WDC_STATUS_SUCCESS != (ret = wdc_de_VU_read_size(dev, 0, 5, (__u32*)&headerPayloadSize)))
{
fprintf(stderr, "ERROR : WDC : %s: Failed to get headerPayloadSize from file directory 0x%x\n",
__func__, ret);
fileIdOffsetsBuffer = (__u8*)calloc(1, fileIdOffsetsBufferSize);
/* 2.Read to get file offsets */
- if (WDC_STATUS_SUCCESS != (ret = wdc_de_VU_read_buffer(fd, 0, 5, 0, fileIdOffsetsBuffer, &fileIdOffsetsBufferSize)))
+ if (WDC_STATUS_SUCCESS != (ret = wdc_de_VU_read_buffer(dev, 0, 5, 0, fileIdOffsetsBuffer, &fileIdOffsetsBufferSize)))
{
fprintf(stderr, "ERROR : WDC : %s: Failed to get fileIdOffsets from file directory 0x%x\n",
__func__, ret);
return essentialType;
}
-static int wdc_fetch_log_directory(int fd, PWDC_DE_VU_LOG_DIRECTORY directory)
+static int wdc_fetch_log_directory(struct nvme_dev *dev, PWDC_DE_VU_LOG_DIRECTORY directory)
{
int ret = WDC_STATUS_FAILURE;
__u8 *fileOffset = NULL;
__u32 entryId = 0;
__u32 fileDirectorySize = 0;
- if (!fd || !directory) {
+ if (!dev || !directory) {
ret = WDC_STATUS_INVALID_PARAMETER;
goto end;
}
- ret = wdc_de_VU_read_size(fd, 0, 5, &fileDirectorySize);
+ ret = wdc_de_VU_read_size(dev, 0, 5, &fileDirectorySize);
if (WDC_STATUS_SUCCESS != ret) {
fprintf(stderr,
"ERROR : WDC : %s: Failed to get filesystem directory size, ret = %d\n",
}
fileDirectory = (__u8*)calloc(1, fileDirectorySize);
- ret = wdc_de_VU_read_buffer(fd, 0, 5, 0, fileDirectory, &fileDirectorySize);
+ ret = wdc_de_VU_read_buffer(dev, 0, 5, 0, fileDirectory, &fileDirectorySize);
if (WDC_STATUS_SUCCESS != ret) {
fprintf(stderr,
"ERROR : WDC : %s: Failed to get filesystem directory, ret = %d\n",
return ret;
}
-static int wdc_fetch_log_file_from_device(int fd, __u32 fileId, __u16 spiDestn, __u64 fileSize, __u8* dataBuffer)
+static int wdc_fetch_log_file_from_device(struct nvme_dev *dev, __u32 fileId,
+ __u16 spiDestn, __u64 fileSize, __u8* dataBuffer)
{
int ret = WDC_STATUS_FAILURE;
__u32 chunckSize = WDC_DE_VU_READ_BUFFER_STANDARD_OFFSET;
__u32 buffSize = 0;
__u64 offsetIdx = 0;
- if (!fd || !dataBuffer || !fileSize)
+ if (!dev || !dataBuffer || !fileSize)
{
ret = WDC_STATUS_INVALID_PARAMETER;
goto end;
}
- if (wdc_get_max_transfer_len(fd, &maximumTransferLength) < 0) {
+ if (wdc_get_max_transfer_len(dev, &maximumTransferLength) < 0) {
ret = WDC_STATUS_FAILURE;
goto end;
}
if (((offsetIdx * chunckSize) + buffSize) > fileSize)
buffSize = (__u32)(fileSize - (offsetIdx * chunckSize));
/* Limitation in VU read buffer - offsetIdx and bufferSize are not greater than u32 */
- ret = wdc_de_VU_read_buffer(fd, fileId, spiDestn,
+ ret = wdc_de_VU_read_buffer(dev, fileId, spiDestn,
(__u32)((offsetIdx * chunckSize) / sizeof(__u32)), dataBuffer + (offsetIdx * chunckSize), &buffSize);
if (ret != WDC_STATUS_SUCCESS)
{
}
} else {
buffSize = (__u32)fileSize;
- ret = wdc_de_VU_read_buffer(fd, fileId, spiDestn,
+ ret = wdc_de_VU_read_buffer(dev, fileId, spiDestn,
(__u32)((offsetIdx * chunckSize) / sizeof(__u32)), dataBuffer, &buffSize);
if (ret != WDC_STATUS_SUCCESS)
{
return ret;
}
-static int wdc_de_get_dump_trace(int fd, char * filePath, __u16 binFileNameLen, char *binFileName)
+static int wdc_de_get_dump_trace(struct nvme_dev *dev, char * filePath, __u16 binFileNameLen, char *binFileName)
{
int ret = WDC_STATUS_FAILURE;
__u8 *readBuffer = NULL;
__u16 i = 0;
__u32 maximumTransferLength = 0;
- if (!fd || !binFileName || !filePath)
+ if (!dev || !binFileName || !filePath)
{
ret = WDC_STATUS_INVALID_PARAMETER;
return ret;
}
- if (wdc_get_max_transfer_len(fd, &maximumTransferLength) < 0)
+ if (wdc_get_max_transfer_len(dev, &maximumTransferLength) < 0)
return WDC_STATUS_FAILURE;
do
{
/* Get dumptrace size */
- ret = wdc_de_VU_read_size(fd, 0, WDC_DE_DUMPTRACE_DESTINATION, &dumptraceSize);
+ ret = wdc_de_VU_read_size(dev, 0, WDC_DE_DUMPTRACE_DESTINATION, &dumptraceSize);
if (ret != WDC_STATUS_SUCCESS)
{
fprintf(stderr, "ERROR : WDC : %s: wdc_de_VU_read_size failed with ret = %d\n",
readBufferLen = lastPktReadBufferLen;
}
- ret = wdc_de_VU_read_buffer(fd, 0, WDC_DE_DUMPTRACE_DESTINATION, 0, readBuffer + offset, &readBufferLen);
+ ret = wdc_de_VU_read_buffer(dev, 0, WDC_DE_DUMPTRACE_DESTINATION, 0, readBuffer + offset, &readBufferLen);
if (ret != WDC_STATUS_SUCCESS)
{
fprintf(stderr, "ERROR : WDC : %s: wdc_de_VU_read_buffer failed, ret = %d on offset 0x%x\n",
return ret;
}
-static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
+static int wdc_do_drive_essentials(nvme_root_t r, struct nvme_dev *dev,
+ char *dir, char *key)
{
int ret = 0;
void *retPtr;
memset(tarCmd,0,sizeof(tarCmd));
memset(&timeInfo,0,sizeof(timeInfo));
- if (wdc_get_serial_and_fw_rev(fd, (char *)idSerialNo, (char *)idFwRev))
+ if (wdc_get_serial_and_fw_rev(dev, (char *)idSerialNo, (char *)idFwRev))
{
fprintf(stderr, "ERROR : WDC : get serial # and fw revision failed\n");
return -1;
/* Get Identify Controller Data */
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &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(fd, 1, &ns);
+ ret = nvme_identify_ns(dev->fd, 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(fd, elogNumEntries, false, elogBuffer);
+ ret = nvme_get_log_error(dev->fd, 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(fd, NVME_NSID_ALL, false, &smart_log);
+ ret = nvme_get_log_smart(dev->fd, 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(fd, false, &fw_log);
+ ret = nvme_get_log_fw_slot(dev->fd, 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(fd, deVULogPagesList[vuLogIdx].logPageId,
+ ret = nvme_get_log_simple(dev->fd, deVULogPagesList[vuLogIdx].logPageId,
dataBufferSize, dataBuffer);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_get_log() for log page 0x%x failed, ret = %d\n",
/* 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(fd, deFeatureIdList[listIdx].featureId, WDC_DE_GLOBAL_NSID,
- sizeof(featureIdBuff), &featureIdBuff, &result);
+ ret = nvme_get_features_data(dev->fd,
+ deFeatureIdList[listIdx].featureId,
+ WDC_DE_GLOBAL_NSID,
+ sizeof(featureIdBuff),
+ &featureIdBuff, &result);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_get_feature id 0x%x failed, ret = %d\n",
}
/* Read Debug Directory */
- ret = wdc_get_log_dir_max_entries(fd, &maxNumOfVUFiles);
+ ret = wdc_get_log_dir_max_entries(dev, &maxNumOfVUFiles);
if (ret == WDC_STATUS_SUCCESS)
{
memset(&deEssentialsList, 0, sizeof(deEssentialsList));
deEssentialsList.maxNumLogEntries = maxNumOfVUFiles;
/* Fetch VU File Directory */
- ret = wdc_fetch_log_directory(fd, &deEssentialsList);
+ ret = wdc_fetch_log_directory(dev, &deEssentialsList);
if (ret == WDC_STATUS_SUCCESS)
{
/* Get Debug Data Files */
} else {
/* Fetch Log File Data */
dataBuffer = (char *)calloc(1, (size_t)deEssentialsList.logEntry[listIdx].metaData.fileSize);
- ret = wdc_fetch_log_file_from_device(fd, deEssentialsList.logEntry[listIdx].metaData.fileID, WDC_DE_DESTN_SPI, deEssentialsList.logEntry[listIdx].metaData.fileSize,
+ ret = wdc_fetch_log_file_from_device(dev, deEssentialsList.logEntry[listIdx].metaData.fileID, WDC_DE_DESTN_SPI, deEssentialsList.logEntry[listIdx].metaData.fileSize,
(__u8 *)dataBuffer);
/* Write databuffer to file */
/* Get Dump Trace Data */
wdc_UtilsSnprintf(fileName, MAX_PATH_LEN, "%s%s%s_%s_%s.bin", (char*)bufferFolderPath, WDC_DE_PATH_SEPARATOR, "dumptrace", serialNo, timeString);
- if (WDC_STATUS_SUCCESS != (ret = wdc_de_get_dump_trace(fd, (char*)bufferFolderPath, 0, fileName)))
+ if (WDC_STATUS_SUCCESS != (ret = wdc_de_get_dump_trace(dev, (char*)bufferFolderPath, 0, fileName)))
{
fprintf(stderr, "ERROR : WDC : wdc_de_get_dump_trace failed, ret = %d\n", ret);
}
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_ESSENTIALS) != WDC_DRIVE_CAP_DRIVE_ESSENTIALS) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
d_ptr = NULL;
}
- ret = wdc_do_drive_essentials(r, dev->fd, d_ptr, k);
+ ret = wdc_do_drive_essentials(r, dev, d_ptr, k);
out:
nvme_free_tree(r);
dev_close(dev);
return ret;
}
-static int wdc_do_drive_resize(int fd, uint64_t new_size)
+static int wdc_do_drive_resize(struct nvme_dev *dev, uint64_t new_size)
{
int ret;
struct nvme_passthru_cmd admin_cmd;
WDC_NVME_DRIVE_RESIZE_CMD);
admin_cmd.cdw13 = new_size;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
return ret;
}
-static int wdc_do_namespace_resize(int fd, __u32 nsid, __u32 op_option)
+static int wdc_do_namespace_resize(struct nvme_dev *dev, __u32 nsid, __u32 op_option)
{
int ret;
struct nvme_passthru_cmd admin_cmd;
admin_cmd.nsid = nsid;
admin_cmd.cdw10 = op_option;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
return ret;
}
-static int wdc_do_drive_info(int fd, __u32 *result)
+static int wdc_do_drive_info(struct nvme_dev *dev, __u32 *result)
{
int ret;
struct nvme_passthru_cmd admin_cmd;
admin_cmd.cdw12 = ((WDC_NVME_DRIVE_INFO_SUBCMD << WDC_NVME_SUBCMD_SHIFT) |
WDC_NVME_DRIVE_INFO_CMD);
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
if (!ret && result)
*result = admin_cmd.result;
return ret;
r = nvme_scan(NULL);
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_RESIZE) == WDC_DRIVE_CAP_RESIZE) {
- ret = wdc_do_drive_resize(dev->fd, cfg.size);
+ ret = wdc_do_drive_resize(dev, cfg.size);
} else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
r = nvme_scan(NULL);
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_NS_RESIZE) == WDC_DRIVE_CAP_NS_RESIZE) {
- ret = wdc_do_namespace_resize(dev->fd, cfg.namespace_id,
+ ret = wdc_do_namespace_resize(dev, cfg.namespace_id,
cfg.op_option);
if (ret != 0)
else
snprintf(fileSuffix, PATH_MAX, "_error_reason_identifier_host_%s", (char*)timeStamp);
- if (wdc_get_serial_name(dev->fd, f, PATH_MAX, fileSuffix) == -1) {
+ if (wdc_get_serial_name(dev, f, PATH_MAX, fileSuffix) == -1) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
ret = -1;
goto close_fd;
fprintf(stderr, "%s: filename = %s\n", __func__, f);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_REASON_ID) == WDC_DRIVE_CAP_REASON_ID) {
- ret = wdc_do_get_reason_id(dev->fd, f, cfg.log_id);
+ ret = wdc_do_get_reason_id(dev, f, cfg.log_id);
} else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
ret = 0;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_LOG_PAGE_DIR) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_get_pci_ids(r, &device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &device_id, &read_vendor_id);
log_id = (device_id == WDC_NVME_ZN350_DEV_ID || device_id == WDC_NVME_ZN350_DEV_ID_1) ?
WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE_C8 : WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE;
/* verify the 0xC2 Device Manageability log page is supported */
- if (wdc_nvme_check_supported_log_page(r, dev->fd, log_id) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev, log_id) == false) {
fprintf(stderr, "%s: ERROR : WDC : 0x%x Log Page not supported\n", __func__, log_id);
ret = -1;
goto out;
}
- if (get_dev_mgment_cbs_data(r, dev->fd, WDC_C2_LOG_PAGES_SUPPORTED_ID, (void *)&cbs_data)) {
+ if (get_dev_mgment_cbs_data(r, dev, WDC_C2_LOG_PAGES_SUPPORTED_ID, (void *)&cbs_data)) {
if (cbs_data != NULL) {
printf("Log Page Directory\n");
/* print the supported pages */
return ret;
}
-static int wdc_get_drive_reason_id(int fd, char *drive_reason_id, size_t len)
+static int wdc_get_drive_reason_id(struct nvme_dev *dev, char *drive_reason_id, size_t len)
{
int i, j;
int ret;
j = sizeof (ctrl.mn) - 1;
memset(drive_reason_id, 0, len);
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev->fd, &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
return 0;
}
-static int wdc_save_reason_id(int fd, __u8 *rsn_ident, int size)
+static int wdc_save_reason_id(struct nvme_dev *dev, __u8 *rsn_ident, int size)
{
int ret = 0;
char *reason_id_file;
char reason_id_path[PATH_MAX] = WDC_REASON_ID_PATH_NAME;
struct stat st = {0};
- if (wdc_get_drive_reason_id(fd, drive_reason_id, PATH_MAX) == -1) {
+ if (wdc_get_drive_reason_id(dev, drive_reason_id, PATH_MAX) == -1) {
fprintf(stderr, "%s: ERROR : failed to get drive reason id\n", __func__);
return -1;
}
return ret;
}
-static int wdc_clear_reason_id(int fd)
+static int wdc_clear_reason_id(struct nvme_dev *dev)
{
int ret = -1;
int verify_file;
char *reason_id_file;
char drive_reason_id[PATH_MAX] = {0};
- if (wdc_get_drive_reason_id(fd, drive_reason_id, PATH_MAX) == -1) {
+ if (wdc_get_drive_reason_id(dev, drive_reason_id, PATH_MAX) == -1) {
fprintf(stderr, "%s: ERROR : failed to get drive reason id\n", __func__);
return -1;
}
return ret;
}
-static int wdc_dump_telemetry_hdr(int fd, int log_id, struct nvme_telemetry_log *log_hdr)
+static int wdc_dump_telemetry_hdr(struct nvme_dev *dev, int log_id, struct nvme_telemetry_log *log_hdr)
{
int ret = 0;
if (log_id == NVME_LOG_LID_TELEMETRY_HOST)
- ret = nvme_get_log_create_telemetry_host(fd, log_hdr);
+ ret = nvme_get_log_create_telemetry_host(dev->fd, log_hdr);
else
- ret = nvme_get_log_telemetry_ctrl(fd, false, 0, 512, (void *)log_hdr);
+ ret = nvme_get_log_telemetry_ctrl(dev->fd, false, 0, 512,
+ (void *)log_hdr);
if (ret < 0)
perror("get-telemetry-log");
return ret;
}
-static int wdc_do_get_reason_id(int fd, char *file, int log_id)
+static int wdc_do_get_reason_id(struct nvme_dev *dev, char *file, int log_id)
{
int ret;
struct nvme_telemetry_log *log_hdr;
}
memset(log_hdr, 0, log_hdr_size);
- ret = wdc_dump_telemetry_hdr(fd, log_id, log_hdr);
+ ret = wdc_dump_telemetry_hdr(dev, log_id, log_hdr);
if (ret != 0) {
fprintf(stderr, "%s: ERROR : get telemetry header failed, ret : %d\n", __func__, ret);
ret = -1;
reason_id_size = sizeof(log_hdr->rsnident);
if (log_id == NVME_LOG_LID_TELEMETRY_CTRL)
- wdc_save_reason_id(fd, log_hdr->rsnident, reason_id_size);
+ wdc_save_reason_id(dev, log_hdr->rsnident, reason_id_size);
ret = wdc_create_log_file(file, (__u8 *)log_hdr->rsnident, reason_id_size);
json_free_object(root);
}
-static int wdc_do_vs_nand_stats_sn810_2(int fd, char *format)
+static int wdc_do_vs_nand_stats_sn810_2(struct nvme_dev *dev, char *format)
{
int ret;
int fmt = -1;
uint8_t *data = NULL;
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_ext_smart_cloud_log(dev->fd, &data, 0, NVME_NSID_ALL);
if (ret) {
fprintf(stderr, "ERROR : WDC : %s : Failed to retreive NAND stats\n", __func__);
return ret;
}
-static int wdc_do_vs_nand_stats(int fd, char *format)
+static int wdc_do_vs_nand_stats(struct nvme_dev *dev, char *format)
{
int ret;
int fmt = -1;
goto out;
}
- ret = nvme_get_log_simple(fd, WDC_NVME_NAND_STATS_LOG_ID,
+ ret = nvme_get_log_simple(dev->fd, 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__);
return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_NAND_STATS) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_get_pci_ids(r, &read_device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &read_device_id, &read_vendor_id);
if (ret < 0)
{
fprintf(stderr, "ERROR : WDC: %s: failure to get pci ids, ret = %d\n", __func__, ret);
switch (read_device_id) {
case WDC_NVME_SN820CL_DEV_ID:
- ret = wdc_do_vs_nand_stats_sn810_2(dev->fd,
+ ret = wdc_do_vs_nand_stats_sn810_2(dev,
cfg.output_format);
break;
default:
- ret = wdc_do_vs_nand_stats(dev->fd, cfg.output_format);
+ ret = wdc_do_vs_nand_stats(dev, cfg.output_format);
break;
}
}
return ret;
}
-static int wdc_do_vs_pcie_stats(int fd,
+static int wdc_do_vs_pcie_stats(struct nvme_dev *dev,
struct wdc_vs_pcie_stats *pcieStatsPtr)
{
int ret;
admin_cmd.addr = (__u64)(uintptr_t)pcieStatsPtr;
admin_cmd.data_len = pcie_stats_size;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &admin_cmd, NULL);
return ret;
}
memset((void *)pcieStatsPtr, 0, pcie_stats_size);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_PCIE_STATS) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_do_vs_pcie_stats(dev->fd, pcieStatsPtr);
+ ret = wdc_do_vs_pcie_stats(dev, pcieStatsPtr);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading PCIE statistics, ret = 0x%x\n", ret);
else {
}
r = nvme_scan(NULL);
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_INFO) == WDC_DRIVE_CAP_INFO) {
- ret = wdc_get_pci_ids(r, &read_device_id, &read_vendor_id);
+ ret = wdc_get_pci_ids(r, dev, &read_device_id, &read_vendor_id);
if (ret < 0)
{
fprintf(stderr, "ERROR : WDC: %s: failure to get pci ids, ret = %d\n", __func__, ret);
case WDC_NVME_SN550_DEV_ID:
case WDC_NVME_ZN350_DEV_ID:
case WDC_NVME_ZN350_DEV_ID_1:
- ret = wdc_do_drive_info(dev->fd, &result);
+ ret = wdc_do_drive_info(dev, &result);
if (!ret) {
size = (__u16)((cpu_to_le32(result) & 0xffff0000) >> 16);
}
/* check if command is supported */
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_TEMP_STATS) != WDC_DRIVE_CAP_TEMP_STATS) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
/* print command and supported status */
printf("WDC Plugin Capabilities for NVME device:%s\n", nvme_dev->name);
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CLOUD_SSD_VERSION) == WDC_DRIVE_CAP_CLOUD_SSD_VERSION) {
/* print command and supported status */
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, dev->fd);
- capabilities = wdc_get_drive_capabilities(r, dev->fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
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 */
if (err < 0)
goto ret;
- if (!wdc_enc_check_model(dev->fd)) {
+ if (!wdc_enc_check_model(dev)) {
err = -EINVAL;
goto closed_fd;
}
if (cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_1 || cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_2
|| cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_3 || cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_4) {
fprintf(stderr, "args - sz:%x logid:%x of:%s\n",xfer_size,cfg.log_id,cfg.file);
- err = wdc_enc_get_nic_log(dev->fd, cfg.log_id,
+ err = wdc_enc_get_nic_log(dev, cfg.log_id,
xfer_size,
WDC_NVME_ENC_NIC_LOG_SIZE,
output_fd);
} else {
fprintf(stderr, "args - sz:%x logid:%x of:%s\n",xfer_size,cfg.log_id,cfg.file);
- err = wdc_enc_submit_move_data(dev->fd, NULL, 0,
+ err = wdc_enc_submit_move_data(dev, NULL, 0,
xfer_size, output_fd,
cfg.log_id, 0, 0);
}
return err;
}
-static int wdc_enc_submit_move_data(int fd, char *cmd, int len, int xfer_size, FILE *out, int log_id, int cdw14, int cdw15)
+static int wdc_enc_submit_move_data(struct nvme_dev *dev, char *cmd, int len,
+ int xfer_size, FILE *out, int log_id,
+ int cdw14, int cdw15)
{
struct timespec time;
uint32_t response_size, more;
d);
#endif
nvme_cmd.result = 0;
- err = nvme_submit_admin_passthru(fd, &nvme_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev->fd, &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(fd, &nvme_cmd, NULL);
+ err = nvme_submit_admin_passthru(dev->fd, &nvme_cmd, NULL);
if (err != 0) {
more = 0;
fprintf(stderr, "%s: ERROR : WDC : NVMe Rcv Mgmt ", __func__);
return err;
}
-static int wdc_enc_get_nic_log(int fd, __u8 log_id, __u32 xfer_size, __u32 data_len, FILE *out)
+static int wdc_enc_get_nic_log(struct nvme_dev *dev, __u8 log_id, __u32 xfer_size, __u32 data_len, FILE *out)
{
__u8 *dump_data;
__u32 curr_data_offset, curr_data_len;
#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(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev->fd, &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",
projects / users / sagi / nvme-cli.git / commitdiff