* [PATCH 4/6] seagate-nvme: fixup coding style
2018-09-20 9:09 [PATCH 0/6] nvme-cli: fixup large log page transfer Hannes Reinecke
` (2 preceding siblings ...)
2018-09-20 9:09 ` [PATCH 3/6] nvme-discover: Re-check generation counter after log page transfer Hannes Reinecke
@ 2018-09-20 9:09 ` Hannes Reinecke
2018-09-20 9:09 ` [PATCH 5/6] nvme-cli: Add 'rae' argument to nvme_get_log() Hannes Reinecke
` (2 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: Hannes Reinecke @ 2018-09-20 9:09 UTC (permalink / raw)
One really should try to adhere to one coding style in one file ...
Signed-off-by: Hannes Reinecke <hare at suse.com>
---
seagate-nvme.c | 2202 +++++++++++++++++++++++++++-----------------------------
1 file changed, 1069 insertions(+), 1133 deletions(-)
diff --git a/seagate-nvme.c b/seagate-nvme.c
index dbba9cb..2d8c708 100755
--- a/seagate-nvme.c
+++ b/seagate-nvme.c
@@ -4,7 +4,7 @@
// Copyright (c) 2017-2018 Seagate Technology LLC and/or its Affiliates, All Rights Reserved
//
// ******************************************************************************************
-//
+//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
@@ -50,159 +50,163 @@
char* log_pages_supp_print(__u32 pageID)
{
switch(pageID) {
- case 0x01:
- return "ERROR_INFORMATION";
+ case 0x01:
+ return "ERROR_INFORMATION";
break;
- case 0x02:
- return "SMART_INFORMATION";
+ case 0x02:
+ return "SMART_INFORMATION";
break;
- case 0x03:
- return "FW_SLOT_INFORMATION";
+ case 0x03:
+ return "FW_SLOT_INFORMATION";
break;
- case 0x04:
- return "CHANGED_NAMESPACE_LIST";
+ case 0x04:
+ return "CHANGED_NAMESPACE_LIST";
break;
- case 0x05:
- return "COMMANDS_SUPPORTED_AND_EFFECTS";
+ case 0x05:
+ return "COMMANDS_SUPPORTED_AND_EFFECTS";
break;
- case 0x06:
- return "DEVICE_SELF_TEST";
+ case 0x06:
+ return "DEVICE_SELF_TEST";
break;
- case 0x07:
- return "TELEMETRY_HOST_INITIATED";
+ case 0x07:
+ return "TELEMETRY_HOST_INITIATED";
break;
- case 0x08:
- return "TELEMETRY_CONTROLLER_INITIATED";
+ case 0x08:
+ return "TELEMETRY_CONTROLLER_INITIATED";
break;
- case 0xC0:
- return "VS_MEDIA_SMART_LOG";
+ case 0xC0:
+ return "VS_MEDIA_SMART_LOG";
break;
- case 0xC1:
- return "VS_DEBUG_LOG1";
+ case 0xC1:
+ return "VS_DEBUG_LOG1";
break;
- case 0xC2:
- return "VS_SEC_ERROR_LOG_PAGE";
+ case 0xC2:
+ return "VS_SEC_ERROR_LOG_PAGE";
break;
- case 0xC3:
- return "VS_LIFE_TIME_DRIVE_HISTORY";
+ case 0xC3:
+ return "VS_LIFE_TIME_DRIVE_HISTORY";
break;
- case 0xC4:
- return "VS_EXTENDED_SMART_INFO";
+ case 0xC4:
+ return "VS_EXTENDED_SMART_INFO";
break;
- case 0xC5:
- return "VS_LIST_SUPPORTED_LOG_PAGE";
+ case 0xC5:
+ return "VS_LIST_SUPPORTED_LOG_PAGE";
break;
- case 0xC6:
- return "VS_POWER_MONITOR_LOG_PAGE";
+ case 0xC6:
+ return "VS_POWER_MONITOR_LOG_PAGE";
break;
- case 0xC7:
- return "VS_CRITICAL_EVENT_LOG_PAGE";
+ case 0xC7:
+ return "VS_CRITICAL_EVENT_LOG_PAGE";
break;
- case 0xC8:
- return "VS_RECENT_DRIVE_HISTORY";
+ case 0xC8:
+ return "VS_RECENT_DRIVE_HISTORY";
break;
- case 0xC9:
- return "VS_SEC_ERROR_LOG_PAGE";
+ case 0xC9:
+ return "VS_SEC_ERROR_LOG_PAGE";
break;
- case 0xCA:
- return "VS_LIFE_TIME_DRIVE_HISTORY";
+ case 0xCA:
+ return "VS_LIFE_TIME_DRIVE_HISTORY";
break;
- case 0xCB:
- return "VS_PCIE_ERROR_LOG_PAGE";
+ case 0xCB:
+ return "VS_PCIE_ERROR_LOG_PAGE";
break;
- case 0xCF:
- return "DRAM Supercap SMART Attributes";
- break;
- case 0xD6:
- return "VS_OEM2_WORK_LOAD";
+ case 0xCF:
+ return "DRAM Supercap SMART Attributes";
break;
- case 0xD7:
- return "VS_OEM2_FW_SECURITY";
+ case 0xD6:
+ return "VS_OEM2_WORK_LOAD";
break;
- case 0xD8:
- return "VS_OEM2_REVISION";
+ case 0xD7:
+ return "VS_OEM2_FW_SECURITY";
+ break;
+ case 0xD8:
+ return "VS_OEM2_REVISION";
+ break;
+ default:
+ return "UNKNOWN";
break;
-
- default:
- return "UNKNOWN";
- break;
}
}
void json_log_pages_supp(log_page_map *logPageMap)
{
- struct json_object *root;
- struct json_array *logPages;
- __u32 i = 0;
-
- root = json_create_object();
- logPages = json_create_array();
- json_object_add_value_array(root, "supported_log_pages", logPages);
-
- for(i =0; i < le32_to_cpu(logPageMap->NumLogPages); i++) {
- struct json_object *lbaf = json_create_object();
- json_object_add_value_int(lbaf, "logpage_id", le32_to_cpu(logPageMap->LogPageEntry[i].LogPageID));
- json_object_add_value_string(lbaf, "logpage_name", log_pages_supp_print(le32_to_cpu(logPageMap->LogPageEntry[i].LogPageID)));
-
- json_array_add_value_object(logPages, lbaf);
- }
- json_print_object(root, NULL);
- printf("\n");
+ struct json_object *root;
+ struct json_array *logPages;
+ __u32 i = 0;
+
+ root = json_create_object();
+ logPages = json_create_array();
+ json_object_add_value_array(root, "supported_log_pages", logPages);
+
+ for (i = 0; i < le32_to_cpu(logPageMap->NumLogPages); i++) {
+ struct json_object *lbaf = json_create_object();
+ json_object_add_value_int(lbaf, "logpage_id",
+ le32_to_cpu(logPageMap->LogPageEntry[i].LogPageID));
+ json_object_add_value_string(lbaf, "logpage_name",
+ log_pages_supp_print(le32_to_cpu(logPageMap->LogPageEntry[i].LogPageID)));
+
+ json_array_add_value_object(logPages, lbaf);
+ }
+ json_print_object(root, NULL);
+ printf("\n");
}
-static int log_pages_supp(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+static int log_pages_supp(int argc, char **argv, struct command *cmd,
+ struct plugin *plugin)
{
- int err = 0;
- int fd = 0;
- __u32 i = 0;
- log_page_map logPageMap;
-
- const char *desc = "Retrieve Seagate Supported Log-Page information for the given device ";
- const char *output_format = "output in binary format";
-
- struct config {
- char *output_format;
- };
-
- struct config cfg = {
- .output_format = "normal",
- };
-
- const struct argconfig_commandline_options command_line_options[] = {
- {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
- {0}
- };
-
- fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
-
- int fmt;
-
- err = nvme_get_log(fd, 1, 0xc5, sizeof(logPageMap), &logPageMap);
- if (!err) {
- if(strcmp(cfg.output_format,"json")) {
- printf ("Seagate Supported Log-pages count :%d\n", le32_to_cpu(logPageMap.NumLogPages));
- printf ("%-15s %-30s\n", "LogPage-Id", "LogPage-Name");
-
- for(fmt=0; fmt<45; fmt++)
- printf ("-");
-
- printf("\n");
- } else
- json_log_pages_supp(&logPageMap);
-
- for(i = 0; i<le32_to_cpu(logPageMap.NumLogPages); i++) {
- if(strcmp(cfg.output_format,"json")) {
- printf("0x%-15X", le32_to_cpu(logPageMap.LogPageEntry[i].LogPageID));
- printf("%-30s\n", log_pages_supp_print(le32_to_cpu(logPageMap.LogPageEntry[i].LogPageID)));
- }
- }
- }
-
- if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(err), err);
-
- return err;
+ int err = 0;
+ int fd = 0;
+ __u32 i = 0;
+ log_page_map logPageMap;
+ const char *desc = "Retrieve Seagate Supported Log-Page information for the given device ";
+ const char *output_format = "output in binary format";
+ int fmt;
+
+ struct config {
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .output_format = "normal",
+ };
+
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format,
+ required_argument, output_format },
+ {0}
+ };
+
+ fd = parse_and_open(argc, argv, desc, command_line_options,
+ &cfg, sizeof(cfg));
+
+ err = nvme_get_log(fd, 1, 0xc5, sizeof(logPageMap), &logPageMap);
+ if (!err) {
+ if (strcmp(cfg.output_format,"json")) {
+ printf ("Seagate Supported Log-pages count :%d\n",
+ le32_to_cpu(logPageMap.NumLogPages));
+ printf ("%-15s %-30s\n", "LogPage-Id", "LogPage-Name");
+
+ for(fmt=0; fmt<45; fmt++)
+ printf ("-");
+ printf("\n");
+ } else
+ json_log_pages_supp(&logPageMap);
+
+ for (i = 0; i<le32_to_cpu(logPageMap.NumLogPages); i++) {
+ if (strcmp(cfg.output_format,"json")) {
+ printf("0x%-15X",
+ le32_to_cpu(logPageMap.LogPageEntry[i].LogPageID));
+ printf("%-30s\n",
+ log_pages_supp_print(le32_to_cpu(logPageMap.LogPageEntry[i].LogPageID)));
+ }
+ }
+ }
+
+ if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ return err;
}
//EOF Command for "log-pages-supp"
@@ -214,763 +218,711 @@ static int log_pages_supp(int argc, char **argv, struct command *cmd, struct plu
char* print_ext_smart_id(__u8 attrId)
{
switch(attrId) {
- case VS_ATTR_ID_SOFT_READ_ERROR_RATE:
- return "Soft ECC error count";
- break;
- case VS_ATTR_ID_REALLOCATED_SECTOR_COUNT:
- return "Bad NAND block count";
- break;
- case VS_ATTR_ID_POWER_ON_HOURS:
- return "Power On Hours";
- break;
- case VS_ATTR_ID_POWER_FAIL_EVENT_COUNT:
- return "Power Fail Event Count";
- break;
- case VS_ATTR_ID_DEVICE_POWER_CYCLE_COUNT:
- return "Device Power Cycle Count";
- break;
- case VS_ATTR_ID_RAW_READ_ERROR_RATE:
- return "Raw Read Error Count";
- break;
- case VS_ATTR_ID_GROWN_BAD_BLOCK_COUNT:
- return "Bad NAND block count";
- break;
- case VS_ATTR_ID_END_2_END_CORRECTION_COUNT:
- return "SSD End to end correction counts";
- break;
- case VS_ATTR_ID_MIN_MAX_WEAR_RANGE_COUNT:
- return "User data erase counts";
- break;
- case VS_ATTR_ID_REFRESH_COUNT:
- return "Refresh count";
- break;
- case VS_ATTR_ID_BAD_BLOCK_COUNT_USER:
- return "User data erase fail count";
- break;
- case VS_ATTR_ID_BAD_BLOCK_COUNT_SYSTEM:
- return "System area erase fail count";
- break;
- case VS_ATTR_ID_THERMAL_THROTTLING_STATUS:
- return "Thermal throttling status and count";
- break;
- case VS_ATTR_ID_ALL_PCIE_CORRECTABLE_ERROR_COUNT:
- return "PCIe Correctable Error count";
- break;
- case VS_ATTR_ID_ALL_PCIE_UNCORRECTABLE_ERROR_COUNT:
- return "PCIe Uncorrectable Error count";
- break;
- case VS_ATTR_ID_INCOMPLETE_SHUTDOWN_COUNT:
- return "Incomplete shutdowns";
- break;
- case VS_ATTR_ID_GB_ERASED_LSB:
- return "LSB of Flash GB erased";
- break;
- case VS_ATTR_ID_GB_ERASED_MSB:
- return "MSB of Flash GB erased";
- break;
- case VS_ATTR_ID_LIFETIME_DEVSLEEP_EXIT_COUNT:
- return "LIFETIME_DEV_SLEEP_EXIT_COUNT";
- break;
- case VS_ATTR_ID_LIFETIME_ENTERING_PS4_COUNT:
- return "LIFETIME_ENTERING_PS4_COUNT";
- break;
- case VS_ATTR_ID_LIFETIME_ENTERING_PS3_COUNT:
- return "LIFETIME_ENTERING_PS3_COUNT";
- break;
- case VS_ATTR_ID_RETIRED_BLOCK_COUNT:
- return "Retired block count"; /*VS_ATTR_ID_RETIRED_BLOCK_COUNT*/
- break;
- case VS_ATTR_ID_PROGRAM_FAILURE_COUNT:
- return "Program fail count";
- break;
- case VS_ATTR_ID_ERASE_FAIL_COUNT:
- return "Erase Fail Count";
- break;
- case VS_ATTR_ID_AVG_ERASE_COUNT:
- return "System data % used";
- break;
- case VS_ATTR_ID_UNEXPECTED_POWER_LOSS_COUNT:
- return "Unexpected power loss count";
- break;
- case VS_ATTR_ID_WEAR_RANGE_DELTA:
- return "Wear range delta";
- break;
- case VS_ATTR_ID_SATA_INTERFACE_DOWNSHIFT_COUNT:
- return "PCIE_INTF_DOWNSHIFT_COUNT";
- break;
- case VS_ATTR_ID_END_TO_END_CRC_ERROR_COUNT:
- return "E2E_CRC_ERROR_COUNT";
- break;
- case VS_ATTR_ID_UNCORRECTABLE_READ_ERRORS:
- return "Uncorrectable Read Error Count";
- break;
- case VS_ATTR_ID_MAX_LIFE_TEMPERATURE:
- return "Max lifetime temperature";/*VS_ATTR_ID_MAX_LIFE_TEMPERATURE for extended*/
- break;
- case VS_ATTR_ID_RAISE_ECC_CORRECTABLE_ERROR_COUNT:
- return "RAIS_ECC_CORRECT_ERR_COUNT";
- break;
- case VS_ATTR_ID_UNCORRECTABLE_RAISE_ERRORS:
- return "Uncorrectable read error count";/*VS_ATTR_ID_UNCORRECTABLE_RAISE_ERRORS*/
- break;
- case VS_ATTR_ID_DRIVE_LIFE_PROTECTION_STATUS:
- return "DRIVE_LIFE_PROTECTION_STATUS";
- break;
- case VS_ATTR_ID_REMAINING_SSD_LIFE:
- return "Remaining SSD life";
- break;
- case VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB:
- return "LSB of Physical (NAND) bytes written";
- break;
- case VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB:
- return "MSB of Physical (NAND) bytes written";
- break;
- case VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB:
- return "LSB of Physical (HOST) bytes written";
- break;
- case VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB:
- return "MSB of Physical (HOST) bytes written";
- break;
- case VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB:
- return "LSB of Physical (NAND) bytes read";
- break;
- case VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB:
- return "MSB of Physical (NAND) bytes read";
- break;
- case VS_ATTR_ID_FREE_SPACE:
- return "Free Space";
- break;
- case VS_ATTR_ID_TRIM_COUNT_LSB:
- return "LSB of Trim count";
- break;
- case VS_ATTR_ID_TRIM_COUNT_MSB:
- return "MSB of Trim count";
- break;
- case VS_ATTR_ID_OP_PERCENTAGE:
- return "OP percentage";
- break;
- case VS_ATTR_ID_MAX_SOC_LIFE_TEMPERATURE:
- return "Max lifetime SOC temperature";
- break;
- default:
- return "Un-Known";
+ case VS_ATTR_ID_SOFT_READ_ERROR_RATE:
+ return "Soft ECC error count";
+ break;
+ case VS_ATTR_ID_REALLOCATED_SECTOR_COUNT:
+ return "Bad NAND block count";
+ break;
+ case VS_ATTR_ID_POWER_ON_HOURS:
+ return "Power On Hours";
+ break;
+ case VS_ATTR_ID_POWER_FAIL_EVENT_COUNT:
+ return "Power Fail Event Count";
+ break;
+ case VS_ATTR_ID_DEVICE_POWER_CYCLE_COUNT:
+ return "Device Power Cycle Count";
+ break;
+ case VS_ATTR_ID_RAW_READ_ERROR_RATE:
+ return "Raw Read Error Count";
+ break;
+ case VS_ATTR_ID_GROWN_BAD_BLOCK_COUNT:
+ return "Bad NAND block count";
+ break;
+ case VS_ATTR_ID_END_2_END_CORRECTION_COUNT:
+ return "SSD End to end correction counts";
+ break;
+ case VS_ATTR_ID_MIN_MAX_WEAR_RANGE_COUNT:
+ return "User data erase counts";
+ break;
+ case VS_ATTR_ID_REFRESH_COUNT:
+ return "Refresh count";
+ break;
+ case VS_ATTR_ID_BAD_BLOCK_COUNT_USER:
+ return "User data erase fail count";
+ break;
+ case VS_ATTR_ID_BAD_BLOCK_COUNT_SYSTEM:
+ return "System area erase fail count";
+ break;
+ case VS_ATTR_ID_THERMAL_THROTTLING_STATUS:
+ return "Thermal throttling status and count";
+ break;
+ case VS_ATTR_ID_ALL_PCIE_CORRECTABLE_ERROR_COUNT:
+ return "PCIe Correctable Error count";
+ break;
+ case VS_ATTR_ID_ALL_PCIE_UNCORRECTABLE_ERROR_COUNT:
+ return "PCIe Uncorrectable Error count";
+ break;
+ case VS_ATTR_ID_INCOMPLETE_SHUTDOWN_COUNT:
+ return "Incomplete shutdowns";
+ break;
+ case VS_ATTR_ID_GB_ERASED_LSB:
+ return "LSB of Flash GB erased";
+ break;
+ case VS_ATTR_ID_GB_ERASED_MSB:
+ return "MSB of Flash GB erased";
+ break;
+ case VS_ATTR_ID_LIFETIME_DEVSLEEP_EXIT_COUNT:
+ return "LIFETIME_DEV_SLEEP_EXIT_COUNT";
+ break;
+ case VS_ATTR_ID_LIFETIME_ENTERING_PS4_COUNT:
+ return "LIFETIME_ENTERING_PS4_COUNT";
+ break;
+ case VS_ATTR_ID_LIFETIME_ENTERING_PS3_COUNT:
+ return "LIFETIME_ENTERING_PS3_COUNT";
+ break;
+ case VS_ATTR_ID_RETIRED_BLOCK_COUNT:
+ return "Retired block count"; /*VS_ATTR_ID_RETIRED_BLOCK_COUNT*/
+ break;
+ case VS_ATTR_ID_PROGRAM_FAILURE_COUNT:
+ return "Program fail count";
+ break;
+ case VS_ATTR_ID_ERASE_FAIL_COUNT:
+ return "Erase Fail Count";
+ break;
+ case VS_ATTR_ID_AVG_ERASE_COUNT:
+ return "System data % used";
+ break;
+ case VS_ATTR_ID_UNEXPECTED_POWER_LOSS_COUNT:
+ return "Unexpected power loss count";
+ break;
+ case VS_ATTR_ID_WEAR_RANGE_DELTA:
+ return "Wear range delta";
+ break;
+ case VS_ATTR_ID_SATA_INTERFACE_DOWNSHIFT_COUNT:
+ return "PCIE_INTF_DOWNSHIFT_COUNT";
+ break;
+ case VS_ATTR_ID_END_TO_END_CRC_ERROR_COUNT:
+ return "E2E_CRC_ERROR_COUNT";
+ break;
+ case VS_ATTR_ID_UNCORRECTABLE_READ_ERRORS:
+ return "Uncorrectable Read Error Count";
+ break;
+ case VS_ATTR_ID_MAX_LIFE_TEMPERATURE:
+ return "Max lifetime temperature";/*VS_ATTR_ID_MAX_LIFE_TEMPERATURE for extended*/
+ break;
+ case VS_ATTR_ID_RAISE_ECC_CORRECTABLE_ERROR_COUNT:
+ return "RAIS_ECC_CORRECT_ERR_COUNT";
+ break;
+ case VS_ATTR_ID_UNCORRECTABLE_RAISE_ERRORS:
+ return "Uncorrectable read error count";/*VS_ATTR_ID_UNCORRECTABLE_RAISE_ERRORS*/
+ break;
+ case VS_ATTR_ID_DRIVE_LIFE_PROTECTION_STATUS:
+ return "DRIVE_LIFE_PROTECTION_STATUS";
+ break;
+ case VS_ATTR_ID_REMAINING_SSD_LIFE:
+ return "Remaining SSD life";
+ break;
+ case VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB:
+ return "LSB of Physical (NAND) bytes written";
+ break;
+ case VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB:
+ return "MSB of Physical (NAND) bytes written";
+ break;
+ case VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB:
+ return "LSB of Physical (HOST) bytes written";
+ break;
+ case VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB:
+ return "MSB of Physical (HOST) bytes written";
+ break;
+ case VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB:
+ return "LSB of Physical (NAND) bytes read";
+ break;
+ case VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB:
+ return "MSB of Physical (NAND) bytes read";
+ break;
+ case VS_ATTR_ID_FREE_SPACE:
+ return "Free Space";
+ break;
+ case VS_ATTR_ID_TRIM_COUNT_LSB:
+ return "LSB of Trim count";
+ break;
+ case VS_ATTR_ID_TRIM_COUNT_MSB:
+ return "MSB of Trim count";
+ break;
+ case VS_ATTR_ID_OP_PERCENTAGE:
+ return "OP percentage";
+ break;
+ case VS_ATTR_ID_MAX_SOC_LIFE_TEMPERATURE:
+ return "Max lifetime SOC temperature";
+ break;
+ default:
+ return "Un-Known";
}
}
__u64 smart_attribute_vs(__u16 verNo, SmartVendorSpecific attr)
-{
+{
__u64 val = 0;
vendor_smart_attribute_data *attrVendor;
- /**
- * These are all Vendor A specific attributes.
- */
- if(verNo >= EXTENDED_SMART_VERSION_VENDOR1)
- {
- attrVendor = (vendor_smart_attribute_data *)&attr;
- memcpy(&val, &(attrVendor->LSDword), sizeof(val));
- return val;
- }
-
- else
+ /**
+ * These are all Vendor A specific attributes.
+ */
+ if (verNo >= EXTENDED_SMART_VERSION_VENDOR1) {
+ attrVendor = (vendor_smart_attribute_data *)&attr;
+ memcpy(&val, &(attrVendor->LSDword), sizeof(val));
+ return val;
+ } else
return le32_to_cpu(attr.Raw0_3);
}
-void print_smart_log(__u16 verNo, SmartVendorSpecific attr, int lastAttr)
+void print_smart_log(__u16 verNo, SmartVendorSpecific attr, int lastAttr)
{
- static __u64 lsbGbErased = 0, msbGbErased = 0, lsbLifWrtToFlash = 0, msbLifWrtToFlash = 0,
- lsbLifWrtFrmHost = 0, msbLifWrtFrmHost = 0, lsbLifRdToHost = 0, msbLifRdToHost = 0, lsbTrimCnt = 0, msbTrimCnt = 0;
- char buf[40] = {0};
- char strBuf[35] = {0};
- int hideAttr = 0;
-
- if(attr.AttributeNumber == VS_ATTR_ID_GB_ERASED_LSB)
- {
- lsbGbErased = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_GB_ERASED_MSB)
- {
- msbGbErased = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB)
- {
- lsbLifWrtToFlash = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB)
- {
- msbLifWrtToFlash = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB)
- {
- lsbLifWrtFrmHost = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB)
- {
- msbLifWrtFrmHost = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB)
- {
- lsbLifRdToHost = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB)
- {
- msbLifRdToHost = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_TRIM_COUNT_LSB)
- {
- lsbTrimCnt = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if(attr.AttributeNumber == VS_ATTR_ID_TRIM_COUNT_MSB)
- {
- msbTrimCnt = smart_attribute_vs(verNo, attr);
- hideAttr = 1;
- }
-
- if((attr.AttributeNumber != 0) &&(hideAttr != 1)) {
- printf("%-40s", print_ext_smart_id(attr.AttributeNumber));
- printf("%-15d", attr.AttributeNumber );
- printf(" 0x%016"PRIx64"", (uint64_t)smart_attribute_vs(verNo, attr));
- printf("\n");
- }
-
- if( lastAttr == 1 ) {
-
- sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_GB_ERASED_LSB) + 7));
- printf("%-40s", strBuf);
-
- printf("%-15d", VS_ATTR_ID_GB_ERASED_MSB << 8 | VS_ATTR_ID_GB_ERASED_LSB);
-
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbGbErased, (uint64_t)lsbGbErased);
- printf(" %s", buf);
- printf("\n");
-
- sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB) + 7));
- printf("%-40s", strBuf);
-
- printf("%-15d", VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB);
-
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtToFlash, (uint64_t)lsbLifWrtToFlash);
- printf(" %s", buf);
- printf("\n");
-
- sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB) + 7));
- printf("%-40s", strBuf);
-
- printf("%-15d", VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB);
-
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtFrmHost, (uint64_t)lsbLifWrtFrmHost);
- printf(" %s", buf);
- printf("\n");
-
- sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB) + 7));
- printf("%-40s", strBuf);
-
- printf("%-15d", VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB);
-
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifRdToHost, (uint64_t)lsbLifRdToHost);
- printf(" %s", buf);
- printf("\n");
+ static __u64 lsbGbErased = 0, msbGbErased = 0, lsbLifWrtToFlash = 0, msbLifWrtToFlash = 0,
+ lsbLifWrtFrmHost = 0, msbLifWrtFrmHost = 0, lsbLifRdToHost = 0, msbLifRdToHost = 0, lsbTrimCnt = 0, msbTrimCnt = 0;
+ char buf[40] = {0};
+ char strBuf[35] = {0};
+ int hideAttr = 0;
+
+ if (attr.AttributeNumber == VS_ATTR_ID_GB_ERASED_LSB) {
+ lsbGbErased = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_GB_ERASED_MSB) {
+ msbGbErased = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB) {
+ lsbLifWrtToFlash = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB) {
+ msbLifWrtToFlash = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB) {
+ lsbLifWrtFrmHost = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB) {
+ msbLifWrtFrmHost = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB) {
+ lsbLifRdToHost = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB) {
+ msbLifRdToHost = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_TRIM_COUNT_LSB) {
+ lsbTrimCnt = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if (attr.AttributeNumber == VS_ATTR_ID_TRIM_COUNT_MSB) {
+ msbTrimCnt = smart_attribute_vs(verNo, attr);
+ hideAttr = 1;
+ }
+
+ if ((attr.AttributeNumber != 0) && (hideAttr != 1)) {
+ printf("%-40s", print_ext_smart_id(attr.AttributeNumber));
+ printf("%-15d", attr.AttributeNumber );
+ printf(" 0x%016"PRIx64"", (uint64_t)smart_attribute_vs(verNo, attr));
+ printf("\n");
+ }
+
+ if (lastAttr == 1) {
+
+ sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_GB_ERASED_LSB) + 7));
+ printf("%-40s", strBuf);
+
+ printf("%-15d", VS_ATTR_ID_GB_ERASED_MSB << 8 | VS_ATTR_ID_GB_ERASED_LSB);
+
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbGbErased, (uint64_t)lsbGbErased);
+ printf(" %s", buf);
+ printf("\n");
- sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_TRIM_COUNT_LSB) + 7));
- printf("%-40s", strBuf);
-
- printf("%-15d", VS_ATTR_ID_TRIM_COUNT_MSB << 8 | VS_ATTR_ID_TRIM_COUNT_LSB);
+ sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB) + 7));
+ printf("%-40s", strBuf);
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbTrimCnt, (uint64_t)lsbTrimCnt);
- printf(" %s", buf);
- printf("\n");
+ printf("%-15d", VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB);
- }
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtToFlash, (uint64_t)lsbLifWrtToFlash);
+ printf(" %s", buf);
+ printf("\n");
+
+ sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB) + 7));
+ printf("%-40s", strBuf);
+
+ printf("%-15d", VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB);
+
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtFrmHost, (uint64_t)lsbLifWrtFrmHost);
+ printf(" %s", buf);
+ printf("\n");
+
+ sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB) + 7));
+ printf("%-40s", strBuf);
+
+ printf("%-15d", VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB);
+
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifRdToHost, (uint64_t)lsbLifRdToHost);
+ printf(" %s", buf);
+ printf("\n");
+
+ sprintf(strBuf, "%s", (print_ext_smart_id(VS_ATTR_ID_TRIM_COUNT_LSB) + 7));
+ printf("%-40s", strBuf);
+
+ printf("%-15d", VS_ATTR_ID_TRIM_COUNT_MSB << 8 | VS_ATTR_ID_TRIM_COUNT_LSB);
+
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbTrimCnt, (uint64_t)lsbTrimCnt);
+ printf(" %s", buf);
+ printf("\n");
+
+ }
}
void json_print_smart_log(struct json_object *root, EXTENDED_SMART_INFO_T* ExtdSMARTInfo )
{
- /*struct json_object *root; */
- struct json_array *lbafs;
+ /*struct json_object *root; */
+ struct json_array *lbafs;
int index = 0;
- static __u64 lsbGbErased = 0, msbGbErased = 0, lsbLifWrtToFlash = 0, msbLifWrtToFlash = 0,
- lsbLifWrtFrmHost = 0, msbLifWrtFrmHost = 0, lsbLifRdToHost = 0, msbLifRdToHost = 0, lsbTrimCnt = 0, msbTrimCnt = 0;
- char buf[40] = {0};
- //char strBuf[35] = {0};
+ static __u64 lsbGbErased = 0, msbGbErased = 0, lsbLifWrtToFlash = 0, msbLifWrtToFlash = 0,
+ lsbLifWrtFrmHost = 0, msbLifWrtFrmHost = 0, lsbLifRdToHost = 0, msbLifRdToHost = 0, lsbTrimCnt = 0, msbTrimCnt = 0;
+ char buf[40] = {0};
+ //char strBuf[35] = {0};
/*root = json_create_object();*/
lbafs = json_create_array();
json_object_add_value_array(root, "Extended-SMART-Attributes", lbafs);
-
- for(index =0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++) {
+
+ for (index =0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++) {
struct json_object *lbaf = json_create_object();
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber != 0) {
+ if (ExtdSMARTInfo->vendorData[index].AttributeNumber != 0) {
json_object_add_value_string(lbaf, "attribute_name", print_ext_smart_id(ExtdSMARTInfo->vendorData[index].AttributeNumber));
json_object_add_value_int(lbaf, "attribute_id",ExtdSMARTInfo->vendorData[index].AttributeNumber);
json_object_add_value_int(lbaf, "attribute_value", smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]));
json_array_add_value_object(lbafs, lbaf);
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_GB_ERASED_LSB)
- {
- lsbGbErased = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_GB_ERASED_MSB)
- {
- msbGbErased = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB)
- {
- lsbLifWrtToFlash = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB)
- {
- msbLifWrtToFlash = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB)
- {
- lsbLifWrtFrmHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB)
- {
- msbLifWrtFrmHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB)
- {
- lsbLifRdToHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB)
- {
- msbLifRdToHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_TRIM_COUNT_LSB)
- {
- lsbTrimCnt = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
-
- if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_TRIM_COUNT_MSB)
- {
- msbTrimCnt = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
- }
- }
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_GB_ERASED_LSB)
+ lsbGbErased = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_GB_ERASED_MSB)
+ msbGbErased = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB)
+ lsbLifWrtToFlash = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB)
+ msbLifWrtToFlash = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB)
+ lsbLifWrtFrmHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB)
+ msbLifWrtFrmHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB)
+ lsbLifRdToHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB)
+ msbLifRdToHost = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_TRIM_COUNT_LSB)
+ lsbTrimCnt = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+
+ if(ExtdSMARTInfo->vendorData[index].AttributeNumber == VS_ATTR_ID_TRIM_COUNT_MSB)
+ msbTrimCnt = smart_attribute_vs(ExtdSMARTInfo->Version, ExtdSMARTInfo->vendorData[index]);
+ }
}
- struct json_object *lbaf = json_create_object();
+ struct json_object *lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_GB_ERASED_LSB) + 7));
+ json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_GB_ERASED_LSB) + 7));
- json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_GB_ERASED_MSB << 8 | VS_ATTR_ID_GB_ERASED_LSB);
+ json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_GB_ERASED_MSB << 8 | VS_ATTR_ID_GB_ERASED_LSB);
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbGbErased, (uint64_t)lsbGbErased);
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(lbafs, lbaf);
-
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbGbErased, (uint64_t)lsbGbErased);
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(lbafs, lbaf);
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB) + 7));
+ lbaf = json_create_object();
- json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB);
+ json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB) + 7));
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtToFlash, (uint64_t)lsbLifWrtToFlash);
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(lbafs, lbaf);
+ json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_TO_FLASH_LSB);
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtToFlash, (uint64_t)lsbLifWrtToFlash);
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(lbafs, lbaf);
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB) + 7));
+ lbaf = json_create_object();
- json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB);
+ json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB) + 7));
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtFrmHost, (uint64_t)lsbLifWrtFrmHost);
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(lbafs, lbaf);
+ json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_WRITES_FROM_HOST_LSB);
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifWrtFrmHost, (uint64_t)lsbLifWrtFrmHost);
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(lbafs, lbaf);
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB) + 7));
+ lbaf = json_create_object();
- json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB);
+ json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB) + 7));
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifRdToHost, (uint64_t)lsbLifRdToHost);
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(lbafs, lbaf);
+ json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_LIFETIME_READS_TO_HOST_MSB << 8 | VS_ATTR_ID_LIFETIME_READS_TO_HOST_LSB);
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbLifRdToHost, (uint64_t)lsbLifRdToHost);
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(lbafs, lbaf);
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_TRIM_COUNT_LSB) + 7));
+ lbaf = json_create_object();
- json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_TRIM_COUNT_MSB << 8 | VS_ATTR_ID_TRIM_COUNT_LSB);
+ json_object_add_value_string(lbaf, "attribute_name", (print_ext_smart_id(VS_ATTR_ID_TRIM_COUNT_LSB) + 7));
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbTrimCnt, (uint64_t)lsbTrimCnt);
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(lbafs, lbaf);
+ json_object_add_value_int(lbaf, "attribute_id", VS_ATTR_ID_TRIM_COUNT_MSB << 8 | VS_ATTR_ID_TRIM_COUNT_LSB);
- /*
- json_print_object(root, NULL);
- printf("\n");
- */
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)msbTrimCnt, (uint64_t)lsbTrimCnt);
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(lbafs, lbaf);
+
+ /*
+ json_print_object(root, NULL);
+ printf("\n");
+ */
}
void print_smart_log_CF(vendor_log_page_CF *pLogPageCF)
{
- __u64 currentTemp, maxTemp;
- printf("\n\nSeagate DRAM Supercap SMART Attributes :\n");
- printf("%-39s %-19s \n", "Description", "Supercap Attributes");
-
- printf("%-40s", "Super-cap current temperature");
- currentTemp = pLogPageCF->AttrCF.SuperCapCurrentTemperature;
- /*currentTemp = currentTemp ? currentTemp - 273 : 0;*/
- printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(currentTemp));
- printf("\n");
-
- maxTemp = pLogPageCF->AttrCF.SuperCapMaximumTemperature;
- /*maxTemp = maxTemp ? maxTemp - 273 : 0;*/
- printf("%-40s", "Super-cap maximum temperature");
- printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(maxTemp));
- printf("\n");
-
- printf("%-40s", "Super-cap status");
- printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.SuperCapStatus));
- printf("\n");
-
- printf("%-40s", "Data units read to DRAM namespace");
- printf(" 0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.MS__u64),
- (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.LS__u64));
- printf("\n");
-
- printf("%-40s", "Data units written to DRAM namespace");
- printf(" 0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.MS__u64),
- (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.LS__u64));
- printf("\n");
-
- printf("%-40s", "DRAM correctable error count");
- printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DramCorrectableErrorCount));
- printf("\n");
-
- printf("%-40s", "DRAM uncorrectable error count");
- printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DramUncorrectableErrorCount));
- printf("\n");
+ __u64 currentTemp, maxTemp;
+ printf("\n\nSeagate DRAM Supercap SMART Attributes :\n");
+ printf("%-39s %-19s \n", "Description", "Supercap Attributes");
+
+ printf("%-40s", "Super-cap current temperature");
+ currentTemp = pLogPageCF->AttrCF.SuperCapCurrentTemperature;
+ /*currentTemp = currentTemp ? currentTemp - 273 : 0;*/
+ printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(currentTemp));
+ printf("\n");
+
+ maxTemp = pLogPageCF->AttrCF.SuperCapMaximumTemperature;
+ /*maxTemp = maxTemp ? maxTemp - 273 : 0;*/
+ printf("%-40s", "Super-cap maximum temperature");
+ printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(maxTemp));
+ printf("\n");
+
+ printf("%-40s", "Super-cap status");
+ printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.SuperCapStatus));
+ printf("\n");
+
+ printf("%-40s", "Data units read to DRAM namespace");
+ printf(" 0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.MS__u64),
+ (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.LS__u64));
+ printf("\n");
+
+ printf("%-40s", "Data units written to DRAM namespace");
+ printf(" 0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.MS__u64),
+ (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.LS__u64));
+ printf("\n");
+
+ printf("%-40s", "DRAM correctable error count");
+ printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DramCorrectableErrorCount));
+ printf("\n");
+
+ printf("%-40s", "DRAM uncorrectable error count");
+ printf(" 0x%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DramUncorrectableErrorCount));
+ printf("\n");
}
void json_print_smart_log_CF(struct json_object *root, vendor_log_page_CF *pLogPageCF)
{
- /*struct json_object *root;*/
- struct json_array *logPages;
- unsigned int currentTemp, maxTemp;
- char buf[40];
-
- /*root = json_create_object(); */
-
- logPages = json_create_array();
- json_object_add_value_array(root, "DRAM Supercap SMART Attributes", logPages);
- struct json_object *lbaf = json_create_object();
-
- currentTemp = pLogPageCF->AttrCF.SuperCapCurrentTemperature;
- /*currentTemp = currentTemp ? currentTemp - 273 : 0;*/
- json_object_add_value_string(lbaf, "attribute_name", "Super-cap current temperature");
- json_object_add_value_int(lbaf, "attribute_value", currentTemp);
- json_array_add_value_object(logPages, lbaf);
-
- lbaf = json_create_object();
- maxTemp = pLogPageCF->AttrCF.SuperCapMaximumTemperature;
- /*maxTemp = maxTemp ? maxTemp - 273 : 0;*/
- json_object_add_value_string(lbaf, "attribute_name", "Super-cap maximum temperature");
- json_object_add_value_int(lbaf, "attribute_value", maxTemp);
- json_array_add_value_object(logPages, lbaf);
-
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", "Super-cap status");
- json_object_add_value_int(lbaf, "attribute_value", pLogPageCF->AttrCF.SuperCapStatus);
- json_array_add_value_object(logPages, lbaf);
-
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", "Data units read to DRAM namespace");
- memset(buf, 0, sizeof(buf));
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.MS__u64),
- (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.LS__u64));
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(logPages, lbaf);
-
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", "Data units written to DRAM namespace");
- memset(buf, 0, sizeof(buf));
- sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.MS__u64),
- (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.LS__u64));
- json_object_add_value_string(lbaf, "attribute_value", buf);
- json_array_add_value_object(logPages, lbaf);
-
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", "DRAM correctable error count");
- json_object_add_value_int(lbaf, "attribute_value", pLogPageCF->AttrCF.DramCorrectableErrorCount);
- json_array_add_value_object(logPages, lbaf);
-
- lbaf = json_create_object();
- json_object_add_value_string(lbaf, "attribute_name", "DRAM uncorrectable error count");
- json_object_add_value_int(lbaf, "attribute_value", pLogPageCF->AttrCF.DramUncorrectableErrorCount);
- json_array_add_value_object(logPages, lbaf);
-
- /*
- json_print_object(root, NULL);
- printf("\n");
- */
+ /*struct json_object *root;*/
+ struct json_array *logPages;
+ unsigned int currentTemp, maxTemp;
+ char buf[40];
+
+ /*root = json_create_object(); */
+
+ logPages = json_create_array();
+ json_object_add_value_array(root, "DRAM Supercap SMART Attributes", logPages);
+ struct json_object *lbaf = json_create_object();
+
+ currentTemp = pLogPageCF->AttrCF.SuperCapCurrentTemperature;
+ /*currentTemp = currentTemp ? currentTemp - 273 : 0;*/
+ json_object_add_value_string(lbaf, "attribute_name", "Super-cap current temperature");
+ json_object_add_value_int(lbaf, "attribute_value", currentTemp);
+ json_array_add_value_object(logPages, lbaf);
+
+ lbaf = json_create_object();
+ maxTemp = pLogPageCF->AttrCF.SuperCapMaximumTemperature;
+ /*maxTemp = maxTemp ? maxTemp - 273 : 0;*/
+ json_object_add_value_string(lbaf, "attribute_name", "Super-cap maximum temperature");
+ json_object_add_value_int(lbaf, "attribute_value", maxTemp);
+ json_array_add_value_object(logPages, lbaf);
+
+ lbaf = json_create_object();
+ json_object_add_value_string(lbaf, "attribute_name", "Super-cap status");
+ json_object_add_value_int(lbaf, "attribute_value", pLogPageCF->AttrCF.SuperCapStatus);
+ json_array_add_value_object(logPages, lbaf);
+
+ lbaf = json_create_object();
+ json_object_add_value_string(lbaf, "attribute_name", "Data units read to DRAM namespace");
+ memset(buf, 0, sizeof(buf));
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.MS__u64),
+ (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsReadToDramNamespace.LS__u64));
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(logPages, lbaf);
+
+ lbaf = json_create_object();
+ json_object_add_value_string(lbaf, "attribute_name", "Data units written to DRAM namespace");
+ memset(buf, 0, sizeof(buf));
+ sprintf(buf, "0x%016"PRIx64"%016"PRIx64"", (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.MS__u64),
+ (uint64_t)le64_to_cpu(pLogPageCF->AttrCF.DataUnitsWrittenToDramNamespace.LS__u64));
+ json_object_add_value_string(lbaf, "attribute_value", buf);
+ json_array_add_value_object(logPages, lbaf);
+
+ lbaf = json_create_object();
+ json_object_add_value_string(lbaf, "attribute_name", "DRAM correctable error count");
+ json_object_add_value_int(lbaf, "attribute_value", pLogPageCF->AttrCF.DramCorrectableErrorCount);
+ json_array_add_value_object(logPages, lbaf);
+
+ lbaf = json_create_object();
+ json_object_add_value_string(lbaf, "attribute_name", "DRAM uncorrectable error count");
+ json_object_add_value_int(lbaf, "attribute_value", pLogPageCF->AttrCF.DramUncorrectableErrorCount);
+ json_array_add_value_object(logPages, lbaf);
+
+ /*
+ json_print_object(root, NULL);
+ printf("\n");
+ */
}
static int vs_smart_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
EXTENDED_SMART_INFO_T ExtdSMARTInfo;
- vendor_log_page_CF logPageCF;
- int fd;
- struct json_object *root;
- struct json_array *lbafs;
- struct json_object *lbafs_ExtSmart, *lbafs_DramSmart;
- root = json_create_object();
- lbafs = json_create_array();
-
- const char *desc = "Retrieve Seagate Extended SMART information for the given device ";
- const char *output_format = "output in binary format";
- int err, index=0;
- struct config {
- char *output_format;
- };
-
- struct config cfg = {
- .output_format = "normal",
- };
-
- const struct argconfig_commandline_options command_line_options[] = {
- {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
- {0}
- };
+ vendor_log_page_CF logPageCF;
+ int fd;
+ struct json_object *root;
+ struct json_array *lbafs;
+ struct json_object *lbafs_ExtSmart, *lbafs_DramSmart;
+ root = json_create_object();
+ lbafs = json_create_array();
+
+ const char *desc = "Retrieve Seagate Extended SMART information for the given device ";
+ const char *output_format = "output in binary format";
+ int err, index=0;
+ struct config {
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .output_format = "normal",
+ };
+
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
+ {0}
+ };
fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- if(strcmp(cfg.output_format,"json")) {
+ if (strcmp(cfg.output_format,"json"))
printf("Seagate Extended SMART Information :\n");
- }
- err = nvme_get_log(fd, 1, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
- if (!err) {
- if(strcmp(cfg.output_format,"json")) {
+ err = nvme_get_log(fd, 1, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
+ if (!err) {
+ if (strcmp(cfg.output_format,"json")) {
printf("%-39s %-15s %-19s \n", "Description", "Ext-Smart-Id", "Ext-Smart-Value");
for(index=0; index<80; index++)
- printf("-");
+ printf("-");
printf("\n");
- for(index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++)
- print_smart_log(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index], index == (NUMBER_EXTENDED_SMART_ATTRIBUTES - 1));
-
+ for(index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++)
+ print_smart_log(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index], index == (NUMBER_EXTENDED_SMART_ATTRIBUTES - 1));
+
+ } else {
+ lbafs_ExtSmart = json_create_object();
+ json_print_smart_log(lbafs_ExtSmart, &ExtdSMARTInfo);
+
+ json_object_add_value_array(root, "SMART-Attributes", lbafs);
+ json_array_add_value_object(lbafs, lbafs_ExtSmart);
}
- else {
- lbafs_ExtSmart = json_create_object();
- json_print_smart_log(lbafs_ExtSmart, &ExtdSMARTInfo);
-
- json_object_add_value_array(root, "SMART-Attributes", lbafs);
- json_array_add_value_object(lbafs, lbafs_ExtSmart);
- }
-
- /**
- * Next get Log Page 0xCF
- */
-
- err = nvme_get_log(fd, 1, 0xCF, sizeof(logPageCF), &logPageCF);
- if (!err) {
- if(strcmp(cfg.output_format,"json")) {
- /*printf("Seagate DRAM Supercap SMART Attributes :\n");*/
-
- print_smart_log_CF(&logPageCF);
- }
- else {
- lbafs_DramSmart = json_create_object();
- json_print_smart_log_CF(lbafs_DramSmart, &logPageCF);
- json_array_add_value_object(lbafs, lbafs_DramSmart);
- json_print_object(root, NULL);
- }
- }
- else
- {
- if(!strcmp(cfg.output_format, "json")) {
- json_print_object(root, NULL);
- }
- }
- }
- else if (err > 0)
+
+ /**
+ * Next get Log Page 0xCF
+ */
+
+ err = nvme_get_log(fd, 1, 0xCF, sizeof(logPageCF), &logPageCF);
+ if (!err) {
+ if(strcmp(cfg.output_format,"json")) {
+ /*printf("Seagate DRAM Supercap SMART Attributes :\n");*/
+
+ print_smart_log_CF(&logPageCF);
+ } else {
+ lbafs_DramSmart = json_create_object();
+ json_print_smart_log_CF(lbafs_DramSmart, &logPageCF);
+ json_array_add_value_object(lbafs, lbafs_DramSmart);
+ json_print_object(root, NULL);
+ }
+ } else if (!strcmp(cfg.output_format, "json"))
+ json_print_object(root, NULL);
+ } else if (err > 0)
fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
+ nvme_status_to_string(err), err);
return err;
}
//EOF Extended-SMART Information
/***************************************
-* Temperature-Stats information
-***************************************/
+ * Temperature-Stats information
+ ***************************************/
static void json_temp_stats(__u32 temperature, __u32 PcbTemp, __u32 SocTemp, __u32 maxTemperature,
- __u32 MaxSocTemp, __u32 cf_err, __u32 scCurrentTemp, __u32 scMaxTem)
+ __u32 MaxSocTemp, __u32 cf_err, __u32 scCurrentTemp, __u32 scMaxTem)
{
struct json_object *root;
root = json_create_object();
json_object_add_value_int(root, "Current temperature", temperature);
- json_object_add_value_int(root, "Current PCB temperature", PcbTemp);
- json_object_add_value_int(root, "Current SOC temperature", SocTemp);
+ json_object_add_value_int(root, "Current PCB temperature", PcbTemp);
+ json_object_add_value_int(root, "Current SOC temperature", SocTemp);
json_object_add_value_int(root, "Highest temperature", maxTemperature);
- json_object_add_value_int(root, "Max SOC temperature", MaxSocTemp);
- if(!cf_err) {
- json_object_add_value_int(root, "SuperCap Current temperature", scCurrentTemp);
- json_object_add_value_int(root, "SuperCap Max temperature", scMaxTem);
- }
+ json_object_add_value_int(root, "Max SOC temperature", MaxSocTemp);
+ if(!cf_err) {
+ json_object_add_value_int(root, "SuperCap Current temperature", scCurrentTemp);
+ json_object_add_value_int(root, "SuperCap Max temperature", scMaxTem);
+ }
- json_print_object(root, NULL);
- printf("\n");
+ json_print_object(root, NULL);
+ printf("\n");
}
static int temp_stats(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
struct nvme_smart_log smart_log;
EXTENDED_SMART_INFO_T ExtdSMARTInfo;
- vendor_log_page_CF logPageCF;
+ vendor_log_page_CF logPageCF;
- int fd;
- int err, cf_err;
+ int fd;
+ int err, cf_err;
int index;
- const char *desc = "Retrieve Seagate Temperature Stats information for the given device ";
- const char *output_format = "output in binary format";
+ const char *desc = "Retrieve Seagate Temperature Stats information for the given device ";
+ const char *output_format = "output in binary format";
unsigned int temperature = 0, PcbTemp = 0, SocTemp = 0, scCurrentTemp = 0, scMaxTemp = 0;
- unsigned long long maxTemperature = 0, MaxSocTemp = 0;
+ unsigned long long maxTemperature = 0, MaxSocTemp = 0;
struct config {
char *output_format;
};
-
+
struct config cfg = {
.output_format = "normal",
};
const struct argconfig_commandline_options command_line_options[] = {
- {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
- {0}
+ {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
+ {0}
};
fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- if (fd < 0) {
- printf ("\nDevice not found \n");;
- return -1;
- }
+ if (fd < 0) {
+ printf ("\nDevice not found \n");;
+ return -1;
+ }
if(strcmp(cfg.output_format,"json"))
printf("Seagate Temperature Stats Information :\n");
//STEP-1 : Get Current Temperature from SMART
err = nvme_smart_log(fd, 0xffffffff, &smart_log);
- if (!err)
- {
- temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]);
- temperature = temperature ? temperature - 273 : 0;
- PcbTemp = le16_to_cpu(smart_log.temp_sensor[0]);
- PcbTemp = PcbTemp ? PcbTemp - 273 : 0;
- SocTemp = le16_to_cpu(smart_log.temp_sensor[1]);
- SocTemp = SocTemp ? SocTemp - 273 : 0;
- if(strcmp(cfg.output_format,"json"))
- {
- printf("%-20s : %u C\n", "Current Temperature", temperature);
- printf("%-20s : %u C\n", "Current PCB Temperature", PcbTemp);
- printf("%-20s : %u C\n", "Current SOC Temperature", SocTemp);
- }
- }
+ if (!err) {
+ temperature = ((smart_log.temperature[1] << 8) | smart_log.temperature[0]);
+ temperature = temperature ? temperature - 273 : 0;
+ PcbTemp = le16_to_cpu(smart_log.temp_sensor[0]);
+ PcbTemp = PcbTemp ? PcbTemp - 273 : 0;
+ SocTemp = le16_to_cpu(smart_log.temp_sensor[1]);
+ SocTemp = SocTemp ? SocTemp - 273 : 0;
+ if (strcmp(cfg.output_format,"json")) {
+ printf("%-20s : %u C\n", "Current Temperature", temperature);
+ printf("%-20s : %u C\n", "Current PCB Temperature", PcbTemp);
+ printf("%-20s : %u C\n", "Current SOC Temperature", SocTemp);
+ }
+ }
// STEP-2 : Get Max temperature form Ext SMART-id 194
- err = nvme_get_log(fd, 1, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
- if (!err)
- {
- for(index =0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++)
- {
- if(ExtdSMARTInfo.vendorData[index].AttributeNumber == VS_ATTR_ID_MAX_LIFE_TEMPERATURE)
- {
- maxTemperature = smart_attribute_vs(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index]);
- maxTemperature = maxTemperature ? maxTemperature - 273 : 0;
- if(strcmp(cfg.output_format,"json"))
- {
- printf("%-20s : %d C\n", "Highest Temperature", (unsigned int)maxTemperature);
- }
- }
-
- if(ExtdSMARTInfo.vendorData[index].AttributeNumber == VS_ATTR_ID_MAX_SOC_LIFE_TEMPERATURE)
- {
- MaxSocTemp = smart_attribute_vs(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index]);
- MaxSocTemp = MaxSocTemp ? MaxSocTemp - 273 : 0;
- if(strcmp(cfg.output_format,"json"))
- {
- printf("%-20s : %d C\n", "Max SOC Temperature", (unsigned int)MaxSocTemp);
- }
- }
+ err = nvme_get_log(fd, 1, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
+ if (!err) {
+ for(index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++) {
+ if (ExtdSMARTInfo.vendorData[index].AttributeNumber == VS_ATTR_ID_MAX_LIFE_TEMPERATURE) {
+ maxTemperature = smart_attribute_vs(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index]);
+ maxTemperature = maxTemperature ? maxTemperature - 273 : 0;
+ if (strcmp(cfg.output_format,"json"))
+ printf("%-20s : %d C\n", "Highest Temperature", (unsigned int)maxTemperature);
+ }
+
+ if (ExtdSMARTInfo.vendorData[index].AttributeNumber == VS_ATTR_ID_MAX_SOC_LIFE_TEMPERATURE) {
+ MaxSocTemp = smart_attribute_vs(ExtdSMARTInfo.Version, ExtdSMARTInfo.vendorData[index]);
+ MaxSocTemp = MaxSocTemp ? MaxSocTemp - 273 : 0;
+ if (strcmp(cfg.output_format,"json"))
+ printf("%-20s : %d C\n", "Max SOC Temperature", (unsigned int)MaxSocTemp);
+ }
}
}
else if (err > 0)
fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
+ nvme_status_to_string(err), err);
- cf_err = nvme_get_log(fd, 1, 0xCF, sizeof(ExtdSMARTInfo), &logPageCF);
+ cf_err = nvme_get_log(fd, 1, 0xCF, sizeof(ExtdSMARTInfo), &logPageCF);
- if(!cf_err) {
- scCurrentTemp = logPageCF.AttrCF.SuperCapCurrentTemperature;
- scCurrentTemp = scCurrentTemp ? scCurrentTemp - 273 : 0;
- printf("%-20s : %d C\n", "Super-cap Current Temperature", scCurrentTemp);
+ if(!cf_err) {
+ scCurrentTemp = logPageCF.AttrCF.SuperCapCurrentTemperature;
+ scCurrentTemp = scCurrentTemp ? scCurrentTemp - 273 : 0;
+ printf("%-20s : %d C\n", "Super-cap Current Temperature", scCurrentTemp);
- scMaxTemp = logPageCF.AttrCF.SuperCapMaximumTemperature;
- scMaxTemp = scMaxTemp ? scMaxTemp - 273 : 0;
- printf("%-20s : %d C\n", "Super-cap Max Temperature", scMaxTemp);
- }
+ scMaxTemp = logPageCF.AttrCF.SuperCapMaximumTemperature;
+ scMaxTemp = scMaxTemp ? scMaxTemp - 273 : 0;
+ printf("%-20s : %d C\n", "Super-cap Max Temperature", scMaxTemp);
+ }
if(!strcmp(cfg.output_format,"json"))
json_temp_stats(temperature, PcbTemp, SocTemp, maxTemperature, MaxSocTemp, cf_err, scCurrentTemp, scMaxTemp);
- return err;
-}
+ return err;
+}
//EOF Temperature Stats information
/***************************************
-* PCIe error-log information
-***************************************/
+ * PCIe error-log information
+ ***************************************/
void print_vs_pcie_error_log(pcie_error_log_page pcieErrorLog)
{
__u32 correctPcieEc = 0;
__u32 uncorrectPcieEc = 0;
- correctPcieEc = pcieErrorLog.BadDllpErrCnt + pcieErrorLog.BadTlpErrCnt
- + pcieErrorLog.RcvrErrCnt + pcieErrorLog.ReplayTOErrCnt
- + pcieErrorLog.ReplayNumRolloverErrCnt;
-
- uncorrectPcieEc = pcieErrorLog.FCProtocolErrCnt + pcieErrorLog.DllpProtocolErrCnt
- + pcieErrorLog.CmpltnTOErrCnt + pcieErrorLog.RcvrQOverflowErrCnt
- + pcieErrorLog.UnexpectedCplTlpErrCnt + pcieErrorLog.CplTlpURErrCnt
- + pcieErrorLog.CplTlpCAErrCnt + pcieErrorLog.ReqCAErrCnt
- + pcieErrorLog.ReqURErrCnt + pcieErrorLog.EcrcErrCnt
- + pcieErrorLog.MalformedTlpErrCnt + pcieErrorLog.CplTlpPoisonedErrCnt
- + pcieErrorLog.MemRdTlpPoisonedErrCnt;
+ correctPcieEc = pcieErrorLog.BadDllpErrCnt + pcieErrorLog.BadTlpErrCnt
+ + pcieErrorLog.RcvrErrCnt + pcieErrorLog.ReplayTOErrCnt
+ + pcieErrorLog.ReplayNumRolloverErrCnt;
+
+ uncorrectPcieEc = pcieErrorLog.FCProtocolErrCnt + pcieErrorLog.DllpProtocolErrCnt
+ + pcieErrorLog.CmpltnTOErrCnt + pcieErrorLog.RcvrQOverflowErrCnt
+ + pcieErrorLog.UnexpectedCplTlpErrCnt + pcieErrorLog.CplTlpURErrCnt
+ + pcieErrorLog.CplTlpCAErrCnt + pcieErrorLog.ReqCAErrCnt
+ + pcieErrorLog.ReqURErrCnt + pcieErrorLog.EcrcErrCnt
+ + pcieErrorLog.MalformedTlpErrCnt + pcieErrorLog.CplTlpPoisonedErrCnt
+ + pcieErrorLog.MemRdTlpPoisonedErrCnt;
printf("%-45s : %u\n", "PCIe Correctable Error Count", correctPcieEc);
- printf("%-45s : %u\n", "PCIe Un-Correctable Error Count", uncorrectPcieEc);
+ printf("%-45s : %u\n", "PCIe Un-Correctable Error Count", uncorrectPcieEc);
printf("%-45s : %u\n", "Unsupported Request Error Status (URES)", pcieErrorLog.ReqURErrCnt);
printf("%-45s : %u\n", "ECRC Error Status (ECRCES)", pcieErrorLog.EcrcErrCnt);
printf("%-45s : %u\n", "Malformed TLP Status (MTS)", pcieErrorLog.MalformedTlpErrCnt);
@@ -996,117 +948,115 @@ void print_vs_pcie_error_log(pcie_error_log_page pcieErrorLog)
void json_vs_pcie_error_log(pcie_error_log_page pcieErrorLog)
{
struct json_object *root;
- root = json_create_object();
- __u32 correctPcieEc = 0;
- __u32 uncorrectPcieEc = 0;
- correctPcieEc = pcieErrorLog.BadDllpErrCnt + pcieErrorLog.BadTlpErrCnt
- + pcieErrorLog.RcvrErrCnt + pcieErrorLog.ReplayTOErrCnt
- + pcieErrorLog.ReplayNumRolloverErrCnt;
-
- uncorrectPcieEc = pcieErrorLog.FCProtocolErrCnt + pcieErrorLog.DllpProtocolErrCnt
- + pcieErrorLog.CmpltnTOErrCnt + pcieErrorLog.RcvrQOverflowErrCnt
- + pcieErrorLog.UnexpectedCplTlpErrCnt + pcieErrorLog.CplTlpURErrCnt
- + pcieErrorLog.CplTlpCAErrCnt + pcieErrorLog.ReqCAErrCnt
- + pcieErrorLog.ReqURErrCnt + pcieErrorLog.EcrcErrCnt
- + pcieErrorLog.MalformedTlpErrCnt + pcieErrorLog.CplTlpPoisonedErrCnt
- + pcieErrorLog.MemRdTlpPoisonedErrCnt;
+ root = json_create_object();
+ __u32 correctPcieEc = 0;
+ __u32 uncorrectPcieEc = 0;
+ correctPcieEc = pcieErrorLog.BadDllpErrCnt + pcieErrorLog.BadTlpErrCnt
+ + pcieErrorLog.RcvrErrCnt + pcieErrorLog.ReplayTOErrCnt
+ + pcieErrorLog.ReplayNumRolloverErrCnt;
+
+ uncorrectPcieEc = pcieErrorLog.FCProtocolErrCnt + pcieErrorLog.DllpProtocolErrCnt
+ + pcieErrorLog.CmpltnTOErrCnt + pcieErrorLog.RcvrQOverflowErrCnt
+ + pcieErrorLog.UnexpectedCplTlpErrCnt + pcieErrorLog.CplTlpURErrCnt
+ + pcieErrorLog.CplTlpCAErrCnt + pcieErrorLog.ReqCAErrCnt
+ + pcieErrorLog.ReqURErrCnt + pcieErrorLog.EcrcErrCnt
+ + pcieErrorLog.MalformedTlpErrCnt + pcieErrorLog.CplTlpPoisonedErrCnt
+ + pcieErrorLog.MemRdTlpPoisonedErrCnt;
json_object_add_value_int(root, "PCIe Correctable Error Count", correctPcieEc);
json_object_add_value_int(root, "PCIe Un-Correctable Error Count", uncorrectPcieEc);
json_object_add_value_int(root, "Unsupported Request Error Status (URES)", pcieErrorLog.ReqURErrCnt);
- json_object_add_value_int(root, "ECRC Error Status (ECRCES)", pcieErrorLog.EcrcErrCnt);
- json_object_add_value_int(root, "Malformed TLP Status (MTS)", pcieErrorLog.MalformedTlpErrCnt);
- json_object_add_value_int(root, "Receiver Overflow Status (ROS)", pcieErrorLog.RcvrQOverflowErrCnt);
- json_object_add_value_int(root, "Unexpected Completion Status(UCS)", pcieErrorLog.UnexpectedCplTlpErrCnt);
- json_object_add_value_int(root, "Completion Timeout Status (CTS)", pcieErrorLog.CmpltnTOErrCnt);
- json_object_add_value_int(root, "Flow Control Protocol Error Status (FCPES)", pcieErrorLog.FCProtocolErrCnt);
- json_object_add_value_int(root, "Poisoned TLP Status (PTS)", pcieErrorLog.MemRdTlpPoisonedErrCnt);
- json_object_add_value_int(root, "Data Link Protocol Error Status(DLPES)", pcieErrorLog.DllpProtocolErrCnt);
- json_object_add_value_int(root, "Replay Timer Timeout Status(RTS)", pcieErrorLog.ReplayTOErrCnt);
- json_object_add_value_int(root, "Replay_NUM Rollover Status(RRS)", pcieErrorLog.ReplayNumRolloverErrCnt);
- json_object_add_value_int(root, "Bad DLLP Status (BDS)", pcieErrorLog.BadDllpErrCnt);
- json_object_add_value_int(root, "Bad TLP Status (BTS)", pcieErrorLog.BadTlpErrCnt);
- json_object_add_value_int(root, "Receiver Error Status (RES)", pcieErrorLog.RcvrErrCnt);
- json_object_add_value_int(root, "Cpl TLP Unsupported Request Error Count", pcieErrorLog.CplTlpURErrCnt);
- json_object_add_value_int(root, "Cpl TLP Completion Abort Error Count", pcieErrorLog.CplTlpCAErrCnt);
- json_object_add_value_int(root, "Cpl TLP Poisoned Error Count", pcieErrorLog.CplTlpPoisonedErrCnt);
- json_object_add_value_int(root, "Request Completion Abort Error Count", pcieErrorLog.ReqCAErrCnt);
+ json_object_add_value_int(root, "ECRC Error Status (ECRCES)", pcieErrorLog.EcrcErrCnt);
+ json_object_add_value_int(root, "Malformed TLP Status (MTS)", pcieErrorLog.MalformedTlpErrCnt);
+ json_object_add_value_int(root, "Receiver Overflow Status (ROS)", pcieErrorLog.RcvrQOverflowErrCnt);
+ json_object_add_value_int(root, "Unexpected Completion Status(UCS)", pcieErrorLog.UnexpectedCplTlpErrCnt);
+ json_object_add_value_int(root, "Completion Timeout Status (CTS)", pcieErrorLog.CmpltnTOErrCnt);
+ json_object_add_value_int(root, "Flow Control Protocol Error Status (FCPES)", pcieErrorLog.FCProtocolErrCnt);
+ json_object_add_value_int(root, "Poisoned TLP Status (PTS)", pcieErrorLog.MemRdTlpPoisonedErrCnt);
+ json_object_add_value_int(root, "Data Link Protocol Error Status(DLPES)", pcieErrorLog.DllpProtocolErrCnt);
+ json_object_add_value_int(root, "Replay Timer Timeout Status(RTS)", pcieErrorLog.ReplayTOErrCnt);
+ json_object_add_value_int(root, "Replay_NUM Rollover Status(RRS)", pcieErrorLog.ReplayNumRolloverErrCnt);
+ json_object_add_value_int(root, "Bad DLLP Status (BDS)", pcieErrorLog.BadDllpErrCnt);
+ json_object_add_value_int(root, "Bad TLP Status (BTS)", pcieErrorLog.BadTlpErrCnt);
+ json_object_add_value_int(root, "Receiver Error Status (RES)", pcieErrorLog.RcvrErrCnt);
+ json_object_add_value_int(root, "Cpl TLP Unsupported Request Error Count", pcieErrorLog.CplTlpURErrCnt);
+ json_object_add_value_int(root, "Cpl TLP Completion Abort Error Count", pcieErrorLog.CplTlpCAErrCnt);
+ json_object_add_value_int(root, "Cpl TLP Poisoned Error Count", pcieErrorLog.CplTlpPoisonedErrCnt);
+ json_object_add_value_int(root, "Request Completion Abort Error Count", pcieErrorLog.ReqCAErrCnt);
json_print_object(root, NULL);
- printf("\n");
+ printf("\n");
}
static int vs_pcie_error_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- pcie_error_log_page pcieErrorLog;
- int fd;
-
- const char *desc = "Retrieve Seagate PCIe error counters for the given device ";
- const char *output_format = "output in binary format";
- int err;
- struct config {
- char *output_format;
- };
-
- struct config cfg = {
- .output_format = "normal",
- };
-
- const struct argconfig_commandline_options command_line_options[] = {
- {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
- {0}
- };
-
- fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- if(strcmp(cfg.output_format,"json"))
- printf("Seagate PCIe error counters Information :\n");
-
- err = nvme_get_log(fd, 1, 0xCB, sizeof(pcieErrorLog), &pcieErrorLog);
- if (!err) {
- if(strcmp(cfg.output_format,"json")) {
- print_vs_pcie_error_log(pcieErrorLog);
- }
- else
- json_vs_pcie_error_log(pcieErrorLog);
-
- }
- else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(err), err);
-
- return err;
+ pcie_error_log_page pcieErrorLog;
+ int fd;
+
+ const char *desc = "Retrieve Seagate PCIe error counters for the given device ";
+ const char *output_format = "output in binary format";
+ int err;
+ struct config {
+ char *output_format;
+ };
+
+ struct config cfg = {
+ .output_format = "normal",
+ };
+
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"output-format", 'o', "FMT", CFG_STRING, &cfg.output_format, required_argument, output_format },
+ {0}
+ };
+
+ fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
+ if(strcmp(cfg.output_format,"json"))
+ printf("Seagate PCIe error counters Information :\n");
+
+ err = nvme_get_log(fd, 1, 0xCB, sizeof(pcieErrorLog), &pcieErrorLog);
+ if (!err) {
+ if(strcmp(cfg.output_format,"json")) {
+ print_vs_pcie_error_log(pcieErrorLog);
+ } else
+ json_vs_pcie_error_log(pcieErrorLog);
+
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(err), err);
+
+ return err;
}
//EOF PCIE error-log information
static int vs_clr_pcie_correctable_errs(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- const char *desc = "Clear Seagate PCIe Correctable counters for the given device ";
- const char *save = "specifies that the controller shall save the attribute";
- int err, fd;
- __u32 result;
- void *buf = NULL;
+ const char *desc = "Clear Seagate PCIe Correctable counters for the given device ";
+ const char *save = "specifies that the controller shall save the attribute";
+ int err, fd;
+ __u32 result;
+ void *buf = NULL;
- struct config {
- int save;
- };
+ struct config {
+ int save;
+ };
- struct config cfg = {
- .save = 0,
- };
+ struct config cfg = {
+ .save = 0,
+ };
- const struct argconfig_commandline_options command_line_options[] = {
- {"save", 's', "FLAG", CFG_NONE, &cfg.save, no_argument, save},
- {NULL}
- };
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"save", 's', "FLAG", CFG_NONE, &cfg.save, no_argument, save},
+ {NULL}
+ };
- fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
+ fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- err = nvme_set_feature(fd, 0, 0xE1, 0xCB, 0, cfg.save, 0, buf, &result);
+ err = nvme_set_feature(fd, 0, 0xE1, 0xCB, 0, cfg.save, 0, buf, &result);
- if (err < 0) {
- perror("set-feature");
- return errno;
- }
+ if (err < 0) {
+ perror("set-feature");
+ return errno;
+ }
- return err;
+ return err;
}
@@ -1123,361 +1073,347 @@ int nvme_get_log_with_offset(int fd, __u32 nsid, __u16 log_id, __u32 data_len, _
cmd.cdw10 = log_id | (numdl << 16);
cmd.cdw11 = numdu;
- cmd.cdw12 = (__u32)(offset & 0xffffffff);
- cmd.cdw13 = (__u32)((offset >> 32) & 0xffffffff);
+ cmd.cdw12 = (__u32)(offset & 0xffffffff);
+ cmd.cdw13 = (__u32)((offset >> 32) & 0xffffffff);
- /***************************************************************************
+ /***************************************************************************
printf("nvme_get_log_with_offset Parameter Details - \n");
printf("data_len : %d cdw10 : %x cdw11 : %x cdw12 : %x cdw13 : %x\n", cmd.data_len, cmd.cdw10, cmd.cdw11, cmd.cdw12, cmd.cdw13);
- ***************************************************************************/
- return nvme_passthru_admin(fd, cmd.opcode, 0, 0,
- cmd.nsid, 0, 0,
- cmd.cdw10, cmd.cdw11, cmd.cdw12,
- cmd.cdw13, 0, 0,
- cmd.data_len, data, 0,
- NULL, 100);
+ ***************************************************************************/
+ return nvme_passthru_admin(fd, cmd.opcode, 0, 0,
+ cmd.nsid, 0, 0,
+ cmd.cdw10, cmd.cdw11, cmd.cdw12,
+ cmd.cdw13, 0, 0,
+ cmd.data_len, data, 0,
+ NULL, 100);
}
static int get_host_tele(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- const char *desc = "Capture the Telemetry Host-Initiated Data in either "\
- "hex-dump (default) or binary format";
- const char *namespace_id = "desired namespace";
- const char *log_specific = "1 - controller shall capture Data representing the internal "\
- "state of the controller at the time the command is processed. "\
- "0 - controller shall not update the Telemetry Host Initiated Data.";
- const char *raw_binary = "output in raw format";
- int err, fd, dump_fd;
- struct nvme_temetry_log_hdr tele_log;
- __le64 offset = 0;
- int blkCnt, maxBlk = 0, blksToGet;
- unsigned char *log;
-
- struct config {
- __u32 namespace_id;
- __u32 log_id;
- int raw_binary;
- };
-
- struct config cfg = {
- .namespace_id = 0xffffffff,
- .log_id = 0,
- };
-
- const struct argconfig_commandline_options command_line_options[] = {
- {"namespace-id", 'n', "NUM", CFG_POSITIVE, &cfg.namespace_id, required_argument, namespace_id},
- {"log_specific", 'i', "NUM", CFG_POSITIVE, &cfg.log_id, required_argument, log_specific},
- {"raw-binary", 'b', "", CFG_NONE, &cfg.raw_binary, no_argument, raw_binary},
- {NULL}
- };
-
- fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- if (fd < 0)
- return fd;
-
- dump_fd = STDOUT_FILENO;
-
-
- cfg.log_id = (cfg.log_id << 8) | 0x07;
-
- err = nvme_get_log_with_offset(fd, cfg.namespace_id, cfg.log_id, sizeof(tele_log), offset, (void *)(&tele_log));
- if (!err) {
-
- maxBlk = tele_log.tele_data_area3;
- offset += 512;
-
- if (!cfg.raw_binary) {
- printf("Device:%s log-id:%d namespace-id:%#x\n",
- devicename, cfg.log_id,
- cfg.namespace_id);
- printf("Data Block 1 Last Block:%d Data Block 2 Last Block:%d Data Block 3 Last Block:%d\n",
- tele_log.tele_data_area1, tele_log.tele_data_area2, tele_log.tele_data_area3);
-
- d((unsigned char *)(&tele_log), sizeof(tele_log), 16, 1);
- } else
- seaget_d_raw((unsigned char *)(&tele_log), sizeof(tele_log), dump_fd);
- } else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
- else
- perror("log page");
-
- blkCnt = 0;
-
- while(blkCnt < maxBlk)
- {
- blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
-
- if(blksToGet == 0) {
- return err;
- }
-
- log = malloc(blksToGet * 512);
-
- if (!log) {
- fprintf(stderr, "could not alloc buffer for log\n");
- return EINVAL;
- }
-
- memset(log, 0, blksToGet * 512);
-
- err = nvme_get_log_with_offset(fd, cfg.namespace_id, cfg.log_id, blksToGet * 512, offset, (void *)log);
- if (!err) {
- offset += blksToGet * 512;
-
- if (!cfg.raw_binary) {
- printf("\nBlock # :%d to %d\n", blkCnt + 1, blkCnt + blksToGet);
-
- d((unsigned char *)log, blksToGet * 512, 16, 1);
- } else
- seaget_d_raw((unsigned char *)log, blksToGet * 512, dump_fd);
- } else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
- else
- perror("log page");
-
- blkCnt += blksToGet;
-
- free(log);
- }
-
- return err;
-
+ const char *desc = "Capture the Telemetry Host-Initiated Data in either " \
+ "hex-dump (default) or binary format";
+ const char *namespace_id = "desired namespace";
+ const char *log_specific = "1 - controller shall capture Data representing the internal " \
+ "state of the controller at the time the command is processed. " \
+ "0 - controller shall not update the Telemetry Host Initiated Data.";
+ const char *raw_binary = "output in raw format";
+ int err, fd, dump_fd;
+ struct nvme_temetry_log_hdr tele_log;
+ __le64 offset = 0;
+ int blkCnt, maxBlk = 0, blksToGet;
+ unsigned char *log;
+
+ struct config {
+ __u32 namespace_id;
+ __u32 log_id;
+ int raw_binary;
+ };
+
+ struct config cfg = {
+ .namespace_id = 0xffffffff,
+ .log_id = 0,
+ };
+
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"namespace-id", 'n', "NUM", CFG_POSITIVE, &cfg.namespace_id, required_argument, namespace_id},
+ {"log_specific", 'i', "NUM", CFG_POSITIVE, &cfg.log_id, required_argument, log_specific},
+ {"raw-binary", 'b', "", CFG_NONE, &cfg.raw_binary, no_argument, raw_binary},
+ {NULL}
+ };
+
+ fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
+ if (fd < 0)
+ return fd;
+
+ dump_fd = STDOUT_FILENO;
+
+
+ cfg.log_id = (cfg.log_id << 8) | 0x07;
+
+ err = nvme_get_log_with_offset(fd, cfg.namespace_id, cfg.log_id, sizeof(tele_log), offset, (void *)(&tele_log));
+ if (!err) {
+
+ maxBlk = tele_log.tele_data_area3;
+ offset += 512;
+
+ if (!cfg.raw_binary) {
+ printf("Device:%s log-id:%d namespace-id:%#x\n",
+ devicename, cfg.log_id,
+ cfg.namespace_id);
+ printf("Data Block 1 Last Block:%d Data Block 2 Last Block:%d Data Block 3 Last Block:%d\n",
+ tele_log.tele_data_area1, tele_log.tele_data_area2, tele_log.tele_data_area3);
+
+ d((unsigned char *)(&tele_log), sizeof(tele_log), 16, 1);
+ } else
+ seaget_d_raw((unsigned char *)(&tele_log), sizeof(tele_log), dump_fd);
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ else
+ perror("log page");
+
+ blkCnt = 0;
+
+ while(blkCnt < maxBlk) {
+ blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
+
+ if(blksToGet == 0)
+ return err;
+
+ log = malloc(blksToGet * 512);
+
+ if (!log) {
+ fprintf(stderr, "could not alloc buffer for log\n");
+ return EINVAL;
+ }
+
+ memset(log, 0, blksToGet * 512);
+
+ err = nvme_get_log_with_offset(fd, cfg.namespace_id, cfg.log_id, blksToGet * 512, offset, (void *)log);
+ if (!err) {
+ offset += blksToGet * 512;
+
+ if (!cfg.raw_binary) {
+ printf("\nBlock # :%d to %d\n", blkCnt + 1, blkCnt + blksToGet);
+
+ d((unsigned char *)log, blksToGet * 512, 16, 1);
+ } else
+ seaget_d_raw((unsigned char *)log, blksToGet * 512, dump_fd);
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ else
+ perror("log page");
+
+ blkCnt += blksToGet;
+
+ free(log);
+ }
+
+ return err;
+
}
static int get_ctrl_tele(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- const char *desc = "Capture the Telemetry Controller-Initiated Data in either "\
- "hex-dump (default) or binary format";
- const char *namespace_id = "desired namespace";
- const char *raw_binary = "output in raw format";
- int err, fd, dump_fd;
- struct nvme_temetry_log_hdr tele_log;
- __le64 offset = 0;
- __u16 log_id;
- int blkCnt, maxBlk = 0, blksToGet;
- unsigned char *log;
-
- struct config {
- __u32 namespace_id;
- int raw_binary;
- };
-
- struct config cfg = {
- .namespace_id = 0xffffffff,
- };
-
- const struct argconfig_commandline_options command_line_options[] = {
- {"namespace-id", 'n', "NUM", CFG_POSITIVE, &cfg.namespace_id, required_argument, namespace_id},
- {"raw-binary", 'b', "", CFG_NONE, &cfg.raw_binary, no_argument, raw_binary},
- {NULL}
- };
-
- fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- if (fd < 0)
- return fd;
-
- dump_fd = STDOUT_FILENO;
-
- log_id = 0x08;
- err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, sizeof(tele_log), offset, (void *)(&tele_log));
- if (!err) {
-
- maxBlk = tele_log.tele_data_area3;
- offset += 512;
-
- if (!cfg.raw_binary) {
- printf("Device:%s namespace-id:%#x\n",
- devicename, cfg.namespace_id);
- printf("Data Block 1 Last Block:%d Data Block 2 Last Block:%d Data Block 3 Last Block:%d\n",
- tele_log.tele_data_area1, tele_log.tele_data_area2, tele_log.tele_data_area3);
-
- d((unsigned char *)(&tele_log), sizeof(tele_log), 16, 1);
- } else
- seaget_d_raw((unsigned char *)(&tele_log), sizeof(tele_log), dump_fd);
- } else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
- else
- perror("log page");
-
- blkCnt = 0;
-
- while(blkCnt < maxBlk)
- {
- blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
-
- if(blksToGet == 0) {
- return err;
- }
-
- log = malloc(blksToGet * 512);
-
- if (!log) {
- fprintf(stderr, "could not alloc buffer for log\n");
- return EINVAL;
- }
-
- memset(log, 0, blksToGet * 512);
-
- err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, blksToGet * 512, offset, (void *)log);
- if (!err) {
- offset += blksToGet * 512;
-
- if (!cfg.raw_binary) {
- printf("\nBlock # :%d to %d\n", blkCnt + 1, blkCnt + blksToGet);
-
- d((unsigned char *)log, blksToGet * 512, 16, 1);
- } else
- seaget_d_raw((unsigned char *)log, blksToGet * 512, dump_fd);
- } else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
- else
- perror("log page");
-
- blkCnt += blksToGet;
-
- free(log);
- }
- return err;
+ const char *desc = "Capture the Telemetry Controller-Initiated Data in either " \
+ "hex-dump (default) or binary format";
+ const char *namespace_id = "desired namespace";
+ const char *raw_binary = "output in raw format";
+ int err, fd, dump_fd;
+ struct nvme_temetry_log_hdr tele_log;
+ __le64 offset = 0;
+ __u16 log_id;
+ int blkCnt, maxBlk = 0, blksToGet;
+ unsigned char *log;
+
+ struct config {
+ __u32 namespace_id;
+ int raw_binary;
+ };
+
+ struct config cfg = {
+ .namespace_id = 0xffffffff,
+ };
+
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"namespace-id", 'n', "NUM", CFG_POSITIVE, &cfg.namespace_id, required_argument, namespace_id},
+ {"raw-binary", 'b', "", CFG_NONE, &cfg.raw_binary, no_argument, raw_binary},
+ {NULL}
+ };
+
+ fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
+ if (fd < 0)
+ return fd;
+
+ dump_fd = STDOUT_FILENO;
+
+ log_id = 0x08;
+ err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, sizeof(tele_log), offset, (void *)(&tele_log));
+ if (!err) {
+ maxBlk = tele_log.tele_data_area3;
+ offset += 512;
+
+ if (!cfg.raw_binary) {
+ printf("Device:%s namespace-id:%#x\n",
+ devicename, cfg.namespace_id);
+ printf("Data Block 1 Last Block:%d Data Block 2 Last Block:%d Data Block 3 Last Block:%d\n",
+ tele_log.tele_data_area1, tele_log.tele_data_area2, tele_log.tele_data_area3);
+
+ d((unsigned char *)(&tele_log), sizeof(tele_log), 16, 1);
+ } else
+ seaget_d_raw((unsigned char *)(&tele_log), sizeof(tele_log), dump_fd);
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ else
+ perror("log page");
+
+ blkCnt = 0;
+
+ while(blkCnt < maxBlk) {
+ blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
+
+ if(blksToGet == 0)
+ return err;
+
+ log = malloc(blksToGet * 512);
+
+ if (!log) {
+ fprintf(stderr, "could not alloc buffer for log\n");
+ return EINVAL;
+ }
+
+ memset(log, 0, blksToGet * 512);
+
+ err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, blksToGet * 512, offset, (void *)log);
+ if (!err) {
+ offset += blksToGet * 512;
+
+ if (!cfg.raw_binary) {
+ printf("\nBlock # :%d to %d\n", blkCnt + 1, blkCnt + blksToGet);
+
+ d((unsigned char *)log, blksToGet * 512, 16, 1);
+ } else
+ seaget_d_raw((unsigned char *)log, blksToGet * 512, dump_fd);
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ else
+ perror("log page");
+
+ blkCnt += blksToGet;
+
+ free(log);
+ }
+ return err;
}
void seaget_d_raw(unsigned char *buf, int len, int fd)
{
- /*********************
+ /*********************
int i;
fflush(stdout);
for (i = 0; i < len; i++)
putchar(*(buf+i));
- *********************/
-
- if(write(fd, (void *)buf, len) <=0)
- {
- printf("%s: Write Failed\n",__FUNCTION__);
- }
+ *********************/
+ if (write(fd, (void *)buf, len) <= 0)
+ printf("%s: Write Failed\n",__FUNCTION__);
}
static int vs_internal_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
- const char *desc = "Capture the Telemetry Controller-Initiated Data in "\
- "binary format";
- const char *namespace_id = "desired namespace";
-
- const char *file = "dump file";
- int err, fd, dump_fd;
- int flags = O_WRONLY | O_CREAT;
- int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
- struct nvme_temetry_log_hdr tele_log;
- __le64 offset = 0;
- __u16 log_id;
- int blkCnt, maxBlk = 0, blksToGet;
- unsigned char *log;
-
- struct config {
- __u32 namespace_id;
- char *file;
- };
-
- struct config cfg = {
- .namespace_id = 0xffffffff,
- .file = "",
- };
-
- const struct argconfig_commandline_options command_line_options[] = {
- {"namespace-id", 'n', "NUM", CFG_POSITIVE, &cfg.namespace_id, required_argument, namespace_id},
- {"dump-file", 'f', "FILE", CFG_STRING, &cfg.file, required_argument, file},
- {NULL}
- };
-
- fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
- if (fd < 0)
- return fd;
+ const char *desc = "Capture the Telemetry Controller-Initiated Data in " \
+ "binary format";
+ const char *namespace_id = "desired namespace";
+
+ const char *file = "dump file";
+ int err, fd, dump_fd;
+ int flags = O_WRONLY | O_CREAT;
+ int mode = S_IRUSR | S_IWUSR |S_IRGRP | S_IWGRP| S_IROTH;
+ struct nvme_temetry_log_hdr tele_log;
+ __le64 offset = 0;
+ __u16 log_id;
+ int blkCnt, maxBlk = 0, blksToGet;
+ unsigned char *log;
- dump_fd = STDOUT_FILENO;
+ struct config {
+ __u32 namespace_id;
+ char *file;
+ };
- if(strlen(cfg.file)) {
- dump_fd = open(cfg.file, flags, mode);
- if (dump_fd < 0) {
- perror(cfg.file);
- return EINVAL;
- }
- }
+ struct config cfg = {
+ .namespace_id = 0xffffffff,
+ .file = "",
+ };
- log_id = 0x08;
- err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, sizeof(tele_log), offset, (void *)(&tele_log));
- if (!err) {
+ const struct argconfig_commandline_options command_line_options[] = {
+ {"namespace-id", 'n', "NUM", CFG_POSITIVE, &cfg.namespace_id, required_argument, namespace_id},
+ {"dump-file", 'f', "FILE", CFG_STRING, &cfg.file, required_argument, file},
+ {NULL}
+ };
- maxBlk = tele_log.tele_data_area3;
- offset += 512;
+ fd = parse_and_open(argc, argv, desc, command_line_options, &cfg, sizeof(cfg));
+ if (fd < 0)
+ return fd;
- /***************************************************************************
- printf("Data Block 1 Last Block:%d Data Block 2 Last Block:%d Data Block 3 Last Block:%d\n",
- tele_log.tele_data_area1, tele_log.tele_data_area2, tele_log.tele_data_area3);
- ***************************************************************************/
+ dump_fd = STDOUT_FILENO;
- seaget_d_raw((unsigned char *)(&tele_log), sizeof(tele_log), dump_fd);
+ if(strlen(cfg.file)) {
+ dump_fd = open(cfg.file, flags, mode);
+ if (dump_fd < 0) {
+ perror(cfg.file);
+ return EINVAL;
+ }
+ }
- } else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
- else
- perror("log page");
+ log_id = 0x08;
+ err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, sizeof(tele_log), offset, (void *)(&tele_log));
+ if (!err) {
+ maxBlk = tele_log.tele_data_area3;
+ offset += 512;
- blkCnt = 0;
+ /***************************************************************************
+ printf("Data Block 1 Last Block:%d Data Block 2 Last Block:%d Data Block 3 Last Block:%d\n",
+ tele_log.tele_data_area1, tele_log.tele_data_area2, tele_log.tele_data_area3);
+ ***************************************************************************/
- while(blkCnt < maxBlk)
- {
- blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
+ seaget_d_raw((unsigned char *)(&tele_log), sizeof(tele_log), dump_fd);
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ else
+ perror("log page");
- if(blksToGet == 0) {
- return err;
- }
+ blkCnt = 0;
- log = malloc(blksToGet * 512);
+ while(blkCnt < maxBlk) {
+ blksToGet = ((maxBlk - blkCnt) >= TELEMETRY_BLOCKS_TO_READ) ? TELEMETRY_BLOCKS_TO_READ : (maxBlk - blkCnt);
- if (!log) {
- fprintf(stderr, "could not alloc buffer for log\n");
- return EINVAL;
- }
+ if(blksToGet == 0) {
+ return err;
+ }
- memset(log, 0, blksToGet * 512);
+ log = malloc(blksToGet * 512);
- err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, blksToGet * 512, offset, (void *)log);
- if (!err) {
- offset += blksToGet * 512;
+ if (!log) {
+ fprintf(stderr, "could not alloc buffer for log\n");
+ return EINVAL;
+ }
- seaget_d_raw((unsigned char *)log, blksToGet * 512, dump_fd);
+ memset(log, 0, blksToGet * 512);
- } else if (err > 0)
- fprintf(stderr, "NVMe Status:%s(%x)\n",
- nvme_status_to_string(err), err);
- else
- perror("log page");
+ err = nvme_get_log_with_offset(fd, cfg.namespace_id, log_id, blksToGet * 512, offset, (void *)log);
+ if (!err) {
+ offset += blksToGet * 512;
- blkCnt += blksToGet;
+ seaget_d_raw((unsigned char *)log, blksToGet * 512, dump_fd);
- free(log);
- }
+ } else if (err > 0)
+ fprintf(stderr, "NVMe Status:%s(%x)\n",
+ nvme_status_to_string(err), err);
+ else
+ perror("log page");
- if(strlen(cfg.file)) {
- close(dump_fd);
- }
+ blkCnt += blksToGet;
+ free(log);
+ }
- return err;
+ if(strlen(cfg.file))
+ close(dump_fd);
+ return err;
}
-
//SEAGATE-PLUGIN Version
-int seagate_plugin_version(int argc, char **argv, struct command *cmd, struct plugin *plugin)
+int seagate_plugin_version(int argc, char **argv, struct command *cmd,
+ struct plugin *plugin)
{
- printf("Seagate-Plugin version : %d.%d \n", SEAGATE_PLUGIN_VERSION_MAJOR, SEAGATE_PLUGIN_VERSION_MINOR);
+ printf("Seagate-Plugin version : %d.%d \n", SEAGATE_PLUGIN_VERSION_MAJOR, SEAGATE_PLUGIN_VERSION_MINOR);
return 0;
}
//EOF SEAGATE-PLUGIN Version
--
2.13.7
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 5/6] nvme-cli: Add 'rae' argument to nvme_get_log()
2018-09-20 9:09 [PATCH 0/6] nvme-cli: fixup large log page transfer Hannes Reinecke
` (3 preceding siblings ...)
2018-09-20 9:09 ` [PATCH 4/6] seagate-nvme: fixup coding style Hannes Reinecke
@ 2018-09-20 9:09 ` Hannes Reinecke
2018-09-20 9:09 ` [PATCH 6/6] nvme-cli: kill nvme_passthru_admin() Hannes Reinecke
2018-09-20 15:22 ` [PATCH 0/6] nvme-cli: fixup large log page transfer Keith Busch
6 siblings, 0 replies; 8+ messages in thread
From: Hannes Reinecke @ 2018-09-20 9:09 UTC (permalink / raw)
We should be setting the 'rae' bit when sending a log page; we don't
want to accidentally overwriting any outstanding AENs when calling
nvme-cli.
Signed-off-by: Hannes Reinecke <hare at suse.com>
---
intel-nvme.c | 12 ++++++++----
memblaze-nvme.c | 3 ++-
nvme-ioctl.c | 27 +++++++++++++++++----------
nvme-ioctl.h | 3 ++-
seagate-nvme.c | 12 ++++++------
toshiba-nvme.c | 2 +-
wdc-nvme.c | 10 +++++-----
7 files changed, 41 insertions(+), 28 deletions(-)
diff --git a/intel-nvme.c b/intel-nvme.c
index 67b8003..e65ed4a 100644
--- a/intel-nvme.c
+++ b/intel-nvme.c
@@ -254,7 +254,8 @@ static int get_additional_smart_log(int argc, char **argv, struct command *cmd,
if (fd < 0)
return fd;
- err = nvme_get_log(fd, cfg.namespace_id, 0xca, sizeof(smart_log), &smart_log);
+ err = nvme_get_log(fd, cfg.namespace_id, 0xca, false,
+ sizeof(smart_log), &smart_log);
if (!err) {
if (cfg.json)
show_intel_smart_log_jsn(&smart_log, cfg.namespace_id, devicename);
@@ -292,7 +293,8 @@ static int get_market_log(int argc, char **argv, struct command *cmd, struct plu
if (fd < 0)
return fd;
- err = nvme_get_log(fd, NVME_NSID_ALL, 0xdd, sizeof(log), log);
+ err = nvme_get_log(fd, NVME_NSID_ALL, 0xdd, false,
+ sizeof(log), log);
if (!err) {
if (!cfg.raw_binary)
printf("Intel Marketing Name Log:\n%s\n", log);
@@ -354,7 +356,8 @@ static int get_temp_stats_log(int argc, char **argv, struct command *cmd, struct
if (fd < 0)
return fd;
- err = nvme_get_log(fd, NVME_NSID_ALL, 0xc5, sizeof(stats), &stats);
+ err = nvme_get_log(fd, NVME_NSID_ALL, 0xc5, false,
+ sizeof(stats), &stats);
if (!err) {
if (!cfg.raw_binary)
show_temp_stats(&stats);
@@ -422,7 +425,8 @@ static int get_lat_stats_log(int argc, char **argv, struct command *cmd, struct
if (fd < 0)
return fd;
- err = nvme_get_log(fd, NVME_NSID_ALL, cfg.write ? 0xc2 : 0xc1, sizeof(stats), &stats);
+ err = nvme_get_log(fd, NVME_NSID_ALL, cfg.write ? 0xc2 : 0xc1,
+ false, sizeof(stats), &stats);
if (!err) {
if (!cfg.raw_binary)
show_lat_stats(&stats, cfg.write);
diff --git a/memblaze-nvme.c b/memblaze-nvme.c
index a5a74d3..471f31c 100644
--- a/memblaze-nvme.c
+++ b/memblaze-nvme.c
@@ -225,7 +225,8 @@ static int get_additional_smart_log(int argc, char **argv, struct command *cmd,
if (fd < 0)
return fd;
- err = nvme_get_log(fd, cfg.namespace_id, 0xca, sizeof(smart_log), &smart_log);
+ err = nvme_get_log(fd, cfg.namespace_id, 0xca, false,
+ sizeof(smart_log), &smart_log);
if (!err) {
if (!cfg.raw_binary)
err = show_memblaze_smart_log(fd, cfg.namespace_id, devicename, &smart_log);
diff --git a/nvme-ioctl.c b/nvme-ioctl.c
index b168699..dc9aad8 100644
--- a/nvme-ioctl.c
+++ b/nvme-ioctl.c
@@ -419,7 +419,8 @@ int nvme_get_log13(int fd, __u32 nsid, __u8 log_id, __u8 lsp, __u64 lpo,
}
-int nvme_get_log(int fd, __u32 nsid, __u8 log_id, __u32 data_len, void *data)
+int nvme_get_log(int fd, __u32 nsid, __u8 log_id, bool rae,
+ __u32 data_len, void *data)
{
void *ptr = data;
__u32 offset = 0, xfer_len = data_len;
@@ -436,7 +437,7 @@ int nvme_get_log(int fd, __u32 nsid, __u8 log_id, __u32 data_len, void *data)
xfer_len = 4096;
ret = nvme_get_log13(fd, nsid, log_id, NVME_NO_LOG_LSP,
- offset, 0, false, xfer_len, ptr);
+ offset, 0, rae, xfer_len, ptr);
if (ret)
return ret;
@@ -466,18 +467,21 @@ int nvme_get_telemetry_log(int fd, void *lp, int generate_report,
int nvme_fw_log(int fd, struct nvme_firmware_log_page *fw_log)
{
- return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_FW_SLOT, sizeof(*fw_log), fw_log);
+ return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_FW_SLOT, true,
+ sizeof(*fw_log), fw_log);
}
int nvme_changed_ns_list_log(int fd, struct nvme_changed_ns_list_log *changed_ns_list_log)
{
- return nvme_get_log(fd, 0, NVME_LOG_CHANGED_NS, sizeof(changed_ns_list_log->log),
+ return nvme_get_log(fd, 0, NVME_LOG_CHANGED_NS, true,
+ sizeof(changed_ns_list_log->log),
changed_ns_list_log->log);
}
int nvme_error_log(int fd, int entries, struct nvme_error_log_page *err_log)
{
- return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_ERROR, entries * sizeof(*err_log), err_log);
+ return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_ERROR, false,
+ entries * sizeof(*err_log), err_log);
}
int nvme_endurance_log(int fd, __u16 group_id, struct nvme_endurance_group_log *endurance_log)
@@ -488,7 +492,8 @@ int nvme_endurance_log(int fd, __u16 group_id, struct nvme_endurance_group_log *
int nvme_smart_log(int fd, __u32 nsid, struct nvme_smart_log *smart_log)
{
- return nvme_get_log(fd, nsid, NVME_LOG_SMART, sizeof(*smart_log), smart_log);
+ return nvme_get_log(fd, nsid, NVME_LOG_SMART, false,
+ sizeof(*smart_log), smart_log);
}
int nvme_ana_log(int fd, void *ana_log, size_t ana_log_len, int rgo)
@@ -501,23 +506,25 @@ int nvme_ana_log(int fd, void *ana_log, size_t ana_log_len, int rgo)
int nvme_self_test_log(int fd, struct nvme_self_test_log *self_test_log)
{
- return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_DEVICE_SELF_TEST,
+ return nvme_get_log(fd, NVME_NSID_ALL, NVME_LOG_DEVICE_SELF_TEST, false,
sizeof(*self_test_log), self_test_log);
}
int nvme_effects_log(int fd, struct nvme_effects_log_page *effects_log)
{
- return nvme_get_log(fd, 0, NVME_LOG_CMD_EFFECTS, sizeof(*effects_log), effects_log);
+ return nvme_get_log(fd, 0, NVME_LOG_CMD_EFFECTS, false,
+ sizeof(*effects_log), effects_log);
}
int nvme_discovery_log(int fd, struct nvmf_disc_rsp_page_hdr *log, __u32 size)
{
- return nvme_get_log(fd, 0, NVME_LOG_DISC, size, log);
+ return nvme_get_log(fd, 0, NVME_LOG_DISC, true, size, log);
}
int nvme_sanitize_log(int fd, struct nvme_sanitize_log_page *sanitize_log)
{
- return nvme_get_log(fd, 0, NVME_LOG_SANITIZE, sizeof(*sanitize_log), sanitize_log);
+ return nvme_get_log(fd, 0, NVME_LOG_SANITIZE, false,
+ sizeof(*sanitize_log), sanitize_log);
}
int nvme_feature(int fd, __u8 opcode, __u32 nsid, __u32 cdw10, __u32 cdw11,
diff --git a/nvme-ioctl.h b/nvme-ioctl.h
index d3823a4..b6abade 100644
--- a/nvme-ioctl.h
+++ b/nvme-ioctl.h
@@ -82,7 +82,8 @@ int nvme_identify_ns_descs(int fd, __u32 nsid, void *data);
int nvme_identify_nvmset(int fd, __u16 nvmset_id, void *data);
int nvme_get_log13(int fd, __u32 nsid, __u8 log_id, __u8 lsp, __u64 lpo,
__u16 group_id, bool rae, __u32 data_len, void *data);
-int nvme_get_log(int fd, __u32 nsid, __u8 log_id, __u32 data_len, void *data);
+int nvme_get_log(int fd, __u32 nsid, __u8 log_id, bool rae,
+ __u32 data_len, void *data);
int nvme_get_telemetry_log(int fd, void *lp, int generate_report,
diff --git a/seagate-nvme.c b/seagate-nvme.c
index 2d8c708..15a91ef 100755
--- a/seagate-nvme.c
+++ b/seagate-nvme.c
@@ -180,7 +180,7 @@ static int log_pages_supp(int argc, char **argv, struct command *cmd,
fd = parse_and_open(argc, argv, desc, command_line_options,
&cfg, sizeof(cfg));
- err = nvme_get_log(fd, 1, 0xc5, sizeof(logPageMap), &logPageMap);
+ err = nvme_get_log(fd, 1, 0xc5, false, sizeof(logPageMap), &logPageMap);
if (!err) {
if (strcmp(cfg.output_format,"json")) {
printf ("Seagate Supported Log-pages count :%d\n",
@@ -743,7 +743,7 @@ static int vs_smart_log(int argc, char **argv, struct command *cmd, struct plugi
if (strcmp(cfg.output_format,"json"))
printf("Seagate Extended SMART Information :\n");
- err = nvme_get_log(fd, 1, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
+ err = nvme_get_log(fd, 1, 0xC4, false, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
if (!err) {
if (strcmp(cfg.output_format,"json")) {
printf("%-39s %-15s %-19s \n", "Description", "Ext-Smart-Id", "Ext-Smart-Value");
@@ -765,7 +765,7 @@ static int vs_smart_log(int argc, char **argv, struct command *cmd, struct plugi
* Next get Log Page 0xCF
*/
- err = nvme_get_log(fd, 1, 0xCF, sizeof(logPageCF), &logPageCF);
+ err = nvme_get_log(fd, 1, 0xCF, false, sizeof(logPageCF), &logPageCF);
if (!err) {
if(strcmp(cfg.output_format,"json")) {
/*printf("Seagate DRAM Supercap SMART Attributes :\n");*/
@@ -861,7 +861,7 @@ static int temp_stats(int argc, char **argv, struct command *cmd, struct plugin
}
// STEP-2 : Get Max temperature form Ext SMART-id 194
- err = nvme_get_log(fd, 1, 0xC4, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
+ err = nvme_get_log(fd, 1, 0xC4, false, sizeof(ExtdSMARTInfo), &ExtdSMARTInfo);
if (!err) {
for(index = 0; index < NUMBER_EXTENDED_SMART_ATTRIBUTES; index++) {
if (ExtdSMARTInfo.vendorData[index].AttributeNumber == VS_ATTR_ID_MAX_LIFE_TEMPERATURE) {
@@ -883,7 +883,7 @@ static int temp_stats(int argc, char **argv, struct command *cmd, struct plugin
fprintf(stderr, "NVMe Status:%s(%x)\n",
nvme_status_to_string(err), err);
- cf_err = nvme_get_log(fd, 1, 0xCF, sizeof(ExtdSMARTInfo), &logPageCF);
+ cf_err = nvme_get_log(fd, 1, 0xCF, false, sizeof(ExtdSMARTInfo), &logPageCF);
if(!cf_err) {
scCurrentTemp = logPageCF.AttrCF.SuperCapCurrentTemperature;
@@ -1012,7 +1012,7 @@ static int vs_pcie_error_log(int argc, char **argv, struct command *cmd, struct
if(strcmp(cfg.output_format,"json"))
printf("Seagate PCIe error counters Information :\n");
- err = nvme_get_log(fd, 1, 0xCB, sizeof(pcieErrorLog), &pcieErrorLog);
+ err = nvme_get_log(fd, 1, 0xCB, false, sizeof(pcieErrorLog), &pcieErrorLog);
if (!err) {
if(strcmp(cfg.output_format,"json")) {
print_vs_pcie_error_log(pcieErrorLog);
diff --git a/toshiba-nvme.c b/toshiba-nvme.c
index d90650b..116c8a0 100644
--- a/toshiba-nvme.c
+++ b/toshiba-nvme.c
@@ -367,7 +367,7 @@ static int nvme_get_vendor_log(int fd, __u32 namespace_id, int log_page, const c
if (err) {
goto end;
}
- err = nvme_get_log(fd, namespace_id, log_page,
+ err = nvme_get_log(fd, namespace_id, log_page, false,
log_len, log);
if (err) {
fprintf(stderr, "%s: couldn't get log 0x%x\n", __func__, log_page);
diff --git a/wdc-nvme.c b/wdc-nvme.c
index 5dd1d9d..dd6d34a 100644
--- a/wdc-nvme.c
+++ b/wdc-nvme.c
@@ -603,7 +603,7 @@ static int wdc_nvme_check_supported_log_page(int fd, __u8 log_id)
/* get the log page length */
ret = nvme_get_log(fd, 0xFFFFFFFF, WDC_NVME_GET_AVAILABLE_LOG_PAGES_OPCODE,
- WDC_C2_LOG_BUF_LEN, data);
+ false, WDC_C2_LOG_BUF_LEN, data);
if (ret) {
fprintf(stderr, "ERROR : WDC : Unable to get C2 Log Page length, ret = %d\n", ret);
goto out;
@@ -617,7 +617,7 @@ static int wdc_nvme_check_supported_log_page(int fd, __u8 log_id)
}
ret = nvme_get_log(fd, 0xFFFFFFFF, WDC_NVME_GET_AVAILABLE_LOG_PAGES_OPCODE,
- hdr_ptr->length, data);
+ false, hdr_ptr->length, data);
/* parse the data until the List of log page ID's is found */
if (ret) {
fprintf(stderr, "ERROR : WDC : Unable to read C2 Log Page data, ret = %d\n", ret);
@@ -1371,7 +1371,7 @@ static int wdc_get_ca_log_page(int fd, char *format)
memset(data, 0, sizeof (__u8) * WDC_CA_LOG_BUF_LEN);
ret = nvme_get_log(fd, 0xFFFFFFFF, WDC_NVME_GET_DEVICE_INFO_LOG_OPCODE,
- WDC_CA_LOG_BUF_LEN, data);
+ false, WDC_CA_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret), ret);
@@ -1420,7 +1420,7 @@ static int wdc_get_c1_log_page(int fd, char *format, uint8_t interval)
memset(data, 0, sizeof (__u8) * WDC_ADD_LOG_BUF_LEN);
ret = nvme_get_log(fd, 0x01, WDC_NVME_ADD_LOG_OPCODE,
- WDC_ADD_LOG_BUF_LEN, data);
+ false, WDC_ADD_LOG_BUF_LEN, data);
if (strcmp(format, "json"))
fprintf(stderr, "NVMe Status:%s(%x)\n", nvme_status_to_string(ret), ret);
if (ret == 0) {
@@ -2107,7 +2107,7 @@ static int wdc_do_drive_essentials(int fd, char *dir, char *key)
memset(dataBuffer, 0, dataBufferSize);
ret = nvme_get_log(fd, WDC_DE_GLOBAL_NSID, deVULogPagesList[vuLogIdx].logPageId,
- dataBufferSize, dataBuffer);
+ false, dataBufferSize, dataBuffer);
if (ret) {
fprintf(stderr, "ERROR : WDC : nvme_get_log() for log page 0x%x failed, ret = %d\n",
deVULogPagesList[vuLogIdx].logPageId, ret);
--
2.13.7
^ permalink raw reply related [flat|nested] 8+ messages in thread