kernel/input/input_helper.c

/*
 * Copyright (c) 2015 Cedric Hnyda <chnyda@suse.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <linux/input.h>
#include <linux/uinput.h>
#include <fnmatch.h>
#include <errno.h>
#include <poll.h>

#include "test.h"
#include "safe_macros.h"
#include "input_helper.h"

#define VIRTUAL_DEVICE "virtual-device-ltp"

#define VIRTUAL_DEVICE_REGEX "*virtual-device-ltp*"

static int uinput_loaded;
static int check_device(void);

static int try_open_device(void)
{
	char path[256];
	char name[256];
	int ret, fd = -1;
	unsigned int i;

	for (i = 0; i < 100; i++) {
		snprintf(path, sizeof(path), "/dev/input/event%i", i);

		fd = open(path, O_RDONLY);

		if (fd < 0 && errno == ENOENT)
			continue;

		if (fd < 0) {
			tst_resm(TINFO | TERRNO, "failed to open %s", path);
			break;
		}

		ret = ioctl(fd, EVIOCGNAME(sizeof(name)), name);
		if (ret < 0) {
			tst_resm(TINFO | TERRNO,
				"ioctl(%s, EVIOCGNAME(256), ...) failed",
				path);
			break;
		}

		if (strcmp(name, VIRTUAL_DEVICE) == 0)
			return fd;
		close(fd);
	}

	return -1;
}

int open_device(void)
{
	int fd;
	int retries = 10;

	while (retries--) {
		fd = try_open_device();
		if (fd > 0)
			return fd;
		tst_resm(TINFO, "Device not found, retrying...");
		usleep(10000);
	}

	tst_brkm(TBROK, NULL, "Unable to find the input device");
}

static int try_load_uinput(void)
{
	const char *argv[] = {"modprobe", "uinput", NULL};
	int ret;

	tst_resm(TINFO, "Trying to load uinput kernel module");

	ret = tst_run_cmd(NULL, argv, NULL, NULL, 1);
	if (ret) {
		tst_resm(TINFO, "Failed to load the uinput module");
		return 0;
	}

	return 1;
}

static void unload_uinput(void)
{
	const char *argv[] = {"modprobe", "-r", "uinput", NULL};
	int ret;

	tst_resm(TINFO, "Unloading uinput kernel module");

	ret = tst_run_cmd(NULL, argv, NULL, NULL, 1);
	if (ret)
		tst_resm(TWARN, "Failed to unload uinput module");
}

static const char *uinput_paths[] = {
	"/dev/input/uinput",
	"/dev/uinput",
};

static int try_open_uinput(void)
{
	unsigned int i;
	int fd;

	for (i = 0; i < ARRAY_SIZE(uinput_paths); i++) {
		fd = open(uinput_paths[i], O_WRONLY | O_NONBLOCK);

		if (fd > 0) {
			tst_resm(TINFO, "Found uinput dev at %s",
			         uinput_paths[i]);
			return fd;
		}

		if (fd < 0 && errno != ENOENT) {
			tst_brkm(TBROK | TERRNO, NULL,
			         "open(%s)", uinput_paths[i]);
		}
	}

	return -1;
}

int open_uinput(void)
{
	int fd;
	int retries = 10;

	fd = try_open_uinput();
	if (fd > 0)
		return fd;

	if (try_load_uinput()) {
		while (retries--) {
			fd = try_open_uinput();
			if (fd > 0) {
				uinput_loaded = 1;
				return fd;
			}
			tst_resm(TINFO, "Uinput dev not found, retrying...");
			usleep(10000);
		}

		unload_uinput();
	}

	tst_brkm(TCONF, NULL, "Unable to find and open uinput");
}

void send_event(int fd, int event, int code, int value)
{
	struct input_event ev = {
		.type = event,
		.code = code,
		.value = value,
	};

	SAFE_WRITE(NULL, 1, fd, &ev, sizeof(ev));
}

void send_rel_move(int fd, int x, int y)
{
	send_event(fd, EV_REL, REL_X, x);
	send_event(fd, EV_REL, REL_Y, y);
	send_event(fd, EV_SYN, 0, 0);
}

void create_device(int fd)
{
	int nb;
	struct uinput_user_dev uidev = {
		.name = VIRTUAL_DEVICE,
		.id = {
			.bustype = BUS_USB,
			.vendor = 0x1,
			.product = 0x1,
			.version = 1,
		}
	};

	SAFE_WRITE(NULL, 1, fd, &uidev, sizeof(uidev));
	SAFE_IOCTL(NULL, fd, UI_DEV_CREATE, NULL);

	for (nb = 100; nb > 0; nb--) {
		if (check_device())
			return;
		usleep(10000);
	}

	destroy_device(fd);
	tst_brkm(TBROK, NULL, "Failed to create device");
}

void setup_mouse_events(int fd)
{
	SAFE_IOCTL(NULL, fd, UI_SET_EVBIT, EV_KEY);
	SAFE_IOCTL(NULL, fd, UI_SET_KEYBIT, BTN_LEFT);
	SAFE_IOCTL(NULL, fd, UI_SET_EVBIT, EV_REL);
	SAFE_IOCTL(NULL, fd, UI_SET_RELBIT, REL_X);
	SAFE_IOCTL(NULL, fd, UI_SET_RELBIT, REL_Y);
}

void destroy_device(int fd)
{
	SAFE_IOCTL(NULL, fd, UI_DEV_DESTROY, NULL);
	SAFE_CLOSE(NULL, fd);

	if (uinput_loaded)
		unload_uinput();
}

int check_event_code(struct input_event *iev, int event, int code)
{
	return iev->type == event && iev->code == code;
}

int check_sync_event(struct input_event *iev)
{
	return check_event_code(iev, EV_SYN, SYN_REPORT);
}

/*
 * the value of stray_sync_event:
 * 0: EV_SYN/SYN_REPORT events should not be received in /dev/input/eventX
 * 1: EV_SYN/SYN_REPORT events may be received in /dev/input/eventX
 * On an old kernel(before v3.7.0), EV_SYN/SYN_REPORT events are always
 * received even though we send empty moves.
 */
int no_events_queued(int fd, int stray_sync_event)
{
	struct pollfd fds = {.fd = fd, .events = POLLIN};
	int ret, res, sync_event_ignored;
	struct input_event ev;

	if (tst_kvercmp(3, 7, 0) < 0 && stray_sync_event)
		sync_event_ignored = 1;

	ret = poll(&fds, 1, 30);

	if (ret > 0) {
		res = read(fd, &ev, sizeof(ev));

		if (res == sizeof(ev)) {
			if (sync_event_ignored && check_sync_event(&ev)) {
				ret = 0;
				tst_resm(TINFO,
					 "Ignoring stray sync event (known problem)");
			} else {
				tst_resm(TINFO,
					 "Unexpected ev type=%i code=%i value=%i",
					 ev.type, ev.code, ev.value);
			}
		}
	}

	return ret == 0;
}

static int check_device(void)
{
	FILE *file;
	char line[256];

	file = fopen("/proc/bus/input/devices", "r");
	if (!file)
		return 0;

	while (fgets(line, 256, file)) {
		if (fnmatch(VIRTUAL_DEVICE_REGEX, line, 0) == 0)
			return 1;
	}

	fclose(file);

	return 0;
}