nvme/nvme-cli
1
0
Fork 0
Code Issues Activity

Adding upstream version 2.7.1.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-16 12:25:41 +01:00
parent 04338f02fe
commit d6e1a5d456
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
663 changed files with 15529 additions and 6994 deletions
Download patch file Download diff file Expand all files Collapse all files

3
plugins/solidigm/meson.build
View file

@ -8,6 +8,9 @@ sources += [
'plugins/solidigm/solidigm-telemetry.c',
'plugins/solidigm/solidigm-internal-logs.c',
'plugins/solidigm/solidigm-market-log.c',
'plugins/solidigm/solidigm-temp-stats.c',
'plugins/solidigm/solidigm-get-drive-info.c',
'plugins/solidigm/solidigm-ocp-version.c',
]
subdir('solidigm-telemetry')

6
plugins/solidigm/solidigm-garbage-collection.c
View file

@ -68,6 +68,7 @@ static void vu_gc_log_show(struct garbage_control_collection_log *payload, const
int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Get and parse Solidigm vendor specific garbage collection event log.";
enum nvme_print_flags flags;
struct nvme_dev *dev;
int err;
__u8 uuid_index;
@ -89,9 +90,8 @@ int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *c
if (err)
return err;
enum nvme_print_flags flags = validate_output_format(cfg.output_format);
if (flags == -EINVAL) {
err = validate_output_format(cfg.output_format, &flags);
if (err) {
fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
dev_close(dev);
return -EINVAL;

79
plugins/solidigm/solidigm-get-drive-info.c Normal file
View file

@ -0,0 +1,79 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright (c) 2023 Solidigm.
*
* Authors: leonardo.da.cunha@solidigm.com
*/
#include <errno.h>
#include "nvme-print.h"
#include "nvme-wrap.h"
#include "common.h"
int sldgm_get_drive_info(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
_cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
const char *desc = "Get drive HW information";
const char *FTL_unit_size_str = "FTL_unit_size";
char *output_format = "normal";
enum nvme_print_flags flags;
nvme_root_t r;
nvme_ctrl_t c;
nvme_ns_t n;
struct nvme_id_ns ns = { 0 };
__u8 flbaf_inUse;
__u16 lba_size;
__u16 ftl_unit_size;
int err;
OPT_ARGS(opts) = {
OPT_FMT("output-format", 'o', &output_format, "normal|json"),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
err = validate_output_format(output_format, &flags);
if ((err < 0) || !(flags == NORMAL || flags == JSON)) {
nvme_show_error("Invalid output format");
return err;
}
r = nvme_scan(NULL);
c = nvme_scan_ctrl(r, dev->name);
n = c ? nvme_ctrl_first_ns(c) : nvme_scan_namespace(dev->name);
if (!n) {
nvme_show_error("solidigm-vs-drive-info: drive missing namespace");
return -EINVAL;
}
err = nvme_ns_identify(n, &ns);
if (err) {
nvme_show_error("identify namespace: %s", nvme_strerror(errno));
return err;
}
if (!(ns.nsfeat & 0x10)) {
nvme_show_error("solidigm-vs-drive-info: performance options not available");
return -EINVAL;
}
nvme_id_ns_flbas_to_lbaf_inuse(ns.flbas, &flbaf_inUse);
lba_size = 1 << ns.lbaf[flbaf_inUse].ds;
ftl_unit_size = (le16_to_cpu(ns.npwg) + 1) * lba_size / 1024;
if (flags == JSON) {
struct json_object *root = json_create_object();
json_object_add_value_int(root, FTL_unit_size_str, ftl_unit_size);
json_print_object(root, NULL);
printf("\n");
json_free_object(root);
} else {
printf("%s: %d\n", FTL_unit_size_str, ftl_unit_size);
}
return err;
}

8
plugins/solidigm/solidigm-get-drive-info.h Normal file
View file

@ -0,0 +1,8 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (c) 2023 Solidigm.
*
* Author: leonardo.da.cunha@solidigm.com
*/
int sldgm_get_drive_info(int argc, char **argv, struct command *cmd, struct plugin *plugin);

34
plugins/solidigm/solidigm-internal-logs.c
View file

@ -19,6 +19,7 @@
#include "libnvme.h"
#include "plugin.h"
#include "nvme-print.h"
#include "solidigm-util.h"
#define DWORD_SIZE 4
@ -427,7 +428,8 @@ static int dump_telemetry(struct nvme_dev *dev, struct config cfg, enum telemetr
int err = 0, output;
__u8 *buffer = NULL;
size_t bytes_remaining = 0;
int data_area = NVME_TELEMETRY_DA_3;
enum nvme_telemetry_da da;
size_t max_data_tx;
char file_path[PATH_MAX];
char *log_name;
@ -444,6 +446,12 @@ static int dump_telemetry(struct nvme_dev *dev, struct config cfg, enum telemetr
default:
return -EINVAL;
}
err = nvme_get_telemetry_max(dev_fd(dev), &da, &max_data_tx);
if (err)
return err;
if (max_data_tx > DRIVER_MAX_TX_256K)
max_data_tx = DRIVER_MAX_TX_256K;
sprintf(file_path, "%s_%s.bin", cfg.file_prefix, log_name);
output = open(file_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
@ -452,16 +460,16 @@ static int dump_telemetry(struct nvme_dev *dev, struct config cfg, enum telemetr
switch (ttype) {
case HOSTGENNEW:
err = nvme_get_new_host_telemetry(dev_fd(dev), &log,
data_area, &log_size);
err = nvme_get_telemetry_log(dev_fd(dev), true, false, false, max_data_tx, da,
&log, &log_size);
break;
case HOSTGENOLD:
err = nvme_get_host_telemetry(dev_fd(dev), &log,
data_area, &log_size);
err = nvme_get_telemetry_log(dev_fd(dev), false, false, false, max_data_tx, da,
&log, &log_size);
break;
case CONTROLLER:
err = nvme_get_ctrl_telemetry(dev_fd(dev), true, &log,
data_area, &log_size);
err = nvme_get_telemetry_log(dev_fd(dev), false, true, true, max_data_tx, da, &log,
&log_size);
break;
}
@ -546,42 +554,42 @@ int solidigm_get_internal_log(int argc, char **argv, struct command *command,
if (err == 0)
log_count++;
else if (err < 0)
perror("Assert log");
perror("Error retrieving Assert log");
}
if (all || !strcmp(cfg.type, "EVENT")) {
err = dump_event_logs(dev, cfg);
if (err == 0)
log_count++;
else if (err < 0)
perror("Eventt log");
perror("Error retrieving Event log");
}
if (all || !strcmp(cfg.type, "NLOG")) {
err = dump_nlogs(dev, cfg, -1);
if (err == 0)
log_count++;
else if (err < 0)
perror("Nlog");
perror("Error retrieving Nlog");
}
if (all || !strcmp(cfg.type, "CONTROLLERINITTELEMETRY")) {
err = dump_telemetry(dev, cfg, CONTROLLER);
if (err == 0)
log_count++;
else if (err < 0)
perror("Telemetry Controller Initated");
perror("Error retrieving Telemetry Controller Initiated");
}
if (all || !strcmp(cfg.type, "HOSTINITTELEMETRYNOGEN")) {
err = dump_telemetry(dev, cfg, HOSTGENOLD);
if (err == 0)
log_count++;
else if (err < 0)
perror("Previously existing Telemetry Host Initated");
perror("Error retrieving previously existing Telemetry Host Initiated");
}
if (all || !strcmp(cfg.type, "HOSTINITTELEMETRY")) {
err = dump_telemetry(dev, cfg, HOSTGENNEW);
if (err == 0)
log_count++;
else if (err < 0)
perror("Telemetry Host Initated");
perror("Error retrieving Telemetry Host Initiated");
}
if (log_count == 0) {

4
plugins/solidigm/solidigm-latency-tracking.c
View file

@ -411,8 +411,8 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *cmd
lt.fd = dev_fd(dev);
lt.print_flags = validate_output_format(lt.cfg.output_format);
if (lt.print_flags == -EINVAL) {
err = validate_output_format(lt.cfg.output_format, &lt.print_flags);
if (err < 0) {
fprintf(stderr, "Invalid output format '%s'\n", lt.cfg.output_format);
dev_close(dev);
return -EINVAL;

46
plugins/solidigm/solidigm-log-page-dir.c
View file

@ -100,38 +100,13 @@ static struct lid_dir *get_standard_lids(struct nvme_supported_log_pages *suppor
static struct lid_dir standard_dir = { 0 };
init_lid_dir(&standard_dir);
standard_dir.lid[0x00].str = "Supported Log Pages";
standard_dir.lid[0x01].str = "Error Information";
standard_dir.lid[0x02].str = "SMART / Health Information";
standard_dir.lid[0x03].str = "Firmware Slot Information";
standard_dir.lid[0x04].str = "Changed Namespace List";
standard_dir.lid[0x05].str = "Commands Supported and Effects";
standard_dir.lid[0x06].str = "Device Self Test";
standard_dir.lid[0x07].str = "Telemetry Host-Initiated";
standard_dir.lid[0x08].str = "Telemetry Controller-Initiated";
standard_dir.lid[0x09].str = "Endurance Group Information";
standard_dir.lid[0x0A].str = "Predictable Latency Per NVM Set";
standard_dir.lid[0x0B].str = "Predictable Latency Event Aggregate";
standard_dir.lid[0x0C].str = "Asymmetric Namespace Access";
standard_dir.lid[0x0D].str = "Persistent Event Log";
standard_dir.lid[0x0E].str = "Predictable Latency Event Aggregate";
standard_dir.lid[0x0F].str = "Endurance Group Event Aggregate";
standard_dir.lid[0x10].str = "Media Unit Status";
standard_dir.lid[0x11].str = "Supported Capacity Configuration List";
standard_dir.lid[0x12].str = "Feature Identifiers Supported and Effects";
standard_dir.lid[0x13].str = "NVMe-MI Commands Supported and Effects";
standard_dir.lid[0x14].str = "Command and Feature lockdown";
standard_dir.lid[0x15].str = "Boot Partition";
standard_dir.lid[0x16].str = "Rotational Media Information";
standard_dir.lid[0x70].str = "Discovery";
standard_dir.lid[0x80].str = "Reservation Notification";
standard_dir.lid[0x81].str = "Sanitize Status";
for (int lid = 0; lid < NVME_LOG_SUPPORTED_LOG_PAGES_MAX; lid++) {
if (!supported->lid_support[lid] || lid >= MIN_VENDOR_LID)
continue;
standard_dir.lid[lid].supported = true;
standard_dir.lid[lid].str = nvme_log_to_string(lid);
}
return &standard_dir;
@ -158,6 +133,14 @@ static struct lid_dir *get_solidigm_lids(struct nvme_supported_log_pages *suppor
solidigm_dir.lid[0xC4].str = "Endurance Manager Statistics";
solidigm_dir.lid[0xC5].str = "Temperature Statistics";
solidigm_dir.lid[0xCA].str = "SMART Attributes";
solidigm_dir.lid[0xCB].str = "VU NVMe IO Queue Metrics Log Page";
solidigm_dir.lid[0xDD].str = "VU Marketing Description Log Page";
solidigm_dir.lid[0xEF].str = "Performance Rating and LBA Access Histogram";
solidigm_dir.lid[0xF2].str = "Get Power Usage Log Page";
solidigm_dir.lid[0xF6].str = "Vt Histo Get Log Page";
solidigm_dir.lid[0xF9].str = "Workload Tracker Get Log Page";
solidigm_dir.lid[0xFD].str = "Garbage Control Collection Log Page";
solidigm_dir.lid[0xFE].str = "Latency Outlier Log Page";
update_vendor_lid_supported(supported, &solidigm_dir);
@ -281,15 +264,18 @@ int solidigm_get_log_page_directory_log(int argc, char **argv, struct command *c
}
if (!err) {
const enum nvme_print_flags print_flag = validate_output_format(format);
enum nvme_print_flags print_flag;
err = validate_output_format(format, &print_flag);
if (err < 0) {
fprintf(stderr, "Error: Invalid output format specified: %s.\n", format);
return err;
}
if (print_flag == NORMAL) {
supported_log_pages_normal(lid_dirs);
} else if (print_flag == JSON) {
supported_log_pages_json(lid_dirs);
} else {
fprintf(stderr, "Error: Invalid output format specified: %s.\n", format);
err = -EINVAL;
}
}

27
plugins/solidigm/solidigm-nvme.c
View file

@ -18,8 +18,11 @@
#include "solidigm-telemetry.h"
#include "solidigm-log-page-dir.h"
#include "solidigm-market-log.h"
#include "solidigm-temp-stats.h"
#include "solidigm-get-drive-info.h"
#include "solidigm-ocp-version.h"
#include "plugins/ocp/ocp-clear-fw-update-history.h"
#include "plugins/ocp/ocp-clear-features.h"
#include "plugins/ocp/ocp-smart-extended-log.h"
#include "plugins/ocp/ocp-fw-activation-history.h"
@ -59,6 +62,12 @@ static int clear_fw_update_history(int argc, char **argv, struct command *cmd,
return ocp_clear_fw_update_history(argc, argv, cmd, plugin);
}
static int clear_pcie_correctable_error_counters(int argc, char **argv, struct command *cmd,
struct plugin *plugin)
{
return ocp_clear_pcie_correctable_errors(argc, argv, cmd, plugin);
}
static int smart_cloud(int argc, char **argv, struct command *cmd,
struct plugin *plugin)
{
@ -82,3 +91,19 @@ static int get_market_log(int argc, char **argv, struct command *cmd,
{
return sldgm_get_market_log(argc, argv, cmd, plugin);
}
static int get_temp_stats_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
return sldgm_get_temp_stats_log(argc, argv, cmd, plugin);
}
static int get_drive_info(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
return sldgm_get_drive_info(argc, argv, cmd, plugin);
}
static int get_cloud_SSDplugin_version(int argc, char **argv, struct command *cmd,
struct plugin *plugin)
{
return sldgm_ocp_version(argc, argv, cmd, plugin);
}

6
plugins/solidigm/solidigm-nvme.h
View file

@ -13,7 +13,7 @@
#include "cmd.h"
#define SOLIDIGM_PLUGIN_VERSION "0.14"
#define SOLIDIGM_PLUGIN_VERSION "1.0"
PLUGIN(NAME("solidigm", "Solidigm vendor specific extensions", SOLIDIGM_PLUGIN_VERSION),
COMMAND_LIST(
@ -25,9 +25,13 @@ PLUGIN(NAME("solidigm", "Solidigm vendor specific extensions", SOLIDIGM_PLUGIN_V
ENTRY("market-log", "Retrieve Market Log", get_market_log)
ENTRY("latency-tracking-log", "Enable/Retrieve Latency tracking Log", get_latency_tracking_log)
ENTRY("parse-telemetry-log", "Parse Telemetry Log binary", get_telemetry_log)
ENTRY("clear-pcie-correctable-errors ", "Clear PCIe Correctable Error Counters (redirects to ocp plug-in)", clear_pcie_correctable_error_counters)
ENTRY("clear-fw-activate-history", "Clear firmware update history log (redirects to ocp plug-in)", clear_fw_update_history)
ENTRY("vs-fw-activate-history", "Get firmware activation history log (redirects to ocp plug-in)", fw_activation_history)
ENTRY("log-page-directory", "Retrieve log page directory", get_log_page_directory_log)
ENTRY("temp-stats", "Retrieve Temperature Statistics log", get_temp_stats_log)
ENTRY("vs-drive-info", "Retrieve drive information", get_drive_info)
ENTRY("cloud-SSDplugin-version", "Prints plug-in OCP version", get_cloud_SSDplugin_version)
)
);

25
plugins/solidigm/solidigm-ocp-version.c Normal file
View file

@ -0,0 +1,25 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright (c) 2023 Solidigm.
*
* Author: leonardo.da.cunha@solidigm.com
*/
#include <stdio.h>
#include "nvme.h"
int sldgm_ocp_version(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
const char *desc = "Prints OCP extensions version of Solidigm plugin";
OPT_ARGS(opts) = {
OPT_END()
};
int err = argconfig_parse(argc, argv, desc, opts);
if (!err)
printf("1.0\n");
return err;
}

8
plugins/solidigm/solidigm-ocp-version.h Normal file
View file

@ -0,0 +1,8 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (c) 2023 Solidigm.
*
* Author: leonardo.da.cunha@solidigm.com
*/
int sldgm_ocp_version(int argc, char **argv, struct command *cmd, struct plugin *plugin);

12
plugins/solidigm/solidigm-smart.c
View file

@ -69,15 +69,17 @@ static char *id_to_name(__u8 id)
case 0xE2:
return "media_wear_percentage";
case 0xE3:
return "host_reads";
return "timed_work_load_host_reads";
case 0xE4:
return "timed_work_load";
return "timed_work_load_timer";
case 0xE5:
return "read_commands_in_flight_counter";
case 0xE6:
return "write_commands_in_flight_counter";
case 0xEA:
return "thermal_throttle_status";
case 0xEE:
return "re_sku_count";
case 0xF0:
return "retry_buffer_overflow_counter";
case 0xF3:
@ -220,11 +222,11 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *cmd
if (err)
return err;
flags = validate_output_format(cfg.output_format);
if (flags == -EINVAL) {
err = validate_output_format(cfg.output_format, &flags);
if (err < 0) {
fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
dev_close(dev);
return flags;
return err;
}
uuid_index = solidigm_get_vu_uuid_index(dev);

35
plugins/solidigm/solidigm-telemetry.c
View file

@ -22,6 +22,7 @@
#include "solidigm-telemetry/header.h"
#include "solidigm-telemetry/config.h"
#include "solidigm-telemetry/data-area.h"
#include "solidigm-util.h"
static int read_file2buffer(char *file_name, char **buffer, size_t *length)
{
@ -71,7 +72,7 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *cmd, struc
struct config cfg = {
.host_gen = 1,
.ctrl_init = false,
.data_area = 3,
.data_area = -1,
.cfg_file = NULL,
.is_input_file = false,
};
@ -90,6 +91,10 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *cmd, struc
if (err)
goto ret;
/* When not selected on the command line, get minimum data area required */
if (cfg.data_area == -1)
cfg.data_area = cfg.cfg_file ? 3 : 1;
if (cfg.is_input_file) {
if (optind >= argc) {
err = errno = EINVAL;
@ -138,19 +143,23 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *cmd, struc
}
if (!cfg.is_input_file) {
if (cfg.ctrl_init)
err = nvme_get_ctrl_telemetry(dev_fd(dev), true,
&tl.log, cfg.data_area,
&tl.log_size);
else if (cfg.host_gen)
err = nvme_get_new_host_telemetry(dev_fd(dev), &tl.log,
cfg.data_area,
&tl.log_size);
else
err = nvme_get_host_telemetry(dev_fd(dev), &tl.log,
cfg.data_area,
&tl.log_size);
size_t max_data_tx;
err = nvme_get_telemetry_max(dev_fd(dev), NULL, &max_data_tx);
if (err < 0) {
SOLIDIGM_LOG_WARNING("identify_ctrl: %s",
nvme_strerror(errno));
goto close_fd;
} else if (err > 0) {
nvme_show_status(err);
SOLIDIGM_LOG_WARNING("Failed to acquire identify ctrl %d!", err);
goto close_fd;
}
if (max_data_tx > DRIVER_MAX_TX_256K)
max_data_tx = DRIVER_MAX_TX_256K;
err = nvme_get_telemetry_log(dev_fd(dev), cfg.host_gen, cfg.ctrl_init, true,
max_data_tx, cfg.data_area, &tl.log, &tl.log_size);
if (err < 0) {
SOLIDIGM_LOG_WARNING("get-telemetry-log: %s",
nvme_strerror(errno));

2
plugins/solidigm/solidigm-telemetry/config.c
View file

@ -9,7 +9,7 @@
#include <string.h>
#include "config.h"
// max 16 bit unsigned integer nummber 65535
// max 16 bit unsigned integer number 65535
#define MAX_16BIT_NUM_AS_STRING_SIZE 6
#define OBJ_NAME_PREFIX "UID_"

2
plugins/solidigm/solidigm-telemetry/data-area.c
View file

@ -57,7 +57,7 @@ static bool telemetry_log_get_value(const struct telemetry_log *tl,
char err_msg[MAX_WARNING_SIZE];
snprintf(err_msg, MAX_WARNING_SIZE,
"Value crossing 64 bit, byte aligned bounday, not supported. size_bit=%u, offset_bit_from_byte=%u.",
"Value crossing 64 bit, byte aligned boundary, not supported. size_bit=%u, offset_bit_from_byte=%u.",
size_bit, offset_bit_from_byte);
*val_obj = json_object_new_string(err_msg);

108
plugins/solidigm/solidigm-temp-stats.c Normal file
View file

@ -0,0 +1,108 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright (c) 2023 Solidigm.
*
* Author: leonardo.da.cunha@solidigm.com
*/
#include <errno.h>
#include "common.h"
#include "nvme-print.h"
#include "solidigm-util.h"
#define SLDGM_TEMP_STATS_LID 0xC5
struct temp_stats {
__le64 curr;
__le64 last_overtemp;
__le64 life_overtemp;
__le64 highest_temp;
__le64 lowest_temp;
__u8 rsvd[40];
__le64 max_operating_temp;
__le64 min_operating_temp;
__le64 est_offset;
};
static void show_temp_stats(struct temp_stats *stats)
{
printf("Current temperature : %"PRIu64"\n", le64_to_cpu(stats->curr));
printf("Last critical overtemp flag : %"PRIu64"\n", le64_to_cpu(stats->last_overtemp));
printf("Life critical overtemp flag : %"PRIu64"\n", le64_to_cpu(stats->life_overtemp));
printf("Highest temperature : %"PRIu64"\n", le64_to_cpu(stats->highest_temp));
printf("Lowest temperature : %"PRIu64"\n", le64_to_cpu(stats->lowest_temp));
printf("Max operating temperature : %"PRIu64"\n", le64_to_cpu(stats->max_operating_temp));
printf("Min operating temperature : %"PRIu64"\n", le64_to_cpu(stats->min_operating_temp));
printf("Estimated offset : %"PRIu64"\n", le64_to_cpu(stats->est_offset));
}
int sldgm_get_temp_stats_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
{
unsigned char buffer[4096] = {0};
struct nvme_dev *dev;
__u8 uuid_idx;
int err;
const char *desc = "Get/show Temperature Statistics log.";
const char *raw = "dump output in binary format";
struct config {
bool raw_binary;
};
struct config cfg = {
.raw_binary = false,
};
OPT_ARGS(opts) = {
OPT_FLAG("raw-binary", 'b', &cfg.raw_binary, raw),
OPT_END()
};
err = parse_and_open(&dev, argc, argv, desc, opts);
if (err)
return err;
uuid_idx = solidigm_get_vu_uuid_index(dev);
struct nvme_get_log_args args = {
.lpo = 0,
.result = NULL,
.log = buffer,
.args_size = sizeof(args),
.fd = dev_fd(dev),
.uuidx = uuid_idx,
.timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
.lid = SLDGM_TEMP_STATS_LID,
.len = sizeof(buffer),
.nsid = NVME_NSID_ALL,
.csi = NVME_CSI_NVM,
.lsi = NVME_LOG_LSI_NONE,
.lsp = NVME_LOG_LSP_NONE,
.rae = false,
.ot = false,
};
err = nvme_get_log(&args);
if (!err) {
uint64_t *guid = (uint64_t *)&buffer[4080];
if (guid[1] == 0xC7BB98B7D0324863 && guid[0] == 0xBB2C23990E9C722F) {
fprintf(stderr, "Error: Log page has 'OCP unsupported Requirements' GUID\n");
err = -EBADMSG;
goto closefd;
}
if (!cfg.raw_binary)
show_temp_stats((struct temp_stats *) buffer);
else
d_raw(buffer, sizeof(struct temp_stats));
} else if (err > 0) {
nvme_show_status(err);
}
closefd:
/* Redundant close() to make static code analysis happy */
close(dev->direct.fd);
dev_close(dev);
return err;
}

8
plugins/solidigm/solidigm-temp-stats.h Normal file
View file

@ -0,0 +1,8 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (c) 2023 Solidigm.
*
* Author: leonardo.da.cunha@solidigm.com
*/
int sldgm_get_temp_stats_log(int argc, char **argv, struct command *cmd, struct plugin *plugin);

2
plugins/solidigm/solidigm-util.h
View file

@ -7,4 +7,6 @@
#include "nvme.h"
#define DRIVER_MAX_TX_256K (256 * 1024)
__u8 solidigm_get_vu_uuid_index(struct nvme_dev *dev);