| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <9D74755ABE8BD88F+20250827072125.139887-1-zhangdandan@uniontech.com>
Date: Wed, 27 Aug 2025 15:21:22 +0800
From: Morduan Zang <zhangdandan@...ontech.com>
To: dmitry.torokhov@...il.com
Cc: linux-input@...r.kernel.org,
linux-kernel@...r.kernel.org,
liziyao@...ontech.com,
WangYuli <wangyuli@...ontech.com>,
Winston Wen <wentao@...ontech.com>,
Morduan Zang <zhangdandan@...ontech.com>
Subject: [PATCH 1/2 v2] input: Add tracepoint support
From: WangYuli <wangyuli@...ontech.com>
Introduce a set of tracepoints for the input subsystem to enable
better debugging, monitoring, and performance analysis of input
device operations.
This tracing event while be default to close.
When you open events of tracing, the input trcaing event with be
opened by "echo 1 > /sys/kernel/tracing/events/enabled", However,
the tracking status of each sub-event is independent of each other.
Suggested-by: Winston Wen <wentao@...ontech.com>
Signed-off-by: WangYuli <wangyuli@...ontech.com>
Signed-off-by: Morduan Zang <zhangdandan@...ontech.com>
---
MAINTAINERS | 1 +
drivers/input/input.c | 18 ++-
include/trace/events/input.h | 263 +++++++++++++++++++++++++++++++++++
3 files changed, 281 insertions(+), 1 deletion(-)
create mode 100644 include/trace/events/input.h
diff --git a/MAINTAINERS b/MAINTAINERS
index daf520a13bdf..4dfa2d60faa0 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -12092,6 +12092,7 @@ F: include/linux/i8042.h
F: include/linux/input.h
F: include/linux/input/
F: include/linux/libps2.h
+F: include/trace/events/input.h
F: include/linux/serio.h
F: include/uapi/linux/gameport.h
F: include/uapi/linux/input-event-codes.h
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 1da41324362b..1c5c7056f040 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -29,6 +29,9 @@
#include "input-core-private.h"
#include "input-poller.h"
+#define CREATE_TRACE_POINTS
+#include <trace/events/input.h>
+
MODULE_AUTHOR("Vojtech Pavlik <vojtech@...e.cz>");
MODULE_DESCRIPTION("Input core");
MODULE_LICENSE("GPL");
@@ -363,6 +366,7 @@ void input_handle_event(struct input_dev *dev,
disposition = input_get_disposition(dev, type, code, &value);
if (disposition != INPUT_IGNORE_EVENT) {
+ trace_input_event(dev, type, code, value);
if (type != EV_SYN)
add_input_randomness(type, code, value);
@@ -525,6 +529,7 @@ int input_grab_device(struct input_handle *handle)
return -EBUSY;
rcu_assign_pointer(dev->grab, handle);
+ trace_input_grab_device(dev, handle);
}
return 0;
@@ -539,6 +544,7 @@ static void __input_release_device(struct input_handle *handle)
grabber = rcu_dereference_protected(dev->grab,
lockdep_is_held(&dev->mutex));
if (grabber == handle) {
+ trace_input_release_device(dev, handle);
rcu_assign_pointer(dev->grab, NULL);
/* Make sure input_pass_values() notices that grab is gone */
synchronize_rcu();
@@ -612,6 +618,7 @@ int input_open_device(struct input_handle *handle)
if (dev->poller)
input_dev_poller_start(dev->poller);
+ trace_input_open_device(dev);
}
return 0;
@@ -652,6 +659,7 @@ void input_close_device(struct input_handle *handle)
input_dev_poller_stop(dev->poller);
if (dev->close)
dev->close(dev);
+ trace_input_close_device(dev);
}
}
@@ -991,9 +999,13 @@ static int input_attach_handler(struct input_dev *dev, struct input_handler *han
return -ENODEV;
error = handler->connect(handler, dev, id);
- if (error && error != -ENODEV)
+ if (error && error != -ENODEV) {
pr_err("failed to attach handler %s to device %s, error: %d\n",
handler->name, kobject_name(&dev->dev.kobj), error);
+ } else if (!error) {
+ /* Connection successful, trace it */
+ trace_input_handler_connect(handler, dev, handler->minor);
+ }
return error;
}
@@ -1791,6 +1803,7 @@ static int input_inhibit_device(struct input_dev *dev)
}
dev->inhibited = true;
+ trace_input_inhibit_device(dev);
return 0;
}
@@ -1818,6 +1831,7 @@ static int input_uninhibit_device(struct input_dev *dev)
scoped_guard(spinlock_irq, &dev->event_lock)
input_dev_toggle(dev, true);
+ trace_input_uninhibit_device(dev);
return 0;
}
@@ -2216,6 +2230,7 @@ static void __input_unregister_device(struct input_dev *dev)
{
struct input_handle *handle, *next;
+ trace_input_device_unregister(dev);
input_disconnect_device(dev);
scoped_guard(mutex, &input_mutex) {
@@ -2414,6 +2429,7 @@ int input_register_device(struct input_dev *dev)
input_wakeup_procfs_readers();
}
+ trace_input_device_register(dev);
if (dev->devres_managed) {
dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
__func__, dev_name(&dev->dev));
diff --git a/include/trace/events/input.h b/include/trace/events/input.h
new file mode 100644
index 000000000000..e01c8b5c61f7
--- /dev/null
+++ b/include/trace/events/input.h
@@ -0,0 +1,263 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* input tracepoints
+ *
+ * Copyright (C) 2025 WangYuli <wangyuli@...ontech.com>
+ */
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM input
+
+#if !defined(_TRACE_INPUT_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_INPUT_H
+
+#include <linux/tracepoint.h>
+#include <linux/input.h>
+
+/**
+ * input_event - called when an input event is processed
+ * @dev: input device that generated the event
+ * @type: event type (EV_KEY, EV_REL, EV_ABS, etc.)
+ * @code: event code within the type
+ * @value: event value
+ *
+ * This tracepoint fires for every input event processed by the input core.
+ * It can be used to monitor input device activity and debug input issues.
+ */
+TRACE_EVENT(
+ input_event,
+
+ TP_PROTO(struct input_dev *dev, unsigned int type, unsigned int code,
+ int value),
+
+ TP_ARGS(dev, type, code, value),
+
+ TP_STRUCT__entry(__string(name, dev->name ?: "unknown")
+ __field(unsigned int, type)
+ __field(unsigned int, code)
+ __field(int, value)
+ __field(u16, bustype)
+ __field(u16, vendor)
+ __field(u16, product)),
+
+ TP_fast_assign(__assign_str(name); __entry->type = type;
+ __entry->code = code; __entry->value = value;
+ __entry->bustype = dev->id.bustype;
+ __entry->vendor = dev->id.vendor;
+ __entry->product = dev->id.product;),
+
+ TP_printk(
+ "dev=%s type=%u code=%u value=%d bus=%04x vendor=%04x product=%04x",
+ __get_str(name), __entry->type, __entry->code, __entry->value,
+ __entry->bustype, __entry->vendor, __entry->product));
+
+/**
+ * input_device_register - called when an input device is registered
+ * @dev: input device being registered
+ *
+ * This tracepoint fires when a new input device is registered with the
+ * input subsystem. Useful for monitoring device hotplug events.
+ */
+TRACE_EVENT(
+ input_device_register,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev),
+
+ TP_STRUCT__entry(__string(name, dev->name ?: "unknown")
+ __string(phys, dev->phys ?: "")
+ __field(u16, bustype)
+ __field(u16, vendor)
+ __field(u16, product)
+ __field(u16, version)),
+
+ TP_fast_assign(__assign_str(name); __assign_str(phys);
+ __entry->bustype = dev->id.bustype;
+ __entry->vendor = dev->id.vendor;
+ __entry->product = dev->id.product;
+ __entry->version = dev->id.version;),
+
+ TP_printk(
+ "dev=%s phys=%s bus=%04x vendor=%04x product=%04x version=%04x",
+ __get_str(name), __get_str(phys), __entry->bustype,
+ __entry->vendor, __entry->product, __entry->version));
+
+/**
+ * input_device_unregister - called when an input device is unregistered
+ * @dev: input device being unregistered
+ *
+ * This tracepoint fires when an input device is unregistered from the
+ * input subsystem. Useful for monitoring device hotplug events.
+ */
+TRACE_EVENT(input_device_unregister,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev),
+
+ TP_STRUCT__entry(__string(name, dev->name ?: "unknown")
+ __string(phys, dev->phys ?: "")
+ __field(u16, bustype)
+ __field(u16, vendor)
+ __field(u16, product)),
+
+ TP_fast_assign(__assign_str(name);
+ __assign_str(phys);
+ __entry->bustype = dev->id.bustype;
+ __entry->vendor = dev->id.vendor;
+ __entry->product = dev->id.product;),
+
+ TP_printk("dev=%s phys=%s bus=%04x vendor=%04x product=%04",
+ __get_str(name), __get_str(phys), __entry->bustype,
+ __entry->vendor, __entry->product));
+
+/**
+ * input_handler_connect - called when an input handler connects to a device
+ * @handler: input handler
+ * @dev: input device
+ * @minor: assigned minor number (if applicable)
+ *
+ * This tracepoint fires when an input handler (like evdev, mousedev) connects
+ * to an input device, creating a new input handle.
+ */
+TRACE_EVENT(input_handler_connect,
+
+ TP_PROTO(struct input_handler *handler, struct input_dev *dev,
+ int minor),
+
+ TP_ARGS(handler, dev, minor),
+
+ TP_STRUCT__entry(__string(handler_name, handler->name)
+ __string(dev_name, dev->name ?: "unknown")
+ __field(int, minor)),
+
+ TP_fast_assign(__assign_str(handler_name);
+ __assign_str(dev_name);
+ __entry->minor = minor;),
+
+ TP_printk("handler=%s dev=%s minor=%d",
+ __get_str(handler_name),
+ __get_str(dev_name),
+ __entry->minor));
+
+/**
+ * input_grab_device - called when a device is grabbed by a handler
+ * @dev: input device being grabbed
+ * @handle: input handle doing the grab
+ *
+ * This tracepoint fires when an input device is grabbed exclusively
+ * by an input handler, typically for security or special processing.
+ */
+TRACE_EVENT(input_grab_device,
+
+ TP_PROTO(struct input_dev *dev, struct input_handle *handle),
+
+ TP_ARGS(dev, handle),
+
+ TP_STRUCT__entry(__string(dev_name, dev->name ?: "unknown")
+ __string(handler_name, handle->handler->name)),
+
+ TP_fast_assign(__assign_str(dev_name);
+ __assign_str(handler_name);),
+
+ TP_printk("dev=%s grabbed_by=%s",
+ __get_str(dev_name),
+ __get_str(handler_name)));
+
+/**
+ * input_release_device - called when a grabbed device is released
+ * @dev: input device being released
+ * @handle: input handle releasing the grab
+ *
+ * This tracepoint fires when an input device grab is released.
+ */
+TRACE_EVENT(input_release_device,
+
+ TP_PROTO(struct input_dev *dev, struct input_handle *handle),
+
+ TP_ARGS(dev, handle),
+
+ TP_STRUCT__entry(__string(dev_name, dev->name ?: "unknown")
+ __string(handler_name, handle->handler->name)),
+
+ TP_fast_assign(__assign_str(dev_name);
+ __assign_str(handler_name);),
+
+ TP_printk("dev=%s released_by=%s",
+ __get_str(dev_name),
+ __get_str(handler_name)));
+
+DECLARE_EVENT_CLASS(input_device_state,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev),
+
+ TP_STRUCT__entry(__string(name, dev->name ?: "unknown")
+ __field(unsigned int, users)
+ __field(bool, inhibited)),
+
+ TP_fast_assign(__assign_str(name);
+ __entry->users = dev->users;
+ __entry->inhibited = dev->inhibited;),
+
+ TP_printk("dev=%s users=%u inhibited=%s",
+ __get_str(name),
+ __entry->users,
+ __entry->inhibited ? "true" : "false"));
+
+/**
+ * input_open_device - called when an input device is opened
+ * @dev: input device being opened
+ *
+ * This tracepoint fires when the user count for an input device increases,
+ * typically when a userspace application opens the device.
+ */
+DEFINE_EVENT(input_device_state, input_open_device,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev));
+
+/**
+ * input_close_device - called when an input device is closed
+ * @dev: input device being closed
+ *
+ * This tracepoint fires when the user count for an input device decreases,
+ * typically when a userspace application closes the device.
+ */
+DEFINE_EVENT(input_device_state, input_close_device,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev));
+
+/**
+ * input_inhibit_device - called when an input device is inhibited
+ * @dev: input device being inhibited
+ *
+ * This tracepoint fires when an input device is inhibited (disabled),
+ * usually for power management or security reasons.
+ */
+DEFINE_EVENT(input_device_state, input_inhibit_device,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev));
+
+/**
+ * input_uninhibit_device - called when an input device is uninhibited
+ * @dev: input device being uninhibited
+ *
+ * This tracepoint fires when an input device is uninhibited (re-enabled)
+ * after being previously inhibited.
+ */
+DEFINE_EVENT(input_device_state, input_uninhibit_device,
+
+ TP_PROTO(struct input_dev *dev),
+
+ TP_ARGS(dev));
+
+#endif /* _TRACE_INPUT_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
--
2.50.1
Powered by blists - more mailing lists