ndctl/papr_scm,uapi: Add support for PAPR nvdimm specific methods (f517f792) · Commits · 戴 / test

arch/powerpc/include/uapi/asm/papr_pdsm.h

0 → 100644

+95 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
		/*
		* PAPR nvDimm Specific Methods (PDSM) and structs for libndctl
		*
		* (C) Copyright IBM 2020
		*
		* Author: Vaibhav Jain <vaibhav at linux.ibm.com>
		*/

		#ifndef _UAPI_ASM_POWERPC_PAPR_PDSM_H_
		#define _UAPI_ASM_POWERPC_PAPR_PDSM_H_

		#include <linux/types.h>
		#include <linux/ndctl.h>

		/*
		* PDSM Envelope:
		*
		* The ioctl ND_CMD_CALL exchange data between user-space and kernel via
		* envelope which consists of 2 headers sections and payload sections as
		* illustrated below:
		* +-----------------+---------------+---------------------------+
		* \| 64-Bytes \| 8-Bytes \| Max 184-Bytes \|
		* +-----------------+---------------+---------------------------+
		* \| ND-HEADER \| PDSM-HEADER \| PDSM-PAYLOAD \|
		* +-----------------+---------------+---------------------------+
		* \| nd_family \| \| \|
		* \| nd_size_out \| cmd_status \| \|
		* \| nd_size_in \| reserved \| nd_pdsm_payload \|
		* \| nd_command \| payload --> \| \|
		* \| nd_fw_size \| \| \|
		* \| nd_payload ---> \| \| \|
		* +---------------+-----------------+---------------------------+
		*
		* ND Header:
		* This is the generic libnvdimm header described as 'struct nd_cmd_pkg'
		* which is interpreted by libnvdimm before passed on to papr_scm. Important
		* member fields used are:
		* 'nd_family' : (In) NVDIMM_FAMILY_PAPR_SCM
		* 'nd_size_in' : (In) PDSM-HEADER + PDSM-IN-PAYLOAD (usually 0)
		* 'nd_size_out' : (In) PDSM-HEADER + PDSM-RETURN-PAYLOAD
		* 'nd_command' : (In) One of PAPR_PDSM_XXX
		* 'nd_fw_size' : (Out) PDSM-HEADER + size of actual payload returned
		*
		* PDSM Header:
		* This is papr-scm specific header that precedes the payload. This is defined
		* as nd_cmd_pdsm_pkg. Following fields aare available in this header:
		*
		* 'cmd_status' : (Out) Errors if any encountered while servicing PDSM.
		* 'reserved' : Not used, reserved for future and should be set to 0.
		* 'payload' : A union of all the possible payload structs
		*
		* PDSM Payload:
		*
		* The layout of the PDSM Payload is defined by various structs shared between
		* papr_scm and libndctl so that contents of payload can be interpreted. As such
		* its defined as a union of all possible payload structs as
		* 'union nd_pdsm_payload'. Based on the value of 'nd_cmd_pkg.nd_command'
		* appropriate member of the union is accessed.
		*/

		/* Max payload size that we can handle */
		#define ND_PDSM_PAYLOAD_MAX_SIZE 184

		/* Max payload size that we can handle */
		#define ND_PDSM_HDR_SIZE \
		(sizeof(struct nd_pkg_pdsm) - ND_PDSM_PAYLOAD_MAX_SIZE)

		/*
		* Methods to be embedded in ND_CMD_CALL request. These are sent to the kernel
		* via 'nd_cmd_pkg.nd_command' member of the ioctl struct
		*/
		enum papr_pdsm {
		PAPR_PDSM_MIN = 0x0,
		PAPR_PDSM_MAX,
		};

		/* Maximal union that can hold all possible payload types */
		union nd_pdsm_payload {
		__u8 buf[ND_PDSM_PAYLOAD_MAX_SIZE];
		} __packed;

		/*
		* PDSM-header + payload expected with ND_CMD_CALL ioctl from libnvdimm
		* Valid member of union 'payload' is identified via 'nd_cmd_pkg.nd_command'
		* that should always precede this struct when sent to papr_scm via CMD_CALL
		* interface.
		*/
		struct nd_pkg_pdsm {
		__s32 cmd_status; /* Out: Sub-cmd status returned back */
		__u16 reserved[2]; /* Ignored and to be set as '0' */
		union nd_pdsm_payload payload;
		} __packed;

		#endif /* _UAPI_ASM_POWERPC_PAPR_PDSM_H_ */

arch/powerpc/platforms/pseries/papr_scm.c

+189 −4

Original line number	Diff line number	Diff line
		@@ -15,13 +15,15 @@
		#include <linux/seq_buf.h>

		#include <asm/plpar_wrappers.h>
		#include <asm/papr_pdsm.h>

		#define BIND_ANY_ADDR (~0ul)

		#define PAPR_SCM_DIMM_CMD_MASK \
		((1ul << ND_CMD_GET_CONFIG_SIZE) \| \
		(1ul << ND_CMD_GET_CONFIG_DATA) \| \
		(1ul << ND_CMD_SET_CONFIG_DATA))
		(1ul << ND_CMD_SET_CONFIG_DATA) \| \
		(1ul << ND_CMD_CALL))

		/* DIMM health bitmap bitmap indicators */
		/* SCM device is unable to persist memory contents */
		@@ -349,17 +351,195 @@ static int papr_scm_meta_set(struct papr_scm_priv *p,
		return 0;
		}

		/*
		* Do a sanity checks on the inputs args to dimm-control function and return
		* '0' if valid. Validation of PDSM payloads happens later in
		* papr_scm_service_pdsm.
		*/
		static int is_cmd_valid(struct nvdimm nvdimm, unsigned int cmd, void buf,
		unsigned int buf_len)
		{
		unsigned long cmd_mask = PAPR_SCM_DIMM_CMD_MASK;
		struct nd_cmd_pkg *nd_cmd;
		struct papr_scm_priv *p;
		enum papr_pdsm pdsm;

		/* Only dimm-specific calls are supported atm */
		if (!nvdimm)
		return -EINVAL;

		/* get the provider data from struct nvdimm */
		p = nvdimm_provider_data(nvdimm);

		if (!test_bit(cmd, &cmd_mask)) {
		dev_dbg(&p->pdev->dev, "Unsupported cmd=%u\n", cmd);
		return -EINVAL;
		}

		/* For CMD_CALL verify pdsm request */
		if (cmd == ND_CMD_CALL) {
		/* Verify the envelope and envelop size */
		if (!buf \|\|
		buf_len < (sizeof(struct nd_cmd_pkg) + ND_PDSM_HDR_SIZE)) {
		dev_dbg(&p->pdev->dev, "Invalid pkg size=%u\n",
		buf_len);
		return -EINVAL;
		}

		/* Verify that the nd_cmd_pkg.nd_family is correct */
		nd_cmd = (struct nd_cmd_pkg *)buf;

		if (nd_cmd->nd_family != NVDIMM_FAMILY_PAPR) {
		dev_dbg(&p->pdev->dev, "Invalid pkg family=0x%llx\n",
		nd_cmd->nd_family);
		return -EINVAL;
		}

		pdsm = (enum papr_pdsm)nd_cmd->nd_command;

		/* Verify if the pdsm command is valid */
		if (pdsm <= PAPR_PDSM_MIN \|\| pdsm >= PAPR_PDSM_MAX) {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Invalid PDSM\n",
		pdsm);
		return -EINVAL;
		}

		/* Have enough space to hold returned 'nd_pkg_pdsm' header */
		if (nd_cmd->nd_size_out < ND_PDSM_HDR_SIZE) {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Invalid payload\n",
		pdsm);
		return -EINVAL;
		}
		}

		/* Let the command be further processed */
		return 0;
		}

		/*
		* 'struct pdsm_cmd_desc'
		* Identifies supported PDSMs' expected length of in/out payloads
		* and pdsm service function.
		*
		* size_in : Size of input payload if any in the PDSM request.
		* size_out : Size of output payload if any in the PDSM request.
		* service : Service function for the PDSM request. Return semantics:
		* rc < 0 : Error servicing PDSM and rc indicates the error.
		* rc >=0 : Serviced successfully and 'rc' indicate number of
		* bytes written to payload.
		*/
		struct pdsm_cmd_desc {
		u32 size_in;
		u32 size_out;
		int (service)(struct papr_scm_priv dimm,
		union nd_pdsm_payload *payload);
		};

		/* Holds all supported PDSMs' command descriptors */
		static const struct pdsm_cmd_desc __pdsm_cmd_descriptors[] = {
		[PAPR_PDSM_MIN] = {
		.size_in = 0,
		.size_out = 0,
		.service = NULL,
		},
		/* New PDSM command descriptors to be added below */

		/* Empty */
		[PAPR_PDSM_MAX] = {
		.size_in = 0,
		.size_out = 0,
		.service = NULL,
		},
		};

		/* Given a valid pdsm cmd return its command descriptor else return NULL */
		static inline const struct pdsm_cmd_desc *pdsm_cmd_desc(enum papr_pdsm cmd)
		{
		if (cmd >= 0 \|\| cmd < ARRAY_SIZE(__pdsm_cmd_descriptors))
		return &__pdsm_cmd_descriptors[cmd];

		return NULL;
		}

		/*
		* For a given pdsm request call an appropriate service function.
		* Returns errors if any while handling the pdsm command package.
		*/
		static int papr_scm_service_pdsm(struct papr_scm_priv *p,
		struct nd_cmd_pkg *pkg)
		{
		/* Get the PDSM header and PDSM command */
		struct nd_pkg_pdsm pdsm_pkg = (struct nd_pkg_pdsm )pkg->nd_payload;
		enum papr_pdsm pdsm = (enum papr_pdsm)pkg->nd_command;
		const struct pdsm_cmd_desc *pdsc;
		int rc;

		/* Fetch corresponding pdsm descriptor for validation and servicing */
		pdsc = pdsm_cmd_desc(pdsm);

		/* Validate pdsm descriptor */
		/* Ensure that reserved fields are 0 */
		if (pdsm_pkg->reserved[0] \|\| pdsm_pkg->reserved[1]) {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Invalid reserved field\n",
		pdsm);
		return -EINVAL;
		}

		/* If pdsm expects some input, then ensure that the size_in matches */
		if (pdsc->size_in &&
		pkg->nd_size_in != (pdsc->size_in + ND_PDSM_HDR_SIZE)) {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Mismatched size_in=%d\n",
		pdsm, pkg->nd_size_in);
		return -EINVAL;
		}

		/* If pdsm wants to return data, then ensure that size_out matches */
		if (pdsc->size_out &&
		pkg->nd_size_out != (pdsc->size_out + ND_PDSM_HDR_SIZE)) {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Mismatched size_out=%d\n",
		pdsm, pkg->nd_size_out);
		return -EINVAL;
		}

		/* Service the pdsm */
		if (pdsc->service) {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Servicing..\n", pdsm);

		rc = pdsc->service(p, &pdsm_pkg->payload);

		if (rc < 0) {
		/* error encountered while servicing pdsm */
		pdsm_pkg->cmd_status = rc;
		pkg->nd_fw_size = ND_PDSM_HDR_SIZE;
		} else {
		/* pdsm serviced and 'rc' bytes written to payload */
		pdsm_pkg->cmd_status = 0;
		pkg->nd_fw_size = ND_PDSM_HDR_SIZE + rc;
		}
		} else {
		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Unsupported PDSM request\n",
		pdsm);
		pdsm_pkg->cmd_status = -ENOENT;
		pkg->nd_fw_size = ND_PDSM_HDR_SIZE;
		}

		return pdsm_pkg->cmd_status;
		}

		static int papr_scm_ndctl(struct nvdimm_bus_descriptor *nd_desc,
		struct nvdimm nvdimm, unsigned int cmd, void buf,
		unsigned int buf_len, int *cmd_rc)
		{
		struct nd_cmd_get_config_size *get_size_hdr;
		struct nd_cmd_pkg *call_pkg = NULL;
		struct papr_scm_priv *p;
		int rc;

		/* Only dimm-specific calls are supported atm */
		if (!nvdimm)
		return -EINVAL;
		rc = is_cmd_valid(nvdimm, cmd, buf, buf_len);
		if (rc) {
		pr_debug("Invalid cmd=0x%x. Err=%d\n", cmd, rc);
		return rc;
		}

		/* Use a local variable in case cmd_rc pointer is NULL */
		if (!cmd_rc)
		@@ -385,6 +565,11 @@ static int papr_scm_ndctl(struct nvdimm_bus_descriptor *nd_desc,
		*cmd_rc = papr_scm_meta_set(p, buf);
		break;

		case ND_CMD_CALL:
		call_pkg = (struct nd_cmd_pkg *)buf;
		*cmd_rc = papr_scm_service_pdsm(p, call_pkg);
		break;

		default:
		dev_dbg(&p->pdev->dev, "Unknown command = %d\n", cmd);
		return -EINVAL;

include/uapi/linux/ndctl.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -244,6 +244,7 @@ struct nd_cmd_pkg {
		#define NVDIMM_FAMILY_HPE2 2
		#define NVDIMM_FAMILY_MSFT 3
		#define NVDIMM_FAMILY_HYPERV 4
		#define NVDIMM_FAMILY_PAPR 5

		#define ND_IOCTL_CALL _IOWR(ND_IOCTL, ND_CMD_CALL,\
		struct nd_cmd_pkg)

Admin message