summaryrefslogtreecommitdiffstats
path: root/plugins/wdc
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2022-11-05 18:23:30 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2022-11-05 18:23:30 +0000
commit4ed089396bc7f14bcb94e80f0f9f4757fd8c48b7 (patch)
tree866986558761a9709a7af1940ba607128a45f775 /plugins/wdc
parentReleasing debian version 2.1.2-2. (diff)
downloadnvme-cli-4ed089396bc7f14bcb94e80f0f9f4757fd8c48b7.tar.xz
nvme-cli-4ed089396bc7f14bcb94e80f0f9f4757fd8c48b7.zip
Merging upstream version 2.2.1.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'plugins/wdc')
-rw-r--r--plugins/wdc/wdc-nvme.c1553
-rw-r--r--plugins/wdc/wdc-nvme.h2
2 files changed, 850 insertions, 705 deletions
diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 5f90c76..cf185be 100644
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -36,6 +36,7 @@
#include "libnvme.h"
#include "plugin.h"
#include "linux/types.h"
+#include "util/types.h"
#include "nvme-print.h"
#define CREATE_CMD
@@ -77,11 +78,15 @@
#define WDC_NVME_SN650_DEV_ID_3 0x2720
#define WDC_NVME_SN650_DEV_ID_4 0x2721
#define WDC_NVME_SN655_DEV_ID 0x2722
+#define WDC_NVME_SN860_DEV_ID 0x2730
+#define WDC_NVME_SN660_DEV_ID 0x2704
+
+/* This id's are no longer supported, delete ?? */
+#define WDC_NVME_SN550_DEV_ID 0x2708
#define WDC_NVME_SN560_DEV_ID_1 0x2712
#define WDC_NVME_SN560_DEV_ID_2 0x2713
#define WDC_NVME_SN560_DEV_ID_3 0x2714
-#define WDC_NVME_SN860_DEV_ID 0x2730
-#define WDC_NVME_SN550_DEV_ID 0x2708
+
#define WDC_NVME_SXSLCL_DEV_ID 0x2001
#define WDC_NVME_SN520_DEV_ID 0x5003
#define WDC_NVME_SN520_DEV_ID_1 0x5004
@@ -89,8 +94,6 @@
#define WDC_NVME_SN530_DEV_ID 0x5009
#define WDC_NVME_SN720_DEV_ID 0x5002
#define WDC_NVME_SN730A_DEV_ID 0x5006
-#define WDC_NVME_SN730B_DEV_ID 0x3714
-#define WDC_NVME_SN730B_DEV_ID_1 0x3734
#define WDC_NVME_SN740_DEV_ID 0x5015
#define WDC_NVME_SN740_DEV_ID_1 0x5016
#define WDC_NVME_SN740_DEV_ID_2 0x5017
@@ -327,7 +330,7 @@
#define WDC_NVME_SMART_CLOUD_ATTR_LEN 0x200
/* C0 SMART Cloud Attributes Log Page*/
-#define WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE 0xC0
+#define WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_ID 0xC0
/* CB - FW Activate History Log Page */
#define WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID 0xCB
@@ -341,7 +344,7 @@
/* C3 Latency Monitor Log Page */
#define WDC_LATENCY_MON_LOG_BUF_LEN 0x200
-#define WDC_LATENCY_MON_OPCODE 0xC3
+#define WDC_LATENCY_MON_LOG_ID 0xC3
#define WDC_LATENCY_MON_VERSION 0x0001
#define WDC_C3_GUID_LENGTH 16
@@ -792,17 +795,18 @@ static NVME_VU_DE_LOGPAGE_LIST deVULogPagesList[] =
{ 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);
@@ -810,10 +814,11 @@ static int wdc_purge(int argc, char **argv,
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,
@@ -822,27 +827,31 @@ static int wdc_clear_assert_dump(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 {
@@ -1084,7 +1093,8 @@ struct __attribute__((__packed__)) wdc_ssd_d0_smart_log {
#define WDC_OCP_C1_GUID_LENGTH 16
#define WDC_ERROR_REC_LOG_BUF_LEN 512
#define WDC_ERROR_REC_LOG_ID 0xC1
-#define WDC_ERROR_REC_LOG_VERSION 0002
+#define WDC_ERROR_REC_LOG_VERSION1 0001
+#define WDC_ERROR_REC_LOG_VERSION2 0002
struct __attribute__((__packed__)) wdc_ocp_c1_error_recovery_log {
__le16 panic_reset_wait_time; /* 000 - Panic Reset Wait Time */
@@ -1096,9 +1106,9 @@ struct __attribute__((__packed__)) wdc_ocp_c1_error_recovery_log {
__u8 rsvd1[3]; /* 017 - 3 Reserved Bytes */
__le32 vs_cmd_cdw12; /* 020 - Vendor Specific Command CDW12 */
__le32 vs_cmd_cdw13; /* 024 - Vendor Specific Command CDW13 */
- __u8 vs_cmd_to; /* 028 - Vendor Specific Command Timeout */
- __u8 dev_recovery_action2; /* 029 - Device Recovery Action 2 */
- __u8 dev_recovery_action2_to; /* 030 - Device Recovery Action 2 Timeout */
+ __u8 vs_cmd_to; /* 028 - Vendor Specific Command Timeout V2 */
+ __u8 dev_recovery_action2; /* 029 - Device Recovery Action 2 V2 */
+ __u8 dev_recovery_action2_to; /* 030 - Device Recovery Action 2 Timeout V2*/
__u8 rsvd2[463]; /* 031 - 463 Reserved Bytes */
__le16 log_page_version; /* 494 - Log Page Version */
__u8 log_page_guid[WDC_OCP_C1_GUID_LENGTH]; /* 496 - Log Page GUID */
@@ -1277,27 +1287,15 @@ static double calc_percent(uint64_t numerator, uint64_t denominator)
(uint64_t)(((double)numerator / (double)denominator) * 100) : 0;
}
-static long double int128_to_double(__u8 *data)
-{
- int i;
- long double result = 0;
-
- for (i = 0; i < 16; i++) {
- result *= 256;
- result += data[15 - i];
- }
- 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, devicename);
+ c = nvme_scan_ctrl(r, dev->name);
if (c) {
snprintf(vid, sizeof(vid), "%s/device/vendor",
nvme_ctrl_get_sysfs_dir(c));
@@ -1305,9 +1303,9 @@ static int wdc_get_pci_ids(nvme_root_t r, uint32_t *device_id,
nvme_ctrl_get_sysfs_dir(c));
nvme_free_ctrl(c);
} else {
- n = nvme_scan_namespace(devicename);
+ n = nvme_scan_namespace(dev->name);
if (!n) {
- fprintf(stderr, "Unable to find %s\n", devicename);
+ fprintf(stderr, "Unable to find %s\n", dev->name);
return -1;
}
@@ -1359,13 +1357,13 @@ static int wdc_get_pci_ids(nvme_root_t r, uint32_t *device_id,
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(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
@@ -1382,13 +1380,13 @@ static bool wdc_check_power_of_2(int num)
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(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
@@ -1404,16 +1402,16 @@ static int wdc_get_model_number(int fd, char *model)
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;
}
@@ -1430,13 +1428,13 @@ static bool wdc_check_device(nvme_root_t r, int fd)
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;
@@ -1450,23 +1448,24 @@ static bool wdc_enc_check_model(int fd)
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;
}
@@ -1484,11 +1483,13 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
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:
@@ -1504,11 +1505,14 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
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:
@@ -1524,8 +1528,12 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
case WDC_NVME_SN560_DEV_ID_2:
/* FALLTHRU */
case WDC_NVME_SN560_DEV_ID_3:
+ /* FALLTHRU */
+ case WDC_NVME_SN660_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_SMART_CLOUD_ATTR_LOG_ID)
+ == true) {
capabilities |= WDC_DRIVE_CAP_C0_LOG_PAGE;
}
@@ -1536,30 +1544,36 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
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_LOG_ID))
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;
@@ -1579,9 +1593,9 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
/* 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 */
@@ -1595,11 +1609,13 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
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:
@@ -1610,23 +1626,45 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
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_SMART_CLOUD_ATTR_LOG_ID))
capabilities |= WDC_DRIVE_CAP_C0_LOG_PAGE;
- }
+
+ /* verify the 0xC1 (OCP Error Recovery) log page is supported */
+ 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, dev, WDC_LATENCY_MON_LOG_ID))
+ 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, 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, dev, WDC_UNSUPPORTED_REQS_LOG_ID))
+ capabilities |= WDC_DRIVE_CAP_OCP_C5_LOG_PAGE;
capabilities |= (WDC_DRIVE_CAP_CAP_DIAG | WDC_DRIVE_CAP_INTERNAL_LOG |
WDC_DRIVE_CAP_DRIVE_STATUS | WDC_DRIVE_CAP_CLEAR_ASSERT |
- WDC_DRIVE_CAP_RESIZE | WDC_DRIVE_CAP_CLEAR_PCIE |
- WDC_DRIVE_CAP_FW_ACTIVATE_HISTORY | WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY |
+ WDC_DRIVE_CAP_RESIZE | WDC_DRIVE_CAP_FW_ACTIVATE_HISTORY |
WDC_DRVIE_CAP_DISABLE_CTLR_TELE_LOG | WDC_DRIVE_CAP_REASON_ID |
- WDC_DRIVE_CAP_LOG_PAGE_DIR | WDC_DRIVE_CAP_INFO |
- WDC_DRIVE_CAP_CLOUD_SSD_VERSION);
+ WDC_DRIVE_CAP_LOG_PAGE_DIR);
+
+ 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 ((cust_id == WDC_CUSTOMER_ID_0x1004) || (cust_id == WDC_CUSTOMER_ID_0x1008) ||
+ (cust_id == WDC_CUSTOMER_ID_0x1005) || (cust_id == WDC_CUSTOMER_ID_0x1304))
+ capabilities |= (WDC_DRIVE_CAP_VU_FID_CLEAR_FW_ACT_HISTORY | WDC_DRIVE_CAP_VU_FID_CLEAR_PCIE |
+ WDC_DRIVE_CAP_INFO | WDC_DRIVE_CAP_CLOUD_SSD_VERSION);
+ else
+ capabilities |= (WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY | WDC_DRIVE_CAP_CLEAR_PCIE);
- break;
- case WDC_NVME_SN730B_DEV_ID:
- /* FALLTHRU */
- case WDC_NVME_SN730B_DEV_ID_1:
- capabilities = WDC_SN730B_CAP_VUC_LOG;
break;
default:
capabilities = 0;
@@ -1685,13 +1723,15 @@ static __u64 wdc_get_drive_capabilities(nvme_root_t r, int fd) {
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;
@@ -1701,11 +1741,11 @@ static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r, int fd) {
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:
@@ -1714,22 +1754,22 @@ static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r, int fd) {
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_LOG_ID) == 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;
@@ -1752,7 +1792,8 @@ static __u64 wdc_get_enc_drive_capabilities(nvme_root_t r, int fd) {
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;
@@ -1765,7 +1806,7 @@ static int wdc_get_serial_name(int fd, char *file, size_t len, const char *suffi
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(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
@@ -1927,7 +1968,8 @@ bool wdc_get_dev_mng_log_entry(__u32 log_length,
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;
@@ -1940,7 +1982,7 @@ static bool get_dev_mgment_cbs_data(nvme_root_t r, int fd, __u8 log_id, void **c
*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;
@@ -1956,7 +1998,7 @@ static bool get_dev_mgment_cbs_data(nvme_root_t r, int fd, __u8 log_id, void **c
/* get the log page length */
struct nvme_get_log_args args_len = {
.args_size = sizeof(args_len),
- .fd = fd,
+ .fd = dev_fd(dev),
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
@@ -1993,7 +2035,7 @@ static bool get_dev_mgment_cbs_data(nvme_root_t r, int fd, __u8 log_id, void **c
/* get the log page data */
struct nvme_get_log_args args_data = {
.args_size = sizeof(args_data),
- .fd = fd,
+ .fd = dev_fd(dev),
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
@@ -2034,7 +2076,7 @@ static bool get_dev_mgment_cbs_data(nvme_root_t r, int fd, __u8 log_id, void **c
/* get the log page data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev_fd(dev),
.lid = lid,
.nsid = 0xFFFFFFFF,
.lpo = 0,
@@ -2072,13 +2114,15 @@ end:
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]) {
@@ -2104,12 +2148,14 @@ static bool wdc_nvme_check_supported_log_page(nvme_root_t r, int fd, __u8 log_id
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);
@@ -2122,7 +2168,7 @@ static bool wdc_nvme_get_dev_status_log_data(nvme_root_t r, int fd, __le32 *ret_
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;
@@ -2130,7 +2176,7 @@ static int wdc_do_clear_dump(int fd, __u8 opcode, __u32 cdw12)
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(dev), &admin_cmd, NULL);
if (ret != 0) {
fprintf(stdout, "ERROR : WDC : Crash dump erase failed\n");
}
@@ -2248,7 +2294,7 @@ static __u32 wdc_dump_dui_data_v2(int fd, __u32 dataLen, __u64 offset, __u8 *dum
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;
@@ -2277,7 +2323,8 @@ static int wdc_do_dump(int fd, __u32 opcode,__u32 data_len,
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(dev), &admin_cmd,
+ NULL);
if (ret != 0) {
nvme_show_status(ret);
fprintf(stderr, "%s: ERROR : WDC : Get chunk %d, size = 0x%x, offset = 0x%x, addr = 0x%lx\n",
@@ -2370,7 +2417,8 @@ static int wdc_do_dump_e6(int fd, __u32 opcode,__u32 data_len,
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;
@@ -2386,7 +2434,7 @@ static int wdc_do_cap_telemetry_log(int fd, char *file, __u32 bs, int type, int
nvme_root_t r;
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- err = nvme_identify_ctrl(fd, &ctrl);
+ err = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (err) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", err);
@@ -2399,7 +2447,7 @@ static int wdc_do_cap_telemetry_log(int fd, char *file, __u32 bs, int type, int
}
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;
@@ -2407,8 +2455,9 @@ static int wdc_do_cap_telemetry_log(int fd, char *file, __u32 bs, int type, int
} 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(dev),
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, 4, buf, &result);
if (err == 0) {
if (result == 0) {
/* enabled */
@@ -2448,11 +2497,14 @@ static int wdc_do_cap_telemetry_log(int fd, char *file, __u32 bs, int type, int
}
if (ctrl_init)
- err = nvme_get_ctrl_telemetry(fd, true, &log, data_area, &full_size);
+ err = nvme_get_ctrl_telemetry(dev_fd(dev), true, &log,
+ data_area, &full_size);
else if (host_gen)
- err = nvme_get_new_host_telemetry(fd, &log, data_area, &full_size);
+ err = nvme_get_new_host_telemetry(dev_fd(dev), &log,
+ data_area, &full_size);
else
- err = nvme_get_host_telemetry(fd, &log, data_area, &full_size);
+ err = nvme_get_host_telemetry(dev_fd(dev), &log, data_area,
+ &full_size);
if (err < 0) {
perror("get-telemetry-log");
@@ -2499,7 +2551,7 @@ close_output:
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;
@@ -2516,7 +2568,8 @@ static int wdc_do_cap_diag(nvme_root_t r, int fd, char *file,
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(dev),
+ WDC_NVME_CAP_DIAG_OPCODE,
WDC_NVME_CAP_DIAG_HEADER_TOC_SIZE>>2,
0x00,
log_hdr);
@@ -2531,7 +2584,9 @@ static int wdc_do_cap_diag(nvme_root_t r, int fd, char *file,
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(dev),
+ WDC_NVME_CAP_DIAG_OPCODE,
+ cap_diag_length,
(WDC_NVME_CAP_DIAG_SUBCMD << WDC_NVME_SUBCMD_SHIFT) | WDC_NVME_CAP_DIAG_CMD,
file, xfer_size, (__u8 *)log_hdr);
@@ -2540,7 +2595,7 @@ static int wdc_do_cap_diag(nvme_root_t r, int fd, char *file,
} 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);
@@ -2932,10 +2987,11 @@ static int wdc_cap_diag(int argc, char **argv, struct command *command,
char *desc = "Capture Diagnostics Log.";
char *file = "Output file pathname.";
char *size = "Data retrieval transfer size.";
+ __u64 capabilities = 0;
char f[PATH_MAX] = {0};
+ struct nvme_dev *dev;
__u32 xfer_size = 0;
- int fd, ret = 0;
- __u64 capabilities = 0;
+ int ret = 0;
struct config {
char *file;
@@ -2953,9 +3009,9 @@ static int wdc_cap_diag(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
@@ -2963,7 +3019,7 @@ static int wdc_cap_diag(int argc, char **argv, struct command *command,
strncpy(f, cfg.file, PATH_MAX - 1);
if (cfg.xfer_size != 0)
xfer_size = cfg.xfer_size;
- ret = wdc_get_serial_name(fd, f, PATH_MAX, "cap_diag");
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, "cap_diag");
if (ret) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
goto out;
@@ -2977,15 +3033,15 @@ static int wdc_cap_diag(int argc, char **argv, struct command *command,
strcat(f, ".bin");
}
- capabilities = wdc_get_drive_capabilities(r, 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, 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");
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -3232,13 +3288,14 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
char *verbose = "Display more debug messages.";
char f[PATH_MAX] = {0};
char fileSuffix[PATH_MAX] = {0};
+ struct nvme_dev *dev;
nvme_root_t r;
__u32 xfer_size = 0;
- int fd, ret = -1;
int telemetry_type = 0, telemetry_data_area = 0;
UtilsTimeInfo timeInfo;
__u8 timeStamp[MAX_PATH_LEN];
__u64 capabilities = 0;
+ int ret = -1;
struct config {
char *file;
@@ -3271,12 +3328,12 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd))
+ if (!wdc_check_device(r, dev))
goto out;
if (cfg.xfer_size != 0)
@@ -3305,7 +3362,7 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
timeInfo.hour, timeInfo.minute, timeInfo.second);
snprintf(fileSuffix, PATH_MAX, "_internal_fw_log_%s", (char*)timeStamp);
- ret = wdc_get_serial_name(fd, f, PATH_MAX, fileSuffix);
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, fileSuffix);
if (ret) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
goto out;
@@ -3349,12 +3406,12 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
goto out;
}
- capabilities = wdc_get_drive_capabilities(r, 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, fd, f, xfer_size,
+ ret = wdc_do_cap_diag(r, dev, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
}
@@ -3364,7 +3421,7 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(fd, f, xfer_size,
+ ret = wdc_do_cap_telemetry_log(dev, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
} else {
@@ -3374,7 +3431,8 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
/* FW requirement - xfer size must be 256k for data area 4 */
if (cfg.data_area >= 4)
xfer_size = 0x40000;
- ret = wdc_do_cap_dui(fd, f, xfer_size, cfg.data_area,
+ ret = wdc_do_cap_dui(dev_fd(dev), f, xfer_size,
+ cfg.data_area,
cfg.verbose, cfg.file_size,
cfg.offset);
goto out;
@@ -3386,29 +3444,29 @@ static int wdc_vs_internal_fw_log(int argc, char **argv, struct command *command
if (telemetry_data_area == 0)
telemetry_data_area = 3; /* Set the default DA to 3 if not specified */
/* Get the desired telemetry log page */
- ret = wdc_do_cap_telemetry_log(fd, f, xfer_size,
+ ret = wdc_do_cap_telemetry_log(dev, f, xfer_size,
telemetry_type, telemetry_data_area);
goto out;
} else {
- ret = wdc_do_cap_dui(fd, f, xfer_size,
+ ret = wdc_do_cap_dui(dev_fd(dev), f, xfer_size,
WDC_NVME_DUI_MAX_DATA_AREA,
cfg.verbose, 0, 0);
goto out;
}
}
if ((capabilities & WDC_SN730B_CAP_VUC_LOG) == WDC_SN730B_CAP_VUC_LOG)
- ret = wdc_do_sn730_get_and_tar(fd, f);
+ ret = wdc_do_sn730_get_and_tar(dev_fd(dev), f);
else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
}
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
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;
@@ -3445,11 +3503,11 @@ static int wdc_do_crash_dump(int fd, char *file, int type)
WDC_NVME_CLEAR_CRASH_DUMP_CMD);
}
- ret = wdc_dump_length(fd,
- opcode,
- cdw10_size,
- cdw12_size,
- &crash_dump_length);
+ ret = wdc_dump_length(dev_fd(dev),
+ opcode,
+ cdw10_size,
+ cdw12_size,
+ &crash_dump_length);
if (ret == -1) {
if (type == WDC_NVME_PFAIL_DUMP_TYPE)
@@ -3466,7 +3524,7 @@ static int wdc_do_crash_dump(int fd, char *file, int type)
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,
@@ -3474,12 +3532,13 @@ static int wdc_do_crash_dump(int fd, char *file, int type)
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;
@@ -3494,26 +3553,26 @@ static int wdc_crash_dump(int fd, char *file, int 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,
- WDC_NVME_DRIVE_LOG_SIZE_NDT,
- (WDC_NVME_DRIVE_LOG_SIZE_SUBCMD <<
- WDC_NVME_SUBCMD_SHIFT | WDC_NVME_DRIVE_LOG_SIZE_CMD),
- &drive_log_length);
+ ret = wdc_dump_length(dev_fd(dev), WDC_NVME_DRIVE_LOG_SIZE_OPCODE,
+ WDC_NVME_DRIVE_LOG_SIZE_NDT,
+ (WDC_NVME_DRIVE_LOG_SIZE_SUBCMD <<
+ WDC_NVME_SUBCMD_SHIFT | WDC_NVME_DRIVE_LOG_SIZE_CMD),
+ &drive_log_length);
if (ret == -1) {
return -1;
}
@@ -3533,7 +3592,7 @@ static int wdc_do_drive_log(int fd, char *file)
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(dev), &admin_cmd, NULL);
nvme_show_status(ret);
if (ret == 0) {
ret = wdc_create_log_file(file, drive_log_data, drive_log_length);
@@ -3548,7 +3607,7 @@ static int wdc_drive_log(int argc, char **argv, struct command *command,
const char *desc = "Capture Drive Log.";
const char *file = "Output file pathname.";
char f[PATH_MAX] = {0};
- int fd;
+ struct nvme_dev *dev;
int ret;
nvme_root_t r;
__u64 capabilities = 0;
@@ -3565,18 +3624,18 @@ static int wdc_drive_log(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_DRIVE_LOG) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
@@ -3585,14 +3644,14 @@ static int wdc_drive_log(int argc, char **argv, struct command *command,
if (cfg.file != NULL) {
strncpy(f, cfg.file, PATH_MAX - 1);
}
- ret = wdc_get_serial_name(fd, f, PATH_MAX, "drive_log");
+ ret = wdc_get_serial_name(dev, f, PATH_MAX, "drive_log");
if (ret)
fprintf(stderr, "ERROR : WDC : failed to generate file name\n");
else
- ret = wdc_do_drive_log(fd, f);
+ ret = wdc_do_drive_log(dev, f);
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -3601,9 +3660,10 @@ static int wdc_get_crash_dump(int argc, char **argv, struct command *command,
{
const char *desc = "Get Crash Dump.";
const char *file = "Output file pathname.";
- int fd, ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
char *file;
@@ -3618,32 +3678,32 @@ static int wdc_get_crash_dump(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_CRASH_DUMP) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_crash_dump(fd, cfg.file, WDC_NVME_CRASH_DUMP_TYPE);
+ ret = wdc_crash_dump(dev, cfg.file, WDC_NVME_CRASH_DUMP_TYPE);
if (ret != 0) {
fprintf(stderr, "ERROR : WDC : failed to read crash dump\n");
}
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -3652,13 +3712,13 @@ static int wdc_get_pfail_dump(int argc, char **argv, struct command *command,
{
char *desc = "Get Pfail Crash Dump.";
char *file = "Output file pathname.";
- int fd;
- int ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
struct config {
char *file;
};
+ nvme_root_t r;
+ int ret;
struct config cfg = {
.file = NULL,
@@ -3669,30 +3729,30 @@ static int wdc_get_pfail_dump(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_PFAIL_DUMP) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
} else {
- ret = wdc_crash_dump(fd, cfg.file, WDC_NVME_PFAIL_DUMP_TYPE);
+ ret = wdc_crash_dump(dev, cfg.file, WDC_NVME_PFAIL_DUMP_TYPE);
if (ret != 0) {
fprintf(stderr, "ERROR : WDC : failed to read pfail crash dump\n");
}
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -3748,29 +3808,30 @@ static int wdc_purge(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
const char *desc = "Send a Purge command.";
- char *err_str;
- int fd, ret;
- nvme_root_t r;
struct nvme_passthru_cmd admin_cmd;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ char *err_str;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if((capabilities & WDC_DRIVE_CAP_PURGE) == 0) {
ret = -1;
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
@@ -3779,7 +3840,8 @@ static int wdc_purge(int argc, char **argv,
memset(&admin_cmd, 0, sizeof (admin_cmd));
admin_cmd.opcode = WDC_NVME_PURGE_CMD_OPCODE;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
if (ret > 0) {
switch (ret) {
case WDC_NVME_PURGE_CMD_SEQ_ERR:
@@ -3798,7 +3860,7 @@ static int wdc_purge(int argc, char **argv,
nvme_show_status(ret);
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -3806,30 +3868,31 @@ static int wdc_purge_monitor(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
const char *desc = "Send a Purge Monitor command.";
- int fd, ret;
- nvme_root_t r;
__u8 output[WDC_NVME_PURGE_MONITOR_DATA_LEN];
double progress_percent;
struct nvme_passthru_cmd admin_cmd;
struct wdc_nvme_purge_monitor_data *mon;
+ struct nvme_dev *dev;
__u64 capabilities;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev)) {
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return -1;
}
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if((capabilities & WDC_DRIVE_CAP_PURGE) == 0) {
ret = -1;
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
@@ -3842,7 +3905,8 @@ static int wdc_purge_monitor(int argc, char **argv,
admin_cmd.cdw10 = WDC_NVME_PURGE_MONITOR_CMD_CDW10;
admin_cmd.timeout_ms = WDC_NVME_PURGE_MONITOR_TIMEOUT;
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
if (ret == 0) {
mon = (struct wdc_nvme_purge_monitor_data *) output;
printf("Purge state = 0x%0x\n", admin_cmd.result);
@@ -3858,7 +3922,7 @@ static int wdc_purge_monitor(int argc, char **argv,
nvme_show_status(ret);
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -4009,15 +4073,16 @@ static int wdc_convert_ts(time_t time, char *ts_buf)
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", devicename);
+ 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(dev), &ctrl);
if (!err)
printf(" Serial Number: %-.*s\n", (int)sizeof(ctrl.sn), ctrl.sn);
else {
@@ -4164,14 +4229,16 @@ static void wdc_print_error_rec_log_normal(struct wdc_ocp_c1_error_recovery_log
printf(" Panic Reset Wait Time : 0x%x \n", le16_to_cpu(log_data->panic_reset_wait_time));
printf(" Panic Reset Action : 0x%x \n", log_data->panic_reset_action);
printf(" Device Recovery Action 1 : 0x%x \n", log_data->dev_recovery_action1);
- printf(" Panic ID : 0x%lx \n", le64_to_cpu(log_data->panic_id));
+ printf(" Panic ID : 0x%" PRIu64 "\n", le64_to_cpu(log_data->panic_id));
printf(" Device Capabilities : 0x%x \n", le32_to_cpu(log_data->dev_capabilities));
printf(" Vendor Specific Recovery Opcode : 0x%x \n", log_data->vs_recovery_opc);
printf(" Vendor Specific Command CDW12 : 0x%x \n", le32_to_cpu(log_data->vs_cmd_cdw12));
printf(" Vendor Specific Command CDW13 : 0x%x \n", le32_to_cpu(log_data->vs_cmd_cdw13));
- printf(" Vendor Specific Command Timeout : 0x%x \n", log_data->vs_cmd_to);
- printf(" Device Recovery Action 2 : 0x%x \n", log_data->dev_recovery_action2);
- printf(" Device Recovery Action 2 Timeout : 0x%x \n", log_data->dev_recovery_action2_to);
+ if (le16_to_cpu(log_data->log_page_version) == WDC_ERROR_REC_LOG_VERSION2) {
+ printf(" Vendor Specific Command Timeout : 0x%x \n", log_data->vs_cmd_to);
+ printf(" Device Recovery Action 2 : 0x%x \n", log_data->dev_recovery_action2);
+ printf(" Device Recovery Action 2 Timeout : 0x%x \n", log_data->dev_recovery_action2_to);
+ }
printf(" Log Page Version : 0x%x \n", le16_to_cpu(log_data->log_page_version));
printf(" Log page GUID : 0x");
for (j = 0; j < WDC_OCP_C1_GUID_LENGTH; j++) {
@@ -4193,9 +4260,11 @@ static void wdc_print_error_rec_log_json(struct wdc_ocp_c1_error_recovery_log *l
json_object_add_value_int(root, "Vendor Specific Recovery Opcode", log_data->vs_recovery_opc);
json_object_add_value_int(root, "Vendor Specific Command CDW12", le32_to_cpu(log_data->vs_cmd_cdw12));
json_object_add_value_int(root, "Vendor Specific Command CDW13", le32_to_cpu(log_data->vs_cmd_cdw13));
- json_object_add_value_int(root, "Vendor Specific Command Timeout", log_data->vs_cmd_to);
- json_object_add_value_int(root, "Device Recovery Action 2", log_data->dev_recovery_action2);
- json_object_add_value_int(root, "Device Recovery Action 2 Timeout", log_data->dev_recovery_action2_to);
+ if (le16_to_cpu(log_data->log_page_version) == WDC_ERROR_REC_LOG_VERSION2) {
+ json_object_add_value_int(root, "Vendor Specific Command Timeout", log_data->vs_cmd_to);
+ json_object_add_value_int(root, "Device Recovery Action 2", log_data->dev_recovery_action2);
+ json_object_add_value_int(root, "Device Recovery Action 2 Timeout", log_data->dev_recovery_action2_to);
+ }
json_object_add_value_int(root, "Log Page Version", le16_to_cpu(log_data->log_page_version));
char guid[40];
@@ -4442,7 +4511,7 @@ static void wdc_print_fb_ca_log_json(struct wdc_ssd_ca_perf_stats *perf)
json_free_object(root);
}
-static void wdc_print_bd_ca_log_normal(void *data)
+static void wdc_print_bd_ca_log_normal(struct nvme_dev *dev, void *data)
{
struct wdc_bd_ca_log_format *bd_data = (struct wdc_bd_ca_log_format *)data;
__u64 *raw;
@@ -4453,7 +4522,7 @@ static void wdc_print_bd_ca_log_normal(void *data)
if (bd_data->field_id == 0x00) {
raw = (__u64*)&bd_data->raw_value[0];
printf("Additional Smart Log for NVME device:%s namespace-id:%x\n",
- devicename, WDC_DE_GLOBAL_NSID);
+ dev->name, WDC_DE_GLOBAL_NSID);
printf("key normalized raw\n");
printf("program_fail_count : %3"PRIu8"%% %"PRIu64"\n",
bd_data->normalized_value, le64_to_cpu(*raw & 0x00FFFFFFFFFFFFFF));
@@ -5056,7 +5125,7 @@ static void wdc_print_fw_act_history_log_json(__u8 *data, int num_entries, __u32
root = json_create_object();
- if(data[0] == WDC_NVME_GET_FW_ACT_HISTORY_C2_LOG_ID) {
+ if (data[0] == WDC_NVME_GET_FW_ACT_HISTORY_C2_LOG_ID) {
struct wdc_fw_act_history_log_format_c2 *fw_act_history_entry = (struct wdc_fw_act_history_log_format_c2 *)(data);
oldestEntryIdx = WDC_MAX_NUM_ACT_HIST_ENTRIES;
@@ -5100,7 +5169,7 @@ static void wdc_print_fw_act_history_log_json(__u8 *data, int num_entries, __u32
json_object_add_value_string(root, "Power on Hour", time_str);
} else {
uint64_t timestamp = (0x0000FFFFFFFFFFFF & le64_to_cpu(fw_act_history_entry->entry[entryIdx].timestamp));
- json_object_add_value_int(root, "Timestamp", timestamp);
+ json_object_add_value_uint64(root, "Timestamp", timestamp);
}
json_object_add_value_int(root, "Power Cycle Count",
@@ -5122,6 +5191,9 @@ static void wdc_print_fw_act_history_log_json(__u8 *data, int num_entries, __u32
json_object_add_value_string(root, "Result", fail_str);
}
+ json_print_object(root, NULL);
+ printf("\n");
+
entryIdx++;
if (entryIdx >= WDC_MAX_NUM_ACT_HIST_ENTRIES)
entryIdx = 0;
@@ -5179,15 +5251,15 @@ static void wdc_print_fw_act_history_log_json(__u8 *data, int num_entries, __u32
json_object_add_value_string(root, "Result", fail_str);
}
+ json_print_object(root, NULL);
+ printf("\n");
+
entryIdx++;
if (entryIdx >= WDC_MAX_NUM_ACT_HIST_ENTRIES)
entryIdx = 0;
}
}
- json_print_object(root, NULL);
- printf("\n");
-
json_free_object(root);
}
@@ -5205,7 +5277,7 @@ static int nvme_get_ext_smart_cloud_log(int fd, __u8 **data, int uuid_index, __u
struct nvme_get_log_args args = {
.args_size = sizeof(args),
.fd = fd,
- .lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ .lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_ID,
.nsid = namespace_id,
.lpo = 0,
.lsp = NVME_LOG_LSP_NONE,
@@ -5626,10 +5698,12 @@ static void wdc_print_ext_smart_cloud_log_normal(void *data, int mask)
else
printf(" SMART Cloud Attributes :- \n");
- printf(" Physical Media Units Written TLC (Bytes) : %'.0Lf\n",
- int128_to_double(ext_smart_log_ptr->ext_smart_pmuwt));
- printf(" Physical Media Units Written SLC (Bytes) : %'.0Lf\n",
- int128_to_double(ext_smart_log_ptr->ext_smart_pmuws));
+ printf(" Physical Media Units Written TLC (Bytes) : %s\n",
+ uint128_t_to_string(le128_to_cpu(
+ ext_smart_log_ptr->ext_smart_pmuwt)));
+ printf(" Physical Media Units Written SLC (Bytes) : %s\n",
+ uint128_t_to_string(le128_to_cpu(
+ ext_smart_log_ptr->ext_smart_pmuws)));
printf(" Bad User NAND Block Count (Normalized) (Int) : %d\n",
le16_to_cpu(*(uint16_t *)ext_smart_log_ptr->ext_smart_bunbc));
printf(" Bad User NAND Block Count (Raw) (Int) : %"PRIu64"\n",
@@ -5677,8 +5751,9 @@ static void wdc_print_ext_smart_cloud_log_normal(void *data, int mask)
le64_to_cpu(ext_smart_log_ptr->ext_smart_svn));
printf(" %% Free Blocks (System) (Int) : %d %%\n",
ext_smart_log_ptr->ext_smart_pfbs);
- printf(" NVMe Stats (# Data Set Management/TRIM Commands Completed) (Int) : %'.0Lf\n",
- int128_to_double(ext_smart_log_ptr->ext_smart_dcc));
+ printf(" NVMe Stats (# Data Set Management/TRIM Commands Completed) (Int) : %s\n",
+ uint128_t_to_string(le128_to_cpu(
+ ext_smart_log_ptr->ext_smart_dcc)));
printf(" Total Namespace Utilization (nvme0n1 NUSE) (Bytes) : %"PRIu64"\n",
le64_to_cpu(ext_smart_log_ptr->ext_smart_tnu));
printf(" NVMe Stats (# NVMe Format Commands Completed) (Int) : %d\n",
@@ -5696,16 +5771,18 @@ static void wdc_print_ext_smart_cloud_log_normal(void *data, int mask)
le16_to_cpu(*(uint16_t *)ext_smart_log_ptr->ext_smart_bsnbc));
printf(" Bad System NAND Block Count (Raw) (Int) : %"PRIu64"\n",
le64_to_cpu(*(uint64_t *)ext_smart_log_ptr->ext_smart_bsnbc & 0xFFFFFFFFFFFF0000));
- printf(" Endurance Estimate (Total Writable Lifetime Bytes) (Bytes) : %'.0Lf\n",
- int128_to_double(ext_smart_log_ptr->ext_smart_eest));
+ printf(" Endurance Estimate (Total Writable Lifetime Bytes) (Bytes) : %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_eest)));
if (mask == WDC_SCA_V1_ALL) {
printf(" Thermal Throttling Status & Count (Number of thermal throttling events) (Int) : %d\n",
le16_to_cpu(ext_smart_log_ptr->ext_smart_ttc));
printf(" Total # Unaligned I/O (Int) : %"PRIu64"\n",
le64_to_cpu(ext_smart_log_ptr->ext_smart_uio));
}
- printf(" Total Physical Media Units Read (Bytes) (Int) : %'.0Lf\n",
- int128_to_double(ext_smart_log_ptr->ext_smart_pmur));
+ printf(" Total Physical Media Units Read (Bytes) (Int) : %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_pmur)));
if (mask == WDC_SCA_V1_ALL) {
printf(" Command Timeout (# of READ Commands > 5 Seconds) (Int) : %"PRIu32"\n",
le32_to_cpu(ext_smart_log_ptr->ext_smart_rtoc));
@@ -5746,10 +5823,10 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
struct json_object *root;
root = json_create_object();
- json_object_add_value_double(root, "physical_media_units_bytes_tlc",
- int128_to_double(ext_smart_log_ptr->ext_smart_pmuwt));
- json_object_add_value_double(root, "physical_media_units_bytes_slc",
- int128_to_double(ext_smart_log_ptr->ext_smart_pmuws));
+ json_object_add_value_uint128(root, "physical_media_units_bytes_tlc",
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_pmuwt));
+ json_object_add_value_uint128(root, "physical_media_units_bytes_slc",
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_pmuws));
json_object_add_value_uint(root, "bad_user_blocks_normalized",
le16_to_cpu(*(uint16_t *)ext_smart_log_ptr->ext_smart_bunbc));
json_object_add_value_uint64(root, "bad_user_blocks_raw",
@@ -5797,8 +5874,8 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
le64_to_cpu(ext_smart_log_ptr->ext_smart_svn));
json_object_add_value_uint(root, "pct_free_blocks_system",
(__u8)ext_smart_log_ptr->ext_smart_pfbs);
- json_object_add_value_double(root, "num_of_trim_commands",
- int128_to_double(ext_smart_log_ptr->ext_smart_dcc));
+ json_object_add_value_uint128(root, "num_of_trim_commands",
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_dcc));
json_object_add_value_uint64(root, "total_nuse_bytes",
le64_to_cpu(ext_smart_log_ptr->ext_smart_tnu));
json_object_add_value_uint(root, "num_of_format_commands",
@@ -5816,16 +5893,16 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
le16_to_cpu(*(uint16_t *)ext_smart_log_ptr->ext_smart_bsnbc));
json_object_add_value_uint64(root, "bad_system_block_raw",
le64_to_cpu(*(uint64_t *)ext_smart_log_ptr->ext_smart_bsnbc & 0xFFFFFFFFFFFF0000));
- json_object_add_value_double(root, "endurance_est_bytes",
- int128_to_double(ext_smart_log_ptr->ext_smart_eest));
+ json_object_add_value_uint128(root, "endurance_est_bytes",
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_eest));
if (mask == WDC_SCA_V1_ALL) {
json_object_add_value_uint(root, "num_throttling_events",
le16_to_cpu(ext_smart_log_ptr->ext_smart_ttc));
json_object_add_value_uint64(root, "total_unaligned_io",
le64_to_cpu(ext_smart_log_ptr->ext_smart_uio));
}
- json_object_add_value_double(root, "physical_media_units_read_bytes",
- int128_to_double(ext_smart_log_ptr->ext_smart_pmur));
+ json_object_add_value_uint128(root, "physical_media_units_read_bytes",
+ le128_to_cpu(ext_smart_log_ptr->ext_smart_pmur));
if (mask == WDC_SCA_V1_ALL) {
json_object_add_value_uint(root, "num_read_timeouts",
le32_to_cpu(ext_smart_log_ptr->ext_smart_rtoc));
@@ -5874,8 +5951,10 @@ static void wdc_print_smart_cloud_attr_C0_normal(void *data)
printf(" SMART Cloud Attributes :- \n");
- printf(" Physical media units written : %'.0Lf\n", int128_to_double(&log_data[SCAO_PMUW]));
- printf(" Physical media units read : %'.0Lf\n", int128_to_double(&log_data[SCAO_PMUR]));
+ printf(" Physical media units written : %s\n",
+ uint128_t_to_string(le128_to_cpu(&log_data[SCAO_PMUW])));
+ printf(" Physical media units read : %s\n",
+ uint128_t_to_string(le128_to_cpu(&log_data[SCAO_PMUR])));
printf(" Bad user nand blocks Raw : %"PRIu64"\n",
(uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_BUNBR] & 0x0000FFFFFFFFFFFF));
printf(" Bad user nand blocks Normalized : %d\n",
@@ -5916,8 +5995,10 @@ static void wdc_print_smart_cloud_attr_C0_normal(void *data)
(uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_SVN]));
printf(" NUSE Namespace utilization : %"PRIu64"\n",
(uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_NUSE]));
- printf(" PLP start count : %'.0Lf\n", int128_to_double(&log_data[SCAO_PSC]));
- printf(" Endurance estimate : %'.0Lf\n", int128_to_double(&log_data[SCAO_EEST]));
+ printf(" PLP start count : %s\n",
+ uint128_t_to_string(le128_to_cpu(&log_data[SCAO_PSC])));
+ printf(" Endurance estimate : %s\n",
+ uint128_t_to_string(le128_to_cpu(&log_data[SCAO_EEST])));
smart_log_ver = (uint16_t)le16_to_cpu(*(uint16_t *)&log_data[SCAO_LPV]);
printf(" Log page version : %"PRIu16"\n",smart_log_ver);
printf(" Log page GUID : 0x");
@@ -5951,10 +6032,10 @@ static void wdc_print_smart_cloud_attr_C0_json(void *data)
uint16_t smart_log_ver = 0;
root = json_create_object();
- json_object_add_value_double(root, "Physical media units written",
- int128_to_double(&log_data[SCAO_PMUW]));
- json_object_add_value_double(root, "Physical media units read",
- int128_to_double(&log_data[SCAO_PMUR]));
+ json_object_add_value_uint128(root, "Physical media units written",
+ le128_to_cpu(&log_data[SCAO_PMUW]));
+ json_object_add_value_uint128(root, "Physical media units read",
+ le128_to_cpu(&log_data[SCAO_PMUR]));
json_object_add_value_uint64(root, "Bad user nand blocks - Raw",
(uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_BUNBR] & 0x0000FFFFFFFFFFFF));
json_object_add_value_uint(root, "Bad user nand blocks - Normalized",
@@ -5999,10 +6080,10 @@ static void wdc_print_smart_cloud_attr_C0_json(void *data)
(uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_SVN]));
json_object_add_value_uint64(root, "NUSE - Namespace utilization",
(uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_NUSE]));
- json_object_add_value_double(root, "PLP start count",
- int128_to_double(&log_data[SCAO_PSC]));
- json_object_add_value_double(root, "Endurance estimate",
- int128_to_double(&log_data[SCAO_EEST]));
+ json_object_add_value_uint128(root, "PLP start count",
+ le128_to_cpu(&log_data[SCAO_PSC]));
+ json_object_add_value_uint128(root, "Endurance estimate",
+ le128_to_cpu(&log_data[SCAO_EEST]));
smart_log_ver = (uint16_t)le16_to_cpu(*(uint16_t *)&log_data[SCAO_LPV]);
json_object_add_value_uint(root, "Log page version", smart_log_ver);
char guid[40];
@@ -6135,7 +6216,7 @@ static int wdc_print_c0_eol_log(void *data, int fmt)
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;
@@ -6145,7 +6226,7 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
__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) {
@@ -6153,7 +6234,7 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
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) {
@@ -6173,7 +6254,8 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
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);
+ case WDC_NVME_SN550_DEV_ID:
+ 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;
@@ -6189,7 +6271,8 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
}
if (namespace_id == NVME_NSID_ALL) {
- ret = nvme_get_nsid(fd, &namespace_id);
+ ret = nvme_get_nsid(dev_fd(dev),
+ &namespace_id);
if (ret < 0) {
namespace_id = NVME_NSID_ALL;
}
@@ -6198,8 +6281,8 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
- .lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ .fd = dev_fd(dev),
+ .lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_ID,
.nsid = namespace_id,
.lpo = 0,
.lsp = NVME_LOG_LSP_NONE,
@@ -6261,7 +6344,7 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
+ .fd = dev_fd(dev),
.lid = WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
.nsid = NVME_NSID_ALL,
.lpo = 0,
@@ -6302,8 +6385,10 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
}
/* Get the 0xC0 log data */
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
- WDC_NVME_EOL_STATUS_LOG_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_EOL_STATUS_LOG_OPCODE,
+ WDC_NVME_EOL_STATUS_LOG_LEN,
+ data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -6328,8 +6413,9 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
}
/* Get the 0xC0 log data */
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
- WDC_NVME_SMART_CLOUD_ATTR_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_ID,
+ WDC_NVME_SMART_CLOUD_ATTR_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -6348,7 +6434,8 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
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(dev), &data,
+ uuid_index, namespace_id);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -6375,7 +6462,9 @@ static int wdc_get_c0_log_page(nvme_root_t r, int fd, char *format,
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");
@@ -6383,7 +6472,7 @@ static int wdc_print_latency_monitor_log(int fd, struct wdc_ssd_latency_monitor_
}
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);
@@ -6460,7 +6549,7 @@ static int wdc_print_fb_ca_log(struct wdc_ssd_ca_perf_stats *perf, int fmt)
return 0;
}
-static int wdc_print_bd_ca_log(void *bd_data, int fmt)
+static int wdc_print_bd_ca_log(struct nvme_dev *dev, void *bd_data, int fmt)
{
if (!bd_data) {
fprintf(stderr, "ERROR : WDC : Invalid buffer to read data\n");
@@ -6468,7 +6557,7 @@ static int wdc_print_bd_ca_log(void *bd_data, int fmt)
}
switch (fmt) {
case NORMAL:
- wdc_print_bd_ca_log_normal(bd_data);
+ wdc_print_bd_ca_log_normal(dev, bd_data);
break;
case JSON:
wdc_print_bd_ca_log_json(bd_data);
@@ -6515,7 +6604,7 @@ static int wdc_print_fw_act_history_log(__u8 *data, int num_entries, int fmt, __
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;
@@ -6524,7 +6613,7 @@ static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
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) {
@@ -6533,19 +6622,19 @@ static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
}
/* 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) {
@@ -6560,8 +6649,9 @@ static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
memset(data, 0, sizeof (__u8) * WDC_FB_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_FB_CA_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ WDC_FB_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -6596,8 +6686,9 @@ static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
memset(data, 0, sizeof (__u8) * WDC_FB_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_FB_CA_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ WDC_FB_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -6617,14 +6708,15 @@ static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
}
memset(data, 0, sizeof (__u8) * WDC_BD_CA_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_BD_CA_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
+ WDC_BD_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
if (ret == 0) {
/* parse the data */
- ret = wdc_print_bd_ca_log(data, fmt);
+ ret = wdc_print_bd_ca_log(dev, data, fmt);
} else {
fprintf(stderr, "ERROR : WDC : Unable to read CA Log Page data\n");
ret = -1;
@@ -6649,7 +6741,7 @@ static int wdc_get_ca_log_page(nvme_root_t r, int fd, char *format)
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;
@@ -6663,7 +6755,7 @@ static int wdc_get_c1_log_page(nvme_root_t r, int fd,
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) {
@@ -6682,8 +6774,8 @@ static int wdc_get_c1_log_page(nvme_root_t r, int fd,
}
memset(data, 0, sizeof (__u8) * WDC_ADD_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_ADD_LOG_OPCODE,
- WDC_ADD_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_NVME_ADD_LOG_OPCODE,
+ WDC_ADD_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
if (ret == 0) {
@@ -6708,7 +6800,7 @@ static int wdc_get_c1_log_page(nvme_root_t r, int fd,
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;
@@ -6716,7 +6808,7 @@ static int wdc_get_c3_log_page(nvme_root_t r, int fd, char *format)
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) {
@@ -6730,7 +6822,7 @@ static int wdc_get_c3_log_page(nvme_root_t r, int fd, char *format)
}
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(dev), WDC_LATENCY_MON_LOG_ID,
WDC_LATENCY_MON_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
@@ -6768,7 +6860,7 @@ static int wdc_get_c3_log_page(nvme_root_t r, int fd, char *format)
}
/* 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");
}
@@ -6779,7 +6871,7 @@ out:
}
-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;
@@ -6787,7 +6879,7 @@ static int wdc_get_ocp_c1_log_page(nvme_root_t r, int fd, char *format)
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) {
@@ -6801,8 +6893,8 @@ static int wdc_get_ocp_c1_log_page(nvme_root_t r, int fd, char *format)
}
memset(data, 0, sizeof (__u8) * WDC_ERROR_REC_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_ERROR_REC_LOG_ID,
- WDC_ERROR_REC_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_ERROR_REC_LOG_ID,
+ WDC_ERROR_REC_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret, false), ret);
@@ -6811,7 +6903,8 @@ static int wdc_get_ocp_c1_log_page(nvme_root_t r, int fd, char *format)
log_data = (struct wdc_ocp_c1_error_recovery_log *)data;
/* check log page version */
- if (log_data->log_page_version != WDC_ERROR_REC_LOG_VERSION) {
+ if ((log_data->log_page_version != WDC_ERROR_REC_LOG_VERSION1) &&
+ (log_data->log_page_version != WDC_ERROR_REC_LOG_VERSION2)) {
fprintf(stderr, "ERROR : WDC : invalid error recovery log version - %d\n", log_data->log_page_version);
ret = -1;
goto out;
@@ -6848,7 +6941,7 @@ out:
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;
@@ -6856,7 +6949,7 @@ static int wdc_get_ocp_c4_log_page(nvme_root_t r, int fd, char *format)
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) {
@@ -6870,8 +6963,8 @@ static int wdc_get_ocp_c4_log_page(nvme_root_t r, int fd, char *format)
}
memset(data, 0, sizeof (__u8) * WDC_DEV_CAP_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_DEV_CAP_LOG_ID,
- WDC_DEV_CAP_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_DEV_CAP_LOG_ID,
+ WDC_DEV_CAP_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret, false), ret);
@@ -6893,7 +6986,7 @@ static int wdc_get_ocp_c4_log_page(nvme_root_t r, int fd, char *format)
int j;
fprintf(stderr, "ERROR : WDC : Expected GUID: 0x");
for (j = 0; j<16; j++) {
- fprintf(stderr, "%x", wdc_ocp_c1_guid[j]);
+ fprintf(stderr, "%x", wdc_ocp_c4_guid[j]);
}
fprintf(stderr, "\nERROR : WDC : Actual GUID: 0x");
for (j = 0; j<16; j++) {
@@ -6917,7 +7010,7 @@ out:
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;
@@ -6925,7 +7018,7 @@ static int wdc_get_ocp_c5_log_page(nvme_root_t r, int fd, char *format)
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) {
@@ -6939,8 +7032,8 @@ static int wdc_get_ocp_c5_log_page(nvme_root_t r, int fd, char *format)
}
memset(data, 0, sizeof (__u8) * WDC_UNSUPPORTED_REQS_LOG_BUF_LEN);
- ret = nvme_get_log_simple(fd, WDC_UNSUPPORTED_REQS_LOG_ID,
- WDC_UNSUPPORTED_REQS_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_UNSUPPORTED_REQS_LOG_ID,
+ WDC_UNSUPPORTED_REQS_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret, false), ret);
@@ -6962,7 +7055,7 @@ static int wdc_get_ocp_c5_log_page(nvme_root_t r, int fd, char *format)
int j;
fprintf(stderr, "ERROR : WDC : Expected GUID: 0x");
for (j = 0; j<16; j++) {
- fprintf(stderr, "%x", wdc_ocp_c1_guid[j]);
+ fprintf(stderr, "%x", wdc_ocp_c5_guid[j]);
}
fprintf(stderr, "\nERROR : WDC : Actual GUID: 0x");
for (j = 0; j<16; j++) {
@@ -6986,14 +7079,14 @@ out:
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) {
@@ -7002,7 +7095,7 @@ static int wdc_get_d0_log_page(nvme_root_t r, int fd, char *format)
}
/* 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;
}
@@ -7013,8 +7106,9 @@ static int wdc_get_d0_log_page(nvme_root_t r, int fd, char *format)
}
memset(data, 0, sizeof (__u8) * WDC_NVME_VU_SMART_LOG_LEN);
- ret = nvme_get_log_simple(fd, WDC_NVME_GET_VU_SMART_LOG_OPCODE,
- WDC_NVME_VU_SMART_LOG_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_VU_SMART_LOG_OPCODE,
+ WDC_NVME_VU_SMART_LOG_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -7036,10 +7130,10 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
{
const char *desc = "Retrieve additional performance statistics.";
const char *interval = "Interval to read the statistics from [1, 15].";
- int fd;
const char *log_page_version = "Log Page Version: 0 = vendor, 1 = WDC";
const char *log_page_mask = "Log Page Mask, comma separated list: 0xC0, 0xC1, 0xCA, 0xD0";
const char *namespace_id = "desired namespace id";
+ struct nvme_dev *dev;
nvme_root_t r;
int ret = 0;
int uuid_index = 0;
@@ -7072,9 +7166,9 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
if (cfg.log_page_version == 0) {
@@ -7121,7 +7215,7 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
fprintf(stderr, "ERROR : WDC: Unknown log page mask - %s\n", cfg.log_page_mask);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_SMART_LOG_MASK) == 0) {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
@@ -7132,35 +7226,37 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
if (((capabilities & WDC_DRIVE_CAP_C0_LOG_PAGE) == WDC_DRIVE_CAP_C0_LOG_PAGE) &&
(page_mask & WDC_C0_PAGE_MASK)) {
/* Get 0xC0 log page if possible. */
- ret = wdc_get_c0_log_page(r, fd, cfg.output_format, uuid_index, cfg.namespace_id);
+ ret = wdc_get_c0_log_page(r, dev, cfg.output_format,
+ uuid_index, cfg.namespace_id);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the C0 Log Page, ret = %d\n", ret);
}
if (((capabilities & (WDC_DRIVE_CAP_CA_LOG_PAGE)) == (WDC_DRIVE_CAP_CA_LOG_PAGE)) &&
(page_mask & WDC_CA_PAGE_MASK)) {
/* Get the CA Log Page */
- ret = wdc_get_ca_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_ca_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the CA Log Page, ret = %d\n", ret);
}
if (((capabilities & WDC_DRIVE_CAP_C1_LOG_PAGE) == WDC_DRIVE_CAP_C1_LOG_PAGE) &&
(page_mask & WDC_C1_PAGE_MASK)) {
/* Get the C1 Log Page */
- ret = wdc_get_c1_log_page(r, fd, cfg.output_format, cfg.interval);
+ ret = wdc_get_c1_log_page(r, dev, cfg.output_format,
+ cfg.interval);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the C1 Log Page, ret = %d\n", ret);
}
if (((capabilities & WDC_DRIVE_CAP_D0_LOG_PAGE) == WDC_DRIVE_CAP_D0_LOG_PAGE) &&
(page_mask & WDC_D0_PAGE_MASK)) {
/* Get the D0 Log Page */
- ret = wdc_get_d0_log_page(r, fd, cfg.output_format);
+ ret = wdc_get_d0_log_page(r, dev, cfg.output_format);
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the D0 Log Page, ret = %d\n", ret);
}
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7169,12 +7265,11 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *command,
{
const char *desc = "Retrieve Cloud Log Smart/Health Information";
const char *namespace_id = "desired namespace id";
- int fd;
- nvme_root_t r;
- int ret = 0;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ int ret, fmt = -1;
+ nvme_root_t r;
__u8 *data;
- int fmt = -1;
struct config {
char *output_format;
@@ -7192,13 +7287,13 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7207,7 +7302,8 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *command,
}
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
+ cfg.namespace_id);
if (strcmp(cfg.output_format, "json"))
nvme_show_status(ret);
@@ -7231,7 +7327,7 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *command,
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7240,12 +7336,11 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *command,
{
const char *desc = "Retrieve Hardware Revision Log Information";
const char *namespace_id = "desired namespace id";
- int fd;
- nvme_root_t r;
- int ret = 0;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ int ret, fmt = -1;
__u8 *data = NULL;
- int fmt = -1;
+ nvme_root_t r;
struct config {
char *output_format;
@@ -7263,13 +7358,13 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7277,7 +7372,7 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *command,
goto out;
}
- ret = nvme_get_hw_rev_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_hw_rev_log(dev_fd(dev), &data, 0, cfg.namespace_id);
if (strcmp(cfg.output_format, "json"))
nvme_show_status(ret);
@@ -7314,7 +7409,7 @@ free_buf:
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7324,8 +7419,8 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
const char *desc = "Retrieve Device Write Amplication Factor";
const char *namespace_id = "desired namespace id";
struct nvme_smart_log smart_log;
+ struct nvme_dev *dev;
__u8 *data;
- int fd;
nvme_root_t r;
int ret = 0;
int fmt = -1;
@@ -7354,13 +7449,13 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7369,7 +7464,8 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
}
/* get data units written from the smart log page */
- ret = nvme_get_log_smart(fd, cfg.namespace_id, false, &smart_log);
+ ret = nvme_get_log_smart(dev_fd(dev), cfg.namespace_id, false,
+ &smart_log);
if (!ret) {
data_units_written = int128_to_double(smart_log.data_units_written);
}
@@ -7385,7 +7481,8 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
/* get Physical Media Units Written from extended smart/C0 log page */
data = NULL;
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
+ cfg.namespace_id);
if (ret == 0) {
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
@@ -7438,7 +7535,7 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7446,10 +7543,10 @@ static int wdc_get_latency_monitor_log(int argc, char **argv, struct command *co
struct plugin *plugin)
{
const char *desc = "Retrieve latency monitor log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
@@ -7464,12 +7561,12 @@ static int wdc_get_latency_monitor_log(int argc, char **argv, struct command *co
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7477,13 +7574,13 @@ static int wdc_get_latency_monitor_log(int argc, char **argv, struct command *co
goto out;
}
- ret = wdc_get_c3_log_page(r, 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);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7491,10 +7588,10 @@ static int wdc_get_error_recovery_log(int argc, char **argv, struct command *com
struct plugin *plugin)
{
const char *desc = "Retrieve error recovery log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
@@ -7509,12 +7606,12 @@ static int wdc_get_error_recovery_log(int argc, char **argv, struct command *com
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7522,13 +7619,13 @@ static int wdc_get_error_recovery_log(int argc, char **argv, struct command *com
goto out;
}
- ret = wdc_get_ocp_c1_log_page(r, 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);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7536,10 +7633,10 @@ static int wdc_get_dev_capabilities_log(int argc, char **argv, struct command *c
struct plugin *plugin)
{
const char *desc = "Retrieve device capabilities log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
@@ -7554,12 +7651,12 @@ static int wdc_get_dev_capabilities_log(int argc, char **argv, struct command *c
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7567,13 +7664,13 @@ static int wdc_get_dev_capabilities_log(int argc, char **argv, struct command *c
goto out;
}
- ret = wdc_get_ocp_c4_log_page(r, 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);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7581,10 +7678,10 @@ static int wdc_get_unsupported_reqs_log(int argc, char **argv, struct command *c
struct plugin *plugin)
{
const char *desc = "Retrieve unsupported requirements log data.";
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret = 0;
- __u64 capabilities = 0;
struct config {
char *output_format;
@@ -7599,12 +7696,12 @@ static int wdc_get_unsupported_reqs_log(int argc, char **argv, struct command *c
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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");
@@ -7612,13 +7709,13 @@ static int wdc_get_unsupported_reqs_log(int argc, char **argv, struct command *c
goto out;
}
- ret = wdc_get_ocp_c5_log_page(r, 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);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7667,25 +7764,26 @@ static int wdc_clear_pcie_correctable_errors(int argc, char **argv, struct comma
struct plugin *plugin)
{
char *desc = "Clear PCIE Correctable Errors.";
- int fd, ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- if (!wdc_check_device(r, fd)) {
+ if (!wdc_check_device(r, dev)) {
ret = -1;
goto out;
}
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -7693,18 +7791,18 @@ static int wdc_clear_pcie_correctable_errors(int argc, char **argv, struct comma
}
if (capabilities & WDC_DRIVE_CAP_CLEAR_PCIE) {
- ret = wdc_do_clear_pcie_correctable_errors(fd);
+ ret = wdc_do_clear_pcie_correctable_errors(dev_fd(dev));
}
else if (capabilities & WDC_DRIVE_CAP_VUC_CLEAR_PCIE) {
- ret = wdc_do_clear_pcie_correctable_errors_vuc(fd);
+ ret = wdc_do_clear_pcie_correctable_errors_vuc(dev_fd(dev));
}
else {
- ret = wdc_do_clear_pcie_correctable_errors_fid(fd);
+ ret = wdc_do_clear_pcie_correctable_errors_fid(dev_fd(dev));
}
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7712,7 +7810,7 @@ static int wdc_drive_status(int argc, char **argv, struct command *command,
struct plugin *plugin)
{
char *desc = "Get Drive Status.";
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
nvme_root_t r;
__le32 system_eol_state;
@@ -7727,12 +7825,12 @@ static int wdc_drive_status(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -7740,41 +7838,42 @@ static int wdc_drive_status(int argc, char **argv, struct command *command,
}
/* verify the 0xC2 Device Manageability log page is supported */
- if (wdc_nvme_check_supported_log_page(r, fd, WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE) == false) {
+ if (wdc_nvme_check_supported_log_page(r, dev,
+ WDC_NVME_GET_DEV_MGMNT_LOG_PAGE_OPCODE) == false) {
fprintf(stderr, "ERROR : WDC : 0xC2 Log Page not supported\n");
ret = -1;
goto out;
}
/* Get the assert dump present status */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &assert_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &assert_status,
WDC_C2_ASSERT_DUMP_PRESENT_ID))
fprintf(stderr, "ERROR : WDC : Get Assert Status Failed\n");
/* Get the thermal throttling status */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &thermal_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &thermal_status,
WDC_C2_THERMAL_THROTTLE_STATUS_ID))
fprintf(stderr, "ERROR : WDC : Get Thermal Throttling Status Failed\n");
/* Get EOL status */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &eol_status,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &eol_status,
WDC_C2_USER_EOL_STATUS_ID)) {
fprintf(stderr, "ERROR : WDC : Get User EOL Status Failed\n");
eol_status = cpu_to_le32(-1);
}
/* Get Customer EOL state */
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &user_eol_state,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &user_eol_state,
WDC_C2_USER_EOL_STATE_ID))
fprintf(stderr, "ERROR : WDC : Get User EOL State Failed\n");
/* Get System EOL state*/
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &system_eol_state,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &system_eol_state,
WDC_C2_SYSTEM_EOL_STATE_ID))
fprintf(stderr, "ERROR : WDC : Get System EOL State Failed\n");
/* Get format corrupt reason*/
- if (!wdc_nvme_get_dev_status_log_data(r, fd, &format_corrupt_reason,
+ if (!wdc_nvme_get_dev_status_log_data(r, dev, &format_corrupt_reason,
WDC_C2_FORMAT_CORRUPT_REASON_ID))
fprintf(stderr, "ERROR : WDC : Get Format Corrupt Reason Failed\n");
@@ -7822,7 +7921,7 @@ static int wdc_drive_status(int argc, char **argv, struct command *command,
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -7830,7 +7929,7 @@ static int wdc_clear_assert_dump(int argc, char **argv, struct command *command,
struct plugin *plugin)
{
char *desc = "Clear Assert Dump Present Status.";
- int fd;
+ struct nvme_dev *dev;
int ret = -1;
nvme_root_t r;
__le32 assert_status = cpu_to_le32(0xFFFFFFFF);
@@ -7841,18 +7940,18 @@ static int wdc_clear_assert_dump(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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, 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;
@@ -7866,25 +7965,27 @@ static int wdc_clear_assert_dump(int argc, char **argv, struct command *command,
admin_cmd.cdw12 = ((WDC_NVME_CLEAR_ASSERT_DUMP_SUBCMD << WDC_NVME_SUBCMD_SHIFT) |
WDC_NVME_CLEAR_ASSERT_DUMP_CMD);
- ret = nvme_submit_admin_passthru(fd, &admin_cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &admin_cmd,
+ NULL);
nvme_show_status(ret);
} else
fprintf(stderr, "INFO : WDC : No Assert Dump Present\n");
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
-static int wdc_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);
@@ -7894,7 +7995,7 @@ static int wdc_get_fw_act_history(nvme_root_t r, int fd, char *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;
}
@@ -7906,8 +8007,9 @@ static int wdc_get_fw_act_history(nvme_root_t r, int fd, char *format)
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,
- WDC_FW_ACT_HISTORY_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_FW_ACT_HISTORY_LOG_ID,
+ WDC_FW_ACT_HISTORY_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -7935,13 +8037,13 @@ static int wdc_get_fw_act_history(nvme_root_t r, int fd, char *format)
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;
@@ -7951,7 +8053,8 @@ static __u32 wdc_get_fw_cust_id(nvme_root_t r, int fd)
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;
@@ -7961,7 +8064,7 @@ static int wdc_get_fw_act_history_C2(nvme_root_t r, int fd, char *format)
__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);
@@ -7970,7 +8073,7 @@ static int wdc_get_fw_act_history_C2(nvme_root_t r, int fd, char *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));
@@ -7979,8 +8082,9 @@ static int wdc_get_fw_act_history_C2(nvme_root_t r, int fd, char *format)
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,
- WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN, data);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ WDC_NVME_GET_FW_ACT_HISTORY_C2_LOG_ID,
+ WDC_FW_ACT_HISTORY_C2_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
nvme_show_status(ret);
@@ -7992,7 +8096,7 @@ static int wdc_get_fw_act_history_C2(nvme_root_t r, int fd, char *format)
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;
@@ -8018,12 +8122,11 @@ freeData:
static int wdc_vs_fw_activate_history(int argc, char **argv, struct command *command,
struct plugin *plugin)
{
- int fd;
- int ret = 0;
- nvme_root_t r;
- __u64 capabilities = 0;
const char *desc = "Retrieve FW activate history table.";
-
+ __u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
char *output_format;
@@ -8038,13 +8141,12 @@ static int wdc_vs_fw_activate_history(int argc, char **argv, struct command *com
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
-
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -8068,8 +8170,8 @@ static int wdc_vs_fw_activate_history(int argc, char **argv, struct command *com
/* Get the 0xC0 log data */
struct nvme_get_log_args args = {
.args_size = sizeof(args),
- .fd = fd,
- .lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_OPCODE,
+ .fd = dev_fd(dev),
+ .lid = WDC_NVME_GET_SMART_CLOUD_ATTR_LOG_ID,
.nsid = 0xFFFFFFFF,
.lpo = 0,
.lsp = NVME_LOG_LSP_NONE,
@@ -8101,21 +8203,22 @@ static int wdc_vs_fw_activate_history(int argc, char **argv, struct command *com
free(data);
if (c0GuidMatch) {
- ret = wdc_get_fw_act_history_C2(r, fd,
+ ret = wdc_get_fw_act_history_C2(r, dev,
cfg.output_format);
}
else {
- ret = wdc_get_fw_act_history(r, fd, cfg.output_format);
+ ret = wdc_get_fw_act_history(r, dev,
+ cfg.output_format);
}
} else {
- ret = wdc_get_fw_act_history_C2(r, fd, cfg.output_format);
+ ret = wdc_get_fw_act_history_C2(r, dev, cfg.output_format);
}
if (ret)
fprintf(stderr, "ERROR : WDC : Failure reading the FW Activate History, ret = %d\n", ret);
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -8152,21 +8255,21 @@ static int wdc_clear_fw_activate_history(int argc, char **argv, struct command *
struct plugin *plugin)
{
char *desc = "Clear FW activate history table.";
- int fd;
- int ret = -1;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -8174,13 +8277,13 @@ static int wdc_clear_fw_activate_history(int argc, char **argv, struct command *
}
if (capabilities & WDC_DRIVE_CAP_CLEAR_FW_ACT_HISTORY)
- ret = wdc_do_clear_fw_activate_history_vuc(fd);
+ ret = wdc_do_clear_fw_activate_history_vuc(dev_fd(dev));
else
- ret = wdc_do_clear_fw_activate_history_fid(fd);
+ ret = wdc_do_clear_fw_activate_history_fid(dev_fd(dev));
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -8191,11 +8294,11 @@ static int wdc_vs_telemetry_controller_option(int argc, char **argv, struct comm
char *disable = "Disable controller option of the telemetry log page.";
char *enable = "Enable controller option of the telemetry log page.";
char *status = "Displays the current state of the controller initiated log page.";
- int fd;
- int ret = -1;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
__u32 result;
+ int ret = -1;
struct config {
@@ -8217,12 +8320,12 @@ static int wdc_vs_telemetry_controller_option(int argc, char **argv, struct comm
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -8238,19 +8341,22 @@ static int wdc_vs_telemetry_controller_option(int argc, char **argv, struct comm
}
if (cfg.disable) {
- ret = nvme_set_features_simple(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0, 1,
- false, &result);
+ ret = nvme_set_features_simple(dev_fd(dev),
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, 1, false, &result);
- wdc_clear_reason_id(fd);
+ wdc_clear_reason_id(dev);
}
else {
if (cfg.enable) {
- ret = nvme_set_features_simple(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0, 0,
- false, &result);
+ ret = nvme_set_features_simple(dev_fd(dev),
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, 0, false, &result);
}
else if (cfg.status) {
- ret = nvme_get_features_simple(fd, WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID, 0,
- &result);
+ ret = nvme_get_features_simple(dev_fd(dev),
+ WDC_VU_DISABLE_CNTLR_TELEMETRY_OPTION_FEATURE_ID,
+ 0, &result);
if (ret == 0) {
if (result)
fprintf(stderr, "Controller Option Telemetry Log Page State: Disabled\n");
@@ -8271,12 +8377,12 @@ static int wdc_vs_telemetry_controller_option(int argc, char **argv, struct comm
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
-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;
@@ -8286,7 +8392,7 @@ static int wdc_get_serial_and_fw_rev(int fd, char *sn, char *fw_rev)
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(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
@@ -8303,7 +8409,7 @@ static int wdc_get_serial_and_fw_rev(int fd, char *sn, char *fw_rev)
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;
@@ -8311,7 +8417,7 @@ static int wdc_get_max_transfer_len(int fd, __u32 *maxTransferLen)
__u32 maxTransferLenDevice = 0;
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed 0x%x\n", ret);
return -1;
@@ -8323,12 +8429,13 @@ static int wdc_get_max_transfer_len(int fd, __u32 *maxTransferLen)
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;
@@ -8340,7 +8447,7 @@ static int wdc_de_VU_read_size(int fd, __u32 fileId, __u16 spiDestn, __u32* logS
cmd.cdw13 = fileId<<16;
cmd.cdw14 = spiDestn;
- ret = nvme_submit_admin_passthru(fd, &cmd, NULL);
+ ret = nvme_submit_admin_passthru(dev_fd(dev), &cmd, NULL);
if (!ret && logSize)
*logSize = cmd.result;
@@ -8353,13 +8460,15 @@ static int wdc_de_VU_read_size(int fd, __u32 fileId, __u16 spiDestn, __u32* logS
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;
@@ -8377,7 +8486,7 @@ static int wdc_de_VU_read_buffer(int fd, __u32 fileId, __u16 spiDestn, __u32 off
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(dev), &cmd, NULL);
if( ret != WDC_STATUS_SUCCESS) {
fprintf(stderr, "ERROR : WDC : VUReadBuffer() failed, ");
@@ -8388,7 +8497,7 @@ static int wdc_de_VU_read_buffer(int fd, __u32 fileId, __u16 spiDestn, __u32 off
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;
@@ -8398,13 +8507,13 @@ static int wdc_get_log_dir_max_entries(int fd, __u32* maxNumOfEntries)
__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);
@@ -8415,7 +8524,7 @@ static int wdc_get_log_dir_max_entries(int fd, __u32* maxNumOfEntries)
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);
@@ -8455,7 +8564,7 @@ static WDC_DRIVE_ESSENTIAL_TYPE wdc_get_essential_type(__u8 fileName[])
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;
@@ -8466,12 +8575,12 @@ static int wdc_fetch_log_directory(int fd, PWDC_DE_VU_LOG_DIRECTORY directory)
__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",
@@ -8480,7 +8589,7 @@ static int wdc_fetch_log_directory(int fd, PWDC_DE_VU_LOG_DIRECTORY directory)
}
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",
@@ -8533,7 +8642,8 @@ end:
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;
@@ -8541,13 +8651,13 @@ static int wdc_fetch_log_file_from_device(int fd, __u32 fileId, __u16 spiDestn,
__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;
}
@@ -8565,7 +8675,7 @@ static int wdc_fetch_log_file_from_device(int fd, __u32 fileId, __u16 spiDestn,
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)
{
@@ -8576,7 +8686,7 @@ static int wdc_fetch_log_file_from_device(int fd, __u32 fileId, __u16 spiDestn,
}
} 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)
{
@@ -8589,7 +8699,7 @@ static int wdc_fetch_log_file_from_device(int fd, __u32 fileId, __u16 spiDestn,
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;
@@ -8604,19 +8714,19 @@ static int wdc_de_get_dump_trace(int fd, char * filePath, __u16 binFileNameLen,
__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",
@@ -8665,7 +8775,7 @@ static int wdc_de_get_dump_trace(int fd, char * filePath, __u16 binFileNameLen,
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",
@@ -8692,7 +8802,8 @@ static int wdc_de_get_dump_trace(int fd, char * filePath, __u16 binFileNameLen,
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;
@@ -8732,7 +8843,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
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;
@@ -8785,7 +8896,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
/* Get Identify Controller Data */
memset(&ctrl, 0, sizeof (struct nvme_id_ctrl));
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed, ret = %d\n", ret);
return -1;
@@ -8796,7 +8907,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
}
memset(&ns, 0, sizeof (struct nvme_id_ns));
- ret = nvme_identify_ns(fd, 1, &ns);
+ ret = nvme_identify_ns(dev_fd(dev), 1, &ns);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ns() failed, ret = %d\n", ret);
} else {
@@ -8811,7 +8922,8 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
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(dev), elogNumEntries, false,
+ elogBuffer);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_error_log() failed, ret = %d\n", ret);
} else {
@@ -8825,7 +8937,8 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
/* 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(dev), NVME_NSID_ALL, false,
+ &smart_log);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_smart_log() failed, ret = %d\n", ret);
} else {
@@ -8836,7 +8949,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
/* 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(dev), false, &fw_log);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_fw_log() failed, ret = %d\n", ret);
} else {
@@ -8856,8 +8969,9 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
dataBuffer = calloc(1, dataBufferSize);
memset(dataBuffer, 0, dataBufferSize);
- ret = nvme_get_log_simple(fd, deVULogPagesList[vuLogIdx].logPageId,
- dataBufferSize, dataBuffer);
+ ret = nvme_get_log_simple(dev_fd(dev),
+ deVULogPagesList[vuLogIdx].logPageId,
+ dataBufferSize, dataBuffer);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_get_log() for log page 0x%x failed, ret = %d\n",
deVULogPagesList[vuLogIdx].logPageId, ret);
@@ -8881,8 +8995,11 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
/* 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(dev),
+ (enum nvme_features_id)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",
@@ -8896,7 +9013,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
}
/* 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));
@@ -8904,7 +9021,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
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 */
@@ -8918,7 +9035,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
} 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 */
@@ -8954,7 +9071,7 @@ static int wdc_do_drive_essentials(nvme_root_t r, int fd, char *dir, char *key)
/* 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);
}
@@ -8987,10 +9104,11 @@ static int wdc_drive_essentials(int argc, char **argv, struct command *command,
char *dirName = "Output directory pathname.";
char d[PATH_MAX] = {0};
char k[PATH_MAX] = {0};
- char *d_ptr;
- int fd, ret;
- nvme_root_t r;
__u64 capabilities = 0;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ char *d_ptr;
+ int ret;
struct config {
char *dirName;
@@ -9006,12 +9124,12 @@ static int wdc_drive_essentials(int argc, char **argv, struct command *command,
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -9025,14 +9143,14 @@ static int wdc_drive_essentials(int argc, char **argv, struct command *command,
d_ptr = NULL;
}
- ret = wdc_do_drive_essentials(r, fd, d_ptr, k);
+ ret = wdc_do_drive_essentials(r, dev, d_ptr, k);
out:
nvme_free_tree(r);
- close(fd);
+ 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;
@@ -9043,11 +9161,11 @@ static int wdc_do_drive_resize(int fd, uint64_t new_size)
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(dev), &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;
@@ -9057,11 +9175,11 @@ static int wdc_do_namespace_resize(int fd, __u32 nsid, __u32 op_option)
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(dev), &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;
@@ -9071,7 +9189,7 @@ static int wdc_do_drive_info(int fd, __u32 *result)
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(dev), &admin_cmd, NULL);
if (!ret && result)
*result = admin_cmd.result;
@@ -9084,9 +9202,10 @@ static int wdc_drive_resize(int argc, char **argv,
{
const char *desc = "Send a Resize command.";
const char *size = "The new size (in GB) to resize the drive to.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
uint64_t size;
@@ -9101,15 +9220,15 @@ static int wdc_drive_resize(int argc, char **argv,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, 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(fd, cfg.size);
+ ret = wdc_do_drive_resize(dev, cfg.size);
} else {
fprintf(stderr, "ERROR : WDC: unsupported device for this command\n");
ret = -1;
@@ -9120,7 +9239,7 @@ static int wdc_drive_resize(int argc, char **argv,
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -9130,9 +9249,10 @@ static int wdc_namespace_resize(int argc, char **argv,
const char *desc = "Send a Namespace Resize command.";
const char *namespace_id = "The namespace id to resize.";
const char *op_option = "The over provisioning option to set for namespace.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
struct config {
__u32 namespace_id;
@@ -9150,9 +9270,9 @@ static int wdc_namespace_resize(int argc, char **argv,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
if ((cfg.op_option != 0x1) &&
(cfg.op_option != 0x2) &&
@@ -9160,15 +9280,16 @@ static int wdc_namespace_resize(int argc, char **argv,
(cfg.op_option != 0xF))
{
fprintf(stderr, "ERROR : WDC: unsupported OP option parameter\n");
- close(fd);
+ dev_close(dev);
return -1;
}
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
if ((capabilities & WDC_DRIVE_CAP_NS_RESIZE) == WDC_DRIVE_CAP_NS_RESIZE) {
- ret = wdc_do_namespace_resize(fd, cfg.namespace_id, cfg.op_option);
+ ret = wdc_do_namespace_resize(dev, cfg.namespace_id,
+ cfg.op_option);
if (ret != 0)
printf("ERROR : WDC: Namespace Resize of namespace id 0x%x, op option 0x%x failed\n", cfg.namespace_id, cfg.op_option);
@@ -9179,7 +9300,7 @@ static int wdc_namespace_resize(int argc, char **argv,
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -9189,8 +9310,8 @@ static int wdc_reason_identifier(int argc, char **argv,
const char *desc = "Retrieve telemetry log reason identifier.";
const char *log_id = "Log ID to retrieve - host - 7 or controller - 8";
const char *fname = "File name to save raw binary identifier";
+ struct nvme_dev *dev;
nvme_root_t r;
- int fd;
int ret;
uint64_t capabilities = 0;
char f[PATH_MAX] = {0};
@@ -9214,10 +9335,10 @@ static int wdc_reason_identifier(int argc, char **argv,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
@@ -9250,7 +9371,7 @@ static int wdc_reason_identifier(int argc, char **argv,
else
snprintf(fileSuffix, PATH_MAX, "_error_reason_identifier_host_%s", (char*)timeStamp);
- if (wdc_get_serial_name(fd, f, PATH_MAX, fileSuffix) == -1) {
+ if (wdc_get_serial_name(dev, f, PATH_MAX, fileSuffix) == -1) {
fprintf(stderr, "ERROR : WDC: failed to generate file name\n");
ret = -1;
goto close_fd;
@@ -9265,9 +9386,9 @@ static int wdc_reason_identifier(int argc, char **argv,
fprintf(stderr, "%s: filename = %s\n", __func__, f);
- capabilities = wdc_get_drive_capabilities(r, 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(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;
@@ -9276,7 +9397,7 @@ static int wdc_reason_identifier(int argc, char **argv,
nvme_show_status(ret);
close_fd:
- close(fd);
+ dev_close(dev);
nvme_free_tree(r);
return ret;
}
@@ -9328,7 +9449,7 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *command
struct plugin *plugin)
{
const char *desc = "Retrieve Log Page Directory.";
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
nvme_root_t r;
__u64 capabilities = 0;
@@ -9350,36 +9471,36 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *command
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
ret = validate_output_format(cfg.output_format);
if (ret < 0) {
fprintf(stderr, "%s: ERROR : WDC : invalid output format\n", __func__);
- close(fd);
+ dev_close(dev);
return ret;
}
ret = 0;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ capabilities = wdc_get_drive_capabilities(r, dev);
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, 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, 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 */
@@ -9416,11 +9537,11 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *command
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
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;
@@ -9432,7 +9553,7 @@ static int wdc_get_drive_reason_id(int fd, char *drive_reason_id, size_t len)
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(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_identify_ctrl() failed "
"0x%x\n", ret);
@@ -9459,7 +9580,7 @@ static int wdc_get_drive_reason_id(int fd, char *drive_reason_id, size_t len)
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;
@@ -9467,7 +9588,7 @@ static int wdc_save_reason_id(int fd, __u8 *rsn_ident, int size)
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;
}
@@ -9494,14 +9615,14 @@ static int wdc_save_reason_id(int fd, __u8 *rsn_ident, int size)
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;
}
@@ -9527,14 +9648,15 @@ static int wdc_clear_reason_id(int fd)
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(dev), log_hdr);
else
- ret = nvme_get_log_telemetry_ctrl(fd, false, 0, 512, (void *)log_hdr);
+ ret = nvme_get_log_telemetry_ctrl(dev_fd(dev), false, 0, 512,
+ (void *)log_hdr);
if (ret < 0)
perror("get-telemetry-log");
@@ -9546,7 +9668,7 @@ static int wdc_dump_telemetry_hdr(int fd, int log_id, struct nvme_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;
@@ -9561,7 +9683,7 @@ static int wdc_do_get_reason_id(int fd, char *file, int log_id)
}
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;
@@ -9571,7 +9693,7 @@ static int wdc_do_get_reason_id(int fd, char *file, int log_id)
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);
@@ -9592,10 +9714,12 @@ static void wdc_print_nand_stats_normal(__u16 version, void *data)
{
case 0:
printf(" NAND Statistics :- \n");
- printf(" NAND Writes TLC (Bytes) %.0Lf\n",
- int128_to_double(nand_stats->nand_write_tlc));
- printf(" NAND Writes SLC (Bytes) %.0Lf\n",
- int128_to_double(nand_stats->nand_write_slc));
+ printf(" NAND Writes TLC (Bytes) %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats->nand_write_tlc)));
+ printf(" NAND Writes SLC (Bytes) %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats->nand_write_slc)));
printf(" NAND Program Failures %"PRIu32"\n",
(uint32_t)le32_to_cpu(nand_stats->nand_prog_failure));
printf(" NAND Erase Failures %"PRIu32"\n",
@@ -9613,10 +9737,12 @@ static void wdc_print_nand_stats_normal(__u16 version, void *data)
break;
case 3:
printf(" NAND Statistics V3:- \n");
- printf(" TLC Units Written %.0Lf\n",
- int128_to_double(nand_stats_v3->nand_write_tlc));
- printf(" SLC Units Written %.0Lf\n",
- int128_to_double(nand_stats_v3->nand_write_slc));
+ printf(" TLC Units Written %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats_v3->nand_write_tlc)));
+ printf(" SLC Units Written %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats_v3->nand_write_slc)));
temp_ptr = (__u64 *)nand_stats_v3->bad_nand_block_count;
temp_norm = (__u16)(*temp_ptr & 0x000000000000FFFF);
temp_raw = ((*temp_ptr & 0xFFFFFFFFFFFF0000) >> 16);
@@ -9666,8 +9792,9 @@ static void wdc_print_nand_stats_normal(__u16 version, void *data)
le64_to_cpu(nand_stats_v3->security_version_number));
printf(" %% Free Blocks (System) %u\n",
nand_stats_v3->percent_free_blocks_system);
- printf(" Data Set Management Commands %.0Lf\n",
- int128_to_double(nand_stats_v3->trim_completions));
+ printf(" Data Set Management Commands %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats_v3->trim_completions)));
printf(" Estimate of Incomplete Trim Data %"PRIu64"\n",
le64_to_cpu(nand_stats_v3->trim_completions[16]));
printf(" %% of completed trim %u\n",
@@ -9685,16 +9812,18 @@ static void wdc_print_nand_stats_normal(__u16 version, void *data)
le16_to_cpu(temp_norm));
printf(" Bad System Nand Block Count - Raw %"PRIu64"\n",
le64_to_cpu(temp_raw));
- printf(" Endurance Estimate %.0Lf\n",
- int128_to_double(nand_stats_v3->endurance_estimate));
+ printf(" Endurance Estimate %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats_v3->endurance_estimate)));
printf(" Thermal Throttling Count %u\n",
nand_stats_v3->thermal_throttling_st_ct[0]);
printf(" Thermal Throttling Status %u\n",
nand_stats_v3->thermal_throttling_st_ct[1]);
printf(" Unaligned I/O %"PRIu64"\n",
le64_to_cpu(nand_stats_v3->unaligned_IO));
- printf(" Physical Media Units Read %.0Lf\n",
- int128_to_double(nand_stats_v3->physical_media_units));
+ printf(" Physical Media Units Read %s\n",
+ uint128_t_to_string(
+ le128_to_cpu(nand_stats_v3->physical_media_units)));
printf(" log page version %"PRIu16"\n",
le16_to_cpu(nand_stats_v3->log_page_version));
break;
@@ -9721,10 +9850,10 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
case 0:
- json_object_add_value_double(root, "NAND Writes TLC (Bytes)",
- int128_to_double(nand_stats->nand_write_tlc));
- json_object_add_value_double(root, "NAND Writes SLC (Bytes)",
- int128_to_double(nand_stats->nand_write_slc));
+ json_object_add_value_uint128(root, "NAND Writes TLC (Bytes)",
+ le128_to_cpu(nand_stats->nand_write_tlc));
+ json_object_add_value_uint128(root, "NAND Writes SLC (Bytes)",
+ le128_to_cpu(nand_stats->nand_write_slc));
json_object_add_value_uint(root, "NAND Program Failures",
le32_to_cpu(nand_stats->nand_prog_failure));
json_object_add_value_uint(root, "NAND Erase Failures",
@@ -9744,10 +9873,10 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
case 3:
- json_object_add_value_double(root, "NAND Writes TLC (Bytes)",
- int128_to_double(nand_stats_v3->nand_write_tlc));
- json_object_add_value_double(root, "NAND Writes SLC (Bytes)",
- int128_to_double(nand_stats_v3->nand_write_slc));
+ json_object_add_value_uint128(root, "NAND Writes TLC (Bytes)",
+ le128_to_cpu(nand_stats_v3->nand_write_tlc));
+ json_object_add_value_uint128(root, "NAND Writes SLC (Bytes)",
+ le128_to_cpu(nand_stats_v3->nand_write_slc));
temp_ptr = (__u64 *)nand_stats_v3->bad_nand_block_count;
temp_norm = (__u16)(*temp_ptr & 0x000000000000FFFF);
temp_raw = ((*temp_ptr & 0xFFFFFFFFFFFF0000) >> 16);
@@ -9797,8 +9926,8 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
le64_to_cpu(nand_stats_v3->security_version_number));
json_object_add_value_uint(root, "% Free Blocks (System)",
nand_stats_v3->percent_free_blocks_system);
- json_object_add_value_double(root, "Data Set Management Commands",
- int128_to_double(nand_stats_v3->trim_completions));
+ json_object_add_value_uint128(root, "Data Set Management Commands",
+ le128_to_cpu(nand_stats_v3->trim_completions));
json_object_add_value_uint64(root, "Estimate of Incomplete Trim Data",
le64_to_cpu(nand_stats_v3->trim_completions[16]));
json_object_add_value_uint(root, "%% of completed trim",
@@ -9816,16 +9945,16 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
le16_to_cpu(temp_norm));
json_object_add_value_uint64(root, "Bad System Nand Block Count - Raw",
le64_to_cpu(temp_raw));
- json_object_add_value_double(root, "Endurance Estimate",
- int128_to_double(nand_stats_v3->endurance_estimate));
+ json_object_add_value_uint128(root, "Endurance Estimate",
+ le128_to_cpu(nand_stats_v3->endurance_estimate));
json_object_add_value_uint(root, "Thermal Throttling Status",
nand_stats_v3->thermal_throttling_st_ct[0]);
json_object_add_value_uint(root, "Thermal Throttling Count",
nand_stats_v3->thermal_throttling_st_ct[1]);
json_object_add_value_uint64(root, "Unaligned I/O",
le64_to_cpu(nand_stats_v3->unaligned_IO));
- json_object_add_value_double(root, "Physical Media Units Read",
- int128_to_double(nand_stats_v3->physical_media_units));
+ json_object_add_value_uint128(root, "Physical Media Units Read",
+ le128_to_cpu(nand_stats_v3->physical_media_units));
json_object_add_value_uint(root, "log page version",
le16_to_cpu(nand_stats_v3->log_page_version));
@@ -9926,14 +10055,15 @@ static void wdc_print_pcie_stats_json(struct wdc_vs_pcie_stats *pcie_stats)
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(dev), &data, 0,
+ NVME_NSID_ALL);
if (ret) {
fprintf(stderr, "ERROR : WDC : %s : Failed to retreive NAND stats\n", __func__);
@@ -9963,7 +10093,7 @@ out:
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;
@@ -9976,8 +10106,8 @@ static int wdc_do_vs_nand_stats(int fd, char *format)
goto out;
}
- ret = nvme_get_log_simple(fd, WDC_NVME_NAND_STATS_LOG_ID,
- WDC_NVME_NAND_STATS_SIZE, (void*)output);
+ ret = nvme_get_log_simple(dev_fd(dev), WDC_NVME_NAND_STATS_LOG_ID,
+ WDC_NVME_NAND_STATS_SIZE, (void*)output);
if (ret) {
fprintf(stderr, "ERROR : WDC : %s : Failed to retreive NAND stats\n", __func__);
goto out;
@@ -10011,12 +10141,11 @@ static int wdc_vs_nand_stats(int argc, char **argv, struct command *command,
struct plugin *plugin)
{
const char *desc = "Retrieve NAND statistics.";
-
- int fd;
- int ret = 0;
+ struct nvme_dev *dev;
nvme_root_t r;
__u64 capabilities = 0;
uint32_t read_device_id = 0, read_vendor_id = 0;
+ int ret;
struct config {
char *output_format;
@@ -10031,18 +10160,18 @@ static int wdc_vs_nand_stats(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
- capabilities = wdc_get_drive_capabilities(r, 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);
@@ -10051,10 +10180,11 @@ static int wdc_vs_nand_stats(int argc, char **argv, struct command *command,
switch (read_device_id) {
case WDC_NVME_SN820CL_DEV_ID:
- ret = wdc_do_vs_nand_stats_sn810_2(fd, cfg.output_format);
+ ret = wdc_do_vs_nand_stats_sn810_2(dev,
+ cfg.output_format);
break;
default:
- ret = wdc_do_vs_nand_stats(fd, cfg.output_format);
+ ret = wdc_do_vs_nand_stats(dev, cfg.output_format);
break;
}
}
@@ -10063,11 +10193,11 @@ static int wdc_vs_nand_stats(int argc, char **argv, struct command *command,
fprintf(stderr, "ERROR : WDC : Failure reading NAND statistics, ret = %d\n", ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
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;
@@ -10079,7 +10209,7 @@ static int wdc_do_vs_pcie_stats(int fd,
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(dev), &admin_cmd, NULL);
return ret;
}
@@ -10088,8 +10218,7 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
struct plugin *plugin)
{
const char *desc = "Retrieve PCIE statistics.";
-
- int fd;
+ struct nvme_dev *dev;
int ret = 0;
nvme_root_t r;
__u64 capabilities = 0;
@@ -10111,9 +10240,9 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
@@ -10133,13 +10262,13 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
memset((void *)pcieStatsPtr, 0, pcie_stats_size);
- capabilities = wdc_get_drive_capabilities(r, 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(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 {
@@ -10159,7 +10288,7 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
out:
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -10169,7 +10298,8 @@ static int wdc_vs_drive_info(int argc, char **argv,
const char *desc = "Send a vs-drive-info command.";
nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret;
+ struct nvme_dev *dev;
+ int ret;
__le32 result;
__u16 size;
double rev;
@@ -10199,31 +10329,31 @@ static int wdc_vs_drive_info(int argc, char **argv,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
fmt = validate_output_format(cfg.output_format);
if (fmt < 0) {
fprintf(stderr, "ERROR : WDC %s invalid output format\n", __func__);
- close(fd);
+ dev_close(dev);
return fmt;
}
/* get the id ctrl data used to fill in drive info below */
- ret = nvme_identify_ctrl(fd, &ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &ctrl);
if (ret) {
fprintf(stderr, "ERROR : WDC %s: Identify Controller failed\n", __func__);
- close(fd);
+ dev_close(dev);
return ret;
}
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev);
+ 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);
@@ -10247,7 +10377,7 @@ static int wdc_vs_drive_info(int argc, char **argv,
case WDC_NVME_SN550_DEV_ID:
case WDC_NVME_ZN350_DEV_ID:
case WDC_NVME_ZN350_DEV_ID_1:
- ret = wdc_do_drive_info(fd, &result);
+ ret = wdc_do_drive_info(dev, &result);
if (!ret) {
size = (__u16)((cpu_to_le32(result) & 0xffff0000) >> 16);
@@ -10299,7 +10429,8 @@ static int wdc_vs_drive_info(int argc, char **argv,
break;
case WDC_NVME_SN820CL_DEV_ID:
/* Get the Drive HW Rev from the C6 Log page */
- ret = nvme_get_hw_rev_log(fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_hw_rev_log(dev_fd(dev), &data, 0,
+ NVME_NSID_ALL);
if (ret == 0) {
wdc_nvme_hw_rev_log *log_data = (wdc_nvme_hw_rev_log *)data;
major_rev = log_data->hw_rev_gdr;
@@ -10319,7 +10450,8 @@ static int wdc_vs_drive_info(int argc, char **argv,
goto out;
}
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, NVME_NSID_ALL);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data,
+ 0, NVME_NSID_ALL);
if (ret == 0) {
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
@@ -10376,7 +10508,7 @@ static int wdc_vs_drive_info(int argc, char **argv,
out:
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -10386,12 +10518,12 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
const char *desc = "Send a vs-temperature-stats command.";
struct nvme_smart_log smart_log;
struct nvme_id_ctrl id_ctrl;
+ struct nvme_dev *dev;
nvme_root_t r;
uint64_t capabilities = 0;
__u32 hctm_tmt;
- int fd, ret;
int temperature, temp_tmt1, temp_tmt2;
- int fmt = -1;
+ int ret, fmt = -1;
struct config {
char *output_format;
@@ -10406,9 +10538,9 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
r = nvme_scan(NULL);
fmt = validate_output_format(cfg.output_format);
@@ -10419,8 +10551,8 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
}
/* check if command is supported */
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, 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;
@@ -10428,10 +10560,11 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
}
/* get the temperature stats or report errors */
- ret = nvme_identify_ctrl(fd, &id_ctrl);
+ ret = nvme_identify_ctrl(dev_fd(dev), &id_ctrl);
if (ret != 0)
goto out;
- ret = nvme_get_log_smart(fd, NVME_NSID_ALL, false, &smart_log);
+ ret = nvme_get_log_smart(dev_fd(dev), NVME_NSID_ALL, false,
+ &smart_log);
if (ret != 0)
goto out;
@@ -10439,14 +10572,14 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]) - 273;
/* retrieve HCTM Thermal Management Temperatures */
- nvme_get_features_simple(fd, 0x10, 0, &hctm_tmt);
+ nvme_get_features_simple(dev_fd(dev), 0x10, 0, &hctm_tmt);
temp_tmt1 = ((hctm_tmt >> 16) & 0xffff) ? ((hctm_tmt >> 16) & 0xffff) - 273 : 0;
temp_tmt2 = (hctm_tmt & 0xffff) ? (hctm_tmt & 0xffff) - 273 : 0;
if (fmt == NORMAL) {
/* print the temperature stats */
printf("Temperature Stats for NVME device:%s namespace-id:%x\n",
- devicename, WDC_DE_GLOBAL_NSID);
+ dev->name, WDC_DE_GLOBAL_NSID);
printf("Current Composite Temperature : %d °C\n", temperature);
printf("WCTEMP : %"PRIu16" °C\n", id_ctrl.wctemp - 273);
@@ -10493,7 +10626,7 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
out:
nvme_show_status(ret);
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -10501,26 +10634,27 @@ static int wdc_capabilities(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
const char *desc = "Send a capabilities command.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) =
{
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev);
+ capabilities = wdc_get_drive_capabilities(r, dev);
/* print command and supported status */
- printf("WDC Plugin Capabilities for NVME device:%s\n", devicename);
+ printf("WDC Plugin Capabilities for NVME device:%s\n", dev->name);
printf("cap-diag : %s\n",
capabilities & WDC_DRIVE_CAP_CAP_DIAG ? "Supported" : "Not Supported");
printf("drive-log : %s\n",
@@ -10598,7 +10732,7 @@ static int wdc_capabilities(int argc, char **argv,
capabilities & WDC_DRIVE_CAP_DEVICE_WAF ? "Supported" : "Not Supported");
printf("capabilities : Supported\n");
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return 0;
}
@@ -10606,22 +10740,23 @@ static int wdc_cloud_ssd_plugin_version(int argc, char **argv,
struct command *command, struct plugin *plugin)
{
const char *desc = "Get Cloud SSD Plugin Version command.";
- nvme_root_t r;
uint64_t capabilities = 0;
- int fd;
+ struct nvme_dev *dev;
+ nvme_root_t r;
+ int ret;
OPT_ARGS(opts) = {
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev);
+ 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 */
@@ -10631,7 +10766,7 @@ static int wdc_cloud_ssd_plugin_version(int argc, char **argv,
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return 0;
}
@@ -10642,7 +10777,8 @@ static int wdc_cloud_boot_SSD_version(int argc, char **argv,
const char *namespace_id = "desired namespace id";
nvme_root_t r;
uint64_t capabilities = 0;
- int fd, ret = -1;
+ struct nvme_dev *dev;
+ int ret;
int major = 0, minor = 0;
__u8 *data = NULL;
wdc_nvme_ext_smart_log *ext_smart_log_ptr = NULL;
@@ -10660,18 +10796,19 @@ static int wdc_cloud_boot_SSD_version(int argc, char **argv,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0)
- return fd;
+ ret = parse_and_open(&dev, argc, argv, desc, opts);
+ if (ret)
+ return ret;
/* get capabilities */
r = nvme_scan(NULL);
- wdc_check_device(r, fd);
- capabilities = wdc_get_drive_capabilities(r, fd);
+ wdc_check_device(r, dev);
+ 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 */
- ret = nvme_get_ext_smart_cloud_log(fd, &data, 0, cfg.namespace_id);
+ ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
+ cfg.namespace_id);
ext_smart_log_ptr = (wdc_nvme_ext_smart_log *)data;
if (ret == 0) {
@@ -10693,7 +10830,7 @@ static int wdc_cloud_boot_SSD_version(int argc, char **argv,
}
nvme_free_tree(r);
- close(fd);
+ dev_close(dev);
return ret;
}
@@ -10704,9 +10841,9 @@ static int wdc_enc_get_log(int argc, char **argv, struct command *command,
char *file = "Output file pathname.";
char *size = "Data retrieval transfer size.";
char *log = "Enclosure Log Page ID.";
+ struct nvme_dev *dev;
FILE *output_fd;
int xfer_size = 0;
- int fd;
int len;
int err = 0;
@@ -10729,12 +10866,11 @@ static int wdc_enc_get_log(int argc, char **argv, struct command *command,
OPT_END()
};
- fd = parse_and_open(argc, argv, desc, opts);
- if (fd < 0) {
+ err = parse_and_open(&dev, argc, argv, desc, opts);
+ if (err)
goto ret;
- }
- if (!wdc_enc_check_model(fd)) {
+ if (!wdc_enc_check_model(dev)) {
err = -EINVAL;
goto closed_fd;
}
@@ -10770,10 +10906,15 @@ static int wdc_enc_get_log(int argc, char **argv, struct command *command,
if (cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_1 || cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_2
|| cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_3 || cfg.log_id == WDC_ENC_NIC_CRASH_DUMP_ID_SLOT_4) {
fprintf(stderr, "args - sz:%x logid:%x of:%s\n",xfer_size,cfg.log_id,cfg.file);
- err = wdc_enc_get_nic_log(fd, cfg.log_id, xfer_size, WDC_NVME_ENC_NIC_LOG_SIZE, output_fd);
+ err = wdc_enc_get_nic_log(dev, cfg.log_id,
+ xfer_size,
+ WDC_NVME_ENC_NIC_LOG_SIZE,
+ output_fd);
} else {
fprintf(stderr, "args - sz:%x logid:%x of:%s\n",xfer_size,cfg.log_id,cfg.file);
- err = wdc_enc_submit_move_data(fd, NULL, 0, xfer_size, output_fd, cfg.log_id, 0, 0);
+ err = wdc_enc_submit_move_data(dev, NULL, 0,
+ xfer_size, output_fd,
+ cfg.log_id, 0, 0);
}
if (err == WDC_RESULT_NOT_AVAILABLE) {
@@ -10784,12 +10925,14 @@ static int wdc_enc_get_log(int argc, char **argv, struct command *command,
}
}
closed_fd:
- close(fd);
+ dev_close(dev);
ret:
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;
@@ -10840,8 +10983,8 @@ static int wdc_enc_submit_move_data(int fd, char *cmd, int len, int xfer_size, F
d);
#endif
nvme_cmd.result = 0;
- err = nvme_submit_admin_passthru(fd, &nvme_cmd, NULL);
- if (err == NVME_SC_INTERNAL) {
+ err = nvme_submit_admin_passthru(dev_fd(dev), &nvme_cmd, NULL);
+ if (nvme_status_equals(err, NVME_STATUS_TYPE_NVME, NVME_SC_INTERNAL)) {
fprintf(stderr, "%s: WARNING : WDC : No log ID:x%x available\n",
__func__, log_id);
}
@@ -10868,7 +11011,8 @@ static int wdc_enc_submit_move_data(int fd, char *cmd, int len, int xfer_size, F
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(dev),
+ &nvme_cmd, NULL);
if (err != 0) {
more = 0;
fprintf(stderr, "%s: ERROR : WDC : NVMe Rcv Mgmt ", __func__);
@@ -10890,7 +11034,7 @@ static int wdc_enc_submit_move_data(int fd, char *cmd, int len, int xfer_size, F
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;
@@ -10925,7 +11069,8 @@ static int wdc_enc_get_nic_log(int fd, __u8 log_id, __u32 xfer_size, __u32 data_
#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(dev), &admin_cmd,
+ NULL);
if (ret != 0) {
nvme_show_status(ret);
fprintf(stderr, "%s: ERROR : WDC : Get chunk %d, size = 0x%x, offset = 0x%x, addr = 0x%lx\n",
diff --git a/plugins/wdc/wdc-nvme.h b/plugins/wdc/wdc-nvme.h
index c7b7f4c..242cf9a 100644
--- a/plugins/wdc/wdc-nvme.h
+++ b/plugins/wdc/wdc-nvme.h
@@ -5,7 +5,7 @@
#if !defined(WDC_NVME) || defined(CMD_HEADER_MULTI_READ)
#define WDC_NVME
-#define WDC_PLUGIN_VERSION "2.0.3"
+#define WDC_PLUGIN_VERSION "2.1.2"
#include "cmd.h"
PLUGIN(NAME("wdc", "Western Digital vendor specific extensions", WDC_PLUGIN_VERSION),
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-17 03:00:34 +0000