[linux.git] / drivers / input / input-compat.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 32bit compatibility wrappers for the input subsystem.
 *
 * Very heavily based on evdev.c - Copyright (c) 1999-2002 Vojtech Pavlik
 */

#include <linux/export.h>
#include <linux/uaccess.h>
#include "input-compat.h"

#ifdef CONFIG_COMPAT

int input_event_from_user(const char __user *buffer,
			  struct input_event *event)
{
	if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
		struct input_event_compat compat_event;

		if (copy_from_user(&compat_event, buffer,
				   sizeof(struct input_event_compat)))
			return -EFAULT;

		event->input_event_sec = compat_event.sec;
		event->input_event_usec = compat_event.usec;
		event->type = compat_event.type;
		event->code = compat_event.code;
		event->value = compat_event.value;

	} else {
		if (copy_from_user(event, buffer, sizeof(struct input_event)))
			return -EFAULT;
	}

	return 0;
}

int input_event_to_user(char __user *buffer,
			const struct input_event *event)
{
	if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
		struct input_event_compat compat_event;

		compat_event.sec = event->input_event_sec;
		compat_event.usec = event->input_event_usec;
		compat_event.type = event->type;
		compat_event.code = event->code;
		compat_event.value = event->value;

		if (copy_to_user(buffer, &compat_event,
				 sizeof(struct input_event_compat)))
			return -EFAULT;

	} else {
		if (copy_to_user(buffer, event, sizeof(struct input_event)))
			return -EFAULT;
	}

	return 0;
}

int input_ff_effect_from_user(const char __user *buffer, size_t size,
			      struct ff_effect *effect)
{
	if (in_compat_syscall()) {
		struct ff_effect_compat *compat_effect;

		if (size != sizeof(struct ff_effect_compat))
			return -EINVAL;

		/*
		 * It so happens that the pointer which needs to be changed
		 * is the last field in the structure, so we can retrieve the
		 * whole thing and replace just the pointer.
		 */
		compat_effect = (struct ff_effect_compat *)effect;

		if (copy_from_user(compat_effect, buffer,
				   sizeof(struct ff_effect_compat)))
			return -EFAULT;

		if (compat_effect->type == FF_PERIODIC &&
		    compat_effect->u.periodic.waveform == FF_CUSTOM)
			effect->u.periodic.custom_data =
				compat_ptr(compat_effect->u.periodic.custom_data);
	} else {
		if (size != sizeof(struct ff_effect))
			return -EINVAL;

		if (copy_from_user(effect, buffer, sizeof(struct ff_effect)))
			return -EFAULT;
	}

	return 0;
}

#else

int input_event_from_user(const char __user *buffer,
			 struct input_event *event)
{
	if (copy_from_user(event, buffer, sizeof(struct input_event)))
		return -EFAULT;

	return 0;
}

int input_event_to_user(char __user *buffer,
			const struct input_event *event)
{
	if (copy_to_user(buffer, event, sizeof(struct input_event)))
		return -EFAULT;

	return 0;
}

int input_ff_effect_from_user(const char __user *buffer, size_t size,
			      struct ff_effect *effect)
{
	if (size != sizeof(struct ff_effect))
		return -EINVAL;

	if (copy_from_user(effect, buffer, sizeof(struct ff_effect)))
		return -EFAULT;

	return 0;
}

#endif /* CONFIG_COMPAT */

EXPORT_SYMBOL_GPL(input_event_from_user);
EXPORT_SYMBOL_GPL(input_event_to_user);
EXPORT_SYMBOL_GPL(input_ff_effect_from_user);
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
2d56f3a3 PL	2	/*
	3	* 32bit compatibility wrappers for the input subsystem.
	4	*
	5	* Very heavily based on evdev.c - Copyright (c) 1999-2002 Vojtech Pavlik
2d56f3a3 PL	6	*/
2d56f3a3 PL	7
15d0580f	8	#include <linux/export.h>
7c0f6ba6	9	#include <linux/uaccess.h>
2d56f3a3 PL	10	#include "input-compat.h"
	11
	12	#ifdef CONFIG_COMPAT
	13
	14	int input_event_from_user(const char __user *buffer,
	15	struct input_event *event)
	16	{
b8b4ead1	17	if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
2d56f3a3 PL	18	struct input_event_compat compat_event;
	19
	20	if (copy_from_user(&compat_event, buffer,
	21	sizeof(struct input_event_compat)))
	22	return -EFAULT;
	23
152194fe DD	24	event->input_event_sec = compat_event.sec;
152194fe DD	25	event->input_event_usec = compat_event.usec;
2d56f3a3 PL	26	event->type = compat_event.type;
	27	event->code = compat_event.code;
	28	event->value = compat_event.value;
	29
	30	} else {
	31	if (copy_from_user(event, buffer, sizeof(struct input_event)))
	32	return -EFAULT;
	33	}
	34
	35	return 0;
	36	}
	37
	38	int input_event_to_user(char __user *buffer,
	39	const struct input_event *event)
	40	{
b8b4ead1	41	if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
2d56f3a3 PL	42	struct input_event_compat compat_event;
2d56f3a3 PL	43
152194fe DD	44	compat_event.sec = event->input_event_sec;
152194fe DD	45	compat_event.usec = event->input_event_usec;
2d56f3a3 PL	46	compat_event.type = event->type;
	47	compat_event.code = event->code;
	48	compat_event.value = event->value;
	49
	50	if (copy_to_user(buffer, &compat_event,
	51	sizeof(struct input_event_compat)))
	52	return -EFAULT;
	53
	54	} else {
	55	if (copy_to_user(buffer, event, sizeof(struct input_event)))
	56	return -EFAULT;
	57	}
	58
	59	return 0;
	60	}
	61
	62	int input_ff_effect_from_user(const char __user *buffer, size_t size,
	63	struct ff_effect *effect)
	64	{
b8b4ead1	65	if (in_compat_syscall()) {
2d56f3a3 PL	66	struct ff_effect_compat *compat_effect;
	67
	68	if (size != sizeof(struct ff_effect_compat))
	69	return -EINVAL;
	70
	71	/*
	72	* It so happens that the pointer which needs to be changed
	73	* is the last field in the structure, so we can retrieve the
	74	* whole thing and replace just the pointer.
	75	*/
	76	compat_effect = (struct ff_effect_compat *)effect;
	77
	78	if (copy_from_user(compat_effect, buffer,
	79	sizeof(struct ff_effect_compat)))
	80	return -EFAULT;
	81
	82	if (compat_effect->type == FF_PERIODIC &&
	83	compat_effect->u.periodic.waveform == FF_CUSTOM)
	84	effect->u.periodic.custom_data =
	85	compat_ptr(compat_effect->u.periodic.custom_data);
	86	} else {
	87	if (size != sizeof(struct ff_effect))
	88	return -EINVAL;
	89
	90	if (copy_from_user(effect, buffer, sizeof(struct ff_effect)))
	91	return -EFAULT;
	92	}
	93
	94	return 0;
	95	}
	96
	97	#else
	98
	99	int input_event_from_user(const char __user *buffer,
	100	struct input_event *event)
	101	{
	102	if (copy_from_user(event, buffer, sizeof(struct input_event)))
	103	return -EFAULT;
	104
	105	return 0;
	106	}
	107
	108	int input_event_to_user(char __user *buffer,
	109	const struct input_event *event)
	110	{
	111	if (copy_to_user(buffer, event, sizeof(struct input_event)))
	112	return -EFAULT;
	113
	114	return 0;
	115	}
	116
	117	int input_ff_effect_from_user(const char __user *buffer, size_t size,
	118	struct ff_effect *effect)
	119	{
	120	if (size != sizeof(struct ff_effect))
	121	return -EINVAL;
	122
	123	if (copy_from_user(effect, buffer, sizeof(struct ff_effect)))
	124	return -EFAULT;
	125
	126	return 0;
	127	}
	128
	129	#endif /* CONFIG_COMPAT */
130
131	EXPORT_SYMBOL_GPL(input_event_from_user);
132	EXPORT_SYMBOL_GPL(input_event_to_user);
133	EXPORT_SYMBOL_GPL(input_ff_effect_from_user);