contrib/vhost-user-input/main.c

   1 /*
   2  * This work is licensed under the terms of the GNU GPL, version 2 or
   3  * (at your option) any later version.  See the COPYING file in the
   4  * top-level directory.
   5  */
   6
   7 #include "qemu/osdep.h"
   8
   9 #include <sys/ioctl.h>
  10
  11 #include "qemu/iov.h"
  12 #include "qemu/bswap.h"
  13 #include "qemu/sockets.h"
  14 #include "libvhost-user-glib.h"
  15 #include "standard-headers/linux/input.h"
  16 #include "standard-headers/linux/virtio_input.h"
  17 #include "qapi/error.h"
  18
  19 enum {
  20     VHOST_USER_INPUT_MAX_QUEUES = 2,
  21 };
  22
  23 typedef struct virtio_input_event virtio_input_event;
  24 typedef struct virtio_input_config virtio_input_config;
  25
  26 typedef struct VuInput {
  27     VugDev dev;
  28     GSource *evsrc;
  29     int evdevfd;
  30     GArray *config;
  31     virtio_input_config *sel_config;
  32     struct {
  33         virtio_input_event event;
  34         VuVirtqElement *elem;
  35     } *queue;
  36     uint32_t qindex, qsize;
  37 } VuInput;
  38
  39 static void vi_input_send(VuInput *vi, struct virtio_input_event *event)
  40 {
  41     VuDev *dev = &vi->dev.parent;
  42     VuVirtq *vq = vu_get_queue(dev, 0);
  43     VuVirtqElement *elem;
  44     int i, len;
  45
  46     /* queue up events ... */
  47     if (vi->qindex == vi->qsize) {
  48         vi->qsize++;
  49         vi->queue = g_realloc_n(vi->queue, vi->qsize, sizeof(vi->queue[0]));
  50     }
  51     vi->queue[vi->qindex++].event = *event;
  52
  53     /* ... until we see a report sync ... */
  54     if (event->type != htole16(EV_SYN) ||
  55         event->code != htole16(SYN_REPORT)) {
  56         return;
  57     }
  58
  59     /* ... then check available space ... */
  60     for (i = 0; i < vi->qindex; i++) {
  61         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
  62         if (!elem) {
  63             while (--i >= 0) {
  64                 vu_queue_unpop(dev, vq, vi->queue[i].elem, 0);
  65             }
  66             vi->qindex = 0;
  67             g_warning("virtio-input queue full");
  68             return;
  69         }
  70         vi->queue[i].elem = elem;
  71     }
  72
  73     /* ... and finally pass them to the guest */
  74     for (i = 0; i < vi->qindex; i++) {
  75         elem = vi->queue[i].elem;
  76         len = iov_from_buf(elem->in_sg, elem->in_num,
  77                            0, &vi->queue[i].event, sizeof(virtio_input_event));
  78         vu_queue_push(dev, vq, elem, len);
  79         free(elem);
  80     }
  81
  82     vu_queue_notify(&vi->dev.parent, vq);
  83     vi->qindex = 0;
  84 }
  85
  86 static void
  87 vi_evdev_watch(VuDev *dev, int condition, void *data)
  88 {
  89     VuInput *vi = data;
  90     int fd = vi->evdevfd;
  91
  92     g_debug("Got evdev condition %x", condition);
  93
  94     struct virtio_input_event virtio;
  95     struct input_event evdev;
  96     int rc;
  97
  98     for (;;) {
  99         rc = read(fd, &evdev, sizeof(evdev));
 100         if (rc != sizeof(evdev)) {
 101             break;
 102         }
 103
 104         g_debug("input %d %d %d", evdev.type, evdev.code, evdev.value);
 105
 106         virtio.type  = htole16(evdev.type);
 107         virtio.code  = htole16(evdev.code);
 108         virtio.value = htole32(evdev.value);
 109         vi_input_send(vi, &virtio);
 110     }
 111 }
 112
 113
 114 static void vi_handle_status(VuInput *vi, virtio_input_event *event)
 115 {
 116     struct input_event evdev;
 117     struct timeval tval;
 118     int rc;
 119
 120     if (gettimeofday(&tval, NULL)) {
 121         perror("vi_handle_status: gettimeofday");
 122         return;
 123     }
 124
 125     evdev.input_event_sec = tval.tv_sec;
 126     evdev.input_event_usec = tval.tv_usec;
 127     evdev.type = le16toh(event->type);
 128     evdev.code = le16toh(event->code);
 129     evdev.value = le32toh(event->value);
 130
 131     rc = write(vi->evdevfd, &evdev, sizeof(evdev));
 132     if (rc == -1) {
 133         perror("vi_host_handle_status: write");
 134     }
 135 }
 136
 137 static void vi_handle_sts(VuDev *dev, int qidx)
 138 {
 139     VuInput *vi = container_of(dev, VuInput, dev.parent);
 140     VuVirtq *vq = vu_get_queue(dev, qidx);
 141     virtio_input_event event;
 142     VuVirtqElement *elem;
 143     int len;
 144
 145     g_debug("%s", G_STRFUNC);
 146
 147     for (;;) {
 148         elem = vu_queue_pop(dev, vq, sizeof(VuVirtqElement));
 149         if (!elem) {
 150             break;
 151         }
 152
 153         memset(&event, 0, sizeof(event));
 154         len = iov_to_buf(elem->out_sg, elem->out_num,
 155                          0, &event, sizeof(event));
 156         vi_handle_status(vi, &event);
 157         vu_queue_push(dev, vq, elem, len);
 158         free(elem);
 159     }
 160
 161     vu_queue_notify(&vi->dev.parent, vq);
 162 }
 163
 164 static void
 165 vi_panic(VuDev *dev, const char *msg)
 166 {
 167     g_critical("%s\n", msg);
 168     exit(EXIT_FAILURE);
 169 }
 170
 171 static void
 172 vi_queue_set_started(VuDev *dev, int qidx, bool started)
 173 {
 174     VuInput *vi = container_of(dev, VuInput, dev.parent);
 175     VuVirtq *vq = vu_get_queue(dev, qidx);
 176
 177     g_debug("queue started %d:%d", qidx, started);
 178
 179     if (qidx == 1) {
 180         vu_set_queue_handler(dev, vq, started ? vi_handle_sts : NULL);
 181     }
 182
 183     started = vu_queue_started(dev, vu_get_queue(dev, 0)) &&
 184         vu_queue_started(dev, vu_get_queue(dev, 1));
 185
 186     if (started && !vi->evsrc) {
 187         vi->evsrc = vug_source_new(&vi->dev, vi->evdevfd,
 188                                    G_IO_IN, vi_evdev_watch, vi);
 189     }
 190
 191     if (!started && vi->evsrc) {
 192         vug_source_destroy(vi->evsrc);
 193         vi->evsrc = NULL;
 194     }
 195 }
 196
 197 static virtio_input_config *
 198 vi_find_config(VuInput *vi, uint8_t select, uint8_t subsel)
 199 {
 200     virtio_input_config *cfg;
 201     int i;
 202
 203     for (i = 0; i < vi->config->len; i++) {
 204         cfg = &g_array_index(vi->config, virtio_input_config, i);
 205         if (select == cfg->select && subsel == cfg->subsel) {
 206             return cfg;
 207         }
 208     }
 209
 210     return NULL;
 211 }
 212
 213 static int vi_get_config(VuDev *dev, uint8_t *config, uint32_t len)
 214 {
 215     VuInput *vi = container_of(dev, VuInput, dev.parent);
 216
 217     if (len > sizeof(*vi->sel_config)) {
 218         return -1;
 219     }
 220
 221     if (vi->sel_config) {
 222         memcpy(config, vi->sel_config, len);
 223     } else {
 224         memset(config, 0, len);
 225     }
 226
 227     return 0;
 228 }
 229
 230 static int vi_set_config(VuDev *dev, const uint8_t *data,
 231                          uint32_t offset, uint32_t size,
 232                          uint32_t flags)
 233 {
 234     VuInput *vi = container_of(dev, VuInput, dev.parent);
 235     virtio_input_config *config = (virtio_input_config *)data;
 236
 237     vi->sel_config = vi_find_config(vi, config->select, config->subsel);
 238
 239     return 0;
 240 }
 241
 242 static const VuDevIface vuiface = {
 243     .queue_set_started = vi_queue_set_started,
 244     .get_config = vi_get_config,
 245     .set_config = vi_set_config,
 246 };
 247
 248 static void
 249 vi_bits_config(VuInput *vi, int type, int count)
 250 {
 251     virtio_input_config bits;
 252     int rc, i, size = 0;
 253
 254     memset(&bits, 0, sizeof(bits));
 255     rc = ioctl(vi->evdevfd, EVIOCGBIT(type, count / 8), bits.u.bitmap);
 256     if (rc < 0) {
 257         return;
 258     }
 259
 260     for (i = 0; i < count / 8; i++) {
 261         if (bits.u.bitmap[i]) {
 262             size = i + 1;
 263         }
 264     }
 265     if (size == 0) {
 266         return;
 267     }
 268
 269     bits.select = VIRTIO_INPUT_CFG_EV_BITS;
 270     bits.subsel = type;
 271     bits.size   = size;
 272     g_array_append_val(vi->config, bits);
 273 }
 274
 275 static char *opt_evdev;
 276 static int opt_fdnum = -1;
 277 static char *opt_socket_path;
 278 static gboolean opt_nograb;
 279 static gboolean opt_print_caps;
 280
 281 static GOptionEntry entries[] = {
 282     { "print-capabilities", 'c', 0, G_OPTION_ARG_NONE, &opt_print_caps,
 283       "Print capabilities", NULL },
 284     { "no-grab", 'n', 0, G_OPTION_ARG_NONE, &opt_nograb,
 285       "Don't grab device", NULL },
 286     { "fd", 'f', 0, G_OPTION_ARG_INT, &opt_fdnum,
 287       "Use inherited fd socket", "FDNUM" },
 288     { "socket-path", 's', 0, G_OPTION_ARG_FILENAME, &opt_socket_path,
 289       "Use UNIX socket path", "PATH" },
 290     { "evdev-path", 'p', 0, G_OPTION_ARG_FILENAME, &opt_evdev,
 291       "evdev input device path", "PATH" },
 292     { NULL, }
 293 };
 294
 295 int
 296 main(int argc, char *argv[])
 297 {
 298     GMainLoop *loop = NULL;
 299     VuInput vi = { 0, };
 300     int rc, ver, fd;
 301     virtio_input_config id;
 302     struct input_id ids;
 303     GError *error = NULL;
 304     GOptionContext *context;
 305
 306     context = g_option_context_new(NULL);
 307     g_option_context_add_main_entries(context, entries, NULL);
 308     if (!g_option_context_parse(context, &argc, &argv, &error)) {
 309         g_printerr("Option parsing failed: %s\n", error->message);
 310         exit(EXIT_FAILURE);
 311     }
 312     if (opt_print_caps) {
 313         g_print("{\n");
 314         g_print("  \"type\": \"input\",\n");
 315         g_print("  \"features\": [\n");
 316         g_print("    \"evdev-path\",\n");
 317         g_print("    \"no-grab\"\n");
 318         g_print("  ]\n");
 319         g_print("}\n");
 320         exit(EXIT_SUCCESS);
 321     }
 322     if (!opt_evdev) {
 323         g_printerr("Please specify an evdev path\n");
 324         exit(EXIT_FAILURE);
 325     }
 326     if ((!!opt_socket_path + (opt_fdnum != -1)) != 1) {
 327         g_printerr("Please specify either --fd or --socket-path\n");
 328         exit(EXIT_FAILURE);
 329     }
 330
 331     vi.evdevfd = open(opt_evdev, O_RDWR);
 332     if (vi.evdevfd < 0) {
 333         g_printerr("Failed to open evdev: %s\n", g_strerror(errno));
 334         exit(EXIT_FAILURE);
 335     }
 336
 337     rc = ioctl(vi.evdevfd, EVIOCGVERSION, &ver);
 338     if (rc < 0) {
 339         g_printerr("%s: is not an evdev device\n", argv[1]);
 340         exit(EXIT_FAILURE);
 341     }
 342
 343     if (!opt_nograb) {
 344         rc = ioctl(vi.evdevfd, EVIOCGRAB, 1);
 345         if (rc < 0) {
 346             g_printerr("Failed to grab device\n");
 347             exit(EXIT_FAILURE);
 348         }
 349     }
 350
 351     vi.config = g_array_new(false, false, sizeof(virtio_input_config));
 352     memset(&id, 0, sizeof(id));
 353     if (ioctl(vi.evdevfd, EVIOCGNAME(sizeof(id.u.string) - 1),
 354               id.u.string) < 0) {
 355         g_printerr("Failed to get evdev name: %s\n", g_strerror(errno));
 356         exit(EXIT_FAILURE);
 357     }
 358     id.select = VIRTIO_INPUT_CFG_ID_NAME;
 359     id.size = strlen(id.u.string);
 360     g_array_append_val(vi.config, id);
 361
 362     if (ioctl(vi.evdevfd, EVIOCGID, &ids) == 0) {
 363         memset(&id, 0, sizeof(id));
 364         id.select = VIRTIO_INPUT_CFG_ID_DEVIDS;
 365         id.size = sizeof(struct virtio_input_devids);
 366         id.u.ids.bustype = cpu_to_le16(ids.bustype);
 367         id.u.ids.vendor  = cpu_to_le16(ids.vendor);
 368         id.u.ids.product = cpu_to_le16(ids.product);
 369         id.u.ids.version = cpu_to_le16(ids.version);
 370         g_array_append_val(vi.config, id);
 371     }
 372
 373     vi_bits_config(&vi, EV_KEY, KEY_CNT);
 374     vi_bits_config(&vi, EV_REL, REL_CNT);
 375     vi_bits_config(&vi, EV_ABS, ABS_CNT);
 376     vi_bits_config(&vi, EV_MSC, MSC_CNT);
 377     vi_bits_config(&vi, EV_SW,  SW_CNT);
 378     g_debug("config length: %u", vi.config->len);
 379
 380     if (opt_socket_path) {
 381         int lsock = unix_listen(opt_socket_path, &error_fatal);
 382         if (lsock < 0) {
 383             g_printerr("Failed to listen on %s.\n", opt_socket_path);
 384             exit(EXIT_FAILURE);
 385         }
 386         fd = accept(lsock, NULL, NULL);
 387         close(lsock);
 388     } else {
 389         fd = opt_fdnum;
 390     }
 391     if (fd == -1) {
 392         g_printerr("Invalid vhost-user socket.\n");
 393         exit(EXIT_FAILURE);
 394     }
 395
 396     if (!vug_init(&vi.dev, VHOST_USER_INPUT_MAX_QUEUES, fd, vi_panic,
 397                   &vuiface)) {
 398         g_printerr("Failed to initialize libvhost-user-glib.\n");
 399         exit(EXIT_FAILURE);
 400     }
 401
 402     loop = g_main_loop_new(NULL, FALSE);
 403     g_main_loop_run(loop);
 404     g_main_loop_unref(loop);
 405
 406     vug_deinit(&vi.dev);
 407
 408     vug_source_destroy(vi.evsrc);
 409     g_array_free(vi.config, TRUE);
 410     g_free(vi.queue);
 411     return 0;
 412 }