rpms/systemd
7
0
Fork 0
Code Issues Pull Requests Releases Activity
cebcd2064c
systemd/0085-terminal-add-systemd-evcat-input-debugging-tool.patch
Zbigniew Jędrzejewski-Szmek 62fe9450da Update to latest git
2014-10-07 15:51:56 -04:00

567 lines
17 KiB
Diff
Raw Blame History

From 8e9371905c743cf997b2e8fa7fe3238f81f741fe Mon Sep 17 00:00:00 2001
From: David Herrmann <dh.herrmann@gmail.com>
Date: Wed, 27 Aug 2014 18:38:01 +0200
Subject: [PATCH] terminal: add systemd-evcat input debugging tool
Like systemd-subterm, this new systemd-evcat tool should only be used to
debug libsystemd-terminal. systemd-evcat attaches to the running session
and pushes all evdev devices attached to the current session into an
idev-session. All events of the created idev-devices are then printed to
stdout for input-event debugging.
---
.gitignore | 1 +
Makefile.am | 14 ++
src/libsystemd-terminal/evcat.c | 499 ++++++++++++++++++++++++++++++++++++++++
3 files changed, 514 insertions(+)
create mode 100644 src/libsystemd-terminal/evcat.c
diff --git a/.gitignore b/.gitignore
index 8aed0b9ba6..f8650870a3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,6 +69,7 @@
/systemd-detect-virt
/systemd-efi-boot-generator
/systemd-escape
+/systemd-evcat
/systemd-firstboot
/systemd-fsck
/systemd-fstab-generator
diff --git a/Makefile.am b/Makefile.am
index 35a4c44a9f..e091febc1f 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -2954,6 +2954,7 @@ noinst_LTLIBRARIES += \
libsystemd-terminal.la
noinst_PROGRAMS += \
+ systemd-evcat \
systemd-subterm
unifontdatadir=$(datadir)/unifont
@@ -2995,6 +2996,19 @@ libsystemd_terminal_la_LIBADD = \
libsystemd-shared.la \
$(TERMINAL_LIBS)
+systemd_evcat_CFLAGS = \
+ $(AM_CFLAGS) \
+ $(TERMINAL_CFLAGS)
+
+systemd_evcat_SOURCES = \
+ src/libsystemd-terminal/evcat.c
+
+systemd_evcat_LDADD = \
+ libsystemd-terminal.la \
+ libsystemd-internal.la \
+ libsystemd-shared.la \
+ $(TERMINAL_LIBS)
+
systemd_subterm_SOURCES = \
src/libsystemd-terminal/subterm.c
diff --git a/src/libsystemd-terminal/evcat.c b/src/libsystemd-terminal/evcat.c
new file mode 100644
index 0000000000..590a30d873
--- /dev/null
+++ b/src/libsystemd-terminal/evcat.c
@@ -0,0 +1,499 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+ This file is part of systemd.
+
+ Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
+
+ systemd is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ systemd is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+/*
+ * Event Catenation
+ * The evcat tool catenates input events of all requested devices and prints
+ * them to standard-output. It's only meant for debugging of input-related
+ * problems.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <getopt.h>
+#include <libevdev/libevdev.h>
+#include <linux/kd.h>
+#include <linux/vt.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <systemd/sd-bus.h>
+#include <systemd/sd-event.h>
+#include <systemd/sd-login.h>
+#include <termios.h>
+#include <unistd.h>
+#include <xkbcommon/xkbcommon.h>
+#include "build.h"
+#include "bus-util.h"
+#include "event-util.h"
+#include "idev.h"
+#include "macro.h"
+#include "sysview.h"
+#include "term-internal.h"
+#include "util.h"
+
+typedef struct Evcat Evcat;
+
+struct Evcat {
+ char *session;
+ char *seat;
+ sd_event *event;
+ sd_bus *bus;
+ sysview_context *sysview;
+ idev_context *idev;
+ idev_session *idev_session;
+
+ bool managed : 1;
+};
+
+static Evcat *evcat_free(Evcat *e) {
+ if (!e)
+ return NULL;
+
+ e->idev_session = idev_session_free(e->idev_session);
+ e->idev = idev_context_unref(e->idev);
+ e->sysview = sysview_context_free(e->sysview);
+ e->bus = sd_bus_unref(e->bus);
+ e->event = sd_event_unref(e->event);
+ free(e->seat);
+ free(e->session);
+ free(e);
+
+ tcflush(0, TCIOFLUSH);
+
+ return NULL;
+}
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(Evcat*, evcat_free);
+
+static bool is_managed(const char *session) {
+ unsigned int vtnr;
+ struct stat st;
+ long mode;
+ int r;
+
+ /* Using logind's Controller API is highly fragile if there is already
+ * a session controller running. If it is registered as controller
+ * itself, TakeControl will simply fail. But if its a legacy controller
+ * that does not use logind's controller API, we must never register
+ * our own controller. Otherwise, we really mess up the VT. Therefore,
+ * only run in managed mode if there's no-one else. */
+
+ if (geteuid() == 0)
+ return false;
+
+ if (!isatty(1))
+ return false;
+
+ if (!session)
+ return false;
+
+ r = sd_session_get_vt(session, &vtnr);
+ if (r < 0 || vtnr < 1 || vtnr > 63)
+ return false;
+
+ mode = 0;
+ r = ioctl(1, KDGETMODE, &mode);
+ if (r < 0 || mode != KD_TEXT)
+ return false;
+
+ r = fstat(1, &st);
+ if (r < 0 || minor(st.st_rdev) != vtnr)
+ return false;
+
+ return true;
+}
+
+static int evcat_new(Evcat **out) {
+ _cleanup_(evcat_freep) Evcat *e = NULL;
+ int r;
+
+ assert(out);
+
+ e = new0(Evcat, 1);
+ if (!e)
+ return log_oom();
+
+ r = sd_pid_get_session(getpid(), &e->session);
+ if (r < 0) {
+ log_error("Cannot retrieve logind session: %s", strerror(-r));
+ return r;
+ }
+
+ r = sd_session_get_seat(e->session, &e->seat);
+ if (r < 0) {
+ log_error("Cannot retrieve seat of logind session: %s", strerror(-r));
+ return r;
+ }
+
+ e->managed = is_managed(e->session);
+
+ r = sd_event_default(&e->event);
+ if (r < 0)
+ return r;
+
+ r = sd_bus_open_system(&e->bus);
+ if (r < 0)
+ return r;
+
+ r = sd_bus_attach_event(e->bus, e->event, SD_EVENT_PRIORITY_NORMAL);
+ if (r < 0)
+ return r;
+
+ r = sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1);
+ if (r < 0)
+ return r;
+
+ r = sd_event_add_signal(e->event, NULL, SIGTERM, NULL, NULL);
+ if (r < 0)
+ return r;
+
+ r = sd_event_add_signal(e->event, NULL, SIGINT, NULL, NULL);
+ if (r < 0)
+ return r;
+
+ r = sysview_context_new(&e->sysview,
+ SYSVIEW_CONTEXT_SCAN_LOGIND |
+ SYSVIEW_CONTEXT_SCAN_EVDEV,
+ e->event,
+ e->bus,
+ NULL);
+ if (r < 0)
+ return r;
+
+ r = idev_context_new(&e->idev, e->event, e->bus);
+ if (r < 0)
+ return r;
+
+ *out = e;
+ e = NULL;
+ return 0;
+}
+
+static void kdata_print(idev_data *data) {
+ idev_data_keyboard *k = &data->keyboard;
+ char buf[128];
+ uint32_t i, c;
+ int cwidth;
+
+ /* Key-press state: UP/DOWN/REPEAT */
+ printf(" %-6s", k->value == 0 ? "UP" :
+ k->value == 1 ? "DOWN" :
+ "REPEAT");
+
+ /* Keycode that triggered the event */
+ printf(" | %5u", (unsigned)k->keycode);
+
+ /* Well-known name of the keycode */
+ printf(" | %-20s", libevdev_event_code_get_name(EV_KEY, k->keycode) ? : "<unknown>");
+
+ /* Well-known modifiers */
+ printf(" | %-5s", (k->mods & IDEV_KBDMOD_SHIFT) ? "SHIFT" : "");
+ printf(" %-4s", (k->mods & IDEV_KBDMOD_CTRL) ? "CTRL" : "");
+ printf(" %-3s", (k->mods & IDEV_KBDMOD_ALT) ? "ALT" : "");
+ printf(" %-5s", (k->mods & IDEV_KBDMOD_LINUX) ? "LINUX" : "");
+ printf(" %-4s", (k->mods & IDEV_KBDMOD_CAPS) ? "CAPS" : "");
+
+ /* Resolved symbols */
+ printf(" |");
+ for (i = 0; i < k->n_syms; ++i) {
+ buf[0] = 0;
+ xkb_keysym_get_name(k->keysyms[i], buf, sizeof(buf));
+
+ if (is_locale_utf8()) {
+ c = k->codepoints[i];
+ if (c < 0x110000 && c > 0x20 && (c < 0x7f || c > 0x9f)) {
+ /* "%4lc" doesn't work well, so hard-code it */
+ cwidth = mk_wcwidth(c);
+ while (cwidth++ < 2)
+ printf(" ");
+
+ printf(" '%lc':", (wchar_t)c);
+ } else {
+ printf(" ");
+ }
+ }
+
+ printf(" XKB_KEY_%-30s", buf);
+ }
+
+ printf("\n");
+}
+
+static bool kdata_is_exit(idev_data *data) {
+ idev_data_keyboard *k = &data->keyboard;
+
+ if (k->value != 1)
+ return false;
+ if (k->n_syms != 1)
+ return false;
+
+ return k->codepoints[0] == 'q';
+}
+
+static int evcat_idev_fn(idev_session *session, void *userdata, idev_event *ev) {
+ Evcat *e = userdata;
+
+ switch (ev->type) {
+ case IDEV_EVENT_DEVICE_ADD:
+ idev_device_enable(ev->device_add.device);
+ break;
+ case IDEV_EVENT_DEVICE_REMOVE:
+ idev_device_disable(ev->device_remove.device);
+ break;
+ case IDEV_EVENT_DEVICE_DATA:
+ switch (ev->device_data.data.type) {
+ case IDEV_DATA_KEYBOARD:
+ if (kdata_is_exit(&ev->device_data.data))
+ sd_event_exit(e->event, 0);
+ else
+ kdata_print(&ev->device_data.data);
+
+ break;
+ }
+
+ break;
+ }
+
+ return 0;
+}
+
+static int evcat_sysview_fn(sysview_context *c, void *userdata, sysview_event *ev) {
+ unsigned int flags, type;
+ Evcat *e = userdata;
+ sysview_device *d;
+ const char *name;
+ int r;
+
+ switch (ev->type) {
+ case SYSVIEW_EVENT_SESSION_FILTER:
+ if (streq_ptr(e->session, ev->session_filter.id))
+ return 1;
+
+ break;
+ case SYSVIEW_EVENT_SESSION_ADD:
+ assert(!e->idev_session);
+
+ name = sysview_session_get_name(ev->session_add.session);
+ flags = 0;
+
+ if (e->managed)
+ flags |= IDEV_SESSION_MANAGED;
+
+ r = idev_session_new(&e->idev_session,
+ e->idev,
+ flags,
+ name,
+ evcat_idev_fn,
+ e);
+ if (r < 0) {
+ log_error("Cannot create idev session: %s", strerror(-r));
+ return r;
+ }
+
+ idev_session_enable(e->idev_session);
+
+ if (e->managed) {
+ r = sysview_session_take_control(ev->session_add.session);
+ if (r < 0) {
+ log_error("Cannot request session control: %s", strerror(-r));
+ return r;
+ }
+ }
+
+ break;
+ case SYSVIEW_EVENT_SESSION_REMOVE:
+ idev_session_disable(e->idev_session);
+ e->idev_session = idev_session_free(e->idev_session);
+ sd_event_exit(e->event, 0);
+ break;
+ case SYSVIEW_EVENT_SESSION_ATTACH:
+ d = ev->session_attach.device;
+ type = sysview_device_get_type(d);
+ if (type == SYSVIEW_DEVICE_EVDEV) {
+ r = idev_session_add_evdev(e->idev_session, sysview_device_get_ud(d));
+ if (r < 0) {
+ log_error("Cannot add evdev device to idev: %s", strerror(-r));
+ return r;
+ }
+ }
+
+ break;
+ case SYSVIEW_EVENT_SESSION_DETACH:
+ d = ev->session_detach.device;
+ type = sysview_device_get_type(d);
+ if (type == SYSVIEW_DEVICE_EVDEV) {
+ r = idev_session_remove_evdev(e->idev_session, sysview_device_get_ud(d));
+ if (r < 0) {
+ log_error("Cannot remove evdev device from idev: %s", strerror(-r));
+ return r;
+ }
+ }
+
+ break;
+ case SYSVIEW_EVENT_SESSION_CONTROL:
+ r = ev->session_control.error;
+ if (r < 0) {
+ log_error("Cannot acquire session control: %s", strerror(-r));
+ return r;
+ }
+
+ r = ioctl(1, KDSKBMODE, K_UNICODE);
+ if (r < 0) {
+ log_error("Cannot set K_UNICODE on stdout: %m");
+ return -errno;
+ }
+
+ r = ioctl(1, KDSETMODE, KD_TEXT);
+ if (r < 0) {
+ log_error("Cannot set KD_TEXT on stdout: %m");
+ return -errno;
+ }
+
+ printf("\n");
+
+ break;
+ }
+
+ return 0;
+}
+
+static int evcat_run(Evcat *e) {
+ struct termios in_attr, saved_attr;
+ int r;
+
+ assert(e);
+
+ if (!e->managed && geteuid() > 0)
+ log_warning("You run in unmanaged mode without being root. This is likely to produce no output..");
+
+ printf("evcat - Read and catenate events from selected input devices\n"
+ " Running on seat '%s' in user-session '%s'\n"
+ " Exit by pressing ^C or 'q'\n\n",
+ e->seat ? : "seat0", e->session ? : "<none>");
+
+ r = sysview_context_start(e->sysview, evcat_sysview_fn, e);
+ if (r < 0)
+ goto out;
+
+ r = tcgetattr(0, &in_attr);
+ if (r < 0) {
+ r = -errno;
+ goto out;
+ }
+
+ saved_attr = in_attr;
+ in_attr.c_lflag &= ~ECHO;
+
+ r = tcsetattr(0, TCSANOW, &in_attr);
+ if (r < 0) {
+ r = -errno;
+ goto out;
+ }
+
+ r = sd_event_loop(e->event);
+ tcsetattr(0, TCSANOW, &saved_attr);
+ printf("exiting..\n");
+
+out:
+ sysview_context_stop(e->sysview);
+ return r;
+}
+
+static int help(void) {
+ printf("%s [OPTIONS...]\n\n"
+ "Read and catenate events from selected input devices.\n\n"
+ " -h --help Show this help\n"
+ " --version Show package version\n"
+ , program_invocation_short_name);
+
+ return 0;
+}
+
+static int parse_argv(int argc, char *argv[]) {
+ enum {
+ ARG_VERSION = 0x100,
+ };
+ static const struct option options[] = {
+ { "help", no_argument, NULL, 'h' },
+ { "version", no_argument, NULL, ARG_VERSION },
+ {},
+ };
+ int c;
+
+ assert(argc >= 0);
+ assert(argv);
+
+ while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
+ switch (c) {
+ case 'h':
+ help();
+ return 0;
+
+ case ARG_VERSION:
+ puts(PACKAGE_STRING);
+ puts(SYSTEMD_FEATURES);
+ return 0;
+
+ case '?':
+ return -EINVAL;
+
+ default:
+ assert_not_reached("Unhandled option");
+ }
+
+ if (argc > optind) {
+ log_error("Too many arguments");
+ return -EINVAL;
+ }
+
+ return 1;
+}
+
+int main(int argc, char *argv[]) {
+ _cleanup_(evcat_freep) Evcat *e = NULL;
+ int r;
+
+ log_set_target(LOG_TARGET_AUTO);
+ log_parse_environment();
+ log_open();
+
+ setlocale(LC_ALL, "");
+ if (!is_locale_utf8())
+ log_warning("Locale is not set to UTF-8. Codepoints will not be printed!");
+
+ r = parse_argv(argc, argv);
+ if (r <= 0)
+ goto finish;
+
+ r = evcat_new(&e);
+ if (r < 0)
+ goto finish;
+
+ r = evcat_run(e);
+
+finish:
+ return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
+}
Reference in New Issue View Git Blame Copy Permalink