Skip to contentSkip to conversation

Input: evdev - add event-mask API

PATCH In review David Herrmann 2 participants 5 messages Sep 3, 2015 – Oct 25, 2015

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Input: evdev - add event-mask API

Hardware manufacturers group keys in the weirdest way possible. This may cause a power-key to be grouped together with normal keyboard keys and thus be reported on the same kernel interface.

However, user-space is often only interested in specific sets of events. For instance, daemons dealing with system-reboot (like systemd-logind) listen for KEY_POWER, but are not interested in any main keyboard keys. Usually, power keys are reported via separate interfaces, however, some i8042 boards report it in the AT matrix. To avoid waking up those system daemons on each key-press, we had two ideas:
- split off KEY_POWER into a separate interface unconditionally
- allow filtering a specific set of events on evdev FDs

Splitting of KEY_POWER is a rather weird way to deal with this and may break backwards-compatibility. It is also specific to KEY_POWER and might be required for other stuff, too. Moreover, we might end up with a huge set of input-devices just to have them properly split.

Hence, this patchset implements the second idea: An event-mask to specify which events you're interested in. Two ioctls allow setting this mask for each event-type. If not set, all events are reported. The type==0 entry is used same as in EVIOCGBIT to set the actual EV_* mask of filtered events. This way, you have a two-level filter.

We are heavily forward-compatible to new event-types and event-codes. So new user-space will be able to run on an old kernel which doesn't know the given event-codes or event-types.

---
 drivers/input/evdev.c      | 206 ++++++++++++++++++++++++++++++++++++++++++++-
 include/uapi/linux/input.h |  60 +++++++++++++
 2 files changed, 264 insertions(+), 2 deletions(-)
drivers/input/evdev.c +204 -2
index 9d35499..37876bb 100644
@@ -58,10 +58,55 @@ struct evdev_client {
 	struct list_head node;
 	int clk_type;
 	bool revoked;
+	unsigned long *evmasks[EV_CNT];
 	unsigned int bufsize;
 	struct input_event buffer[];
 };
 
+static size_t evdev_get_mask_cnt(unsigned int type)
+{
+	static const size_t counts[EV_CNT] = {
+		/* EV_SYN==0 is EV_CNT, _not_ SYN_CNT, see EVIOCGBIT */
+		[EV_SYN]	= EV_CNT,
+		[EV_KEY]	= KEY_CNT,
+		[EV_REL]	= REL_CNT,
+		[EV_ABS]	= ABS_CNT,
+		[EV_MSC]	= MSC_CNT,
+		[EV_SW]		= SW_CNT,
+		[EV_LED]	= LED_CNT,
+		[EV_SND]	= SND_CNT,
+		[EV_FF]		= FF_CNT,
+	};
+
+	return (type < EV_CNT) ? counts[type] : 0;
+}
+
+/* requires the buffer lock to be held */
+static bool __evdev_is_filtered(struct evdev_client *client,
+				unsigned int type,
+				unsigned int code)
+{
+	unsigned long *mask;
+	size_t cnt;
+
+	/* EV_SYN and unknown codes are never filtered */
+	if (type == EV_SYN || type >= EV_CNT)
+		return false;
+
+	/* first test whether the type is filtered */
+	mask = client->evmasks[0];
+	if (mask && !test_bit(type, mask))
+		return true;
+
+	/* unknown values are never filtered */
+	cnt = evdev_get_mask_cnt(type);
+	if (!cnt || code >= cnt)
+		return false;
+
+	mask = client->evmasks[type];
+	return mask && !test_bit(code, mask);
+}
+
 /* flush queued events of type @type, caller must hold client->buffer_lock */
 static void __evdev_flush_queue(struct evdev_client *client, unsigned int type)
 {
@@ -226,12 +271,21 @@ static void evdev_pass_values(struct evdev_client *client,
 	spin_lock(&client->buffer_lock);
 
 	for (v = vals; v != vals + count; v++) {
+		if (__evdev_is_filtered(client, v->type, v->code))
+			continue;
+
+		if (v->type == EV_SYN && v->code == SYN_REPORT) {
+			/* drop empty SYN_REPORT */
+			if (client->packet_head == client->head)
+				continue;
+
+			wakeup = true;
+		}
+
 		event.type = v->type;
 		event.code = v->code;
 		event.value = v->value;
 		__pass_event(client, &event);
-		if (v->type == EV_SYN && v->code == SYN_REPORT)
-			wakeup = true;
 	}
 
 	spin_unlock(&client->buffer_lock);
@@ -415,6 +469,7 @@ static int evdev_release(struct inode *inode, struct file *file)
 {
 	struct evdev_client *client = file->private_data;
 	struct evdev *evdev = client->evdev;
+	unsigned int i;
 
 	mutex_lock(&evdev->mutex);
 	evdev_ungrab(evdev, client);
@@ -422,6 +477,9 @@ static int evdev_release(struct inode *inode, struct file *file)
 
 	evdev_detach_client(evdev, client);
 
+	for (i = 0; i < EV_CNT; ++i)
+		kfree(client->evmasks[i]);
+
 	kvfree(client);
 
 	evdev_close_device(evdev);
@@ -662,6 +720,47 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 
 #endif /* CONFIG_COMPAT */
 
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+			  unsigned int maxlen, const void __user *p, int compat)
+{
+	int len;
+
+#if IS_ENABLED(CONFIG_COMPAT)
+	if (compat) {
+		if (maxlen % sizeof(compat_long_t))
+			return -EINVAL;
+		len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
+	} else
+#endif
+	{
+		if (maxlen % sizeof(long))
+			return -EINVAL;
+		len = BITS_TO_LONGS(maxbit) * sizeof(long);
+	}
+
+	if (len > maxlen)
+		len = maxlen;
+
+#if IS_ENABLED(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
+	if (compat) {
+		int i;
+
+		for (i = 0; i < len / sizeof(compat_long_t); i++)
+			if (copy_from_user((compat_long_t *) bits +
+						i + 1 - ((i % 2) << 1),
+					   (compat_long_t __user *) p + i,
+					   sizeof(compat_long_t)))
+				return -EFAULT;
+		if (i % 2)
+			*((compat_long_t *) bits + i - 1) = 0;
+	} else
+#endif
+		if (copy_from_user(bits, p, len))
+			return -EFAULT;
+
+	return len;
+}
+
 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 {
 	int len;
@@ -854,6 +953,86 @@ static int evdev_revoke(struct evdev *evdev, struct evdev_client *client,
 	return 0;
 }
 
+/* must be called with evdev-mutex held */
+static int evdev_set_mask(struct evdev_client *client,
+			  unsigned int type,
+			  const void __user *codes,
+			  u32 codes_size,
+			  int compat)
+{
+	unsigned long flags, *mask, *oldmask;
+	size_t cnt, size, min;
+	int error;
+
+	/* we allow unknown types and 'codes_size > size' for forward-compat */
+	cnt = evdev_get_mask_cnt(type);
+	if (!cnt)
+		return 0;
+
+	size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
+	min = min_t(size_t, codes_size, size);
+
+	mask = kzalloc(size, GFP_KERNEL);
+	if (!mask)
+		return -ENOMEM;
+
+	error = bits_from_user(mask, cnt - 1, min, codes, compat);
+	if (error < 0) {
+		kfree(mask);
+		return error;
+	}
+
+	spin_lock_irqsave(&client->buffer_lock, flags);
+	oldmask = client->evmasks[type];
+	client->evmasks[type] = mask;
+	spin_unlock_irqrestore(&client->buffer_lock, flags);
+
+	kfree(oldmask);
+
+	return 0;
+}
+
+/* must be called with evdev-mutex held */
+static int evdev_get_mask(struct evdev_client *client,
+			  unsigned int type,
+			  void __user *codes,
+			  u32 codes_size,
+			  int compat)
+{
+	unsigned long *mask;
+	size_t cnt, size, min, i;
+	u8 __user *out;
+	int error;
+
+	/* we allow unknown types and 'codes_size > size' for forward-compat */
+	cnt = evdev_get_mask_cnt(type);
+	size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
+	min = min_t(size_t, codes_size, size);
+
+	if (cnt > 0) {
+		mask = client->evmasks[type];
+		if (mask) {
+			error = bits_to_user(mask, cnt - 1, min, codes, compat);
+			if (error < 0)
+				return error;
+		} else {
+			/* fake mask with all bits set */
+			out = (u8 __user*)codes;
+			for (i = 0; i < min; ++i)
+				if (put_user((u8)0xff,  out + i))
+					return -EFAULT;
+		}
+	}
+
+	codes = (u8*)codes + min;
+	codes_size -= min;
+
+	if (codes_size > 0 && clear_user(codes, codes_size))
+		return -EFAULT;
+
+	return 0;
+}
+
 static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 			   void __user *p, int compat_mode)
 {
@@ -861,6 +1040,7 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 	struct evdev *evdev = client->evdev;
 	struct input_dev *dev = evdev->handle.dev;
 	struct input_absinfo abs;
+	struct input_mask mask;
 	struct ff_effect effect;
 	int __user *ip = (int __user *)p;
 	unsigned int i, t, u, v;
@@ -922,6 +1102,28 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 		else
 			return evdev_revoke(evdev, client, file);
 
+	case EVIOCGMASK:
+		if (copy_from_user(&mask, p, sizeof(mask)))
+			return -EFAULT;
+
+		return evdev_get_mask(client,
+				      mask.type,
+				      (void __user*)
+				      (unsigned long)mask.codes_ptr,
+				      mask.codes_size,
+				      compat_mode);
+
+	case EVIOCSMASK:
+		if (copy_from_user(&mask, p, sizeof(mask)))
+			return -EFAULT;
+
+		return evdev_set_mask(client,
+				      mask.type,
+				      (const void __user*)
+				      (unsigned long)mask.codes_ptr,
+				      mask.codes_size,
+				      compat_mode);
+
 	case EVIOCSCLOCKID:
 		if (copy_from_user(&i, p, sizeof(unsigned int)))
 			return -EFAULT;
include/uapi/linux/input.h +60 -0

72 lines not on this page · raw message

Signature · 1 line
2.5.1
#1 lore raw

Hey

Quoted 24 lines · David Herrmann

Hardware manufacturers group keys in the weirdest way possible. This may cause a power-key to be grouped together with normal keyboard keys and thus be reported on the same kernel interface.

However, user-space is often only interested in specific sets of events. For instance, daemons dealing with system-reboot (like systemd-logind) listen for KEY_POWER, but are not interested in any main keyboard keys. Usually, power keys are reported via separate interfaces, however, some i8042 boards report it in the AT matrix. To avoid waking up those system daemons on each key-press, we had two ideas:
- split off KEY_POWER into a separate interface unconditionally
- allow filtering a specific set of events on evdev FDs

Splitting of KEY_POWER is a rather weird way to deal with this and may break backwards-compatibility. It is also specific to KEY_POWER and might be required for other stuff, too. Moreover, we might end up with a huge set of input-devices just to have them properly split.

Hence, this patchset implements the second idea: An event-mask to specify which events you're interested in. Two ioctls allow setting this mask for each event-type. If not set, all events are reported. The type==0 entry is used same as in EVIOCGBIT to set the actual EV_* mask of filtered events. This way, you have a two-level filter.

Quoted 5 lines

We are heavily forward-compatible to new event-types and event-codes. So new user-space will be able to run on an old kernel which doesn't know the given event-codes or event-types.

Ping?

David

maintainer
#2 lore raw
In reply to David Herrmann

Hi David,

Quoted 30 lines · David Herrmann
(quoted diff) +30 -0
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+			  unsigned int maxlen, const void __user *p, int compat)
+{
+	int len;
+
+#if IS_ENABLED(CONFIG_COMPAT)
+	if (compat) {
+		if (maxlen % sizeof(compat_long_t))
+			return -EINVAL;
+		len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
+	} else
+#endif
+	{
+		if (maxlen % sizeof(long))
+			return -EINVAL;
+		len = BITS_TO_LONGS(maxbit) * sizeof(long);
+	}
+
+	if (len > maxlen)
+		len = maxlen;
+
+#if IS_ENABLED(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
+	if (compat) {
+		int i;
+
+		for (i = 0; i < len / sizeof(compat_long_t); i++)
+			if (copy_from_user((compat_long_t *) bits +
+						i + 1 - ((i % 2) << 1),
+					   (compat_long_t __user *) p + i,
+					   sizeof(compat_long_t)))

Review

Quoted 10 lines
(quoted diff) +10 -0
+				return -EFAULT;
+		if (i % 2)
+			*((compat_long_t *) bits + i - 1) = 0;
+	} else
+#endif
+		if (copy_from_user(bits, p, len))
+			return -EFAULT;
+
+	return len;
+}

I do not quite like how we sprinkle ifdefs throughout, I prefer the way we have bits_to_user defined, even if it is more verbose.

Quoted 22 lines
(quoted diff) +15 -0
+
 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 {
 	int len;
@@ -854,6 +953,86 @@ static int evdev_revoke(struct evdev *evdev, struct evdev_client *client,
 	return 0;
 }
 
+/* must be called with evdev-mutex held */
+static int evdev_set_mask(struct evdev_client *client,
+			  unsigned int type,
+			  const void __user *codes,
+			  u32 codes_size,
+			  int compat)
+{
+	unsigned long flags, *mask, *oldmask;
+	size_t cnt, size, min;
+	int error;
+
+	/* we allow unknown types and 'codes_size > size' for forward-compat */
+	cnt = evdev_get_mask_cnt(type);
+	if (!cnt)

Review static int evdev_revoke(struct evdev *evdev, struct evdev_client *client, · line 979

Quoted 10 lines
(quoted diff) +10 -0
+		return 0;
+
+	size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
+	min = min_t(size_t, codes_size, size);
+
+	mask = kzalloc(size, GFP_KERNEL);
+	if (!mask)
+		return -ENOMEM;
+
+	error = bits_from_user(mask, cnt - 1, min, codes, compat);

I do not think we need to calculate and pass min here: bits_from_user() will limit the output for us already.

Does it still work if you apply the patch below?

Thanks!

Signature · 10 lines
Dmitry

Input: evdev - mask api misc changes

From: Dmitry Torokhov <[email protected]>

Signed-off-by: Dmitry Torokhov <[email protected]>
---
 drivers/input/evdev.c |  148 +++++++++++++++++++++++++++++--------------------
 1 file changed, 88 insertions(+), 60 deletions(-)
drivers/input/evdev.c +88 -60
index 83d699f..ce35ea3 100644
@@ -685,7 +685,46 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 
 	return len;
 }
+
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+			  unsigned int maxlen, const void __user *p, int compat)
+{
+	int len, i;
+
+	if (compat) {
+		if (maxlen % sizeof(compat_long_t))
+			return -EINVAL;
+
+		len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
+		if (len > maxlen)
+			len = maxlen;
+
+		for (i = 0; i < len / sizeof(compat_long_t); i++)
+			if (copy_from_user((compat_long_t *) bits +
+						i + 1 - ((i % 2) << 1),
+					   (compat_long_t __user *) p + i,
+					   sizeof(compat_long_t)))
+				return -EFAULT;
+		if (i % 2)
+			*((compat_long_t *) bits + i - 1) = 0;
+
+	} else {
+		if (maxlen % sizeof(long))
+			return -EINVAL;
+
+		len = BITS_TO_LONGS(maxbit) * sizeof(long);
+		if (len > maxlen)
+			len = maxlen;
+
+		if (copy_from_user(p, bits, len))
+			return -EFAULT;
+	}
+
+	return len;
+}
+
 #else
+
 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 			unsigned int maxlen, void __user *p, int compat)
 {
@@ -698,6 +737,24 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 
 	return copy_to_user(p, bits, len) ? -EFAULT : len;
 }
+
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+			  unsigned int maxlen, const void __user *p, int compat)
+{
+	size_t chunk_size = compat ? sizeof(compat_long_t) : sizeof(long);
+	int len;
+
+	if (maxlen % chunk_size)
+		return -EINVAL;
+
+	len = compat ? BITS_TO_LONGS_COMPAT(maxbit) : BITS_TO_LONGS(maxbit);
+	len *= chunk_size;
+	if (len > maxlen)
+		len = maxlen;
+
+	return copy_from_user(bits, p, len) ? -EFAULT : len;
+}
+
 #endif /* __BIG_ENDIAN */
 
 #else
@@ -713,49 +770,23 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 	return copy_to_user(p, bits, len) ? -EFAULT : len;
 }
 
-#endif /* CONFIG_COMPAT */
-
 static int bits_from_user(unsigned long *bits, unsigned int maxbit,
 			  unsigned int maxlen, const void __user *p, int compat)
 {
 	int len;
 
-#if IS_ENABLED(CONFIG_COMPAT)
-	if (compat) {
-		if (maxlen % sizeof(compat_long_t))
-			return -EINVAL;
-		len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
-	} else
-#endif
-	{
-		if (maxlen % sizeof(long))
-			return -EINVAL;
-		len = BITS_TO_LONGS(maxbit) * sizeof(long);
-	}
+	if (maxlen % sizeof(long))
+		return -EINVAL;
 
+	len = BITS_TO_LONGS(maxbit) * sizeof(long);
 	if (len > maxlen)
 		len = maxlen;
 
-#if IS_ENABLED(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
-	if (compat) {
-		int i;
-
-		for (i = 0; i < len / sizeof(compat_long_t); i++)
-			if (copy_from_user((compat_long_t *) bits +
-						i + 1 - ((i % 2) << 1),
-					   (compat_long_t __user *) p + i,
-					   sizeof(compat_long_t)))
-				return -EFAULT;
-		if (i % 2)
-			*((compat_long_t *) bits + i - 1) = 0;
-	} else
-#endif
-		if (copy_from_user(bits, p, len))
-			return -EFAULT;
-
-	return len;
+	return copy_from_user(bits, p, len) ? -EFAULT : len;
 }
 
+#endif /* CONFIG_COMPAT */
+
 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 {
 	int len;
@@ -956,7 +987,7 @@ static int evdev_set_mask(struct evdev_client *client,
 			  int compat)
 {
 	unsigned long flags, *mask, *oldmask;
-	size_t cnt, size, min;
+	size_t cnt;
 	int error;
 
 	/* we allow unknown types and 'codes_size > size' for forward-compat */
@@ -964,14 +995,11 @@ static int evdev_set_mask(struct evdev_client *client,
 	if (!cnt)
 		return 0;
 
-	size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
-	min = min_t(size_t, codes_size, size);
-
-	mask = kzalloc(size, GFP_KERNEL);
+	mask = kcalloc(sizeof(unsigned long), BITS_TO_LONGS(cnt), GFP_KERNEL);
 	if (!mask)
 		return -ENOMEM;
 
-	error = bits_from_user(mask, cnt - 1, min, codes, compat);
+	error = bits_from_user(mask, cnt - 1, codes_size, codes, compat);
 	if (error < 0) {
 		kfree(mask);
 		return error;
@@ -995,35 +1023,33 @@ static int evdev_get_mask(struct evdev_client *client,
 			  int compat)
 {
 	unsigned long *mask;
-	size_t cnt, size, min, i;
-	u8 __user *out;
+	size_t cnt, size, xfer_size;
+	int i;
 	int error;
 
 	/* we allow unknown types and 'codes_size > size' for forward-compat */
 	cnt = evdev_get_mask_cnt(type);
 	size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
-	min = min_t(size_t, codes_size, size);
+	xfer_size = min_t(size_t, codes_size, size);
 
 	if (cnt > 0) {
 		mask = client->evmasks[type];
 		if (mask) {
-			error = bits_to_user(mask, cnt - 1, min, codes, compat);
+			error = bits_to_user(mask, cnt - 1,
+					     xfer_size, codes, compat);
 			if (error < 0)
 				return error;
 		} else {
 			/* fake mask with all bits set */
-			out = (u8 __user*)codes;
-			for (i = 0; i < min; ++i)
-				if (put_user((u8)0xff,  out + i))
+			for (i = 0; i < xfer_size; i++)
+				if (put_user(0xffU, (u8 __user *)codes + i))
 					return -EFAULT;
 		}
 	}
 
-	codes = (u8*)codes + min;
-	codes_size -= min;
-
-	if (codes_size > 0 && clear_user(codes, codes_size))
-		return -EFAULT;
+	if (xfer_size < codes_size)
+		if (clear_user(codes + xfer_size, codes_size - xfer_size))
+			return -EFAULT;
 
 	return 0;
 }
@@ -1097,27 +1123,29 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 		else
 			return evdev_revoke(evdev, client, file);
 
-	case EVIOCGMASK:
+	case EVIOCGMASK: {
+		void __user *codes_ptr;
+
 		if (copy_from_user(&mask, p, sizeof(mask)))
 			return -EFAULT;
 
+		codes_ptr = (void __user *)(unsigned long)mask.codes_ptr;
 		return evdev_get_mask(client,
-				      mask.type,
-				      (void __user*)
-				      (unsigned long)mask.codes_ptr,
-				      mask.codes_size,
+				      mask.type, codes_ptr, mask.codes_size,
 				      compat_mode);
+	}
+
+	case EVIOCSMASK: {
+		const void __user *codes_ptr;
 
-	case EVIOCSMASK:
 		if (copy_from_user(&mask, p, sizeof(mask)))
 			return -EFAULT;
 
+		codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr;
 		return evdev_set_mask(client,
-				      mask.type,
-				      (const void __user*)
-				      (unsigned long)mask.codes_ptr,
-				      mask.codes_size,
+				      mask.type, codes_ptr, mask.codes_size,
 				      compat_mode);
+	}
 
 	case EVIOCSCLOCKID:
 		if (copy_from_user(&i, p, sizeof(unsigned int)))
#3 lore raw

Hi

Quoted 38 lines · Dmitry Torokhov

Hi David,

Quoted 35 lines · David Herrmann
(quoted diff) +35 -0
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+                       unsigned int maxlen, const void __user *p, int compat)
+{
+     int len;
+
+#if IS_ENABLED(CONFIG_COMPAT)
+     if (compat) {
+             if (maxlen % sizeof(compat_long_t))
+                     return -EINVAL;
+             len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
+     } else
+#endif
+     {
+             if (maxlen % sizeof(long))
+                     return -EINVAL;
+             len = BITS_TO_LONGS(maxbit) * sizeof(long);
+     }
+
+     if (len > maxlen)
+             len = maxlen;
+
+#if IS_ENABLED(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
+     if (compat) {
+             int i;
+
+             for (i = 0; i < len / sizeof(compat_long_t); i++)
+                     if (copy_from_user((compat_long_t *) bits +
+                                             i + 1 - ((i % 2) << 1),
+                                        (compat_long_t __user *) p + i,
+                                        sizeof(compat_long_t)))
+                             return -EFAULT;
+             if (i % 2)
+                     *((compat_long_t *) bits + i - 1) = 0;
+     } else
+#endif
Quoted 8 lines

drivers/input/evdev.c static int bits_to_user(unsigned long *bits, unsigned int maxbit, · line 724

Quoted 5 lines
drivers/input/evdev.c +5 -0
+             if (copy_from_user(bits, p, len))
+                     return -EFAULT;
+
+     return len;
+}

I do not quite like how we sprinkle ifdefs throughout, I prefer the way we have bits_to_user defined, even if it is more verbose.

Makes sense.

Quoted 36 lines
Quoted 22 lines
drivers/input/evdev.c +15 -0
+
 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 {
      int len;
@@ -854,6 +953,86 @@ static int evdev_revoke(struct evdev *evdev, struct evdev_client *client,
      return 0;
 }
 
+/* must be called with evdev-mutex held */
+static int evdev_set_mask(struct evdev_client *client,
+                       unsigned int type,
+                       const void __user *codes,
+                       u32 codes_size,
+                       int compat)
+{
+     unsigned long flags, *mask, *oldmask;
+     size_t cnt, size, min;
+     int error;
+
+     /* we allow unknown types and 'codes_size > size' for forward-compat */
+     cnt = evdev_get_mask_cnt(type);
+     if (!cnt)

drivers/input/evdev.c static int evdev_revoke(struct evdev *evdev, struct evdev_client *client, · line 979

Quoted 10 lines
drivers/input/evdev.c +10 -0
+             return 0;
+
+     size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
+     min = min_t(size_t, codes_size, size);
+
+     mask = kzalloc(size, GFP_KERNEL);
+     if (!mask)
+             return -ENOMEM;
+
+     error = bits_from_user(mask, cnt - 1, min, codes, compat);

I do not think we need to calculate and pass min here: bits_from_user() will limit the output for us already.

Quoted 1 line

Does it still work if you apply the patch below?

One comment on void*-arithmetic below. Otherwise, this is reviewed and tested by me.

Thanks a lot!
David

Quoted 194 lines
---
 drivers/input/evdev.c |  148 +++++++++++++++++++++++++++++--------------------
 1 file changed, 88 insertions(+), 60 deletions(-)
drivers/input/evdev.c +73 -45
index 83d699f..ce35ea3 100644
@@ -685,7 +685,46 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 
        return len;
 }
+
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+                         unsigned int maxlen, const void __user *p, int compat)
+{
+       int len, i;
+
+       if (compat) {
+               if (maxlen % sizeof(compat_long_t))
+                       return -EINVAL;
+
+               len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
+               if (len > maxlen)
+                       len = maxlen;
+
+               for (i = 0; i < len / sizeof(compat_long_t); i++)
+                       if (copy_from_user((compat_long_t *) bits +
+                                               i + 1 - ((i % 2) << 1),
+                                          (compat_long_t __user *) p + i,
+                                          sizeof(compat_long_t)))
+                               return -EFAULT;
+               if (i % 2)
+                       *((compat_long_t *) bits + i - 1) = 0;
+
+       } else {
+               if (maxlen % sizeof(long))
+                       return -EINVAL;
+
+               len = BITS_TO_LONGS(maxbit) * sizeof(long);
+               if (len > maxlen)
+                       len = maxlen;
+
+               if (copy_from_user(p, bits, len))
+                       return -EFAULT;
+       }
+
+       return len;
+}
+
 #else
+
 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
                        unsigned int maxlen, void __user *p, int compat)
 {
@@ -698,6 +737,24 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
 
        return copy_to_user(p, bits, len) ? -EFAULT : len;
 }
+
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+                         unsigned int maxlen, const void __user *p, int compat)
+{
+       size_t chunk_size = compat ? sizeof(compat_long_t) : sizeof(long);
+       int len;
+
+       if (maxlen % chunk_size)
+               return -EINVAL;
+
+       len = compat ? BITS_TO_LONGS_COMPAT(maxbit) : BITS_TO_LONGS(maxbit);
+       len *= chunk_size;
+       if (len > maxlen)
+               len = maxlen;
+
+       return copy_from_user(bits, p, len) ? -EFAULT : len;
+}
+
 #endif /* __BIG_ENDIAN */
 
 #else
@@ -713,49 +770,23 @@ static int bits_to_user(unsigned long *bits, unsigned int maxbit,
        return copy_to_user(p, bits, len) ? -EFAULT : len;
 }
 
-#endif /* CONFIG_COMPAT */
-
 static int bits_from_user(unsigned long *bits, unsigned int maxbit,
                          unsigned int maxlen, const void __user *p, int compat)
 {
        int len;
 
-#if IS_ENABLED(CONFIG_COMPAT)
-       if (compat) {
-               if (maxlen % sizeof(compat_long_t))
-                       return -EINVAL;
-               len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
-       } else
-#endif
-       {
-               if (maxlen % sizeof(long))
-                       return -EINVAL;
-               len = BITS_TO_LONGS(maxbit) * sizeof(long);
-       }
+       if (maxlen % sizeof(long))
+               return -EINVAL;
 
+       len = BITS_TO_LONGS(maxbit) * sizeof(long);
        if (len > maxlen)
                len = maxlen;
 
-#if IS_ENABLED(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
-       if (compat) {
-               int i;
-
-               for (i = 0; i < len / sizeof(compat_long_t); i++)
-                       if (copy_from_user((compat_long_t *) bits +
-                                               i + 1 - ((i % 2) << 1),
-                                          (compat_long_t __user *) p + i,
-                                          sizeof(compat_long_t)))
-                               return -EFAULT;
-               if (i % 2)
-                       *((compat_long_t *) bits + i - 1) = 0;
-       } else
-#endif
-               if (copy_from_user(bits, p, len))
-                       return -EFAULT;
-
-       return len;
+       return copy_from_user(bits, p, len) ? -EFAULT : len;
 }
 
+#endif /* CONFIG_COMPAT */
+
 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 {
        int len;
@@ -956,7 +987,7 @@ static int evdev_set_mask(struct evdev_client *client,
                          int compat)
 {
        unsigned long flags, *mask, *oldmask;
-       size_t cnt, size, min;
+       size_t cnt;
        int error;
 
        /* we allow unknown types and 'codes_size > size' for forward-compat */
@@ -964,14 +995,11 @@ static int evdev_set_mask(struct evdev_client *client,
        if (!cnt)
                return 0;
 
-       size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
-       min = min_t(size_t, codes_size, size);
-
-       mask = kzalloc(size, GFP_KERNEL);
+       mask = kcalloc(sizeof(unsigned long), BITS_TO_LONGS(cnt), GFP_KERNEL);
        if (!mask)
                return -ENOMEM;
 
-       error = bits_from_user(mask, cnt - 1, min, codes, compat);
+       error = bits_from_user(mask, cnt - 1, codes_size, codes, compat);
        if (error < 0) {
                kfree(mask);
                return error;
@@ -995,35 +1023,33 @@ static int evdev_get_mask(struct evdev_client *client,
                          int compat)
 {
        unsigned long *mask;
-       size_t cnt, size, min, i;
-       u8 __user *out;
+       size_t cnt, size, xfer_size;
+       int i;
        int error;
 
        /* we allow unknown types and 'codes_size > size' for forward-compat */
        cnt = evdev_get_mask_cnt(type);
        size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
-       min = min_t(size_t, codes_size, size);
+       xfer_size = min_t(size_t, codes_size, size);
 
        if (cnt > 0) {
                mask = client->evmasks[type];
                if (mask) {
-                       error = bits_to_user(mask, cnt - 1, min, codes, compat);
+                       error = bits_to_user(mask, cnt - 1,
+                                            xfer_size, codes, compat);
                        if (error < 0)
                                return error;
                } else {
                        /* fake mask with all bits set */
-                       out = (u8 __user*)codes;
-                       for (i = 0; i < min; ++i)
-                               if (put_user((u8)0xff,  out + i))
+                       for (i = 0; i < xfer_size; i++)
+                               if (put_user(0xffU, (u8 __user *)codes + i))
                                        return -EFAULT;

drivers/input/evdev.c static int evdev_get_mask(struct evdev_client *client, · line 1051

Quoted 10 lines
drivers/input/evdev.c +2 -5
                }
        }
 
-       codes = (u8*)codes + min;
-       codes_size -= min;
-
-       if (codes_size > 0 && clear_user(codes, codes_size))
-               return -EFAULT;
+       if (xfer_size < codes_size)
+               if (clear_user(codes + xfer_size, codes_size - xfer_size))

'codes' is void*. Want to cast it to u8 first? void* arithmetic is a gnu extension, iirc. But maybe kernel code doesn't care, not sure.

Quoted 44 lines
drivers/input/evdev.c +13 -10
+                       return -EFAULT;
 
        return 0;
 }
@@ -1097,27 +1123,29 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                else
                        return evdev_revoke(evdev, client, file);
 
-       case EVIOCGMASK:
+       case EVIOCGMASK: {
+               void __user *codes_ptr;
+
                if (copy_from_user(&mask, p, sizeof(mask)))
                        return -EFAULT;
 
+               codes_ptr = (void __user *)(unsigned long)mask.codes_ptr;
                return evdev_get_mask(client,
-                                     mask.type,
-                                     (void __user*)
-                                     (unsigned long)mask.codes_ptr,
-                                     mask.codes_size,
+                                     mask.type, codes_ptr, mask.codes_size,
                                      compat_mode);
+       }
+
+       case EVIOCSMASK: {
+               const void __user *codes_ptr;
 
-       case EVIOCSMASK:
                if (copy_from_user(&mask, p, sizeof(mask)))
                        return -EFAULT;
 
+               codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr;
                return evdev_set_mask(client,
-                                     mask.type,
-                                     (const void __user*)
-                                     (unsigned long)mask.codes_ptr,
-                                     mask.codes_size,
+                                     mask.type, codes_ptr, mask.codes_size,
                                      compat_mode);
+       }
 
        case EVIOCSCLOCKID:
                if (copy_from_user(&i, p, sizeof(unsigned int)))
maintainer
#4 lore raw
Quoted 89 lines · David Herrmann

Hi

Quoted 38 lines · Dmitry Torokhov

Hi David,

Quoted 35 lines · David Herrmann
(quoted diff) +35 -0
+static int bits_from_user(unsigned long *bits, unsigned int maxbit,
+                       unsigned int maxlen, const void __user *p, int compat)
+{
+     int len;
+
+#if IS_ENABLED(CONFIG_COMPAT)
+     if (compat) {
+             if (maxlen % sizeof(compat_long_t))
+                     return -EINVAL;
+             len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
+     } else
+#endif
+     {
+             if (maxlen % sizeof(long))
+                     return -EINVAL;
+             len = BITS_TO_LONGS(maxbit) * sizeof(long);
+     }
+
+     if (len > maxlen)
+             len = maxlen;
+
+#if IS_ENABLED(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
+     if (compat) {
+             int i;
+
+             for (i = 0; i < len / sizeof(compat_long_t); i++)
+                     if (copy_from_user((compat_long_t *) bits +
+                                             i + 1 - ((i % 2) << 1),
+                                        (compat_long_t __user *) p + i,
+                                        sizeof(compat_long_t)))
+                             return -EFAULT;
+             if (i % 2)
+                     *((compat_long_t *) bits + i - 1) = 0;
+     } else
+#endif
Quoted 8 lines

drivers/input/evdev.c static int bits_to_user(unsigned long *bits, unsigned int maxbit, · line 724

Quoted 5 lines
drivers/input/evdev.c +5 -0
+             if (copy_from_user(bits, p, len))
+                     return -EFAULT;
+
+     return len;
+}

I do not quite like how we sprinkle ifdefs throughout, I prefer the way we have bits_to_user defined, even if it is more verbose.

Makes sense.

Quoted 36 lines
Quoted 22 lines
drivers/input/evdev.c +15 -0
+
 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 {
      int len;
@@ -854,6 +953,86 @@ static int evdev_revoke(struct evdev *evdev, struct evdev_client *client,
      return 0;
 }
 
+/* must be called with evdev-mutex held */
+static int evdev_set_mask(struct evdev_client *client,
+                       unsigned int type,
+                       const void __user *codes,
+                       u32 codes_size,
+                       int compat)
+{
+     unsigned long flags, *mask, *oldmask;
+     size_t cnt, size, min;
+     int error;
+
+     /* we allow unknown types and 'codes_size > size' for forward-compat */
+     cnt = evdev_get_mask_cnt(type);
+     if (!cnt)

drivers/input/evdev.c static int evdev_revoke(struct evdev *evdev, struct evdev_client *client, · line 979

Quoted 10 lines
drivers/input/evdev.c +10 -0
+             return 0;
+
+     size = sizeof(unsigned long) * BITS_TO_LONGS(cnt);
+     min = min_t(size_t, codes_size, size);
+
+     mask = kzalloc(size, GFP_KERNEL);
+     if (!mask)
+             return -ENOMEM;
+
+     error = bits_from_user(mask, cnt - 1, min, codes, compat);

I do not think we need to calculate and pass min here: bits_from_user() will limit the output for us already.

Quoted 4 lines
Quoted 1 line

Does it still work if you apply the patch below?

One comment on void*-arithmetic below. Otherwise, this is reviewed and tested by me.

Yeah, I am not concerned about using this extension - it is used in kernel quite often I think and it actually makes sense to me.

Thank you for giving it a spin, I'll fold into original patch and apply.

Signature · 1 line
Dmitry