Add support for reporting papr-scm nvdimm health
v4 cover Add support for reporting papr-scm nvdimm health
Changes since v3 [1]:
* Updated 'papr_scm_psdm.h' to recent kernel version that removes 'payload_offset' field from 'struct nd_pdsm_cmd_pkg'.
* Changes to 'papr_scm.c' to remove code that was populating 'payload_offset'.
[1] https://lore.kernel.org/linux-nvdimm/[email protected]
---
This patch-set proposes changes to libndctl to add support for reporting health for nvdimms that support the PAPR standard[2]. The standard defines machenism (HCALL) through which a guest kernel can query and fetch health and performance stats of an nvdimm attached to the hypervisor[3]. Until now 'ndctl' was unable to report these stats for papr_scm dimms on PPC64 guests due to absence of ACPI/NFIT, a limitation which this patch-set tries to address.
The patch-set introduces support for the new PAPR-SCM PDSM family defined at [4] via a new dimm-ops named 'papr_scm_dimm_ops'. Infrastructure to probe and distinguish papr-scm dimms from other dimm families that may support ACPI/NFIT is implemented by updating the 'struct ndctl_dimm' initialization routines to bifurcate based on the nvdimm type. We also introduce two new dimm-ops member for handling initialization of dimm specific data for specific DSM families.
These changes coupled with proposed kernel changes located at Ref[1] should provide a way for the user to retrieve NVDIMM health status using ndtcl for papr_scm guests. Below is a sample output using proposed kernel + ndctl changes:
# ndctl list -DH
[
{
"dev":"nmem0",
"flag_smart_event":true,
"health":{
"health_state":"fatal",
"shutdown_state":"dirty"
}
}
]Structure of the patchset
=========================
We start with a re-factoring patch that splits the 'add_dimm()' function into two functions one that take care of allocating and initializing 'struct ndctl_dimm' and another that takes care of initializing nfit specific dimm attributes.
Patch-2 introduces probe function of papr_scm nvdimms and assigning 'papr_scm_dimm_ops' defined in 'papr_scm.c' to 'dimm->ops' if needed. The patch also code to parse the dimm flags specific to papr-scm nvdimms
Patch-3 introduces new dimm ops 'dimm_init()' & 'dimm_uninit()' to handle DSM family specific initialization of 'struct ndctl_dimm'.
Patches-4,5 implements scaffolding to add support for PAPR_SCM PDSM requests and pull in their definitions from the kernel.
Finally Patch-6 add support for issuing and handling the result of 'struct ndctl_cmd' to request dimm health stats from papr_scm kernel module and returning appropriate health status to libndctl for reporting.
References
==========
[2] "Power Architecture Platform Reference"
https://en.wikipedia.org/wiki/Power_Architecture_Platform_Reference
[3] "Hypercall Op-codes (hcalls)"
https://github.com/torvalds/linux/blob/master/Documentation/powerpc/papr_hcalls.rst
[4] "ndctl/papr_scm,uapi: Add support for PAPR nvdimm specific methods"
https://lore.kernel.org/linux-nvdimm/[email protected]/
---
Vaibhav Jain (6):
libndctl: Refactor out add_dimm() to handle NFIT specific init
libncdtl: Add initial support for NVDIMM_FAMILY_PAPR_SCM dimm family
libndctl: Introduce new dimm-ops dimm_init() & dimm_uninit() libndctl,papr_scm: Add definitions for PAPR nvdimm specific methods libndctl,papr_scm: Add scaffolding to issue and handle PDSM requests libndctl,papr_scm: Implement support for PAPR_SCM_PDSM_HEALTH
ndctl/lib/Makefile.am | 1 + ndctl/lib/libndctl.c | 260 +++++++++++++++++++++++--------- ndctl/lib/papr_scm.c | 301 ++++++++++++++++++++++++++++++++++++++ ndctl/lib/papr_scm_pdsm.h | 175 ++++++++++++++++++++++ ndctl/lib/private.h | 9 ++ ndctl/libndctl.h | 1 + ndctl/ndctl.h | 1 + 7 files changed, 678 insertions(+), 70 deletions(-) create mode 100644 ndctl/lib/papr_scm.c create mode 100644 ndctl/lib/papr_scm_pdsm.h
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v4 1/6 libndctl: Refactor out add_dimm() to handle NFIT specific init
Presently add_dimm() only probes dimms that support NFIT/ACPI. Hence this patch refactors this functionality into two functions namely add_dimm() and add_nfit_dimm(). Function add_dimm() performs allocation and common 'struct ndctl_dimm' initialization and depending on whether the dimm-bus supports NIFT, calls add_nfit_dimm(). Once the probe is completed based on the value of 'ndctl_dimm.cmd_family' appropriate dimm-ops are assigned to the dimm.
In case dimm-bus is of unknown type or doesn't support NFIT the initialization still continues, with no dimm-ops assigned to the 'struct ndctl_dimm' there-by limiting the functionality available.
This patch shouldn't introduce any behavioral change.
---
Changelog:
v3..v4:
* None
v2..v3:
* None
v1..v2:
* None
--- ndctl/lib/libndctl.c | 193 +++++++++++++++++++++++++------------------ 1 file changed, 112 insertions(+), 81 deletions(-)
ndctl/lib/libndctl.c +112 -81
@@ -1441,82 +1441,15 @@ static int ndctl_bind(struct ndctl_ctx *ctx, struct kmod_module *module,static int ndctl_unbind (struct ndctl_ctx *ctx,const char *devpath);static struct kmod_module *to_module (struct ndctl_ctx *ctx,const char *alias); -static void *add_dimm (void *parent,int id,const char *dimm_base) +static int add_nfit_dimm (struct ndctl_dimm *dimm,const char *dimm_base) { -int formats, i; -struct ndctl_dimm *dimm; +int i, rc =-1 ;char buf[SYSFS_ATTR_SIZE ]; -struct ndctl_bus *bus = parent; -struct ndctl_ctx *ctx = bus->ctx; +struct ndctl_ctx *ctx = dimm->bus->ctx;char *path =calloc (1 ,strlen (dimm_base) +100 );if (!path) -return NULL ; - -sprintf (path,"%s/nfit/formats" , dimm_base); -if (sysfs_read_attr (ctx, path, buf) <0 ) - formats =1 ; -else - formats =clamp (strtoul (buf,NULL ,0 ),1UL ,2UL ); - - dimm =calloc (1 ,sizeof (*dimm) +sizeof (int ) * formats); -if (!dimm) - goto err_dimm; - dimm->bus = bus; - dimm->id = id; - -sprintf (path,"%s/dev" , dimm_base); -if (sysfs_read_attr (ctx, path, buf) <0 ) - goto err_read; -if (sscanf (buf,"%d:%d" , &dimm->major, &dimm->minor) !=2 ) - goto err_read; - -sprintf (path,"%s/commands" , dimm_base); -if (sysfs_read_attr (ctx, path, buf) <0 ) - goto err_read; - dimm->cmd_mask =parse_commands (buf,1 ); - - dimm->dimm_buf =calloc (1 ,strlen (dimm_base) +50 ); -if (!dimm->dimm_buf) - goto err_read; - dimm->buf_len =strlen (dimm_base) +50 ; - - dimm->dimm_path =strdup (dimm_base); -if (!dimm->dimm_path) - goto err_read; - -sprintf (path,"%s/modalias" , dimm_base); -if (sysfs_read_attr (ctx, path, buf) <0 ) - goto err_read; - dimm->module =to_module (ctx, buf); - - dimm->handle =-1 ; - dimm->phys_id =-1 ; - dimm->serial =-1 ; - dimm->vendor_id =-1 ; - dimm->device_id =-1 ; - dimm->revision_id =-1 ; - dimm->health_eventfd =-1 ; - dimm->dirty_shutdown = -ENOENT ; - dimm->subsystem_vendor_id =-1 ; - dimm->subsystem_device_id =-1 ; - dimm->subsystem_revision_id =-1 ; - dimm->manufacturing_date =-1 ; - dimm->manufacturing_location =-1 ; - dimm->cmd_family =-1 ; - dimm->nfit_dsm_mask =ULONG_MAX ; -for (i =0 ; i < formats; i++) - dimm->format[i] =-1 ; - -sprintf (path,"%s/flags" , dimm_base); -if (sysfs_read_attr (ctx, path, buf) <0 ) { - dimm->locked =-1 ; - dimm->aliased =-1 ; - }else -parse_dimm_flags (dimm, buf); - -if (!ndctl_bus_has_nfit (bus)) - goto out; +return -1 ;/* * 'unique_id' may not be available on older kernels, so don't
@@ -1582,24 +1515,15 @@ static void *add_dimm(void *parent, int id, const char *dimm_base)sprintf (path,"%s/nfit/family" , dimm_base);if (sysfs_read_attr (ctx, path, buf) ==0 ) dimm->cmd_family =strtoul (buf,NULL ,0 ); -if (dimm->cmd_family ==NVDIMM_FAMILY_INTEL ) - dimm->ops = intel_dimm_ops; -if (dimm->cmd_family ==NVDIMM_FAMILY_HPE1 ) - dimm->ops = hpe1_dimm_ops; -if (dimm->cmd_family ==NVDIMM_FAMILY_MSFT ) - dimm->ops = msft_dimm_ops; -if (dimm->cmd_family ==NVDIMM_FAMILY_HYPERV ) - dimm->ops = hyperv_dimm_ops;sprintf (path,"%s/nfit/dsm_mask" , dimm_base);if (sysfs_read_attr (ctx, path, buf) ==0 ) dimm->nfit_dsm_mask =strtoul (buf,NULL ,0 ); - dimm->formats = formats;sprintf (path,"%s/nfit/format" , dimm_base);if (sysfs_read_attr (ctx, path, buf) ==0 ) dimm->format[0 ] =strtoul (buf,NULL ,0 ); -for (i =1 ; i < formats; i++) { +for (i =1 ; i < dimm->formats; i++) {sprintf (path,"%s/nfit/format%d" , dimm_base, i);if (sysfs_read_attr (ctx, path, buf) ==0 ) dimm->format[i] =strtoul (buf,NULL ,0 );
@@ -1610,7 +1534,114 @@ static void *add_dimm(void *parent, int id, const char *dimm_base)parse_nfit_mem_flags (dimm, buf); dimm->health_eventfd =open (path,O_RDONLY |O_CLOEXEC ); + rc =0 ; + err_read: + +free (path); +return rc; +} + +static void *add_dimm (void *parent,int id,const char *dimm_base) +{ +int formats, i, rc = -ENODEV ; +struct ndctl_dimm *dimm =NULL ; +char buf[SYSFS_ATTR_SIZE ]; +struct ndctl_bus *bus = parent; +struct ndctl_ctx *ctx = bus->ctx; +char *path =calloc (1 ,strlen (dimm_base) +100 ); + +if (!path) +return NULL ; + +sprintf (path,"%s/nfit/formats" , dimm_base); +if (sysfs_read_attr (ctx, path, buf) <0 ) + formats =1 ; +else + formats =clamp (strtoul (buf,NULL ,0 ),1UL ,2UL ); + + dimm =calloc (1 ,sizeof (*dimm) +sizeof (int ) * formats); +if (!dimm) + goto err_dimm; + dimm->bus = bus; + dimm->id = id; + +sprintf (path,"%s/dev" , dimm_base); +if (sysfs_read_attr (ctx, path, buf) <0 ) + goto err_read; +if (sscanf (buf,"%d:%d" , &dimm->major, &dimm->minor) !=2 ) + goto err_read; + +sprintf (path,"%s/commands" , dimm_base); +if (sysfs_read_attr (ctx, path, buf) <0 ) + goto err_read; + dimm->cmd_mask =parse_commands (buf,1 ); + + dimm->dimm_buf =calloc (1 ,strlen (dimm_base) +50 ); +if (!dimm->dimm_buf) + goto err_read; + dimm->buf_len =strlen (dimm_base) +50 ; + + dimm->dimm_path =strdup (dimm_base); +if (!dimm->dimm_path) + goto err_read; + +sprintf (path,"%s/modalias" , dimm_base); +if (sysfs_read_attr (ctx, path, buf) <0 ) + goto err_read; + dimm->module =to_module (ctx, buf); + + dimm->handle =-1 ; + dimm->phys_id =-1 ; + dimm->serial =-1 ; + dimm->vendor_id =-1 ; + dimm->device_id =-1 ; + dimm->revision_id =-1 ; + dimm->health_eventfd =-1 ; + dimm->dirty_shutdown = -ENOENT ; + dimm->subsystem_vendor_id =-1 ; + dimm->subsystem_device_id =-1 ; + dimm->subsystem_revision_id =-1 ; + dimm->manufacturing_date =-1 ; + dimm->manufacturing_location =-1 ; + dimm->cmd_family =-1 ; + dimm->nfit_dsm_mask =ULONG_MAX ; +for (i =0 ; i < formats; i++) + dimm->format[i] =-1 ; + +sprintf (path,"%s/flags" , dimm_base); +if (sysfs_read_attr (ctx, path, buf) <0 ) { + dimm->locked =-1 ; + dimm->aliased =-1 ; + }else +parse_dimm_flags (dimm, buf); + +/* Check if the given dimm supports nfit */ +if (ndctl_bus_has_nfit (bus)) { + dimm->formats = formats; + rc =add_nfit_dimm (dimm, dimm_base); + } + +if (rc == -ENODEV ) { +/* Unprobed dimm with no family */ + rc =0 ; + goto out; + } + +/* Assign dimm-ops based on command family */ +if (dimm->cmd_family ==NVDIMM_FAMILY_INTEL ) + dimm->ops = intel_dimm_ops; +if (dimm->cmd_family ==NVDIMM_FAMILY_HPE1 ) + dimm->ops = hpe1_dimm_ops; +if (dimm->cmd_family ==NVDIMM_FAMILY_MSFT ) + dimm->ops = msft_dimm_ops; +if (dimm->cmd_family ==NVDIMM_FAMILY_HYPERV ) + dimm->ops = hyperv_dimm_ops; out: +if (rc) { +err (ctx,"Unable to probe dimm:%d. Err:%d\n" , id, rc); + goto err_read; + } +list_add (&bus->dimms, &dimm->list);free (path);
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v4 2/6 libncdtl: Add initial support for NVDIMM_FAMILY_PAPR_SCM dimm family
In reply to Vaibhav JainAdd necessary scaffolding in libndctl for dimms that support papr_scm specification[1]. Since there can be platforms that support Open-Firmware[2] but not the papr_scm specification, hence the changes proposed first add support for probing if the dimm bus supports Open-Firmware. This is done via querying for sysfs attribute 'of_node' in dimm device sysfs directory. If available newly introduced member 'struct ndctl_bus.has_of_node' is set. During the probe of the dimm and execution of add_dimm(), the newly introduced add_papr_dimm() is called if dimm bus reports supports Open-Firmware.
Function add_papr_dimm() queries the 'compatible' device tree attribute and based on its value assign NVDIMM_FAMILY_PAPR_SCM to the dimm command family. In future, based on the contents of 'compatible' attribute more of_pmem dimm families can be queried.
We also add support for parsing the dimm flags for NVDIMM_FAMILY_PAPR_SCM supporting nvdimms as described at [3]. A newly introduced function parse_papr_scm_flags() reads the contents of this flag file and sets appropriate flag bits in 'struct ndctl_dimm.flags'.
Also we advertise support for monitor mode by allocating a file descriptor to the dimm 'flags' file and assigning it to 'struct ndctl_dimm.health_event_fd'.
The dimm-ops implementation for NVDIMM_FAMILY_PAPR_SCM is available in global variable 'papr_scm_dimm_ops' which points to skeleton implementation in newly introduced file 'lib/papr_scm.c'.
References:
[1] Documentation/powerpc/papr_hcalls.rst
https://lore.kernel.org/linux-nvdimm/[email protected]/
[2] https://en.wikipedia.org/wiki/Open_Firmware
[3] Documentation/ABI/testing/sysfs-bus-papr-scm
https://lore.kernel.org/linux-nvdimm/[email protected]/
---
Changelog:
v3..v4:
* None
v2..v3:
* Renamed add_of_pmem() to add_papr_dimm() [ Aneesh ]
v1..v2:
* Squashed the patch to parse dimm flags
* Updated the dimm flags parsing to add case for 'restore_fail' and 'flush_fail'.
* Renamed parse_of_pmem_flags() to parse_papr_scm_flags().
* Updated the path to dimm flags file to 'papr/flags'.
* Introduced 'papr_scm.c' file in this patch rather than later in the patch series.
* Update add_of_pmem_dimm() to parse dimm flags and enable monitoring only if 'ibm,pmemory' compatible nvdimm is found.
--- ndctl/lib/Makefile.am | 1 + ndctl/lib/libndctl.c | 78 +++++++++++++++++++++++++++++++++++++++++++ ndctl/lib/papr_scm.c | 32 ++++++++++++++++++ ndctl/lib/private.h | 2 ++ ndctl/libndctl.h | 1 + ndctl/ndctl.h | 1 + 6 files changed, 115 insertions(+) create mode 100644 ndctl/lib/papr_scm.c
ndctl/lib/Makefile.am +1 -0
@@ -23,6 +23,7 @@ libndctl_la_SOURCES =\ hpe1.c \ msft.c \ hyperv.c \ + papr_scm.c \ ars.c \ firmware.c \ libndctl.c \
ndctl/lib/libndctl.c +78 -0
114 lines not on this page · raw message
ndctl/lib/papr_scm.c new file +32 -0
@@ -0,0 +1,32 @@ +/* +* Copyright (C) 2020 IBM Corporation +* +* This program is free software; you can redistribute it and/or modify it +* under the terms and conditions of the GNU Lesser General Public License, +* version 2.1, as published by the Free Software Foundation. +* +* This program is distributed in the hope it will be useful, but WITHOUT ANY +* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for +* more details. +*/ +#include <stdint.h> +#include <stdlib.h> +#include <limits.h> +#include <util/log.h> +#include <ndctl.h> +#include <ndctl/libndctl.h> +#include <lib/private.h> + +static bool papr_cmd_is_supported (struct ndctl_dimm *dimm,int cmd) +{ +/* Handle this separately to support monitor mode */ +if (cmd ==ND_CMD_SMART ) +return true; + +return !!(dimm->cmd_mask & (1ULL << cmd)); +} + +struct ndctl_dimm_ops *const papr_scm_dimm_ops = &(struct ndctl_dimm_ops ) { + .cmd_is_supported = papr_cmd_is_supported, +};
ndctl/lib/private.h +2 -0
@@ -167,6 +167,7 @@ struct ndctl_bus {int dimms_init;int regions_init;int has_nfit; +int has_of_node;char *bus_path;char *bus_buf;size_t buf_len;
@@ -352,6 +353,7 @@ extern struct ndctl_dimm_ops * const intel_dimm_ops;extern struct ndctl_dimm_ops *const hpe1_dimm_ops;extern struct ndctl_dimm_ops *const msft_dimm_ops;extern struct ndctl_dimm_ops *const hyperv_dimm_ops; +extern struct ndctl_dimm_ops *const papr_scm_dimm_ops;static inline struct ndctl_bus *cmd_to_bus (struct ndctl_cmd *cmd) {
ndctl/libndctl.h +1 -0
@@ -119,6 +119,7 @@ struct ndctl_bus *ndctl_bus_get_next(struct ndctl_bus *bus); bus = ndctl_bus_get_next(bus))struct ndctl_ctx *ndctl_bus_get_ctx (struct ndctl_bus *bus);int ndctl_bus_has_nfit (struct ndctl_bus *bus); +int ndctl_bus_has_of_node (struct ndctl_bus *bus);unsigned int ndctl_bus_get_major (struct ndctl_bus *bus);unsigned int ndctl_bus_get_minor (struct ndctl_bus *bus);const char *ndctl_bus_get_devname (struct ndctl_bus *bus);
ndctl/ndctl.h +1 -0
@@ -263,6 +263,7 @@ struct nd_cmd_pkg {#define NVDIMM_FAMILY_HPE2 2#define NVDIMM_FAMILY_MSFT 3#define NVDIMM_FAMILY_HYPERV 4 +#define NVDIMM_FAMILY_PAPR_SCM 5#define ND_IOCTL_CALL _IOWR(ND_IOCTL, ND_CMD_CALL,\ struct nd_cmd_pkg)
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v4 3/6 libndctl: Introduce new dimm-ops dimm_init() & dimm_uninit()
In reply to Vaibhav JainThere are scenarios when a dimm-provider need to allocate some per-dimm data that can be quickly retrieved. This data can be used to cache data that spans multiple 'struct ndctl_cmd' submissions.
Unfortunately currently in libnvdimm there is no easy way to implement this. Even if this data is some how stored in some field of 'struct ndctl_dimm', managing its lifetime is a challenge.
To solve this problem, the patch proposes a new member 'struct ndctl_dimm.dimm_user_data' to store per-dimm data interpretation of which is specific to a dimm-provider. Also two new dimm-ops namely dimm_init() & dimm_uninit() are introduced that can be used to manage the lifetime of this per-dimm data.
Semantics
=========
int (*dimm_init)(struct ndctl_dimm *):
This callback will be called just after dimm-probe inside add_dimm() is completed. Dimm-providers should use this callback to allocate per-dimm data and assign it to 'struct ndctl_dimm.dimm_user_data' member. In case this function returns an error, dimm initialization is halted and errors out.
void (*dimm_uninit)(struct ndctl_dimm *):
This callback will be called during free_dimm() and is only called if previous call to 'dimm_ops->dimm_init()' had reported no error. Dimm-providers should use this callback to unallocate and cleanup 'dimm_user_data'.
---
Changelog:
v3..v4:
* None
v2..v3:
* None
v1..v2:
* Changed the patch order
--- ndctl/lib/libndctl.c | 11 +++++++++++ ndctl/lib/private.h | 5 +++++ 2 files changed, 16 insertions(+)
ndctl/lib/libndctl.c +11 -0
@@ -598,6 +598,11 @@ static void free_dimm(struct ndctl_dimm *dimm) {if (!dimm)return ; + +/* If needed call the dimm uninitialization function */ +if (dimm->ops && dimm->ops->dimm_uninit) + dimm->ops->dimm_uninit (dimm); +free (dimm->unique_id);free (dimm->dimm_buf);free (dimm->dimm_path);
@@ -1714,8 +1719,14 @@ static void *add_dimm(void *parent, int id, const char *dimm_base)if (dimm->cmd_family ==NVDIMM_FAMILY_PAPR_SCM ) dimm->ops = papr_scm_dimm_ops; +/* Call the dimm initialization function if needed */ +if (!rc && dimm->ops && dimm->ops->dimm_init) + rc = dimm->ops->dimm_init (dimm); + out:if (rc) { +/* Ensure dimm_uninit() is not called during free_dimm() */ + dimm->ops =NULL ;err (ctx,"Unable to probe dimm:%d. Err:%d\n" , id, rc); goto err_read; }
ndctl/lib/private.h +5 -0
@@ -99,6 +99,7 @@ struct ndctl_dimm { } flags;int locked;int aliased; +void *dimm_user_data;struct list_node list;int formats;int format[0 ];
@@ -347,6 +348,10 @@ struct ndctl_dimm_ops {int (*fw_update_supported)(struct ndctl_dimm *);int (*xlat_firmware_status)(struct ndctl_cmd *);u32 (*get_firmware_status)(struct ndctl_cmd *); +/* Called just after dimm is initialized and probed */ +int (*dimm_init)(struct ndctl_dimm *); +/* Called just before struct ndctl_dimm is de-allocated */ +void (*dimm_uninit)(struct ndctl_dimm *); };extern struct ndctl_dimm_ops *const intel_dimm_ops;
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v4 4/6 libndctl,papr_scm: Add definitions for PAPR nvdimm specific methods
In reply to Vaibhav JainPull the kernel definition of PAPR_SCM DSM command which is located in the proposed kernel tree patches at Ref[1] & [2].
Also add instance of 'struct nd_pdsm_cmd_pkg' to 'struct ndctl_cmd' named as 'papr'.
References:
[1] "powerpc/papr_scm: Add support for reporting nvdimm health"
https://lore.kernel.org/linux-nvdimm/[email protected]
[2] "ndctl/papr_scm,uapi: Add support for PAPR nvdimm specific methods"
https://lore.kernel.org/linux-nvdimm/[email protected]/
---
Changelog:
v3..v4:
* Updated the definition of 'struct nd_pdsm_cmd_pkg' and pdsm_cmd_to_payload() to remove 'payload_offset' field. [ Aneesh ]
v2..v3:
* Added instance of 'struct nd_pdsm_cmd_pkg' to 'struct ndctl_cmd'
* Updated commit description.
* Updated the papr_scm_pdsm.h header to recently proposed kernel version.
v1..v2:
* Switched from obsolete papr_scm_dsm.h to recent papr_scm_pdsm.h that describes the ND_CMD_CALL interface between libndctl and papr_scm module.
--- ndctl/lib/papr_scm.c | 1 + ndctl/lib/papr_scm_pdsm.h | 175 ++++++++++++++++++++++++++++++++++++++ ndctl/lib/private.h | 2 + 3 files changed, 178 insertions(+) create mode 100644 ndctl/lib/papr_scm_pdsm.h
ndctl/lib/papr_scm.c +1 -0
@@ -17,6 +17,7 @@#include <ndctl.h> #include <ndctl/libndctl.h> #include <lib/private.h> +#include <papr_scm_pdsm.h> static bool papr_cmd_is_supported (struct ndctl_dimm *dimm,int cmd) {
ndctl/lib/papr_scm_pdsm.h new file +175 -0
175 lines not on this page · raw message
ndctl/lib/private.h +2 -0
@@ -32,6 +32,7 @@#include "hpe1.h" #include "msft.h" #include "hyperv.h" +#include "papr_scm_pdsm.h" #include "libndctl-nfit.h" struct nvdimm_data {
@@ -278,6 +279,7 @@ struct ndctl_cmd {struct ndn_pkg_msft msft[0 ];struct nd_pkg_hyperv hyperv[0 ];struct nd_pkg_intel intel[0 ]; +struct nd_pdsm_cmd_pkg papr[0 ];struct nd_cmd_get_config_size get_size[0 ];struct nd_cmd_get_config_data_hdr get_data[0 ];struct nd_cmd_set_config_hdr set_data[0 ];
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v4 5/6 libndctl,papr_scm: Add scaffolding to issue and handle PDSM requests
In reply to Vaibhav JainThis patch implement necessary infrastructure inside 'papr_scm.c' to issue and handle PDSM requests. Changes implemented are:
* Implement dimm initialization/un-initialization functions papr_dimm_init()/unint() to allocate a per-dimm 'struct dimm_priv' instance.
* New helper function allocate_cmd() to allocate command packages for a specific PDSM command and payload size.
* New function update_dimm_state() to parse a given command payload and update per dimm 'struct dimm_priv'.
* Provide an implementation of 'dimm_ops->smart_get_flags' to send the submitted instance of 'struct ndctl_cmd' to update_dimm_state().
* Logging helpers for papr_scm that use the underlying libndctl provided logging.
---
Changelog:
v3..v4:
* Remove the initialization of 'nd_pdsm_cmd_pkg.payload_offset' field from allocate_cmd(). [ Aneesh ]
v2..v3:
* None
v1..v2:
* Added new dimm callback 'papr_get_firmware_status'
* Switched to new papr_scm interface as described by papr_scm_dsm.h
* Changed the case of logging functions [ Santosh Sivaraj ]
* Removed redundant logging functions.
* Minor updates to patch description to s/DSM/PDSM/
--- ndctl/lib/papr_scm.c | 184 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+)
ndctl/lib/papr_scm.c +184 -0
@@ -19,6 +19,32 @@#include <lib/private.h> #include <papr_scm_pdsm.h> +/* Utility logging maros for simplify logging */ +#define papr_dbg (_dimm_, _format_str_, ...) dbg(_dimm_->bus->ctx, \ + "papr_scm:"#_format_str_, \ + ##__VA_ARGS__) +#define papr_err (_dimm_, _format_str_, ...) err(_dimm_->bus->ctx, \ + "papr_scm:"#_format_str_, \ + ##__VA_ARGS__) + +/* Helpers to evaluate the size of PDSM envelope */ +/* Calculate the papr_scm-header size */ +#define ND_PDSM_ENVELOPE_CONTENT_HDR_SIZE \ + (sizeof(struct nd_pdsm_cmd_pkg) - sizeof(struct nd_cmd_pkg)) + +/* Given a type calculate envelope-content size (papr_scm-header + payload) */ +#define ND_PDSM_ENVELOPE_CONTENT_SIZE (_type_) \ + (sizeof(_type_) + ND_PDSM_ENVELOPE_CONTENT_HDR_SIZE) + +/* Command flags to indicate if a given command is parsed of not */ +#define CMD_PKG_SUBMITTED 1 +#define CMD_PKG_PARSED 2 + +/* Per dimm data. Holds per-dimm data parsed from the cmd_pkgs */ +struct dimm_priv { +/* Empty for now */ +}; +static bool papr_cmd_is_supported (struct ndctl_dimm *dimm,int cmd) {/* Handle this separately to support monitor mode */
@@ -28,6 +54,164 @@ static bool papr_cmd_is_supported(struct ndctl_dimm *dimm, int cmd)return !!(dimm->cmd_mask & (1ULL << cmd)); } +static __u64 pcmd_to_pdsm (const struct nd_pdsm_cmd_pkg *pcmd) +{ +return pcmd->hdr.nd_command; +} + +static u32 papr_get_firmware_status (struct ndctl_cmd *cmd) +{ +const struct nd_pdsm_cmd_pkg *pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg); + +return (u32 ) pcmd->cmd_status; +} + +/* Verify if the given command is supported and valid */ +static bool cmd_is_valid (struct ndctl_dimm *dimm,struct ndctl_cmd *cmd) +{ +const struct nd_pdsm_cmd_pkg *pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg); + +if (dimm ==NULL ) +return false; + +if (cmd ==NULL ) { +papr_err (dimm,"Invalid command\n" ); +return false; + } + +/* Verify the command family */ +if (pcmd->hdr.nd_family !=NVDIMM_FAMILY_PAPR_SCM ) { +papr_err (dimm,"Invalid command family:0x%016llx\n" , + pcmd->hdr.nd_family); +return false; + } + +/* Verify the PDSM */ +if (pcmd_to_pdsm (pcmd) <=PAPR_SCM_PDSM_MIN || +pcmd_to_pdsm (pcmd) >=PAPR_SCM_PDSM_MAX ) { +papr_err (dimm,"Invalid command :0x%016llx\n" , + pcmd->hdr.nd_command); +return false; + } + +return true; +} + +/* Parse a command payload and update dimm flags/private data */ +static int update_dimm_stats (struct ndctl_dimm *dimm,struct ndctl_cmd *cmd) +{ +const struct nd_pdsm_cmd_pkg *pcmd; + +if (!cmd_is_valid (dimm, cmd)) +return -EINVAL ; + +/* +* Silently prevent parsing of an already parsed ndctl_cmd else +* mark the command as parsed. +*/ +if (cmd->status >=CMD_PKG_PARSED ) { +return 0 ; + }else if (cmd->status <0 ) { +papr_err (dimm,"Command error %d\n" , cmd->status); +return -ENXIO ; + } + +/* Mark the command as parsed */ + cmd->status =CMD_PKG_PARSED ; + +/* Get the pdsm request and handle it */ + pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg); +switch (pcmd_to_pdsm (pcmd)) { +default : +papr_err (dimm,"Unhandled pdsm-request 0x%016llx\n" , +pcmd_to_pdsm (pcmd)); +return -ENOENT ; + } +} + +/* Allocate a struct ndctl_cmd for given pdsm request with payload size */ +static struct ndctl_cmd *allocate_cmd (struct ndctl_dimm *dimm, +__u64 pdsm_cmd,size_t payload_size, +uint16_t payload_version) +{ +struct ndctl_cmd *cmd; +struct nd_pdsm_cmd_pkg *pcmd; +size_t size; + + size =sizeof (struct ndctl_cmd ) + +sizeof (struct nd_pdsm_cmd_pkg ) + payload_size; + cmd =calloc (1 , size); +if (!cmd) +return NULL ; + pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg); + +ndctl_cmd_ref (cmd); + cmd->dimm = dimm; + cmd->type =ND_CMD_CALL ; + cmd->size = size; + cmd->status =CMD_PKG_SUBMITTED ; + cmd->get_firmware_status = &papr_get_firmware_status; + +/* Populate the nd_cmd_pkg contained in nd_pdsm_cmd_pkg */ + pcmd->hdr.nd_family =NVDIMM_FAMILY_PAPR_SCM ; + pcmd->hdr.nd_command = pdsm_cmd; + + pcmd->payload_version = payload_version; + +/* Keep payload size empty. To be populated by called */ + pcmd->hdr.nd_fw_size =0 ; + pcmd->hdr.nd_size_out =0 ; + pcmd->hdr.nd_size_in =0 ; + +return cmd; +} + +static unsigned int papr_smart_get_flags (struct ndctl_cmd *cmd) +{ +/* In case of error return empty flags * */ +if (update_dimm_stats (cmd->dimm, cmd)) +return 0 ; + +/* Return empty flags for now as no DSM support */ +return 0 ; +} + +static int papr_dimm_init (struct ndctl_dimm *dimm) +{ +struct dimm_priv *p; + +if (dimm->dimm_user_data) { +papr_dbg (dimm,"Dimm already initialized !!\n" ); +return 0 ; + } + + p =calloc (1 ,sizeof (struct dimm_priv )); +if (!p) { +papr_err (dimm,"Unable to allocate memory for dimm-private\n" ); +return -1 ; + } + + dimm->dimm_user_data = p; +return 0 ; +} + +static void papr_dimm_uninit (struct ndctl_dimm *dimm) +{ +struct dimm_priv *p = dimm->dimm_user_data; + +if (!p) { +papr_dbg (dimm,"Dimm already un-initialized !!\n" ); +return ; + } + + dimm->dimm_user_data =NULL ; +free (p); +} +struct ndctl_dimm_ops *const papr_scm_dimm_ops = &(struct ndctl_dimm_ops ) { .cmd_is_supported = papr_cmd_is_supported, + .dimm_init = papr_dimm_init, + .dimm_uninit = papr_dimm_uninit, + .smart_get_flags = papr_smart_get_flags, + .get_firmware_status = papr_get_firmware_status, };
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v4 6/6 libndctl,papr_scm: Implement support for PAPR_SCM_PDSM_HEALTH
In reply to Vaibhav JainAdd support for reporting DIMM health and shutdown state by issuing PAPR_SCM_PDSM_HEALTH request to papr_scm module. It returns an instance of 'struct nd_papr_pdsm_health' as defined in 'papr_scm_pdsm.h'. The patch provides support for dimm-ops 'new_smart', 'smart_get_health' & 'smart_get_shutdown_state' as newly introduced functions papr_new_smart_health(), papr_smart_get_health() & papr_smart_get_shutdown_state() respectively. These callbacks should enable ndctl to report DIMM health.
Also a new member 'struct dimm_priv.health' is introduced which holds the current health status of the dimm. This member is set inside newly added function 'update_dimm_health_v1()' which parses the v1 payload returned by the kernel after servicing PAPR_SCM_PDSM_HEALTH. The function will also update dimm-flags viz 'struct ndctl_dimm.flags.f_*' based on the flags set in the returned payload.
---
Changelog:
v3..v4:
* None
v2..v3:
* None
v1..v2:
* Squashed patch to report nvdimm bad shutdown state with this patch.
* Switched to new structs/enums as defined in papr_scm_pdsm.h
--- ndctl/lib/papr_scm.c | 90 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 87 insertions(+), 3 deletions(-)
ndctl/lib/papr_scm.c +87 -3
@@ -42,7 +42,9 @@/* Per dimm data. Holds per-dimm data parsed from the cmd_pkgs */ struct dimm_priv { -/* Empty for now */ + +/* Cache the dimm health status */ +struct nd_papr_pdsm_health health; };static bool papr_cmd_is_supported (struct ndctl_dimm *dimm,int cmd)
@@ -97,6 +99,43 @@ static bool cmd_is_valid(struct ndctl_dimm *dimm, struct ndctl_cmd *cmd)return true; } +/* +* Parse the nd_papr_pdsm_health_v1 payload embedded in ndctl_cmd and +* update dimm health/flags +*/ +static int update_dimm_health_v1 (struct ndctl_dimm *dimm,struct ndctl_cmd *cmd) +{ +struct nd_pdsm_cmd_pkg *pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg); +struct dimm_priv *p = dimm->dimm_user_data; +const struct nd_papr_pdsm_health_v1 *health = +pdsm_cmd_to_payload (pcmd); + +/* Update the dimm flags */ + dimm->flags.f_arm = health->dimm_unarmed; + dimm->flags.f_flush = health->dimm_bad_shutdown; + dimm->flags.f_restore = health->dimm_bad_restore; + dimm->flags.f_smart = (health->dimm_health !=0 ); + +/* Cache the dimm health information */ +memcpy (&p->health, health,sizeof (*health)); +return 0 ; +} + +/* Check payload version returned and pass the packet to appropriate handler */ +static int update_dimm_health (struct ndctl_dimm *dimm,struct ndctl_cmd *cmd) +{ +const struct nd_pdsm_cmd_pkg *pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg); + +if (pcmd->payload_version ==1 ) +return update_dimm_health_v1 (dimm, cmd); + +/* unknown version */ +papr_err (dimm,"Unknown payload version for dimm_health.\n" ); +papr_dbg (dimm,"dimm_health payload Ver=%d, Supported=%d\n" , + pcmd->payload_version,ND_PAPR_PDSM_HEALTH_VERSION ); +return -EINVAL ; +} +/* Parse a command payload and update dimm flags/private data */ static int update_dimm_stats (struct ndctl_dimm *dimm,struct ndctl_cmd *cmd) {
@@ -122,6 +161,8 @@ static int update_dimm_stats(struct ndctl_dimm *dimm, struct ndctl_cmd *cmd)/* Get the pdsm request and handle it */ pcmd =nd_to_pdsm_cmd_pkg (cmd->pkg);switch (pcmd_to_pdsm (pcmd)) { +case PAPR_SCM_PDSM_HEALTH : +return update_dimm_health (dimm, cmd);default :papr_err (dimm,"Unhandled pdsm-request 0x%016llx\n" ,pcmd_to_pdsm (pcmd));
@@ -166,14 +207,54 @@ static struct ndctl_cmd *allocate_cmd(struct ndctl_dimm *dimm,return cmd; } +static struct ndctl_cmd *papr_new_smart_health (struct ndctl_dimm *dimm) +{ +struct ndctl_cmd *cmd_ret; + + cmd_ret =allocate_cmd (dimm,PAPR_SCM_PDSM_HEALTH , +sizeof (struct nd_papr_pdsm_health ), +ND_PAPR_PDSM_HEALTH_VERSION ); +if (!cmd_ret) { +papr_err (dimm,"Unable to allocate smart_health command\n" ); +return NULL ; + } + + cmd_ret->pkg[0 ].nd_size_out =ND_PDSM_ENVELOPE_CONTENT_SIZE ( + struct nd_papr_pdsm_health); + +return cmd_ret; +} + +static unsigned int papr_smart_get_health (struct ndctl_cmd *cmd) +{ +struct dimm_priv *p = cmd->dimm->dimm_user_data; + +/* +* Update the dimm stats and use some math to return one of +* defined ND_SMART_*_HEALTH values +*/ +if (update_dimm_stats (cmd->dimm, cmd) || !p->health.dimm_health) +return 0 ; +else +return 1 << (p->health.dimm_health -1 ); +} + +static unsigned int papr_smart_get_shutdown_state (struct ndctl_cmd *cmd) +{ +struct dimm_priv *p = cmd->dimm->dimm_user_data; + +/* Update dimm state and return f_flush */ +return update_dimm_stats (cmd->dimm, cmd) ? +0 : p->health.dimm_bad_shutdown; +} +static unsigned int papr_smart_get_flags (struct ndctl_cmd *cmd) {/* In case of error return empty flags * */ if (update_dimm_stats (cmd->dimm, cmd))return 0 ; -/* Return empty flags for now as no DSM support */ -return 0 ; +return ND_SMART_HEALTH_VALID |ND_SMART_SHUTDOWN_VALID ; }static int papr_dimm_init (struct ndctl_dimm *dimm)
@@ -214,4 +295,7 @@ struct ndctl_dimm_ops * const papr_scm_dimm_ops = &(struct ndctl_dimm_ops) { .dimm_uninit = papr_dimm_uninit, .smart_get_flags = papr_smart_get_flags, .get_firmware_status = papr_get_firmware_status, + .new_smart = papr_new_smart_health, + .smart_get_health = papr_smart_get_health, + .smart_get_shutdown_state = papr_smart_get_shutdown_state, };
Signature · 4 lines
2.26.2 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]