Add support for reporting papr-scm nvdimm health
v2 cover Add support for reporting papr-scm nvdimm health
This patch-set proposes changes to libndctl to add support for reporting health for nvdimms that support the PAPR standard[1]. 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[2]. 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 [3] 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[4] 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.
Changelog
=========
v1..v2:
* Reordered and squashed couple of patches to reduce the patchset size.
* Addressed few offline review comments from Santosh Sivaraj.
* Updated the uapi header file for papr_scm_pdsm.h.
* Updated the struct names based on the new uapi header.
References
==========
[1] "Power Architecture Platform Reference"
https://en.wikipedia.org/wiki/Power_Architecture_Platform_Reference
[2] "Hypercall Op-codes (hcalls)"
https://github.com/torvalds/linux/blob/master/Documentation/powerpc/papr_hcalls.rst
[3] "[PATCH v6 3/4] ndctl/papr_scm,uapi: Add support for PAPR nvdimm specific methods"
https://lore.kernel.org/linux-nvdimm/[email protected]/
[4] "powerpc/papr_scm: Add support for reporting nvdimm health"
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 | 293 ++++++++++++++++++++++++++++++++++++++ ndctl/lib/papr_scm_pdsm.h | 192 +++++++++++++++++++++++++ ndctl/lib/private.h | 7 + ndctl/libndctl.h | 1 + ndctl/ndctl.h | 1 + 7 files changed, 685 insertions(+), 70 deletions(-) create mode 100644 ndctl/lib/papr_scm.c create mode 100644 ndctl/lib/papr_scm_pdsm.h
Signature · 4 lines
2.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 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:
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.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [ndctl PATCH v2 1/6] libndctl: Refactor out add_dimm() to handle NFIT specific init
Quoted 12 lines · Vaibhav Jain
Presently
add_dimm()only probes dimms that support NFIT/ACPI. Hence this patch refactors this functionality into two functions namelyadd_dimm()andadd_nfit_dimm(). Functionadd_dimm()performs allocation and common 'structndctl_dimm' initialization and depending on whether the dimm-bus supports NIFT, callsadd_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.
Quoted 8 lines
This patch shouldn't introduce any behavioral change.
Signed-off-by Vaibhav Jain <[email protected]>---
Changelog:v1..v2:
* None
Looks good to me. For the series,
Thanks,
Santosh
Quoted 238 lines
--- 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 · 1 line
2.25.3
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [ndctl PATCH v2 1/6] libndctl: Refactor out add_dimm() to handle NFIT specific init
In reply to Vaibhav JainQuoted 51 lines · Vaibhav Jain
Presently
add_dimm()only probes dimms that support NFIT/ACPI. Hence this patch refactors this functionality into two functions namelyadd_dimm()andadd_nfit_dimm(). Functionadd_dimm()performs allocation and common 'structndctl_dimm' initialization and depending on whether the dimm-bus supports NIFT, callsadd_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.
Signed-off-by Vaibhav Jain <[email protected]>---
Changelog:v1..v2:
* None--- ndctl/lib/libndctl.c | 193 +++++++++++++++++++++++++------------------ 1 file changed, 112 insertions(+), 81 deletions(-)ndctl/lib/libndctl.c +3
-11@@ -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
....
Quoted 10 lines
ndctl/lib/libndctl.c +10
-0+ 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 ;
ndctl/lib/libndctl.c static void *add_dimm(void *parent, int id, const char *dimm_base) · line 1556
Quoted 10 lines
ndctl/lib/libndctl.c +10
-0+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);
Witht that abstraction this should be part of add_nfit_dimm?
ndctl/lib/libndctl.c static void *add_dimm(void *parent, int id, const char *dimm_base) · line 1567
Quoted 11 lines
ndctl/lib/libndctl.c +11
-0+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; +
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [ndctl PATCH v2 1/6] libndctl: Refactor out add_dimm() to handle NFIT specific init
Hi Aneesh,
Thanks for looking into this patch.
Quoted 69 lines · Aneesh Kumar K.V
Quoted 51 lines · Vaibhav Jain
Presently
add_dimm()only probes dimms that support NFIT/ACPI. Hence this patch refactors this functionality into two functions namelyadd_dimm()andadd_nfit_dimm(). Functionadd_dimm()performs allocation and common 'structndctl_dimm' initialization and depending on whether the dimm-bus supports NIFT, callsadd_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.
Signed-off-by Vaibhav Jain <[email protected]>---
Changelog:v1..v2:
* None--- ndctl/lib/libndctl.c | 193 +++++++++++++++++++++++++------------------ 1 file changed, 112 insertions(+), 81 deletions(-)ndctl/lib/libndctl.c +3
-11@@ -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 ....
Quoted 14 lines
ndctl/lib/libndctl.c +14
-0+ 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;
Quoted 8 lines
ndctl/lib/libndctl.c static void *add_dimm(void *parent, int id, const char *dimm_base) · line 1556
Quoted 6 lines
ndctl/lib/libndctl.c +6
-0+char *path =calloc (1 ,strlen (dimm_base) +100 ); + +if (!path) +return NULL ; + +sprintf (path,"%s/nfit/formats" , dimm_base);Witht that abstraction this should be part of
add_nfit_dimm?
This part is needed to calculate the size of 'struct ndctl_dimm' to be allocated which is based on number of nfit formats reported in sysfs.
Quoted 15 lines
ndctl/lib/libndctl.c static void *add_dimm(void *parent, int id, const char *dimm_base) · line 1567
Quoted 12 lines
ndctl/lib/libndctl.c +11
-0+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; +_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
~ Vaibhav
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 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_of_pmem_dimm() is called if dimm bus reports supports Open-Firmware.
Function add_of_pmem_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:
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.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [ndctl PATCH v2 2/6] libncdtl: Add initial support for NVDIMM_FAMILY_PAPR_SCM dimm family
Quoted 15 lines · Vaibhav Jain
Add necessary scaffolding in libndctl for dimms that support
papr_scmspecification[1]. Since there can be platforms that support Open-Firmware[2] but not thepapr_scmspecification, 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 ofadd_dimm(), the newly introducedadd_of_pmem_dimm()is called if dimm bus reports supports Open-Firmware.Function
add_of_pmem_dimm()queries the 'compatible' device tree attribute and based on its value assignNVDIMM_FAMILY_PAPR_SCMto the dimm command family. In future, based on the contents of 'compatible' attribute moreof_pmemdimm families can be queried.
Quoted 5 lines
We also add support for parsing the dimm flags for
NVDIMM_FAMILY_PAPR_SCMsupporting nvdimms as described at [3]. A newly introduced functionparse_papr_scm_flags()reads the contents of this flag file and sets appropriate flag bits in 'struct ndctl_dimm.flags'.
The mixing of of_pmem and papr_scm is confuring here considering we have two different driver in the kernel. If both can be handled by the same code them possibly function that indicate both? ie, replace add_of_pmem_dimm() with something more generic?
Quoted 9 lines
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_SCMis available in global variable 'papr_scm_dimm_ops' which points to skeleton implementation in newly introduced file 'lib/papr_scm.c'.
-aneesh
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [ndctl PATCH v2 2/6] libncdtl: Add initial support for NVDIMM_FAMILY_PAPR_SCM dimm family
Quoted 23 lines · Aneesh Kumar K.V
Quoted 15 lines · Vaibhav Jain
Add necessary scaffolding in libndctl for dimms that support
papr_scmspecification[1]. Since there can be platforms that support Open-Firmware[2] but not thepapr_scmspecification, 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 ofadd_dimm(), the newly introducedadd_of_pmem_dimm()is called if dimm bus reports supports Open-Firmware.Function
add_of_pmem_dimm()queries the 'compatible' device tree attribute and based on its value assignNVDIMM_FAMILY_PAPR_SCMto the dimm command family. In future, based on the contents of 'compatible' attribute moreof_pmemdimm families can be queried.Quoted 5 lines
We also add support for parsing the dimm flags for
NVDIMM_FAMILY_PAPR_SCMsupporting nvdimms as described at [3]. A newly introduced functionparse_papr_scm_flags()reads the contents of this flag file and sets appropriate flag bits in 'struct ndctl_dimm.flags'.
Quoted 4 lines
The mixing of
of_pmemandpapr_scmis confuring here considering we have two different driver in the kernel. If both can be handled by the same code them possibly function that indicate both? ie, replaceadd_of_pmem_dimm()with something more generic?
Currently this function handles only papr compliant memory hence will rename the function to add_papr_pmem_dimm() as discussed offline.
Quoted 12 lines
Quoted 10 lines
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_SCMis available in global variable 'papr_scm_dimm_ops' which points to skeleton implementation in newly introduced file 'lib/papr_scm.c'.
Quoted 4 lines
-aneesh
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
~ Vaibhav
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 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:
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.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 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].
References:
[1] "ndctl/papr_scm,uapi: Add support for PAPR nvdimm specific methods"
https://lore.kernel.org/linux-nvdimm/[email protected]/
[2] "powerpc/papr_scm: Implement support for PAPR_SCM_PDSM_HEALTH"
https://lore.kernel.org/linux-nvdimm/[email protected]/
---
Changelog:
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 | 192 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 193 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 +192 -0
192 lines not on this page · raw message
Signature · 4 lines
2.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 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:
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 | 176 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 176 insertions(+)
ndctl/lib/papr_scm.c +176 -0
@@ -19,6 +19,23 @@#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__) + +/* 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 +45,165 @@ 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; + pcmd->payload_offset =sizeof (struct nd_pdsm_cmd_pkg ); + +/* 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.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 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:
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
@@ -33,7 +33,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)
@@ -88,6 +90,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) {
@@ -113,6 +152,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));
@@ -158,14 +199,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)
@@ -206,4 +287,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.25.3 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]