ocp: add Persistent Event log support

This introduces a new OCP plugin command that mirrors the base nvme
persistent-event-log command, but has additional parsing for the OCP 2.5
TCG Activity Event data.

Signed-off-by: Brandon Paupore <[email protected]>
Reviewed-by: Jeffrey Lien <[email protected]>

Author: brandon-paupore-sndk

Documentation/nvme-ocp-persistent-event-log.txt

@@ -0,0 +1,79 @@
+nvme-ocp-persistent-event-log(1)
+================================
+
+NAME
+----
+nvme-ocp-persistent-event-log - Send NVMe persistent event log page request,
+returns result and log additional OCP-specific data
+
+SYNOPSIS
+--------
+[verse]
+'nvme ocp persistent-event-log' <device> [--action=<action> | -a <action>]
+			[--log-len=<log-len> | -l <log-len>] [--raw-binary | -b]
+			[--output-format=<fmt> | -o <fmt>] [--verbose | -v]
+
+DESCRIPTION
+-----------
+Retrieves the NVMe persistent event log page from an NVMe device
+and provides the returned structure.
+
+The <device> parameter is mandatory and may be either the NVMe character
+device (ex: /dev/nvme0), or a namespace block device (ex: /dev/nvme0n1).
+
+On success, the returned persistent event log structure may be returned
+in one of several ways depending on the option flags; the structure may
+parsed by the program and printed in a readable format or the raw buffer
+may be printed to stdout for another program to parse.
+
+OPTIONS
+-------
+-a <action>::
+--action=<action>::
+	While try to retrieve this log action the controller shall take
+	during processing this persistent log page command. This mandatory
+	field, based on the value issued it may Read Log Data, Establish
+	Context and Read Log Data or Release Context can occur. For More
+	details see NVM Express 1.4 Spec. Section 5.14.1.13 Persistent
+	Event Log (Log Identifier 0Dh)
+
+-l <log-len>::
+--log-len=<log-len>::
+	Allocates a buffer of <log-len> bytes size and requests this
+	many bytes be returned in the constructed NVMe command. This
+	param is mandatory. If <log-len> given is 0 and action is 0,
+	it will read the Total Log Length(TLL) of the page.
+
+-b::
+--raw-binary::
+	Print the raw persistent event log buffer to stdout.
+
+-o <fmt>::
+--output-format=<fmt>::
+	Set the reporting format to 'normal', 'json' or 'binary'. Only one
+	output format can be used at a time.
+
+-v::
+--verbose::
+	Increase the information detail in the output.
+
+EXAMPLES
+--------
+* Print the persistent event log page in a human readable format:
++
+------------
+# nvme ocp persistent-event-log /dev/nvme0
+------------
++
+
+* Print the raw persistent event log to a file:
++
+------------
+# nvme ocp persistent-event-log /dev/nvme0 --raw-binary > persistent_log.raw
+------------
++
+It is probably a bad idea to not redirect stdout when using this mode.
+
+NVME
+----
+Part of the nvme-user suite

plugins/ocp/ocp-nvme.c

@@ -195,6 +195,7 @@ static const char *type = "Error injection type";
 static const char *nrtdp = "Number of reads to trigger device panic";
 static const char *save = "Specifies that the controller shall save the attribute";
 static const char *enable_ieee1667_silo = "enable IEEE1667 silo";
+static const char *raw_use = "use binary output";
 
 static int get_c3_log_page(struct nvme_transport_handle *hdl, char *format)
 {
@@ -2974,3 +2975,125 @@ static int hwcomp_log(int argc, char **argv, struct command *acmd, struct plugin
 {
 	return ocp_hwcomp_log(argc, argv, acmd, plugin);
 }
+
+static int ocp_get_persistent_event_log(int argc, char **argv,
+		struct command *command, struct plugin *plugin)
+{
+	const char *desc = "Retrieve Persistent Event log info for the given " \
+		"device in either decoded format(default), json or binary.";
+	const char *action = "action the controller shall take during " \
+		"processing this persistent log page command.";
+	const char *log_len = "number of bytes to retrieve";
+
+	_cleanup_free_ struct nvme_persistent_event_log *pevent = NULL;
+	struct nvme_persistent_event_log *pevent_collected = NULL;
+	_cleanup_huge_ struct nvme_mem_huge mh = { 0, };
+	_cleanup_nvme_global_ctx_ struct nvme_global_ctx *ctx = NULL;
+	_cleanup_nvme_transport_handle_ struct nvme_transport_handle *hdl = NULL;
+
+	nvme_print_flags_t flags;
+	void *pevent_log_info;
+	int err;
+
+	struct config {
+		__u8	action;
+		__u32	log_len;
+		bool	raw_binary;
+	};
+
+	struct config cfg = {
+		.action		= 0xff,
+		.log_len	= 0,
+		.raw_binary	= false,
+	};
+
+	NVME_ARGS(opts,
+		  OPT_BYTE("action",       'a', &cfg.action,        action),
+		  OPT_UINT("log_len",      'l', &cfg.log_len,       log_len),
+		  OPT_FLAG("raw-binary",   'b', &cfg.raw_binary,    raw_use));
+
+	err = parse_and_open(&ctx, &hdl, argc, argv, desc, opts);
+	if (err)
+		return err;
+
+	err = validate_output_format(nvme_cfg.output_format, &flags);
+	if (err < 0) {
+		nvme_show_error("Invalid output format");
+		return err;
+	}
+
+	if (cfg.raw_binary)
+		flags = BINARY;
+
+	pevent = nvme_alloc(sizeof(*pevent));
+	if (!pevent)
+		return -ENOMEM;
+
+	err = nvme_get_log_persistent_event(hdl, cfg.action,
+					    pevent, sizeof(*pevent));
+	if (err < 0) {
+		nvme_show_error("persistent event log: %s", nvme_strerror(err));
+		return err;
+	} else if (err) {
+		nvme_show_status(err);
+		return err;
+	}
+
+	if (cfg.action == NVME_PEVENT_LOG_RELEASE_CTX) {
+		printf("Releasing Persistent Event Log Context\n");
+		return 0;
+	}
+
+	if (!cfg.log_len && cfg.action != NVME_PEVENT_LOG_EST_CTX_AND_READ) {
+		cfg.log_len = le64_to_cpu(pevent->tll);
+	} else if (!cfg.log_len && cfg.action == NVME_PEVENT_LOG_EST_CTX_AND_READ) {
+		printf("Establishing Persistent Event Log Context\n");
+		return 0;
+	}
+
+	/*
+	 * if header already read with context establish action 0x1,
+	 * action shall not be 0x1 again in the subsequent request,
+	 * until the current context is released by issuing action
+	 * with 0x2, otherwise throws command sequence error, make
+	 * it as zero to read the log page
+	 */
+	if (cfg.action == NVME_PEVENT_LOG_EST_CTX_AND_READ)
+		cfg.action = NVME_PEVENT_LOG_READ;
+
+	pevent_log_info = nvme_alloc_huge(cfg.log_len, &mh);
+	if (!pevent_log_info) {
+		nvme_show_error("failed to allocate huge memory");
+		return -ENOMEM;
+	}
+
+	err = nvme_get_log_persistent_event(hdl, cfg.action,
+					    pevent_log_info, cfg.log_len);
+	if (!err) {
+		err = nvme_get_log_persistent_event(hdl, cfg.action,
+							pevent,
+							sizeof(*pevent));
+		if (err < 0) {
+			nvme_show_error("persistent event log: %s", nvme_strerror(err));
+			return err;
+		} else if (err) {
+			nvme_show_status(err);
+			return err;
+		}
+		pevent_collected = pevent_log_info;
+		if (pevent_collected->gen_number != pevent->gen_number) {
+			printf("Collected Persistent Event Log may be invalid,\n"
+			       "Re-read the log is required\n");
+			return -EINVAL;
+		}
+
+		ocp_show_persistent_event_log(pevent_log_info, cfg.action,
+			cfg.log_len, nvme_transport_handle_get_name(hdl), flags);
+	} else if (err > 0) {
+		nvme_show_status(err);
+	} else {
+		nvme_show_error("persistent event log: %s", nvme_strerror(err));
+	}
+
+	return err;
+}

plugins/ocp/ocp-nvme.h

@@ -48,6 +48,8 @@ PLUGIN(NAME("ocp", "OCP cloud SSD extensions", OCP_PLUGIN_VERSION),
 		      get_clear_pcie_correctable_error_counters)
 		ENTRY("get-telemetry-profile", "Get Telemetry Profile Feature",
 		      ocp_get_telemetry_profile_feature)
+		ENTRY("persistent-event-log", "Retrieve Persistent Event Log with OCP events",
+		      ocp_get_persistent_event_log)
 	)
 );
 
@@ -280,4 +282,28 @@ enum ocp_dssd_feature_id {
 	OCP_FID_TEL_CFG, /* Telemetry Profile */
 	OCP_FID_DAEC, /* DSSD Asynchronous Event Configuration */
 };
+
+/*
+ * struct tcg_activity_event_data - TCG Activity Event Data
+ * @rsvd:                          Reserved
+ * @tcg_command_count:             TCG Command Count
+ * @invoking_id:                   Invoking ID
+ * @method_id:                     Method ID
+ * @com_id:                        Com ID
+ * @protocol_id:                   Protocol ID
+ * @status:                        Status of the TCG command
+ * @process_time:                  Time in milliseconds to process command
+ * @tcg_activity_specific_context: Additional context for the TCG activity
+ */
+struct __packed tcg_activity_event_data {
+	__u8    rsvd[2];
+	__le32  tcg_command_count;
+	__le64  invoking_id;
+	__le64  method_id;
+	__le16  com_id;
+	__le16  protocol_id;
+	__u8    status;
+	__le16  process_time;
+	__u8    tcg_activity_specific_context[10];
+};
 #endif /* OCP_NVME_H */

plugins/ocp/ocp-print-binary.c

@@ -15,6 +15,12 @@ static void binary_hwcomp_log(struct hwcomp_log *log, __u32 id, bool list)
 	d_raw((unsigned char *)log, log_bytes);
 }
 
+static void binary_persistent_event_log(void *pevent_log_info,
+	__u8 action, __u32 size, const char *devname)
+{
+	d_raw((unsigned char *)pevent_log_info, size);
+}
+
 static void binary_c5_log(struct nvme_transport_handle *hdl, struct unsupported_requirement_log *log_data)
 {
 	d_raw((unsigned char *)log_data, sizeof(*log_data));
@@ -43,6 +49,7 @@ static void binary_c7_log(struct nvme_transport_handle *hdl, struct tcg_configur
 
 static struct ocp_print_ops binary_print_ops = {
 	.hwcomp_log = binary_hwcomp_log,
+	.persistent_event_log = binary_persistent_event_log,
 	.c5_log = binary_c5_log,
 	.c1_log = binary_c1_log,
 	.c4_log = binary_c4_log,