From edcd9b7e10b3b33a9660e412a2db1beab30936d3 Mon Sep 17 00:00:00 2001

From: Vaibhav Jain <vaibhav@linux.ibm.com>

Date: Tue, 25 Jan 2022 02:07:35 +0530

Subject: [PATCH 126/217] libndctl, intel: Indicate supported smart-inject

 types

Presently the inject-smart code assumes support for injecting all

smart-errors namely media-temperature, controller-temperature,

spares-remaining, fatal-health and unsafe-shutdown. This assumption

may break in case of other non-Intel NVDIMM types namely PAPR NVDIMMs

which presently only have support for injecting unsafe-shutdown and

fatal health events.

Trying to inject-smart errors on PAPR NVDIMMs causes problems as

smart_inject() prematurely exits when trying to inject

media-temperature smart-error errors out.

To fix this issue the patch proposes extending the definition of

dimm_op 'smart_inject_supported' to return bitmap of flags indicating

the type of smart-error injections supported by an NVDIMM. These types

are indicated by the newly introduced defines ND_SMART_INJECT_* . A

dimm-ops provide can return an bitmap composed of these flags back

from its implementation of 'smart_inject_supported' to indicate to

dimm_inject_smart() which type of smart-error injection it

supports. In case of an error the dimm-op is still expected to return

a negative error code back to the caller.

The patch updates intel_dimm_smart_inject_supported() to return a

bitmap composed of all ND_SMART_INJECT_* flags to indicate support for

all smart-error types.

Finally the patch also updates smart_inject() to test for specific

ND_START_INJECT_* flags before sending a smart-inject command via

dimm-provider.

Link: https://lore.kernel.org/r/20220124203735.1490186-1-vaibhav@linux.ibm.com

Reviewed-by: Ira Weiny <ira.weiny@intel.com>

Signed-off-by: Vaibhav Jain <vaibhav@linux.ibm.com>

Signed-off-by: Vishal Verma <vishal.l.verma@intel.com>

---

 ndctl/inject-smart.c | 31 ++++++++++++++++++++++++-------

 ndctl/lib/intel.c    |  7 ++++++-

 ndctl/libndctl.h     |  8 ++++++++

 3 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/ndctl/inject-smart.c b/ndctl/inject-smart.c

index 2b9d7e8..bd8c01e 100644

--- a/ndctl/inject-smart.c

+++ b/ndctl/inject-smart.c

@@ -395,18 +395,26 @@ out:

 	} \

 }

-static int smart_inject(struct ndctl_dimm *dimm)

+static int smart_inject(struct ndctl_dimm *dimm, unsigned int inject_types)

 {

 	const char *name = ndctl_dimm_get_devname(dimm);

 	struct ndctl_cmd *si_cmd = NULL;

 	int rc = -EOPNOTSUPP;

-	send_inject_val(media_temperature)

-	send_inject_val(ctrl_temperature)

-	send_inject_val(spares)

-	send_inject_bool(fatal)

-	send_inject_bool(unsafe_shutdown)

+	if (inject_types & ND_SMART_INJECT_MEDIA_TEMPERATURE)

+		send_inject_val(media_temperature);

+	if (inject_types & ND_SMART_INJECT_CTRL_TEMPERATURE)

+		send_inject_val(ctrl_temperature);

+

+	if (inject_types & ND_SMART_INJECT_SPARES_REMAINING)

+		send_inject_val(spares);

+

+	if (inject_types & ND_SMART_INJECT_HEALTH_STATE)

+		send_inject_bool(fatal);

+

+	if (inject_types & ND_SMART_INJECT_UNCLEAN_SHUTDOWN)

+		send_inject_bool(unsafe_shutdown);

 out:

 	ndctl_cmd_unref(si_cmd);

 	return rc;

@@ -417,6 +425,7 @@ static int dimm_inject_smart(struct ndctl_dimm *dimm)

 	struct json_object *jhealth;

 	struct json_object *jdimms;

 	struct json_object *jdimm;

+	unsigned int supported_types;

 	int rc;

 	rc = ndctl_dimm_smart_inject_supported(dimm);

@@ -433,6 +442,14 @@ static int dimm_inject_smart(struct ndctl_dimm *dimm)

 		error("%s: smart injection not supported by either platform firmware or the kernel.",

 			ndctl_dimm_get_devname(dimm));

 		return rc;

+	default:

+		if (rc < 0) {

+			error("%s: Unknown error %d while checking for smart injection support",

+			      ndctl_dimm_get_devname(dimm), rc);

+			return rc;

+		}

+		supported_types = rc;

+		break;

 	}

 	if (sctx.op_mask & (1 << OP_SET)) {

@@ -441,7 +458,7 @@ static int dimm_inject_smart(struct ndctl_dimm *dimm)

 			goto out;

 	}

 	if (sctx.op_mask & (1 << OP_INJECT)) {

-		rc = smart_inject(dimm);

+		rc = smart_inject(dimm, supported_types);

 		if (rc)

 			goto out;

 	}

diff --git a/ndctl/lib/intel.c b/ndctl/lib/intel.c

index a3df26e..1314854 100644

--- a/ndctl/lib/intel.c

+++ b/ndctl/lib/intel.c

@@ -455,7 +455,12 @@ static int intel_dimm_smart_inject_supported(struct ndctl_dimm *dimm)

 		return -EIO;

 	}

-	return 0;

+	/* Indicate all smart injection types are supported */

+	return ND_SMART_INJECT_SPARES_REMAINING |

+		ND_SMART_INJECT_MEDIA_TEMPERATURE |

+		ND_SMART_INJECT_CTRL_TEMPERATURE |

+		ND_SMART_INJECT_HEALTH_STATE |

+		ND_SMART_INJECT_UNCLEAN_SHUTDOWN;

 }

 static const char *intel_cmd_desc(int fn)

diff --git a/ndctl/libndctl.h b/ndctl/libndctl.h

index b59026c..4d5cdbf 100644

--- a/ndctl/libndctl.h

+++ b/ndctl/libndctl.h

@@ -69,6 +69,13 @@ extern "C" {

 #define ND_EVENT_HEALTH_STATE		(1 << 3)

 #define ND_EVENT_UNCLEAN_SHUTDOWN	(1 << 4)

+/* Flags indicating support for various smart injection types */

+#define ND_SMART_INJECT_SPARES_REMAINING	(1 << 0)

+#define ND_SMART_INJECT_MEDIA_TEMPERATURE	(1 << 1)

+#define ND_SMART_INJECT_CTRL_TEMPERATURE	(1 << 2)

+#define ND_SMART_INJECT_HEALTH_STATE		(1 << 3)

+#define ND_SMART_INJECT_UNCLEAN_SHUTDOWN	(1 << 4)

+

 size_t ndctl_min_namespace_size(void);

 size_t ndctl_sizeof_namespace_index(void);

 size_t ndctl_sizeof_namespace_label(void);

@@ -311,6 +318,7 @@ int ndctl_cmd_smart_inject_spares(struct ndctl_cmd *cmd, bool enable,

 		unsigned int spares);

 int ndctl_cmd_smart_inject_fatal(struct ndctl_cmd *cmd, bool enable);

 int ndctl_cmd_smart_inject_unsafe_shutdown(struct ndctl_cmd *cmd, bool enable);

+/* Returns a bitmap of ND_SMART_INJECT_* supported */

 int ndctl_dimm_smart_inject_supported(struct ndctl_dimm *dimm);

 struct ndctl_cmd *ndctl_dimm_cmd_new_vendor_specific(struct ndctl_dimm *dimm,

-- 

2.27.0