plugins/solidigm: Add uuid index resolution

Add automated uuid_index resolution when retrieving latency-tracking
log, garbage collection log, and SMART log.

diff --git a/plugins/solidigm/meson.build b/plugins/solidigm/meson.build
index bca13bbe421e9f36151e8d76b031892d32b1c420..526fb02f9bbc31ecdfef22585a29aca1961af94c 100644 (file)
--- a/plugins/solidigm/meson.build
+++ b/plugins/solidigm/meson.build
@@ -1,4 +1,5 @@
 sources += [
+  'plugins/solidigm/solidigm-util.c',
   'plugins/solidigm/solidigm-smart.c',
   'plugins/solidigm/solidigm-garbage-collection.c',
   'plugins/solidigm/solidigm-latency-tracking.c',

diff --git a/plugins/solidigm/solidigm-garbage-collection.c b/plugins/solidigm/solidigm-garbage-collection.c
index 8e2ecccf5360a92ce4aef23aa898f47e2597d3b5..3828b9e67e1de01f2a38ed0c6b128a6b469897d1 100644 (file)
--- a/plugins/solidigm/solidigm-garbage-collection.c
+++ b/plugins/solidigm/solidigm-garbage-collection.c
@@ -19,6 +19,7 @@
 #include "linux/types.h"
 #include "nvme-print.h"
 #include "solidigm-garbage-collection.h"
+#include "solidigm-util.h"
 
 typedef struct __attribute__((packed)) gc_item {
        __le32 timer_type;
@@ -49,9 +50,11 @@ static void vu_gc_log_show_json(garbage_control_collection_log_t *payload, const
        json_free_object(gc_entries);
 }
 
-static void vu_gc_log_show(garbage_control_collection_log_t *payload, const char *devname)
+static void vu_gc_log_show(garbage_control_collection_log_t *payload, const char *devname,
+                          __u8 uuid_index)
 {
-       printf("Solidigm Garbage Collection Log for NVME device: %s\n", devname);
+       printf("Solidigm Garbage Collection Log for NVME device:%s UUID-idx:%d\n", devname,
+              uuid_index);
        printf("Timestamp     Timer Type\n");
 
        for (int i = 0; i < VU_GC_MAX_ITEMS; i++) {
@@ -65,6 +68,7 @@ int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *c
        const char *desc = "Get and parse Solidigm vendor specific garbage collection event log.";
        struct nvme_dev *dev;
        int err;
+       __u8 uuid_index;
 
        struct config {
                char    *output_format;
@@ -90,18 +94,36 @@ int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *c
                return EINVAL;
        }
 
+       uuid_index = solidigm_get_vu_uuid_index(dev);
+
        garbage_control_collection_log_t gc_log;
        const int solidigm_vu_gc_log_id = 0xfd;
+       struct nvme_get_log_args args = {
+               .lpo = 0,
+               .result = NULL,
+               .log = &gc_log,
+               .args_size = sizeof(args),
+               .fd = dev_fd(dev),
+               .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+               .lid = solidigm_vu_gc_log_id,
+               .len = sizeof(gc_log),
+               .nsid = NVME_NSID_ALL,
+               .csi = NVME_CSI_NVM,
+               .lsi = NVME_LOG_LSI_NONE,
+               .lsp = NVME_LOG_LSP_NONE,
+               .uuidx = uuid_index,
+               .rae = false,
+               .ot = false,
+       };
 
-       err = nvme_get_log_simple(dev_fd(dev), solidigm_vu_gc_log_id,
-                                 sizeof(gc_log), &gc_log);
+       err =  nvme_get_log(&args);
        if (!err) {
                if (flags & BINARY)     {
                        d_raw((unsigned char *)&gc_log, sizeof(gc_log));
                } else if (flags & JSON) {
                        vu_gc_log_show_json(&gc_log, dev->name);
                } else {
-                       vu_gc_log_show(&gc_log, dev->name);
+                       vu_gc_log_show(&gc_log, dev->name, uuid_index);
                }
        }
        else if (err > 0) {

diff --git a/plugins/solidigm/solidigm-latency-tracking.c b/plugins/solidigm/solidigm-latency-tracking.c
index 1013ae81830f3bbfab8a2a21da3d827cb07a6b79..b96ac6e6ce1ae675095f1b238b7bc4f71f38beaf 100644 (file)
--- a/plugins/solidigm/solidigm-latency-tracking.c
+++ b/plugins/solidigm/solidigm-latency-tracking.c
@@ -17,6 +17,7 @@
 #include "plugin.h"
 #include "linux/types.h"
 #include "nvme-print.h"
+#include "solidigm-util.h"
 
 #define BUCKET_LIST_SIZE_4_0 152
 #define BUCKET_LIST_SIZE_4_1 1216
@@ -42,6 +43,7 @@ struct config {
 
 struct latency_tracker {
        int fd;
+       __u8 uuid_index;
        struct config cfg;
        enum nvme_print_flags print_flags;
        struct latency_statistics stats;
@@ -213,6 +215,7 @@ static void latency_tracker_pre_parse(struct latency_tracker *lt)
        if (lt->print_flags == NORMAL) {
                printf("Solidigm IO %s Command Latency Tracking Statistics type %d\n",
                        lt->cfg.write ? "Write" : "Read", lt->cfg.type);
+               printf("UUID-idx: %d\n", lt->uuid_index);
                printf("Major Revision: %u\nMinor Revision: %u\n",
                        le16_to_cpu(lt->stats.version_major), le16_to_cpu(lt->stats.version_minor));
                if (lt->has_average_latency_field) {
@@ -276,7 +279,8 @@ static int latency_tracking_is_enable(struct latency_tracker *lt, __u32 * enable
 {
        struct nvme_get_features_args args_get = {
                .args_size      = sizeof(args_get),
-               .fd                     = lt->fd,
+               .fd             = lt->fd,
+               .uuidx          = lt->uuid_index,
                .fid            = LATENCY_TRACKING_FID,
                .nsid           = 0,
                .sel            = 0,
@@ -307,6 +311,7 @@ static int latency_tracking_enable(struct latency_tracker *lt)
        struct nvme_set_features_args args_set = {
                .args_size      = sizeof(args_set),
                .fd             = lt->fd,
+               .uuidx          = lt->uuid_index,
                .fid            = LATENCY_TRACKING_FID,
                .nsid           = 0,
                .cdw11          = lt->cfg.enable,
@@ -328,8 +333,8 @@ static int latency_tracking_enable(struct latency_tracker *lt)
                fprintf(stderr, "Command failed while parsing.\n");
        } else {
                if (lt->print_flags == NORMAL) {
-                       printf("Successfully set enable bit for FID (0x%X) to %i.\n",
-                               LATENCY_TRACKING_FID, lt->cfg.enable);
+                       printf("Successfully set enable bit for UUID-idx:%d FID:0x%X, to %i.\n",
+                               lt->uuid_index, LATENCY_TRACKING_FID, lt->cfg.enable);
                }
        }
        return err;
@@ -356,6 +361,7 @@ static int latency_tracker_get_log(struct latency_tracker *lt)
                .log    = &lt->stats,
                .args_size = sizeof(args),
                .fd     = lt->fd,
+               .uuidx  = lt->uuid_index,
                .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
                .lid    = lt->cfg.write ? WRITE_LOG_ID : READ_LOG_ID,
                .len    = sizeof(lt->stats),
@@ -390,6 +396,7 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *cmd
        int err;
 
        struct latency_tracker lt = {
+               .uuid_index = 0,
                .cfg = {
                        .output_format  = "normal",
                },
@@ -433,6 +440,8 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *cmd
                return EINVAL;
        }
 
+       lt.uuid_index = solidigm_get_vu_uuid_index(dev);
+
        err = latency_tracking_enable(&lt);
        if (err){
                dev_close(dev);
@@ -462,8 +471,8 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *cmd
                        putchar(enabled);
                } else {
                printf(
-                       "Latency Statistics Tracking (FID 0x%X) is currently (%i).\n",
-                       LATENCY_TRACKING_FID, enabled);
+                       "Latency Statistics Tracking (UUID-idx:%d, FID:0x%X) is currently %i.\n",
+                       lt.uuid_index, LATENCY_TRACKING_FID, enabled);
                }
        } else {
                fprintf(stderr, "Could not read feature id 0xE2.\n");

diff --git a/plugins/solidigm/solidigm-nvme.h b/plugins/solidigm/solidigm-nvme.h
index 778dbf99f63aeb601c72f9802dc3e8603797f4a3..efc444840cadf4b259a87a7e6469d4161e40afa6 100644 (file)
--- a/plugins/solidigm/solidigm-nvme.h
+++ b/plugins/solidigm/solidigm-nvme.h
@@ -13,7 +13,7 @@
 
 #include "cmd.h"
 
-#define SOLIDIGM_PLUGIN_VERSION "0.7"
+#define SOLIDIGM_PLUGIN_VERSION "0.8"
 
 PLUGIN(NAME("solidigm", "Solidigm vendor specific extensions", SOLIDIGM_PLUGIN_VERSION),
        COMMAND_LIST(

diff --git a/plugins/solidigm/solidigm-smart.c b/plugins/solidigm/solidigm-smart.c
index 77c26ac19bd6e789ab7987349f9f524217735103..568d3abfd3294d73ed9bd309428ed121cfc9de2e 100644 (file)
--- a/plugins/solidigm/solidigm-smart.c
+++ b/plugins/solidigm/solidigm-smart.c
@@ -19,6 +19,7 @@
 #include "nvme-print.h"
 
 #include "solidigm-smart.h"
+#include "solidigm-util.h"
 
 struct  __attribute__((packed)) nvme_additional_smart_log_item {
        __u8                    id;
@@ -179,12 +180,13 @@ static void vu_smart_log_show_json(vu_smart_log_t *payload, unsigned int nsid, c
        json_free_object(root);
 }
 
-static void vu_smart_log_show(vu_smart_log_t *payload, unsigned int nsid, const char *devname)
+static void vu_smart_log_show(vu_smart_log_t *payload, unsigned int nsid, const char *devname,
+                             __u8 uuid_index)
 {
        smart_log_item_t *item = payload->item;
 
-       printf("Additional Smart Log for NVME device:%s namespace-id:%x\n",
-               devname, nsid);
+       printf("Additional Smart Log for NVMe device:%s namespace-id:%x UUID-idx:%d\n",
+               devname, nsid, uuid_index);
        printf("ID             KEY                                 Normalized     Raw\n");
 
        for (int i = 0; i < VU_SMART_MAX_ITEMS; i++) {
@@ -201,6 +203,7 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *cmd
        enum nvme_print_flags flags;
        struct nvme_dev *dev;
        int err;
+       __u8 uuid_index;
 
        struct config {
                __u32   namespace_id;
@@ -229,8 +232,27 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *cmd
                return flags;
        }
 
-       err = nvme_get_log_simple(dev_fd(dev), solidigm_vu_smart_log_id,
-                                 sizeof(smart_log_payload), &smart_log_payload);
+       uuid_index = solidigm_get_vu_uuid_index(dev);
+
+       struct nvme_get_log_args args = {
+               .lpo = 0,
+               .result = NULL,
+               .log = &smart_log_payload,
+               .args_size = sizeof(args),
+               .fd = dev_fd(dev),
+               .timeout = NVME_DEFAULT_IOCTL_TIMEOUT,
+               .lid = solidigm_vu_smart_log_id,
+               .len = sizeof(smart_log_payload),
+               .nsid = NVME_NSID_ALL,
+               .csi = NVME_CSI_NVM,
+               .lsi = NVME_LOG_LSI_NONE,
+               .lsp = NVME_LOG_LSP_NONE,
+               .uuidx = uuid_index,
+               .rae = false,
+               .ot = false,
+       };
+
+       err =  nvme_get_log(&args);
        if (!err) {
                if (flags & JSON) {
                        vu_smart_log_show_json(&smart_log_payload,
@@ -239,7 +261,7 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *cmd
                        d_raw((unsigned char *)&smart_log_payload, sizeof(smart_log_payload));
                } else {
                        vu_smart_log_show(&smart_log_payload, cfg.namespace_id,
-                                         dev->name);
+                                         dev->name, uuid_index);
                }
        } else if (err > 0) {
                nvme_show_status(err);

diff --git a/plugins/solidigm/solidigm-util.c b/plugins/solidigm/solidigm-util.c
new file mode 100644 (file)
index 0000000..0171a49
--- /dev/null
+++ b/plugins/solidigm/solidigm-util.c
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2023 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#include "plugins/ocp/ocp-utils.h"
+#include "solidigm-util.h"
+
+__u8 solidigm_get_vu_uuid_index(struct nvme_dev *dev)
+{
+       int ocp_uuid_index = 0;
+
+       if (ocp_get_uuid_index(dev, &ocp_uuid_index) == 0)
+               if (ocp_uuid_index == 2)
+                       return 1;
+
+       return 0;
+}

diff --git a/plugins/solidigm/solidigm-util.h b/plugins/solidigm/solidigm-util.h
new file mode 100644 (file)
index 0000000..3a18501
--- /dev/null
+++ b/plugins/solidigm/solidigm-util.h
@@ -0,0 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2023 Solidigm.
+ *
+ * Author: leonardo.da.cunha@solidigm.com
+ */
+
+#include "nvme.h"
+
+__u8 solidigm_get_vu_uuid_index(struct nvme_dev *dev);