usr.sbin/bhyve/pci_virtio_input.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer
  12  *    in this position and unchanged.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * virtio input device emulation.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/param.h>
  38 #ifndef WITHOUT_CAPSICUM
  39 #include <sys/capsicum.h>
  40
  41 #include <capsicum_helpers.h>
  42 #endif
  43 #include <sys/ioctl.h>
  44 #include <sys/linker_set.h>
  45 #include <sys/uio.h>
  46
  47 #include <dev/evdev/input.h>
  48
  49 #include <assert.h>
  50 #include <err.h>
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <pthread.h>
  54 #include <stddef.h>
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <string.h>
  58 #include <sysexits.h>
  59 #include <unistd.h>
  60
  61 #include "bhyverun.h"
  62 #include "config.h"
  63 #include "debug.h"
  64 #include "mevent.h"
  65 #include "pci_emul.h"
  66 #include "virtio.h"
  67
  68 #define VTINPUT_RINGSZ 64
  69
  70 #define VTINPUT_MAX_PKT_LEN 10
  71
  72 /*
  73  * Queue definitions.
  74  */
  75 #define VTINPUT_EVENTQ 0
  76 #define VTINPUT_STATUSQ 1
  77
  78 #define VTINPUT_MAXQ 2
  79
  80 static int pci_vtinput_debug;
  81 #define DPRINTF(params)        \
  82         if (pci_vtinput_debug) \
  83         PRINTLN params
  84 #define WPRINTF(params) PRINTLN params
  85
  86 enum vtinput_config_select {
  87         VTINPUT_CFG_UNSET = 0x00,
  88         VTINPUT_CFG_ID_NAME = 0x01,
  89         VTINPUT_CFG_ID_SERIAL = 0x02,
  90         VTINPUT_CFG_ID_DEVIDS = 0x03,
  91         VTINPUT_CFG_PROP_BITS = 0x10,
  92         VTINPUT_CFG_EV_BITS = 0x11,
  93         VTINPUT_CFG_ABS_INFO = 0x12
  94 };
  95
  96 struct vtinput_absinfo {
  97         uint32_t min;
  98         uint32_t max;
  99         uint32_t fuzz;
 100         uint32_t flat;
 101         uint32_t res;
 102 } __packed;
 103
 104 struct vtinput_devids {
 105         uint16_t bustype;
 106         uint16_t vendor;
 107         uint16_t product;
 108         uint16_t version;
 109 } __packed;
 110
 111 struct vtinput_config {
 112         uint8_t select;
 113         uint8_t subsel;
 114         uint8_t size;
 115         uint8_t reserved[5];
 116         union {
 117                 char string[128];
 118                 uint8_t bitmap[128];
 119                 struct vtinput_absinfo abs;
 120                 struct vtinput_devids ids;
 121         } u;
 122 } __packed;
 123
 124 struct vtinput_event {
 125         uint16_t type;
 126         uint16_t code;
 127         uint32_t value;
 128 } __packed;
 129
 130 struct vtinput_event_elem {
 131         struct vtinput_event event;
 132         struct iovec iov;
 133         uint16_t idx;
 134 };
 135
 136 struct vtinput_eventqueue {
 137         struct vtinput_event_elem *events;
 138         uint32_t size;
 139         uint32_t idx;
 140 };
 141
 142 /*
 143  * Per-device softc
 144  */
 145 struct pci_vtinput_softc {
 146         struct virtio_softc vsc_vs;
 147         struct vqueue_info vsc_queues[VTINPUT_MAXQ];
 148         pthread_mutex_t vsc_mtx;
 149         const char *vsc_evdev;
 150         int vsc_fd;
 151         struct vtinput_config vsc_config;
 152         int vsc_config_valid;
 153         struct mevent *vsc_evp;
 154         struct vtinput_eventqueue vsc_eventqueue;
 155 };
 156
 157 static void pci_vtinput_reset(void *);
 158 static int pci_vtinput_cfgread(void *, int, int, uint32_t *);
 159 static int pci_vtinput_cfgwrite(void *, int, int, uint32_t);
 160
 161 static struct virtio_consts vtinput_vi_consts = {
 162         "vtinput",                     /* our name */
 163         VTINPUT_MAXQ,                  /* we support 1 virtqueue */
 164         sizeof(struct vtinput_config), /* config reg size */
 165         pci_vtinput_reset,             /* reset */
 166         NULL,                          /* device-wide qnotify -- not used */
 167         pci_vtinput_cfgread,           /* read virtio config */
 168         pci_vtinput_cfgwrite,          /* write virtio config */
 169         NULL,                          /* apply negotiated features */
 170         0,                             /* our capabilities */
 171 };
 172
 173 static void
 174 pci_vtinput_reset(void *vsc)
 175 {
 176         struct pci_vtinput_softc *sc = vsc;
 177
 178         DPRINTF(("%s: device reset requested", __func__));
 179         vi_reset_dev(&sc->vsc_vs);
 180 }
 181
 182 static void
 183 pci_vtinput_notify_eventq(void *vsc, struct vqueue_info *vq)
 184 {
 185         DPRINTF(("%s", __func__));
 186 }
 187
 188 static void
 189 pci_vtinput_notify_statusq(void *vsc, struct vqueue_info *vq)
 190 {
 191         struct pci_vtinput_softc *sc = vsc;
 192
 193         while (vq_has_descs(vq)) {
 194                 /* get descriptor chain */
 195                 struct iovec iov;
 196                 struct vi_req req;
 197                 const int n = vq_getchain(vq, &iov, 1, &req);
 198                 if (n <= 0) {
 199                         WPRINTF(("%s: invalid descriptor: %d", __func__, n));
 200                         return;
 201                 }
 202
 203                 /* get event */
 204                 struct vtinput_event event;
 205                 memcpy(&event, iov.iov_base, sizeof(event));
 206
 207                 /*
 208                  * on multi touch devices:
 209                  * - host send EV_MSC to guest
 210                  * - guest sends EV_MSC back to host
 211                  * - host writes EV_MSC to evdev
 212                  * - evdev saves EV_MSC in it's event buffer
 213                  * - host receives an extra EV_MSC by reading the evdev event
 214                  *   buffer
 215                  * - frames become larger and larger
 216                  * avoid endless loops by ignoring EV_MSC
 217                  */
 218                 if (event.type == EV_MSC) {
 219                         vq_relchain(vq, req.idx, sizeof(event));
 220                         continue;
 221                 }
 222
 223                 /* send event to evdev */
 224                 struct input_event host_event;
 225                 host_event.type = event.type;
 226                 host_event.code = event.code;
 227                 host_event.value = event.value;
 228                 if (gettimeofday(&host_event.time, NULL) != 0) {
 229                         WPRINTF(("%s: failed gettimeofday", __func__));
 230                 }
 231                 if (write(sc->vsc_fd, &host_event, sizeof(host_event)) == -1) {
 232                         WPRINTF(("%s: failed to write host_event", __func__));
 233                 }
 234
 235                 vq_relchain(vq, req.idx, sizeof(event));
 236         }
 237         vq_endchains(vq, 1);
 238 }
 239
 240 static int
 241 pci_vtinput_get_bitmap(struct pci_vtinput_softc *sc, int cmd, int count)
 242 {
 243         if (count <= 0 || !sc) {
 244                 return (-1);
 245         }
 246
 247         /* query bitmap */
 248         memset(sc->vsc_config.u.bitmap, 0, sizeof(sc->vsc_config.u.bitmap));
 249         if (ioctl(sc->vsc_fd, cmd, sc->vsc_config.u.bitmap) < 0) {
 250                 return (-1);
 251         }
 252
 253         /* get number of set bytes in bitmap */
 254         for (int i = count - 1; i >= 0; i--) {
 255                 if (sc->vsc_config.u.bitmap[i]) {
 256                         return i + 1;
 257                 }
 258         }
 259
 260         return (-1);
 261 }
 262
 263 static int
 264 pci_vtinput_read_config_id_name(struct pci_vtinput_softc *sc)
 265 {
 266         char name[128];
 267         if (ioctl(sc->vsc_fd, EVIOCGNAME(sizeof(name) - 1), name) < 0) {
 268                 return (1);
 269         }
 270
 271         memcpy(sc->vsc_config.u.string, name, sizeof(name));
 272         sc->vsc_config.size = strnlen(name, sizeof(name));
 273
 274         return (0);
 275 }
 276
 277 static int
 278 pci_vtinput_read_config_id_serial(struct pci_vtinput_softc *sc)
 279 {
 280         /* serial isn't supported */
 281         sc->vsc_config.size = 0;
 282
 283         return (0);
 284 }
 285
 286 static int
 287 pci_vtinput_read_config_id_devids(struct pci_vtinput_softc *sc)
 288 {
 289         struct input_id devids;
 290         if (ioctl(sc->vsc_fd, EVIOCGID, &devids)) {
 291                 return (1);
 292         }
 293
 294         sc->vsc_config.u.ids.bustype = devids.bustype;
 295         sc->vsc_config.u.ids.vendor = devids.vendor;
 296         sc->vsc_config.u.ids.product = devids.product;
 297         sc->vsc_config.u.ids.version = devids.version;
 298         sc->vsc_config.size = sizeof(struct vtinput_devids);
 299
 300         return (0);
 301 }
 302
 303 static int
 304 pci_vtinput_read_config_prop_bits(struct pci_vtinput_softc *sc)
 305 {
 306         /*
 307          * Evdev bitmap countains 1 bit per count. Additionally evdev bitmaps
 308          * are arrays of longs instead of chars. Calculate how many longs are
 309          * required for evdev bitmap. Multiply that with sizeof(long) to get the
 310          * number of elements.
 311          */
 312         const int count = howmany(INPUT_PROP_CNT, sizeof(long) * 8) *
 313             sizeof(long);
 314         const unsigned int cmd = EVIOCGPROP(count);
 315         const int size = pci_vtinput_get_bitmap(sc, cmd, count);
 316         if (size <= 0) {
 317                 return (1);
 318         }
 319
 320         sc->vsc_config.size = size;
 321
 322         return (0);
 323 }
 324
 325 static int
 326 pci_vtinput_read_config_ev_bits(struct pci_vtinput_softc *sc, uint8_t type)
 327 {
 328         int count;
 329
 330         switch (type) {
 331         case EV_KEY:
 332                 count = KEY_CNT;
 333                 break;
 334         case EV_REL:
 335                 count = REL_CNT;
 336                 break;
 337         case EV_ABS:
 338                 count = ABS_CNT;
 339                 break;
 340         case EV_MSC:
 341                 count = MSC_CNT;
 342                 break;
 343         case EV_SW:
 344                 count = SW_CNT;
 345                 break;
 346         case EV_LED:
 347                 count = LED_CNT;
 348                 break;
 349         default:
 350                 return (1);
 351         }
 352
 353         /*
 354          * Evdev bitmap countains 1 bit per count. Additionally evdev bitmaps
 355          * are arrays of longs instead of chars. Calculate how many longs are
 356          * required for evdev bitmap. Multiply that with sizeof(long) to get the
 357          * number of elements.
 358          */
 359         count = howmany(count, sizeof(long) * 8) * sizeof(long);
 360         const unsigned int cmd = EVIOCGBIT(sc->vsc_config.subsel, count);
 361         const int size = pci_vtinput_get_bitmap(sc, cmd, count);
 362         if (size <= 0) {
 363                 return (1);
 364         }
 365
 366         sc->vsc_config.size = size;
 367
 368         return (0);
 369 }
 370
 371 static int
 372 pci_vtinput_read_config_abs_info(struct pci_vtinput_softc *sc)
 373 {
 374         /* check if evdev has EV_ABS */
 375         if (!pci_vtinput_read_config_ev_bits(sc, EV_ABS)) {
 376                 return (1);
 377         }
 378
 379         /* get abs information */
 380         struct input_absinfo abs;
 381         if (ioctl(sc->vsc_fd, EVIOCGABS(sc->vsc_config.subsel), &abs) < 0) {
 382                 return (1);
 383         }
 384
 385         /* save abs information */
 386         sc->vsc_config.u.abs.min = abs.minimum;
 387         sc->vsc_config.u.abs.max = abs.maximum;
 388         sc->vsc_config.u.abs.fuzz = abs.fuzz;
 389         sc->vsc_config.u.abs.flat = abs.flat;
 390         sc->vsc_config.u.abs.res = abs.resolution;
 391         sc->vsc_config.size = sizeof(struct vtinput_absinfo);
 392
 393         return (0);
 394 }
 395
 396 static int
 397 pci_vtinput_read_config(struct pci_vtinput_softc *sc)
 398 {
 399         switch (sc->vsc_config.select) {
 400         case VTINPUT_CFG_UNSET:
 401                 return (0);
 402         case VTINPUT_CFG_ID_NAME:
 403                 return pci_vtinput_read_config_id_name(sc);
 404         case VTINPUT_CFG_ID_SERIAL:
 405                 return pci_vtinput_read_config_id_serial(sc);
 406         case VTINPUT_CFG_ID_DEVIDS:
 407                 return pci_vtinput_read_config_id_devids(sc);
 408         case VTINPUT_CFG_PROP_BITS:
 409                 return pci_vtinput_read_config_prop_bits(sc);
 410         case VTINPUT_CFG_EV_BITS:
 411                 return pci_vtinput_read_config_ev_bits(
 412                     sc, sc->vsc_config.subsel);
 413         case VTINPUT_CFG_ABS_INFO:
 414                 return pci_vtinput_read_config_abs_info(sc);
 415         default:
 416                 return (1);
 417         }
 418 }
 419
 420 static int
 421 pci_vtinput_cfgread(void *vsc, int offset, int size, uint32_t *retval)
 422 {
 423         struct pci_vtinput_softc *sc = vsc;
 424
 425         /* check for valid offset and size */
 426         if (offset + size > sizeof(struct vtinput_config)) {
 427                 WPRINTF(("%s: read to invalid offset/size %d/%d", __func__,
 428                     offset, size));
 429                 memset(retval, 0, size);
 430                 return (0);
 431         }
 432
 433         /* read new config values, if select and subsel changed. */
 434         if (!sc->vsc_config_valid) {
 435                 if (pci_vtinput_read_config(sc) != 0) {
 436                         DPRINTF(("%s: could not read config %d/%d", __func__,
 437                             sc->vsc_config.select, sc->vsc_config.subsel));
 438                         memset(retval, 0, size);
 439                         return (0);
 440                 }
 441                 sc->vsc_config_valid = 1;
 442         }
 443
 444         uint8_t *ptr = (uint8_t *)&sc->vsc_config;
 445         memcpy(retval, ptr + offset, size);
 446
 447         return (0);
 448 }
 449
 450 static int
 451 pci_vtinput_cfgwrite(void *vsc, int offset, int size, uint32_t value)
 452 {
 453         struct pci_vtinput_softc *sc = vsc;
 454
 455         /* guest can only write to select and subsel fields */
 456         if (offset + size > 2) {
 457                 WPRINTF(("%s: write to readonly reg %d", __func__, offset));
 458                 return (1);
 459         }
 460
 461         /* copy value into config */
 462         uint8_t *ptr = (uint8_t *)&sc->vsc_config;
 463         memcpy(ptr + offset, &value, size);
 464
 465         /* select/subsel changed, query new config on next cfgread */
 466         sc->vsc_config_valid = 0;
 467
 468         return (0);
 469 }
 470
 471 static int
 472 vtinput_eventqueue_add_event(
 473     struct vtinput_eventqueue *queue, struct input_event *e)
 474 {
 475         /* check if queue is full */
 476         if (queue->idx >= queue->size) {
 477                 /* alloc new elements for queue */
 478                 const uint32_t newSize = queue->idx;
 479                 const void *newPtr = realloc(queue->events,
 480                     queue->size * sizeof(struct vtinput_event_elem));
 481                 if (newPtr == NULL) {
 482                         WPRINTF(("%s: realloc memory for eventqueue failed!",
 483                             __func__));
 484                         return (1);
 485                 }
 486                 /* save new size and eventqueue */
 487                 queue->events = (struct vtinput_event_elem *)newPtr;
 488                 queue->size = newSize;
 489         }
 490
 491         /* save event */
 492         struct vtinput_event *event = &queue->events[queue->idx].event;
 493         event->type = e->type;
 494         event->code = e->code;
 495         event->value = e->value;
 496         queue->idx++;
 497
 498         return (0);
 499 }
 500
 501 static void
 502 vtinput_eventqueue_clear(struct vtinput_eventqueue *queue)
 503 {
 504         /* just reset index to clear queue */
 505         queue->idx = 0;
 506 }
 507
 508 static void
 509 vtinput_eventqueue_send_events(
 510     struct vtinput_eventqueue *queue, struct vqueue_info *vq)
 511 {
 512         /*
 513          * First iteration through eventqueue:
 514          *   Get descriptor chains.
 515          */
 516         for (uint32_t i = 0; i < queue->idx; ++i) {
 517                 /* get descriptor */
 518                 if (!vq_has_descs(vq)) {
 519                         /*
 520                          * We don't have enough descriptors for all events.
 521                          * Return chains back to guest.
 522                          */
 523                         vq_retchains(vq, i);
 524                         WPRINTF((
 525                             "%s: not enough available descriptors, dropping %d events",
 526                             __func__, queue->idx));
 527                         goto done;
 528                 }
 529
 530                 /* get descriptor chain */
 531                 struct iovec iov;
 532                 struct vi_req req;
 533                 const int n = vq_getchain(vq, &iov, 1, &req);
 534                 if (n <= 0) {
 535                         WPRINTF(("%s: invalid descriptor: %d", __func__, n));
 536                         return;
 537                 }
 538                 if (n != 1) {
 539                         WPRINTF(
 540                             ("%s: invalid number of descriptors in chain: %d",
 541                                 __func__, n));
 542                         /* release invalid chain */
 543                         vq_relchain(vq, req.idx, 0);
 544                         return;
 545                 }
 546                 if (iov.iov_len < sizeof(struct vtinput_event)) {
 547                         WPRINTF(("%s: invalid descriptor length: %lu", __func__,
 548                             iov.iov_len));
 549                         /* release invalid chain */
 550                         vq_relchain(vq, req.idx, 0);
 551                         return;
 552                 }
 553
 554                 /* save descriptor */
 555                 queue->events[i].iov = iov;
 556                 queue->events[i].idx = req.idx;
 557         }
 558
 559         /*
 560          * Second iteration through eventqueue:
 561          *   Send events to guest by releasing chains
 562          */
 563         for (uint32_t i = 0; i < queue->idx; ++i) {
 564                 struct vtinput_event_elem event = queue->events[i];
 565                 memcpy(event.iov.iov_base, &event.event,
 566                     sizeof(struct vtinput_event));
 567                 vq_relchain(vq, event.idx, sizeof(struct vtinput_event));
 568         }
 569 done:
 570         /* clear queue and send interrupt to guest */
 571         vtinput_eventqueue_clear(queue);
 572         vq_endchains(vq, 1);
 573
 574         return;
 575 }
 576
 577 static int
 578 vtinput_read_event_from_host(int fd, struct input_event *event)
 579 {
 580         const int len = read(fd, event, sizeof(struct input_event));
 581         if (len != sizeof(struct input_event)) {
 582                 if (len == -1 && errno != EAGAIN) {
 583                         WPRINTF(("%s: event read failed! len = %d, errno = %d",
 584                             __func__, len, errno));
 585                 }
 586
 587                 /* host doesn't have more events for us */
 588                 return (1);
 589         }
 590
 591         return (0);
 592 }
 593
 594 static void
 595 vtinput_read_event(int fd __attribute((unused)),
 596     enum ev_type t __attribute__((unused)), void *arg __attribute__((unused)))
 597 {
 598         struct pci_vtinput_softc *sc = arg;
 599
 600         /* skip if driver isn't ready */
 601         if (!(sc->vsc_vs.vs_status & VIRTIO_CONFIG_STATUS_DRIVER_OK))
 602                 return;
 603
 604         /* read all events from host */
 605         struct input_event event;
 606         while (vtinput_read_event_from_host(sc->vsc_fd, &event) == 0) {
 607                 /* add events to our queue */
 608                 vtinput_eventqueue_add_event(&sc->vsc_eventqueue, &event);
 609
 610                 /* only send events to guest on EV_SYN or SYN_REPORT */
 611                 if (event.type != EV_SYN || event.type != SYN_REPORT) {
 612                         continue;
 613                 }
 614
 615                 /* send host events to guest */
 616                 vtinput_eventqueue_send_events(
 617                     &sc->vsc_eventqueue, &sc->vsc_queues[VTINPUT_EVENTQ]);
 618         }
 619 }
 620
 621 static int
 622 pci_vtinput_legacy_config(nvlist_t *nvl, const char *opts)
 623 {
 624         if (opts == NULL)
 625                 return (-1);
 626
 627         /*
 628          * parse opts:
 629          *   virtio-input,/dev/input/eventX
 630          */
 631         char *cp = strchr(opts, ',');
 632         if (cp == NULL) {
 633                 set_config_value_node(nvl, "path", opts);
 634                 return (0);
 635         }
 636         char *path = strndup(opts, cp - opts);
 637         set_config_value_node(nvl, "path", path);
 638         free(path);
 639
 640         return (pci_parse_legacy_config(nvl, cp + 1));
 641 }
 642
 643 static int
 644 pci_vtinput_init(struct vmctx *ctx, struct pci_devinst *pi, nvlist_t *nvl)
 645 {
 646         struct pci_vtinput_softc *sc;
 647
 648         /*
 649          * Keep it here.
 650          * Else it's possible to access it uninitialized by jumping to failed.
 651          */
 652         pthread_mutexattr_t mtx_attr = NULL;
 653
 654         sc = calloc(1, sizeof(struct pci_vtinput_softc));
 655
 656         sc->vsc_evdev = get_config_value_node(nvl, "path");
 657         if (sc->vsc_evdev == NULL) {
 658                 WPRINTF(("%s: missing required path config value", __func__));
 659                 goto failed;
 660         }
 661
 662         /*
 663          * open evdev by using non blocking I/O:
 664          *   read from /dev/input/eventX would block our thread otherwise
 665          */
 666         sc->vsc_fd = open(sc->vsc_evdev, O_RDWR | O_NONBLOCK);
 667         if (sc->vsc_fd < 0) {
 668                 WPRINTF(("%s: failed to open %s", __func__, sc->vsc_evdev));
 669                 goto failed;
 670         }
 671
 672         /* check if evdev is really a evdev */
 673         int evversion;
 674         int error = ioctl(sc->vsc_fd, EVIOCGVERSION, &evversion);
 675         if (error < 0) {
 676                 WPRINTF(("%s: %s is no evdev", __func__, sc->vsc_evdev));
 677                 goto failed;
 678         }
 679
 680         /* gain exclusive access to evdev */
 681         error = ioctl(sc->vsc_fd, EVIOCGRAB, 1);
 682         if (error < 0) {
 683                 WPRINTF(("%s: failed to grab %s", __func__, sc->vsc_evdev));
 684                 goto failed;
 685         }
 686
 687         if (pthread_mutexattr_init(&mtx_attr)) {
 688                 WPRINTF(("%s: init mutexattr failed", __func__));
 689                 goto failed;
 690         }
 691         if (pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_RECURSIVE)) {
 692                 WPRINTF(("%s: settype mutexattr failed", __func__));
 693                 goto failed;
 694         }
 695         if (pthread_mutex_init(&sc->vsc_mtx, &mtx_attr)) {
 696                 WPRINTF(("%s: init mutex failed", __func__));
 697                 goto failed;
 698         }
 699
 700         /* init softc */
 701         sc->vsc_eventqueue.idx = 0;
 702         sc->vsc_eventqueue.size = VTINPUT_MAX_PKT_LEN;
 703         sc->vsc_eventqueue.events = calloc(
 704             sc->vsc_eventqueue.size, sizeof(struct vtinput_event_elem));
 705         sc->vsc_config_valid = 0;
 706         if (sc->vsc_eventqueue.events == NULL) {
 707                 WPRINTF(("%s: failed to alloc eventqueue", __func__));
 708                 goto failed;
 709         }
 710
 711         /* register event handler */
 712         sc->vsc_evp = mevent_add(sc->vsc_fd, EVF_READ, vtinput_read_event, sc);
 713         if (sc->vsc_evp == NULL) {
 714                 WPRINTF(("%s: could not register mevent", __func__));
 715                 goto failed;
 716         }
 717
 718 #ifndef WITHOUT_CAPSICUM
 719         cap_rights_t rights;
 720         cap_rights_init(&rights, CAP_EVENT, CAP_IOCTL, CAP_READ, CAP_WRITE);
 721         if (caph_rights_limit(sc->vsc_fd, &rights) == -1) {
 722                 errx(EX_OSERR, "Unable to apply rights for sandbox");
 723         }
 724 #endif
 725
 726         /* link virtio to softc */
 727         vi_softc_linkup(
 728             &sc->vsc_vs, &vtinput_vi_consts, sc, pi, sc->vsc_queues);
 729         sc->vsc_vs.vs_mtx = &sc->vsc_mtx;
 730
 731         /* init virtio queues */
 732         sc->vsc_queues[VTINPUT_EVENTQ].vq_qsize = VTINPUT_RINGSZ;
 733         sc->vsc_queues[VTINPUT_EVENTQ].vq_notify = pci_vtinput_notify_eventq;
 734         sc->vsc_queues[VTINPUT_STATUSQ].vq_qsize = VTINPUT_RINGSZ;
 735         sc->vsc_queues[VTINPUT_STATUSQ].vq_notify = pci_vtinput_notify_statusq;
 736
 737         /* initialize config space */
 738         pci_set_cfgdata16(pi, PCIR_DEVICE, VIRTIO_DEV_INPUT);
 739         pci_set_cfgdata16(pi, PCIR_VENDOR, VIRTIO_VENDOR);
 740         pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_INPUTDEV);
 741         pci_set_cfgdata8(pi, PCIR_SUBCLASS, PCIS_INPUTDEV_OTHER);
 742         pci_set_cfgdata8(pi, PCIR_REVID, VIRTIO_REV_INPUT);
 743         pci_set_cfgdata16(pi, PCIR_SUBDEV_0, VIRTIO_SUBDEV_INPUT);
 744         pci_set_cfgdata16(pi, PCIR_SUBVEND_0, VIRTIO_SUBVEN_INPUT);
 745
 746         /* add MSI-X table BAR */
 747         if (vi_intr_init(&sc->vsc_vs, 1, fbsdrun_virtio_msix()))
 748                 goto failed;
 749         /* add virtio register */
 750         vi_set_io_bar(&sc->vsc_vs, 0);
 751
 752         return (0);
 753
 754 failed:
 755         if (sc == NULL) {
 756                 return (-1);
 757         }
 758
 759         if (sc->vsc_evp)
 760                 mevent_delete(sc->vsc_evp);
 761         if (sc->vsc_eventqueue.events)
 762                 free(sc->vsc_eventqueue.events);
 763         if (sc->vsc_mtx)
 764                 pthread_mutex_destroy(&sc->vsc_mtx);
 765         if (mtx_attr)
 766                 pthread_mutexattr_destroy(&mtx_attr);
 767         if (sc->vsc_fd)
 768                 close(sc->vsc_fd);
 769
 770         free(sc);
 771
 772         return (-1);
 773 }
 774
 775 struct pci_devemu pci_de_vinput = {
 776         .pe_emu = "virtio-input",
 777         .pe_init = pci_vtinput_init,
 778         .pe_legacy_config = pci_vtinput_legacy_config,
 779         .pe_barwrite = vi_pci_write,
 780         .pe_barread = vi_pci_read,
 781 };
 782 PCI_EMUL_SET(pci_de_vinput);