arch/powerpc/platforms/pseries/papr-sysparm.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only

 #define pr_fmt(fmt)	"papr-sysparm: " fmt

 #include <linux/anon_inodes.h>
 #include <linux/bug.h>
 #include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/miscdevice.h>
 #include <linux/printk.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <asm/machdep.h>
 #include <asm/papr-sysparm.h>
 #include <asm/rtas-work-area.h>
 #include <asm/rtas.h>

 struct papr_sysparm_buf *papr_sysparm_buf_alloc(void)
 {
 	struct papr_sysparm_buf *buf = kzalloc(sizeof(*buf), GFP_KERNEL);

 	return buf;
 }

 void papr_sysparm_buf_free(struct papr_sysparm_buf *buf)
 {
 	kfree(buf);
 }

 static size_t papr_sysparm_buf_get_length(const struct papr_sysparm_buf *buf)
 {
 	return be16_to_cpu(buf->len);
 }

 static void papr_sysparm_buf_set_length(struct papr_sysparm_buf *buf, size_t length)
 {
 	WARN_ONCE(length > sizeof(buf->val),
 		  "bogus length %zu, clamping to safe value", length);
 	length = min(sizeof(buf->val), length);
 	buf->len = cpu_to_be16(length);
 }

 /*
  * For use on buffers returned from ibm,get-system-parameter before
  * returning them to callers. Ensures the encoded length of valid data
  * cannot overrun buf->val[].
  */
 static void papr_sysparm_buf_clamp_length(struct papr_sysparm_buf *buf)
 {
 	papr_sysparm_buf_set_length(buf, papr_sysparm_buf_get_length(buf));
 }

 /*
  * Perform some basic diligence on the system parameter buffer before
  * submitting it to RTAS.
  */
 static bool papr_sysparm_buf_can_submit(const struct papr_sysparm_buf *buf)
 {
 	/*
 	 * Firmware ought to reject buffer lengths that exceed the
 	 * maximum specified in PAPR, but there's no reason for the
 	 * kernel to allow them either.
 	 */
 	if (papr_sysparm_buf_get_length(buf) > sizeof(buf->val))
 		return false;

 	return true;
 }

 /**
  * papr_sysparm_get() - Retrieve the value of a PAPR system parameter.
  * @param: PAPR system parameter token as described in
  *         7.3.16 "System Parameters Option".
  * @buf: A &struct papr_sysparm_buf as returned from papr_sysparm_buf_alloc().
  *
  * Place the result of querying the specified parameter, if available,
  * in @buf. The result includes a be16 length header followed by the
  * value, which may be a string or binary data. See &struct papr_sysparm_buf.
  *
  * Since there is at least one parameter (60, OS Service Entitlement
  * Status) where the results depend on the incoming contents of the
  * work area, the caller-supplied buffer is copied unmodified into the
  * work area before calling ibm,get-system-parameter.
  *
  * A defined parameter may not be implemented on a given system, and
  * some implemented parameters may not be available to all partitions
  * on a system. A parameter's disposition may change at any time due
  * to system configuration changes or partition migration.
  *
  * Context: This function may sleep.
  *
  * Return: 0 on success, -errno otherwise. @buf is unmodified on error.
  */
 int papr_sysparm_get(papr_sysparm_t param, struct papr_sysparm_buf *buf)
 {
 	const s32 token = rtas_function_token(RTAS_FN_IBM_GET_SYSTEM_PARAMETER);
 	struct rtas_work_area *work_area;
 	s32 fwrc;
 	int ret;

 	might_sleep();

 	if (WARN_ON(!buf))
 		return -EFAULT;

 	if (token == RTAS_UNKNOWN_SERVICE)
 		return -ENOENT;

 	if (!papr_sysparm_buf_can_submit(buf))
 		return -EINVAL;

 	work_area = rtas_work_area_alloc(sizeof(*buf));

 	memcpy(rtas_work_area_raw_buf(work_area), buf, sizeof(*buf));

 	do {
 		fwrc = rtas_call(token, 3, 1, NULL, param.token,
 				 rtas_work_area_phys(work_area),
 				 rtas_work_area_size(work_area));
 	} while (rtas_busy_delay(fwrc));

 	switch (fwrc) {
 	case 0:
 		ret = 0;
 		memcpy(buf, rtas_work_area_raw_buf(work_area), sizeof(*buf));
 		papr_sysparm_buf_clamp_length(buf);
 		break;
 	case -3: /* parameter not implemented */
 		ret = -EOPNOTSUPP;
 		break;
 	case -9002: /* this partition not authorized to retrieve this parameter */
 		ret = -EPERM;
 		break;
 	case -9999: /* "parameter error" e.g. the buffer is too small */
 		ret = -EINVAL;
 		break;
 	default:
 		pr_err("unexpected ibm,get-system-parameter result %d\n", fwrc);
 		fallthrough;
 	case -1: /* Hardware/platform error */
 		ret = -EIO;
 		break;
 	}

 	rtas_work_area_free(work_area);

 	return ret;
 }

 int papr_sysparm_set(papr_sysparm_t param, const struct papr_sysparm_buf *buf)
 {
 	const s32 token = rtas_function_token(RTAS_FN_IBM_SET_SYSTEM_PARAMETER);
 	struct rtas_work_area *work_area;
 	s32 fwrc;
 	int ret;

 	might_sleep();

 	if (WARN_ON(!buf))
 		return -EFAULT;

 	if (token == RTAS_UNKNOWN_SERVICE)
 		return -ENOENT;

 	if (!papr_sysparm_buf_can_submit(buf))
 		return -EINVAL;

 	work_area = rtas_work_area_alloc(sizeof(*buf));

 	memcpy(rtas_work_area_raw_buf(work_area), buf, sizeof(*buf));

 	do {
 		fwrc = rtas_call(token, 2, 1, NULL, param.token,
 				 rtas_work_area_phys(work_area));
 	} while (rtas_busy_delay(fwrc));

 	switch (fwrc) {
 	case 0:
 		ret = 0;
 		break;
 	case -3: /* parameter not supported */
 		ret = -EOPNOTSUPP;
 		break;
 	case -9002: /* this partition not authorized to modify this parameter */
 		ret = -EPERM;
 		break;
 	case -9999: /* "parameter error" e.g. invalid input data */
 		ret = -EINVAL;
 		break;
 	default:
 		pr_err("unexpected ibm,set-system-parameter result %d\n", fwrc);
 		fallthrough;
 	case -1: /* Hardware/platform error */
 		ret = -EIO;
 		break;
 	}

 	rtas_work_area_free(work_area);

 	return ret;
 }

 static struct papr_sysparm_buf *
 papr_sysparm_buf_from_user(const struct papr_sysparm_io_block __user *user_iob)
 {
 	struct papr_sysparm_buf *kern_spbuf;
 	long err;
 	u16 len;

 	/*
 	 * The length of valid data that userspace claims to be in
 	 * user_iob->data[].
 	 */
 	if (get_user(len, &user_iob->length))
 		return ERR_PTR(-EFAULT);

 	static_assert(sizeof(user_iob->data) >= PAPR_SYSPARM_MAX_INPUT);
 	static_assert(sizeof(kern_spbuf->val) >= PAPR_SYSPARM_MAX_INPUT);

 	if (len > PAPR_SYSPARM_MAX_INPUT)
 		return ERR_PTR(-EINVAL);

 	kern_spbuf = papr_sysparm_buf_alloc();
 	if (!kern_spbuf)
 		return ERR_PTR(-ENOMEM);

 	papr_sysparm_buf_set_length(kern_spbuf, len);

 	if (len > 0 && copy_from_user(kern_spbuf->val, user_iob->data, len)) {
 		err = -EFAULT;
 		goto free_sysparm_buf;
 	}

 	return kern_spbuf;

 free_sysparm_buf:
 	papr_sysparm_buf_free(kern_spbuf);
 	return ERR_PTR(err);
 }

 static int papr_sysparm_buf_to_user(const struct papr_sysparm_buf *kern_spbuf,
 				    struct papr_sysparm_io_block __user *user_iob)
 {
 	u16 len_out = papr_sysparm_buf_get_length(kern_spbuf);

 	if (put_user(len_out, &user_iob->length))
 		return -EFAULT;

 	static_assert(sizeof(user_iob->data) >= PAPR_SYSPARM_MAX_OUTPUT);
 	static_assert(sizeof(kern_spbuf->val) >= PAPR_SYSPARM_MAX_OUTPUT);

 	if (copy_to_user(user_iob->data, kern_spbuf->val, PAPR_SYSPARM_MAX_OUTPUT))
 		return -EFAULT;

 	return 0;
 }

 static long papr_sysparm_ioctl_get(struct papr_sysparm_io_block __user *user_iob)
 {
 	struct papr_sysparm_buf *kern_spbuf;
 	papr_sysparm_t param;
 	long ret;

 	if (get_user(param.token, &user_iob->parameter))
 		return -EFAULT;

 	kern_spbuf = papr_sysparm_buf_from_user(user_iob);
 	if (IS_ERR(kern_spbuf))
 		return PTR_ERR(kern_spbuf);

 	ret = papr_sysparm_get(param, kern_spbuf);
 	if (ret)
 		goto free_sysparm_buf;

 	ret = papr_sysparm_buf_to_user(kern_spbuf, user_iob);
 	if (ret)
 		goto free_sysparm_buf;

 	ret = 0;

 free_sysparm_buf:
 	papr_sysparm_buf_free(kern_spbuf);
 	return ret;
 }


 static long papr_sysparm_ioctl_set(struct papr_sysparm_io_block __user *user_iob)
 {
 	struct papr_sysparm_buf *kern_spbuf;
 	papr_sysparm_t param;
 	long ret;

 	if (get_user(param.token, &user_iob->parameter))
 		return -EFAULT;

 	kern_spbuf = papr_sysparm_buf_from_user(user_iob);
 	if (IS_ERR(kern_spbuf))
 		return PTR_ERR(kern_spbuf);

 	ret = papr_sysparm_set(param, kern_spbuf);
 	if (ret)
 		goto free_sysparm_buf;

 	ret = 0;

 free_sysparm_buf:
 	papr_sysparm_buf_free(kern_spbuf);
 	return ret;
 }

 static long papr_sysparm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg)
 {
 	void __user *argp = (__force void __user *)arg;
 	long ret;

 	switch (ioctl) {
 	case PAPR_SYSPARM_IOC_GET:
 		ret = papr_sysparm_ioctl_get(argp);
 		break;
 	case PAPR_SYSPARM_IOC_SET:
 		if (filp->f_mode & FMODE_WRITE)
 			ret = papr_sysparm_ioctl_set(argp);
 		else
 			ret = -EBADF;
 		break;
 	default:
 		ret = -ENOIOCTLCMD;
 		break;
 	}
 	return ret;
 }

 static const struct file_operations papr_sysparm_ops = {
 	.unlocked_ioctl = papr_sysparm_ioctl,
 };

 static struct miscdevice papr_sysparm_dev = {
 	.minor = MISC_DYNAMIC_MINOR,
 	.name = "papr-sysparm",
 	.fops = &papr_sysparm_ops,
 };

 static __init int papr_sysparm_init(void)
 {
 	if (!rtas_function_implemented(RTAS_FN_IBM_GET_SYSTEM_PARAMETER))
 		return -ENODEV;

 	return misc_register(&papr_sysparm_dev);
 }
 machine_device_initcall(pseries, papr_sysparm_init);
	// SPDX-License-Identifier: GPL-2.0-only

	#define pr_fmt(fmt) "papr-sysparm: " fmt

	#include <linux/anon_inodes.h>
	#include <linux/bug.h>
	#include <linux/file.h>
	#include <linux/fs.h>
	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/miscdevice.h>
	#include <linux/printk.h>
	#include <linux/slab.h>
	#include <linux/uaccess.h>
	#include <asm/machdep.h>
	#include <asm/papr-sysparm.h>
	#include <asm/rtas-work-area.h>
	#include <asm/rtas.h>

	struct papr_sysparm_buf *papr_sysparm_buf_alloc(void)
	{
	struct papr_sysparm_buf buf = kzalloc(sizeof(buf), GFP_KERNEL);

	return buf;
	}

	void papr_sysparm_buf_free(struct papr_sysparm_buf *buf)
	{
	kfree(buf);
	}

	static size_t papr_sysparm_buf_get_length(const struct papr_sysparm_buf *buf)
	{
	return be16_to_cpu(buf->len);
	}

	static void papr_sysparm_buf_set_length(struct papr_sysparm_buf *buf, size_t length)
	{
	WARN_ONCE(length > sizeof(buf->val),
	"bogus length %zu, clamping to safe value", length);
	length = min(sizeof(buf->val), length);
	buf->len = cpu_to_be16(length);
	}

	/*
	* For use on buffers returned from ibm,get-system-parameter before
	* returning them to callers. Ensures the encoded length of valid data
	* cannot overrun buf->val[].
	*/
	static void papr_sysparm_buf_clamp_length(struct papr_sysparm_buf *buf)
	{
	papr_sysparm_buf_set_length(buf, papr_sysparm_buf_get_length(buf));
	}

	/*
	* Perform some basic diligence on the system parameter buffer before
	* submitting it to RTAS.
	*/
	static bool papr_sysparm_buf_can_submit(const struct papr_sysparm_buf *buf)
	{
	/*
	* Firmware ought to reject buffer lengths that exceed the
	* maximum specified in PAPR, but there's no reason for the
	* kernel to allow them either.
	*/
	if (papr_sysparm_buf_get_length(buf) > sizeof(buf->val))
	return false;

	return true;
	}

	/**
	* papr_sysparm_get() - Retrieve the value of a PAPR system parameter.
	* @param: PAPR system parameter token as described in
	* 7.3.16 "System Parameters Option".
	* @buf: A &struct papr_sysparm_buf as returned from papr_sysparm_buf_alloc().
	*
	* Place the result of querying the specified parameter, if available,
	* in @buf. The result includes a be16 length header followed by the
	* value, which may be a string or binary data. See &struct papr_sysparm_buf.
	*
	* Since there is at least one parameter (60, OS Service Entitlement
	* Status) where the results depend on the incoming contents of the
	* work area, the caller-supplied buffer is copied unmodified into the
	* work area before calling ibm,get-system-parameter.
	*
	* A defined parameter may not be implemented on a given system, and
	* some implemented parameters may not be available to all partitions
	* on a system. A parameter's disposition may change at any time due
	* to system configuration changes or partition migration.
	*
	* Context: This function may sleep.
	*
	* Return: 0 on success, -errno otherwise. @buf is unmodified on error.
	*/
	int papr_sysparm_get(papr_sysparm_t param, struct papr_sysparm_buf *buf)
	{
	const s32 token = rtas_function_token(RTAS_FN_IBM_GET_SYSTEM_PARAMETER);
	struct rtas_work_area *work_area;
	s32 fwrc;
	int ret;

	might_sleep();

	if (WARN_ON(!buf))
	return -EFAULT;

	if (token == RTAS_UNKNOWN_SERVICE)
	return -ENOENT;

	if (!papr_sysparm_buf_can_submit(buf))
	return -EINVAL;

	work_area = rtas_work_area_alloc(sizeof(*buf));

	memcpy(rtas_work_area_raw_buf(work_area), buf, sizeof(*buf));

	do {
	fwrc = rtas_call(token, 3, 1, NULL, param.token,
	rtas_work_area_phys(work_area),
	rtas_work_area_size(work_area));
	} while (rtas_busy_delay(fwrc));

	switch (fwrc) {
	case 0:
	ret = 0;
	memcpy(buf, rtas_work_area_raw_buf(work_area), sizeof(*buf));
	papr_sysparm_buf_clamp_length(buf);
	break;
	case -3: /* parameter not implemented */
	ret = -EOPNOTSUPP;
	break;
	case -9002: /* this partition not authorized to retrieve this parameter */
	ret = -EPERM;
	break;
	case -9999: /* "parameter error" e.g. the buffer is too small */
	ret = -EINVAL;
	break;
	default:
	pr_err("unexpected ibm,get-system-parameter result %d\n", fwrc);
	fallthrough;
	case -1: /* Hardware/platform error */
	ret = -EIO;
	break;
	}

	rtas_work_area_free(work_area);

	return ret;
	}

	int papr_sysparm_set(papr_sysparm_t param, const struct papr_sysparm_buf *buf)
	{
	const s32 token = rtas_function_token(RTAS_FN_IBM_SET_SYSTEM_PARAMETER);
	struct rtas_work_area *work_area;
	s32 fwrc;
	int ret;

	might_sleep();

	if (WARN_ON(!buf))
	return -EFAULT;

	if (token == RTAS_UNKNOWN_SERVICE)
	return -ENOENT;

	if (!papr_sysparm_buf_can_submit(buf))
	return -EINVAL;

	work_area = rtas_work_area_alloc(sizeof(*buf));

	memcpy(rtas_work_area_raw_buf(work_area), buf, sizeof(*buf));

	do {
	fwrc = rtas_call(token, 2, 1, NULL, param.token,
	rtas_work_area_phys(work_area));
	} while (rtas_busy_delay(fwrc));

	switch (fwrc) {
	case 0:
	ret = 0;
	break;
	case -3: /* parameter not supported */
	ret = -EOPNOTSUPP;
	break;
	case -9002: /* this partition not authorized to modify this parameter */
	ret = -EPERM;
	break;
	case -9999: /* "parameter error" e.g. invalid input data */
	ret = -EINVAL;
	break;
	default:
	pr_err("unexpected ibm,set-system-parameter result %d\n", fwrc);
	fallthrough;
	case -1: /* Hardware/platform error */
	ret = -EIO;
	break;
	}

	rtas_work_area_free(work_area);

	return ret;
	}

	static struct papr_sysparm_buf *
	papr_sysparm_buf_from_user(const struct papr_sysparm_io_block __user *user_iob)
	{
	struct papr_sysparm_buf *kern_spbuf;
	long err;
	u16 len;

	/*
	* The length of valid data that userspace claims to be in
	* user_iob->data[].
	*/
	if (get_user(len, &user_iob->length))
	return ERR_PTR(-EFAULT);

	static_assert(sizeof(user_iob->data) >= PAPR_SYSPARM_MAX_INPUT);
	static_assert(sizeof(kern_spbuf->val) >= PAPR_SYSPARM_MAX_INPUT);

	if (len > PAPR_SYSPARM_MAX_INPUT)
	return ERR_PTR(-EINVAL);

	kern_spbuf = papr_sysparm_buf_alloc();
	if (!kern_spbuf)
	return ERR_PTR(-ENOMEM);

	papr_sysparm_buf_set_length(kern_spbuf, len);

	if (len > 0 && copy_from_user(kern_spbuf->val, user_iob->data, len)) {
	err = -EFAULT;
	goto free_sysparm_buf;
	}

	return kern_spbuf;

	free_sysparm_buf:
	papr_sysparm_buf_free(kern_spbuf);
	return ERR_PTR(err);
	}

	static int papr_sysparm_buf_to_user(const struct papr_sysparm_buf *kern_spbuf,
	struct papr_sysparm_io_block __user *user_iob)
	{
	u16 len_out = papr_sysparm_buf_get_length(kern_spbuf);

	if (put_user(len_out, &user_iob->length))
	return -EFAULT;

	static_assert(sizeof(user_iob->data) >= PAPR_SYSPARM_MAX_OUTPUT);
	static_assert(sizeof(kern_spbuf->val) >= PAPR_SYSPARM_MAX_OUTPUT);

	if (copy_to_user(user_iob->data, kern_spbuf->val, PAPR_SYSPARM_MAX_OUTPUT))
	return -EFAULT;

	return 0;
	}

	static long papr_sysparm_ioctl_get(struct papr_sysparm_io_block __user *user_iob)
	{
	struct papr_sysparm_buf *kern_spbuf;
	papr_sysparm_t param;
	long ret;

	if (get_user(param.token, &user_iob->parameter))
	return -EFAULT;

	kern_spbuf = papr_sysparm_buf_from_user(user_iob);
	if (IS_ERR(kern_spbuf))
	return PTR_ERR(kern_spbuf);

	ret = papr_sysparm_get(param, kern_spbuf);
	if (ret)
	goto free_sysparm_buf;

	ret = papr_sysparm_buf_to_user(kern_spbuf, user_iob);
	if (ret)
	goto free_sysparm_buf;

	ret = 0;

	free_sysparm_buf:
	papr_sysparm_buf_free(kern_spbuf);
	return ret;
	}


	static long papr_sysparm_ioctl_set(struct papr_sysparm_io_block __user *user_iob)
	{
	struct papr_sysparm_buf *kern_spbuf;
	papr_sysparm_t param;
	long ret;

	if (get_user(param.token, &user_iob->parameter))
	return -EFAULT;

	kern_spbuf = papr_sysparm_buf_from_user(user_iob);
	if (IS_ERR(kern_spbuf))
	return PTR_ERR(kern_spbuf);

	ret = papr_sysparm_set(param, kern_spbuf);
	if (ret)
	goto free_sysparm_buf;

	ret = 0;

	free_sysparm_buf:
	papr_sysparm_buf_free(kern_spbuf);
	return ret;
	}

	static long papr_sysparm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg)
	{
	void __user argp = (__force void __user )arg;
	long ret;

	switch (ioctl) {
	case PAPR_SYSPARM_IOC_GET:
	ret = papr_sysparm_ioctl_get(argp);
	break;
	case PAPR_SYSPARM_IOC_SET:
	if (filp->f_mode & FMODE_WRITE)
	ret = papr_sysparm_ioctl_set(argp);
	else
	ret = -EBADF;
	break;
	default:
	ret = -ENOIOCTLCMD;
	break;
	}
	return ret;
	}

	static const struct file_operations papr_sysparm_ops = {
	.unlocked_ioctl = papr_sysparm_ioctl,
	};

	static struct miscdevice papr_sysparm_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "papr-sysparm",
	.fops = &papr_sysparm_ops,
	};

	static __init int papr_sysparm_init(void)
	{
	if (!rtas_function_implemented(RTAS_FN_IBM_GET_SYSTEM_PARAMETER))
	return -ENODEV;

	return misc_register(&papr_sysparm_dev);
	}
	machine_device_initcall(pseries, papr_sysparm_init);