plugins/solidigm: parse-telemetry-log aware of OCP2.5 binaries

Made parse-telemetry-log aware of OCP2.5 binaries.
Display proper OCP reason identifier.
Don't extract toc from DA1/DA2 when OCP log detected.
Show DA4 last block in the header.
Removed ccan ilog.h dependency
Fixed Nlog parser by taking Nlog header into account.
Added verbose mode.

Signed-off-by: Leonardo da Cunha <[email protected]>

Author: lgdacunh

plugins/solidigm/solidigm-telemetry.c

@@ -83,6 +83,7 @@ int solidigm_get_telemetry_log(int argc, char **argv, struct command *cmd, struc
 		OPT_UINT("data-area",       'd', &cfg.data_area, dgen),
 		OPT_FILE("config-file",     'j', &cfg.cfg_file, cfile),
 		OPT_FLAG("source-file",     's', &cfg.is_input_file, sfile),
+		OPT_INCR("verbose",      'v', &nvme_cfg.verbose, verbose),
 		OPT_END()
 	};
 

plugins/solidigm/solidigm-telemetry/data-area.c

@@ -18,6 +18,23 @@
 
 #define MAX_WARNING_SIZE 1024
 #define MAX_ARRAY_RANK 16
+#define NLOG_HEADER_ID 101
+
+
+static void reverse_string(char *buff, size_t len)
+{
+	char *start = buff;
+	char *end = buff + len - 1;
+	char temp;
+
+	while (end > start) {
+		temp = *end;
+		*end = *start;
+		*start = temp;
+		start++;
+		end--;
+	}
+}
 
 static bool telemetry_log_get_value(const struct telemetry_log *tl,
 				    uint64_t offset_bit, uint32_t size_bit,
@@ -418,6 +435,13 @@ static void telemetry_log_data_area_toc_parse(const struct telemetry_log *tl,
 									header->Token);
 			if (!nlog_name)
 				continue;
+
+			// NLOGs have different parser from other Telemetry objects
+			has_struct = solidigm_config_get_struct_by_token_version(tl->configuration,
+				NLOG_HEADER_ID,
+				header->versionMajor,
+				header->versionMinor,
+				&structure_definition);
 		}
 		struct json_object *tele_obj_item = json_create_object();
 
@@ -443,29 +467,72 @@ static void telemetry_log_data_area_toc_parse(const struct telemetry_log *tl,
 			telemetry_log_structure_parse(tl, structure_definition,
 						BITS_IN_BYTE * object_file_offset,
 						parsed_struct, toc_item);
-		} else if (nlog_formats) {
+		}
+		// NLOGs have different parser from other Telemetry objects
+		if (nlog_name) {
+			if (has_struct) {
+				struct json_object *header_sizeBits = NULL;
+				struct json_object *header_nlogSelect = NULL;
+				struct json_object *header_nlogName = NULL;
+
+				if (json_object_object_get_ex(structure_definition, "sizeBit",
+							      &header_sizeBits))
+					header_offset = json_object_get_int(header_sizeBits) /
+							BITS_IN_BYTE;
+				// Overwrite nlogName with correct type
+				if (json_object_object_get_ex(parsed_struct, "nlogSelect",
+				    &header_nlogSelect) &&
+				    json_object_object_get_ex(header_nlogSelect, "nlogName",
+				    &header_nlogName)) {
+					int nlogName = json_object_get_int(header_nlogName);
+					char *name = (char *)&nlogName;
+
+					reverse_string(name, sizeof(uint32_t));
+					json_object_object_add(header_nlogSelect, "nlogName",
+						json_object_new_string_len(name,
+									   sizeof(uint32_t)));
+				}
+			}
+			// Overwrite the object name
 			json_object_object_add(toc_item, "objName",
 					       json_object_new_string(nlog_name));
-			telemetry_log_nlog_parse(tl, nlog_formats, object_file_offset,
+
+			telemetry_log_nlog_parse(tl, nlog_formats,
+						 object_file_offset + header_offset,
 						 toc->items[i].ContentSizeBytes - header_offset,
 						 parsed_struct, toc_item);
 		}
 	}
 }
 
+void solidigm_telemetry_log_da1_check_ocp(struct telemetry_log *tl)
+{
+	const uint64_t ocp_telemetry_uuid[] = {0xBC73719D87E64EFA, 0xBA560A9C3043424C};
+	const uint64_t *log_uuid = (uint64_t *) &tl->log->data_area[16];
+
+	tl->is_ocp = tl->log_size >= (&tl->log->data_area[32] - (uint8_t *) tl->log) &&
+		log_uuid[0] == ocp_telemetry_uuid[0] && log_uuid[1] == ocp_telemetry_uuid[1];
+}
+
 int solidigm_telemetry_log_data_areas_parse(struct telemetry_log *tl,
 					    enum nvme_telemetry_da last_da)
 {
 	struct json_object *tele_obj_array = json_create_array();
 	struct json_object *toc_array = json_create_array();
 
+	solidigm_telemetry_log_da1_check_ocp(tl);
 	solidigm_telemetry_log_header_parse(tl);
 	solidigm_telemetry_log_cod_parse(tl);
 	if (tl->configuration) {
+		enum nvme_telemetry_da first_da = NVME_TELEMETRY_DA_1;
+
+		if (tl->is_ocp)
+			first_da = NVME_TELEMETRY_DA_3;
+
 		json_object_add_value_array(tl->root, "tableOfContents", toc_array);
 		json_object_add_value_array(tl->root, "telemetryObjects", tele_obj_array);
 
-		for (enum nvme_telemetry_da da = NVME_TELEMETRY_DA_1; da <= last_da; da++)
+		for (enum nvme_telemetry_da da = first_da; da <= last_da; da++)
 			telemetry_log_data_area_toc_parse(tl, da, toc_array, tele_obj_array);
 	}
 	return 0;

plugins/solidigm/solidigm-telemetry/data-area.h

@@ -8,3 +8,4 @@
 
 int solidigm_telemetry_log_data_areas_parse(struct telemetry_log *tl,
 					    enum nvme_telemetry_da last_da);
+void solidigm_telemetry_log_da1_check_ocp(struct telemetry_log *tl);

plugins/solidigm/solidigm-telemetry/header.c

@@ -57,6 +57,28 @@ struct reason_indentifier_1_2 {
 static_assert(sizeof(const struct reason_indentifier_1_2) ==
 	      MEMBER_SIZE(struct nvme_telemetry_log, rsnident),
 	      "Size mismatch for reason_indentifier_1_2");
+
+struct reason_identifier_ocp_2_5 {
+	char errorId[64];
+	char fileId[8];
+	uint16_t lineNum;
+	union {
+		struct {
+			uint8_t validLineNum:1;
+			uint8_t validFileId:1;
+			uint8_t validErrorId:1;
+			uint8_t validVuExtension:1;
+			uint8_t reservedBits:4;
+		};
+		uint8_t raw;
+	} validFlags;
+	uint8_t reserved[21];
+	uint8_t vuExtension[32];
+};
+static_assert(sizeof(const struct reason_identifier_ocp_2_5) ==
+	      MEMBER_SIZE(struct nvme_telemetry_log, rsnident),
+	      "Size mismatch for reason_identifier_ocp_2_5");
+
 #pragma pack(pop, reason_indentifier)
 
 static void telemetry_log_reason_id_parse1_0_ext(const struct telemetry_log *tl,
@@ -153,6 +175,43 @@ static void telemetry_log_reason_id_parse1_2_ext(const struct telemetry_log *tl,
 		json_object_array_add(dp_reserved, val);
 	}
 }
+static void telemetry_log_reason_id_parse_ocp_2_5(const struct telemetry_log *tl,
+						 struct json_object *reason_id)
+{
+	const struct reason_identifier_ocp_2_5 *ri;
+	struct json_object *reserved;
+	struct json_object *vu_extension;
+
+	ri = (struct reason_identifier_ocp_2_5 *) tl->log->rsnident;
+
+	json_object_object_add(reason_id, "errorId",
+			       json_object_new_string_len(ri->errorId,
+							  sizeof(ri->errorId)));
+	json_object_object_add(reason_id, "fileId",
+			       json_object_new_string_len(ri->fileId,
+							  sizeof(ri->fileId)));
+	json_object_add_value_uint(reason_id, "lineNum", le16_to_cpu(ri->lineNum));
+	json_object_add_value_uint(reason_id, "validLineNum", ri->validFlags.validLineNum);
+	json_object_add_value_uint(reason_id, "validFileId", ri->validFlags.validFileId);
+	json_object_add_value_uint(reason_id, "validErrorId", ri->validFlags.validErrorId);
+	json_object_add_value_uint(reason_id, "validVuExtension", ri->validFlags.validVuExtension);
+
+	reserved = json_create_array();
+	json_object_add_value_array(reason_id, "reserved", reserved);
+	for (int i = 0; i < sizeof(ri->reserved); i++) {
+		struct json_object *val = json_object_new_int(ri->reserved[i]);
+
+		json_object_array_add(reserved, val);
+	}
+
+	vu_extension = json_create_array();
+	json_object_add_value_array(reason_id, "vuExtension", vu_extension);
+	for (int i = 0; i < sizeof(ri->vuExtension); i++) {
+		struct json_object *val = json_object_new_int(ri->vuExtension[i]);
+
+		json_object_array_add(vu_extension, val);
+	}
+}
 
 static void solidigm_telemetry_log_reason_id_parse(const struct telemetry_log *tl, struct json_object *reason_id)
 {
@@ -161,12 +220,18 @@ static void solidigm_telemetry_log_reason_id_parse(const struct telemetry_log *t
 	uint16_t version_major = le16_to_cpu(ri1_0->versionMajor);
 	uint16_t version_minor = le16_to_cpu(ri1_0->versionMinor);
 
+	if (tl->is_ocp) {
+		telemetry_log_reason_id_parse_ocp_2_5(tl, reason_id);
+		return;
+	}
+
 	json_object_add_value_uint(reason_id, "versionMajor", version_major);
 	json_object_add_value_uint(reason_id, "versionMinor", version_minor);
 	json_object_add_value_uint(reason_id, "reasonCode", le32_to_cpu(ri1_0->reasonCode));
 	json_object_add_value_object(reason_id, "driveStatus",
 				     json_object_new_string_len(ri1_0->DriveStatus,
 								sizeof(ri1_0->DriveStatus)));
+
 	if (version_major == 1) {
 		switch (version_minor) {
 		case 0:
@@ -211,6 +276,7 @@ bool solidigm_telemetry_log_header_parse(const struct telemetry_log *tl)
 	json_object_add_value_uint(header, "dataArea1LastBlock", log->dalb1);
 	json_object_add_value_uint(header, "dataArea2LastBlock", log->dalb2);
 	json_object_add_value_uint(header, "dataArea3LastBlock", log->dalb3);
+	json_object_add_value_uint(header, "dataArea4LastBlock", log->dalb4);
 	json_object_add_value_uint(header, "hostInitiatedDataGeneration", log->hostdgn);
 	json_object_add_value_uint(header, "controllerInitiatedDataAvailable", log->ctrlavail);
 	json_object_add_value_uint(header, "controllerInitiatedDataGeneration", log->ctrldgn);

plugins/solidigm/solidigm-telemetry/nlog.c

@@ -10,14 +10,12 @@
 #include <string.h>
 #include <stdio.h>
 
-#include "ccan/ilog/ilog.h"
-
 #define LOG_ENTRY_HEADER_SIZE 1
 #define LOG_ENTRY_TIMESTAMP_SIZE 2
 #define LOG_ENTRY_NUM_ARGS_MAX 8
+#define LOG_ENTRY_NUM_ARGS_MASK 0xF
 #define LOG_ENTRY_MAX_SIZE (LOG_ENTRY_HEADER_SIZE + LOG_ENTRY_TIMESTAMP_SIZE + \
 			    LOG_ENTRY_NUM_ARGS_MAX)
-#define NUM_ARGS_MASK ((1 << ((int)STATIC_ILOG_32(LOG_ENTRY_NUM_ARGS_MAX))) - 1)
 #define MAX_HEADER_MISMATCH_TRACK 10
 
 static int formats_find(struct json_object *formats, uint32_t val, struct json_object **format)
@@ -41,13 +39,13 @@ static uint32_t nlog_get_events(const uint32_t *nlog, const uint32_t nlog_size,
 	uint32_t tail_count = 0;
 
 	for (int i = nlog_size - start_offset - 1; i >= -start_offset; i--) {
-		struct json_object *format;
+		struct json_object *format = NULL;
 		uint32_t header = nlog_get_pos(nlog, nlog_size, i);
 		uint32_t num_data;
 
 		if (header == 0 || !formats_find(formats, header, &format)) {
 			if (event_count > 0) {
-				//check if fould circular buffer tail
+				//check if found circular buffer tail
 				if (i != (last_bad_header_pos - 1)) {
 					if (tail_mismatches &&
 					    (tail_count < MAX_HEADER_MISMATCH_TRACK))
@@ -58,7 +56,7 @@ static uint32_t nlog_get_events(const uint32_t *nlog, const uint32_t nlog_size,
 			}
 			continue;
 		}
-		num_data = header & NUM_ARGS_MASK;
+		num_data = header & LOG_ENTRY_NUM_ARGS_MASK;
 		if (events) {
 			struct json_object *event = json_object_new_array();
 			struct json_object *param = json_object_new_array();

plugins/solidigm/solidigm-telemetry/telemetry-log.h

@@ -11,6 +11,7 @@
 #include "libnvme.h"
 #include "util/json.h"
 #include <assert.h>
+#include <stdbool.h>
 
 #if !defined __cplusplus
 #define static_assert _Static_assert
@@ -26,6 +27,7 @@ struct telemetry_log {
 	size_t log_size;
 	struct json_object *root;
 	struct json_object *configuration;
+	bool is_ocp;
 };
 
 #endif /* _SOLIDIGM_TELEMETRY_LOG_H */