[linux-2.6-block.git] / drivers / s390 / char / sclp_ctl.c

// SPDX-License-Identifier: GPL-2.0
/*
 * IOCTL interface for SCLP
 *
 * Copyright IBM Corp. 2012
 *
 * Author: Michael Holzheu <holzheu@linux.vnet.ibm.com>
 */

#include <linux/compat.h>
#include <linux/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/gfp.h>
#include <linux/init.h>
#include <linux/ioctl.h>
#include <linux/fs.h>
#include <asm/compat.h>
#include <asm/sclp_ctl.h>
#include <asm/sclp.h>

#include "sclp.h"

/*
 * Supported command words
 */
static unsigned int sclp_ctl_sccb_wlist[] = {
	0x00400002,
	0x00410002,
};

/*
 * Check if command word is supported
 */
static int sclp_ctl_cmdw_supported(unsigned int cmdw)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(sclp_ctl_sccb_wlist); i++) {
		if (cmdw == sclp_ctl_sccb_wlist[i])
			return 1;
	}
	return 0;
}

static void __user *u64_to_uptr(u64 value)
{
	if (is_compat_task())
		return compat_ptr(value);
	else
		return (void __user *)(unsigned long)value;
}

/*
 * Start SCLP request
 */
static int sclp_ctl_ioctl_sccb(void __user *user_area)
{
	struct sclp_ctl_sccb ctl_sccb;
	struct sccb_header *sccb;
	unsigned long copied;
	int rc;

	if (copy_from_user(&ctl_sccb, user_area, sizeof(ctl_sccb)))
		return -EFAULT;
	if (!sclp_ctl_cmdw_supported(ctl_sccb.cmdw))
		return -EOPNOTSUPP;
	sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!sccb)
		return -ENOMEM;
	copied = PAGE_SIZE -
		copy_from_user(sccb, u64_to_uptr(ctl_sccb.sccb), PAGE_SIZE);
	if (offsetof(struct sccb_header, length) +
	    sizeof(sccb->length) > copied || sccb->length > copied) {
		rc = -EFAULT;
		goto out_free;
	}
	if (sccb->length < 8) {
		rc = -EINVAL;
		goto out_free;
	}
	rc = sclp_sync_request(ctl_sccb.cmdw, sccb);
	if (rc)
		goto out_free;
	if (copy_to_user(u64_to_uptr(ctl_sccb.sccb), sccb, sccb->length))
		rc = -EFAULT;
out_free:
	free_page((unsigned long) sccb);
	return rc;
}

/*
 * SCLP SCCB ioctl function
 */
static long sclp_ctl_ioctl(struct file *filp, unsigned int cmd,
			   unsigned long arg)
{
	void __user *argp;

	if (is_compat_task())
		argp = compat_ptr(arg);
	else
		argp = (void __user *) arg;
	switch (cmd) {
	case SCLP_CTL_SCCB:
		return sclp_ctl_ioctl_sccb(argp);
	default: /* unknown ioctl number */
		return -ENOTTY;
	}
}

/*
 * File operations
 */
static const struct file_operations sclp_ctl_fops = {
	.owner = THIS_MODULE,
	.open = nonseekable_open,
	.unlocked_ioctl = sclp_ctl_ioctl,
	.compat_ioctl = sclp_ctl_ioctl,
	.llseek = no_llseek,
};

/*
 * Misc device definition
 */
static struct miscdevice sclp_ctl_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "sclp",
	.fops = &sclp_ctl_fops,
};
builtin_misc_device(sclp_ctl_device);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
d475f942 MH	2	/*
	3	* IOCTL interface for SCLP
	4	*
	5	* Copyright IBM Corp. 2012
	6	*
	7	* Author: Michael Holzheu <holzheu@linux.vnet.ibm.com>
	8	*/
	9
	10	#include <linux/compat.h>
	11	#include <linux/uaccess.h>
	12	#include <linux/miscdevice.h>
	13	#include <linux/gfp.h>
c1eac0d0	14	#include <linux/init.h>
d475f942 MH	15	#include <linux/ioctl.h>
d475f942 MH	16	#include <linux/fs.h>
d475f942 MH	17	#include <asm/compat.h>
	18	#include <asm/sclp_ctl.h>
	19	#include <asm/sclp.h>
	20
	21	#include "sclp.h"
	22
	23	/*
	24	* Supported command words
	25	*/
	26	static unsigned int sclp_ctl_sccb_wlist[] = {
	27	0x00400002,
	28	0x00410002,
	29	};
	30
	31	/*
	32	* Check if command word is supported
	33	*/
	34	static int sclp_ctl_cmdw_supported(unsigned int cmdw)
	35	{
	36	int i;
	37
	38	for (i = 0; i < ARRAY_SIZE(sclp_ctl_sccb_wlist); i++) {
	39	if (cmdw == sclp_ctl_sccb_wlist[i])
	40	return 1;
	41	}
	42	return 0;
	43	}
	44
	45	static void __user *u64_to_uptr(u64 value)
	46	{
	47	if (is_compat_task())
	48	return compat_ptr(value);
	49	else
	50	return (void __user *)(unsigned long)value;
	51	}
	52
	53	/*
	54	* Start SCLP request
	55	*/
	56	static int sclp_ctl_ioctl_sccb(void __user *user_area)
	57	{
	58	struct sclp_ctl_sccb ctl_sccb;
	59	struct sccb_header *sccb;
532c34b5	60	unsigned long copied;
d475f942 MH	61	int rc;
	62
	63	if (copy_from_user(&ctl_sccb, user_area, sizeof(ctl_sccb)))
	64	return -EFAULT;
	65	if (!sclp_ctl_cmdw_supported(ctl_sccb.cmdw))
	66	return -EOPNOTSUPP;
	67	sccb = (void *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
	68	if (!sccb)
	69	return -ENOMEM;
532c34b5 MS	70	copied = PAGE_SIZE -
	71	copy_from_user(sccb, u64_to_uptr(ctl_sccb.sccb), PAGE_SIZE);
	72	if (offsetof(struct sccb_header, length) +
	73	sizeof(sccb->length) > copied \|\| sccb->length > copied) {
d475f942 MH	74	rc = -EFAULT;
	75	goto out_free;
	76	}
532c34b5 MS	77	if (sccb->length < 8) {
532c34b5 MS	78	rc = -EINVAL;
d475f942 MH	79	goto out_free;
	80	}
	81	rc = sclp_sync_request(ctl_sccb.cmdw, sccb);
	82	if (rc)
	83	goto out_free;
	84	if (copy_to_user(u64_to_uptr(ctl_sccb.sccb), sccb, sccb->length))
	85	rc = -EFAULT;
	86	out_free:
	87	free_page((unsigned long) sccb);
	88	return rc;
	89	}
	90
	91	/*
	92	* SCLP SCCB ioctl function
	93	*/
	94	static long sclp_ctl_ioctl(struct file *filp, unsigned int cmd,
	95	unsigned long arg)
	96	{
	97	void __user *argp;
	98
	99	if (is_compat_task())
	100	argp = compat_ptr(arg);
	101	else
	102	argp = (void __user *) arg;
	103	switch (cmd) {
	104	case SCLP_CTL_SCCB:
	105	return sclp_ctl_ioctl_sccb(argp);
	106	default: /* unknown ioctl number */
	107	return -ENOTTY;
	108	}
	109	}
	110
	111	/*
	112	* File operations
	113	*/
	114	static const struct file_operations sclp_ctl_fops = {
	115	.owner = THIS_MODULE,
	116	.open = nonseekable_open,
	117	.unlocked_ioctl = sclp_ctl_ioctl,
	118	.compat_ioctl = sclp_ctl_ioctl,
	119	.llseek = no_llseek,
	120	};
	121
	122	/*
	123	* Misc device definition
	124	*/
	125	static struct miscdevice sclp_ctl_device = {
	126	.minor = MISC_DYNAMIC_MINOR,
	127	.name = "sclp",
	128	.fops = &sclp_ctl_fops,
	129	};
c1eac0d0	130	builtin_misc_device(sclp_ctl_device);