sys/dev/evdev/cdev.c

   1 /*-
   2  * Copyright (c) 2014 Jakub Wojciech Klama <jceel@FreeBSD.org>
   3  * Copyright (c) 2015-2016 Vladimir Kondratyev <wulf@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 #include "opt_evdev.h"
  31
  32 #include <sys/param.h>
  33 #include <sys/bitstring.h>
  34 #include <sys/conf.h>
  35 #include <sys/epoch.h>
  36 #include <sys/filio.h>
  37 #include <sys/fcntl.h>
  38 #include <sys/kernel.h>
  39 #include <sys/malloc.h>
  40 #include <sys/poll.h>
  41 #include <sys/proc.h>
  42 #include <sys/selinfo.h>
  43 #include <sys/systm.h>
  44 #include <sys/time.h>
  45 #include <sys/uio.h>
  46
  47 #include <dev/evdev/evdev.h>
  48 #include <dev/evdev/evdev_private.h>
  49 #include <dev/evdev/input.h>
  50
  51 #ifdef COMPAT_FREEBSD32
  52 #include <sys/mount.h>
  53 #include <sys/sysent.h>
  54 #include <compat/freebsd32/freebsd32.h>
  55 struct input_event32 {
  56         struct timeval32        time;
  57         uint16_t                type;
  58         uint16_t                code;
  59         int32_t                 value;
  60 };
  61 #endif
  62
  63 #ifdef EVDEV_DEBUG
  64 #define debugf(client, fmt, args...)    printf("evdev cdev: "fmt"\n", ##args)
  65 #else
  66 #define debugf(client, fmt, args...)
  67 #endif
  68
  69 #define DEF_RING_REPORTS        8
  70
  71 static d_open_t         evdev_open;
  72 static d_read_t         evdev_read;
  73 static d_write_t        evdev_write;
  74 static d_ioctl_t        evdev_ioctl;
  75 static d_poll_t         evdev_poll;
  76 static d_kqfilter_t     evdev_kqfilter;
  77
  78 static int evdev_kqread(struct knote *kn, long hint);
  79 static void evdev_kqdetach(struct knote *kn);
  80 static void evdev_dtor(void *);
  81 static int evdev_ioctl_eviocgbit(struct evdev_dev *, int, int, caddr_t);
  82 static void evdev_client_filter_queue(struct evdev_client *, uint16_t);
  83
  84 static struct cdevsw evdev_cdevsw = {
  85         .d_version = D_VERSION,
  86         .d_open = evdev_open,
  87         .d_read = evdev_read,
  88         .d_write = evdev_write,
  89         .d_ioctl = evdev_ioctl,
  90         .d_poll = evdev_poll,
  91         .d_kqfilter = evdev_kqfilter,
  92         .d_name = "evdev",
  93 };
  94
  95 static struct filterops evdev_cdev_filterops = {
  96         .f_isfd = 1,
  97         .f_attach = NULL,
  98         .f_detach = evdev_kqdetach,
  99         .f_event = evdev_kqread,
 100 };
 101
 102 static int
 103 evdev_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 104 {
 105         struct evdev_dev *evdev = dev->si_drv1;
 106         struct evdev_client *client;
 107         size_t buffer_size;
 108         int ret;
 109
 110         if (evdev == NULL)
 111                 return (ENODEV);
 112
 113         /* Initialize client structure */
 114         buffer_size = evdev->ev_report_size * DEF_RING_REPORTS;
 115         client = malloc(offsetof(struct evdev_client, ec_buffer) +
 116             sizeof(struct input_event) * buffer_size,
 117             M_EVDEV, M_WAITOK | M_ZERO);
 118
 119         /* Initialize ring buffer */
 120         client->ec_buffer_size = buffer_size;
 121         client->ec_buffer_head = 0;
 122         client->ec_buffer_tail = 0;
 123         client->ec_buffer_ready = 0;
 124
 125         client->ec_evdev = evdev;
 126         mtx_init(&client->ec_buffer_mtx, "evclient", "evdev", MTX_DEF);
 127         knlist_init_mtx(&client->ec_selp.si_note, &client->ec_buffer_mtx);
 128
 129         /* Avoid race with evdev_unregister */
 130         EVDEV_LIST_LOCK(evdev);
 131         if (dev->si_drv1 == NULL)
 132                 ret = ENODEV;
 133         else
 134                 ret = evdev_register_client(evdev, client);
 135
 136         if (ret != 0)
 137                 evdev_revoke_client(client);
 138         EVDEV_LIST_UNLOCK(evdev);
 139
 140         if (ret == 0)
 141                 ret = devfs_set_cdevpriv(client, evdev_dtor);
 142
 143         if (ret != 0) {
 144                 debugf(client, "cannot register evdev client");
 145                 evdev_dtor(client);
 146         }
 147
 148         return (ret);
 149 }
 150
 151 static void
 152 evdev_dtor(void *data)
 153 {
 154         struct evdev_client *client = (struct evdev_client *)data;
 155
 156         EVDEV_LIST_LOCK(client->ec_evdev);
 157         if (!client->ec_revoked)
 158                 evdev_dispose_client(client->ec_evdev, client);
 159         EVDEV_LIST_UNLOCK(client->ec_evdev);
 160
 161         if (client->ec_evdev->ev_lock_type != EV_LOCK_MTX)
 162                 epoch_wait_preempt(INPUT_EPOCH);
 163         knlist_clear(&client->ec_selp.si_note, 0);
 164         seldrain(&client->ec_selp);
 165         knlist_destroy(&client->ec_selp.si_note);
 166         funsetown(&client->ec_sigio);
 167         mtx_destroy(&client->ec_buffer_mtx);
 168         free(client, M_EVDEV);
 169 }
 170
 171 static int
 172 evdev_read(struct cdev *dev, struct uio *uio, int ioflag)
 173 {
 174         struct evdev_client *client;
 175         union {
 176                 struct input_event t;
 177 #ifdef COMPAT_FREEBSD32
 178                 struct input_event32 t32;
 179 #endif
 180         } event;
 181         struct input_event *head;
 182         size_t evsize;
 183         int ret = 0;
 184         int remaining;
 185
 186         ret = devfs_get_cdevpriv((void **)&client);
 187         if (ret != 0)
 188                 return (ret);
 189
 190         debugf(client, "read %zd bytes by thread %d", uio->uio_resid,
 191             uio->uio_td->td_tid);
 192
 193         if (client->ec_revoked)
 194                 return (ENODEV);
 195
 196 #ifdef COMPAT_FREEBSD32
 197         if (SV_CURPROC_FLAG(SV_ILP32))
 198                 evsize = sizeof(struct input_event32);
 199         else
 200 #endif
 201                 evsize = sizeof(struct input_event);
 202
 203         /* Zero-sized reads are allowed for error checking */
 204         if (uio->uio_resid != 0 && uio->uio_resid < evsize)
 205                 return (EINVAL);
 206
 207         remaining = uio->uio_resid / evsize;
 208
 209         EVDEV_CLIENT_LOCKQ(client);
 210
 211         if (EVDEV_CLIENT_EMPTYQ(client)) {
 212                 if (ioflag & O_NONBLOCK)
 213                         ret = EWOULDBLOCK;
 214                 else {
 215                         if (remaining != 0) {
 216                                 client->ec_blocked = true;
 217                                 ret = mtx_sleep(client, &client->ec_buffer_mtx,
 218                                     PCATCH, "evread", 0);
 219                                 if (ret == 0 && client->ec_revoked)
 220                                         ret = ENODEV;
 221                         }
 222                 }
 223         }
 224
 225         while (ret == 0 && !EVDEV_CLIENT_EMPTYQ(client) && remaining > 0) {
 226                 head = client->ec_buffer + client->ec_buffer_head;
 227 #ifdef COMPAT_FREEBSD32
 228                 if (SV_CURPROC_FLAG(SV_ILP32)) {
 229                         bzero(&event.t32, sizeof(struct input_event32));
 230                         TV_CP(*head, event.t32, time);
 231                         CP(*head, event.t32, type);
 232                         CP(*head, event.t32, code);
 233                         CP(*head, event.t32, value);
 234                 } else
 235 #endif
 236                         bcopy(head, &event.t, evsize);
 237
 238                 client->ec_buffer_head =
 239                     (client->ec_buffer_head + 1) % client->ec_buffer_size;
 240                 remaining--;
 241
 242                 EVDEV_CLIENT_UNLOCKQ(client);
 243                 ret = uiomove(&event, evsize, uio);
 244                 EVDEV_CLIENT_LOCKQ(client);
 245         }
 246
 247         EVDEV_CLIENT_UNLOCKQ(client);
 248
 249         return (ret);
 250 }
 251
 252 static int
 253 evdev_write(struct cdev *dev, struct uio *uio, int ioflag)
 254 {
 255         struct evdev_dev *evdev = dev->si_drv1;
 256         struct evdev_client *client;
 257         union {
 258                 struct input_event t;
 259 #ifdef COMPAT_FREEBSD32
 260                 struct input_event32 t32;
 261 #endif
 262         } event;
 263         size_t evsize;
 264         int ret = 0;
 265
 266         ret = devfs_get_cdevpriv((void **)&client);
 267         if (ret != 0)
 268                 return (ret);
 269
 270         debugf(client, "write %zd bytes by thread %d", uio->uio_resid,
 271             uio->uio_td->td_tid);
 272
 273         if (client->ec_revoked || evdev == NULL)
 274                 return (ENODEV);
 275
 276 #ifdef COMPAT_FREEBSD32
 277         if (SV_CURPROC_FLAG(SV_ILP32))
 278                 evsize = sizeof(struct input_event32);
 279         else
 280 #endif
 281                 evsize = sizeof(struct input_event);
 282
 283         if (uio->uio_resid % evsize != 0) {
 284                 debugf(client, "write size not multiple of input_event size");
 285                 return (EINVAL);
 286         }
 287
 288         while (uio->uio_resid > 0 && ret == 0) {
 289                 ret = uiomove(&event, evsize, uio);
 290                 if (ret == 0) {
 291 #ifdef COMPAT_FREEBSD32
 292                         if (SV_CURPROC_FLAG(SV_ILP32))
 293                                 ret = evdev_inject_event(evdev, event.t32.type,
 294                                     event.t32.code, event.t32.value);
 295                         else
 296 #endif
 297                                 ret = evdev_inject_event(evdev, event.t.type,
 298                                     event.t.code, event.t.value);
 299                 }
 300         }
 301
 302         return (ret);
 303 }
 304
 305 static int
 306 evdev_poll(struct cdev *dev, int events, struct thread *td)
 307 {
 308         struct evdev_client *client;
 309         int ret;
 310         int revents = 0;
 311
 312         ret = devfs_get_cdevpriv((void **)&client);
 313         if (ret != 0)
 314                 return (POLLNVAL);
 315
 316         debugf(client, "poll by thread %d", td->td_tid);
 317
 318         if (client->ec_revoked)
 319                 return (POLLHUP);
 320
 321         if (events & (POLLIN | POLLRDNORM)) {
 322                 EVDEV_CLIENT_LOCKQ(client);
 323                 if (!EVDEV_CLIENT_EMPTYQ(client))
 324                         revents = events & (POLLIN | POLLRDNORM);
 325                 else {
 326                         client->ec_selected = true;
 327                         selrecord(td, &client->ec_selp);
 328                 }
 329                 EVDEV_CLIENT_UNLOCKQ(client);
 330         }
 331
 332         return (revents);
 333 }
 334
 335 static int
 336 evdev_kqfilter(struct cdev *dev, struct knote *kn)
 337 {
 338         struct evdev_client *client;
 339         int ret;
 340
 341         ret = devfs_get_cdevpriv((void **)&client);
 342         if (ret != 0)
 343                 return (ret);
 344
 345         if (client->ec_revoked)
 346                 return (ENODEV);
 347
 348         switch(kn->kn_filter) {
 349         case EVFILT_READ:
 350                 kn->kn_fop = &evdev_cdev_filterops;
 351                 break;
 352         default:
 353                 return(EINVAL);
 354         }
 355         kn->kn_hook = (caddr_t)client;
 356
 357         knlist_add(&client->ec_selp.si_note, kn, 0);
 358         return (0);
 359 }
 360
 361 static int
 362 evdev_kqread(struct knote *kn, long hint)
 363 {
 364         struct evdev_client *client;
 365         int ret;
 366
 367         client = (struct evdev_client *)kn->kn_hook;
 368
 369         EVDEV_CLIENT_LOCKQ_ASSERT(client);
 370
 371         if (client->ec_revoked) {
 372                 kn->kn_flags |= EV_EOF;
 373                 ret = 1;
 374         } else {
 375                 kn->kn_data = EVDEV_CLIENT_SIZEQ(client) *
 376                     sizeof(struct input_event);
 377                 ret = !EVDEV_CLIENT_EMPTYQ(client);
 378         }
 379         return (ret);
 380 }
 381
 382 static void
 383 evdev_kqdetach(struct knote *kn)
 384 {
 385         struct evdev_client *client;
 386
 387         client = (struct evdev_client *)kn->kn_hook;
 388         knlist_remove(&client->ec_selp.si_note, kn, 0);
 389 }
 390
 391 static int
 392 evdev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
 393     struct thread *td)
 394 {
 395         struct evdev_dev *evdev = dev->si_drv1;
 396         struct evdev_client *client;
 397         struct input_keymap_entry *ke;
 398         int ret, len, limit, type_num;
 399         uint32_t code;
 400         size_t nvalues;
 401
 402         ret = devfs_get_cdevpriv((void **)&client);
 403         if (ret != 0)
 404                 return (ret);
 405
 406         if (client->ec_revoked || evdev == NULL)
 407                 return (ENODEV);
 408
 409         /*
 410          * Fix evdev state corrupted with discarding of kdb events.
 411          * EVIOCGKEY and EVIOCGLED ioctls can suffer from this.
 412          */
 413         if (evdev->ev_kdb_active) {
 414                 EVDEV_LOCK(evdev);
 415                 if (evdev->ev_kdb_active) {
 416                         evdev->ev_kdb_active = false;
 417                         evdev_restore_after_kdb(evdev);
 418                 }
 419                 EVDEV_UNLOCK(evdev);
 420         }
 421
 422         /* file I/O ioctl handling */
 423         switch (cmd) {
 424         case FIOSETOWN:
 425                 return (fsetown(*(int *)data, &client->ec_sigio));
 426
 427         case FIOGETOWN:
 428                 *(int *)data = fgetown(&client->ec_sigio);
 429                 return (0);
 430
 431         case FIONBIO:
 432                 return (0);
 433
 434         case FIOASYNC:
 435                 if (*(int *)data)
 436                         client->ec_async = true;
 437                 else
 438                         client->ec_async = false;
 439
 440                 return (0);
 441
 442         case FIONREAD:
 443                 EVDEV_CLIENT_LOCKQ(client);
 444                 *(int *)data =
 445                     EVDEV_CLIENT_SIZEQ(client) * sizeof(struct input_event);
 446                 EVDEV_CLIENT_UNLOCKQ(client);
 447                 return (0);
 448         }
 449
 450         len = IOCPARM_LEN(cmd);
 451         debugf(client, "ioctl called: cmd=0x%08lx, data=%p", cmd, data);
 452
 453         /* evdev fixed-length ioctls handling */
 454         switch (cmd) {
 455         case EVIOCGVERSION:
 456                 *(int *)data = EV_VERSION;
 457                 return (0);
 458
 459         case EVIOCGID:
 460                 debugf(client, "EVIOCGID: bus=%d vendor=0x%04x product=0x%04x",
 461                     evdev->ev_id.bustype, evdev->ev_id.vendor,
 462                     evdev->ev_id.product);
 463                 memcpy(data, &evdev->ev_id, sizeof(struct input_id));
 464                 return (0);
 465
 466         case EVIOCGREP:
 467                 if (!evdev_event_supported(evdev, EV_REP))
 468                         return (ENOTSUP);
 469
 470                 memcpy(data, evdev->ev_rep, sizeof(evdev->ev_rep));
 471                 return (0);
 472
 473         case EVIOCSREP:
 474                 if (!evdev_event_supported(evdev, EV_REP))
 475                         return (ENOTSUP);
 476
 477                 evdev_inject_event(evdev, EV_REP, REP_DELAY, ((int *)data)[0]);
 478                 evdev_inject_event(evdev, EV_REP, REP_PERIOD,
 479                     ((int *)data)[1]);
 480                 return (0);
 481
 482         case EVIOCGKEYCODE:
 483                 /* Fake unsupported ioctl */
 484                 return (0);
 485
 486         case EVIOCGKEYCODE_V2:
 487                 if (evdev->ev_methods == NULL ||
 488                     evdev->ev_methods->ev_get_keycode == NULL)
 489                         return (ENOTSUP);
 490
 491                 ke = (struct input_keymap_entry *)data;
 492                 evdev->ev_methods->ev_get_keycode(evdev, ke);
 493                 return (0);
 494
 495         case EVIOCSKEYCODE:
 496                 /* Fake unsupported ioctl */
 497                 return (0);
 498
 499         case EVIOCSKEYCODE_V2:
 500                 if (evdev->ev_methods == NULL ||
 501                     evdev->ev_methods->ev_set_keycode == NULL)
 502                         return (ENOTSUP);
 503
 504                 ke = (struct input_keymap_entry *)data;
 505                 evdev->ev_methods->ev_set_keycode(evdev, ke);
 506                 return (0);
 507
 508         case EVIOCGABS(0) ... EVIOCGABS(ABS_MAX):
 509                 if (evdev->ev_absinfo == NULL)
 510                         return (EINVAL);
 511
 512                 memcpy(data, &evdev->ev_absinfo[cmd - EVIOCGABS(0)],
 513                     sizeof(struct input_absinfo));
 514                 return (0);
 515
 516         case EVIOCSABS(0) ... EVIOCSABS(ABS_MAX):
 517                 if (evdev->ev_absinfo == NULL)
 518                         return (EINVAL);
 519
 520                 code = cmd - EVIOCSABS(0);
 521                 /* mt-slot number can not be changed */
 522                 if (code == ABS_MT_SLOT)
 523                         return (EINVAL);
 524
 525                 EVDEV_LOCK(evdev);
 526                 evdev_set_absinfo(evdev, code, (struct input_absinfo *)data);
 527                 EVDEV_UNLOCK(evdev);
 528                 return (0);
 529
 530         case EVIOCSFF:
 531         case EVIOCRMFF:
 532         case EVIOCGEFFECTS:
 533                 /* Fake unsupported ioctls */
 534                 return (0);
 535
 536         case EVIOCGRAB:
 537                 EVDEV_LOCK(evdev);
 538                 if (*(int *)data)
 539                         ret = evdev_grab_client(evdev, client);
 540                 else
 541                         ret = evdev_release_client(evdev, client);
 542                 EVDEV_UNLOCK(evdev);
 543                 return (ret);
 544
 545         case EVIOCREVOKE:
 546                 if (*(int *)data != 0)
 547                         return (EINVAL);
 548
 549                 EVDEV_LIST_LOCK(evdev);
 550                 if (dev->si_drv1 != NULL && !client->ec_revoked) {
 551                         evdev_dispose_client(evdev, client);
 552                         evdev_revoke_client(client);
 553                 }
 554                 EVDEV_LIST_UNLOCK(evdev);
 555                 return (0);
 556
 557         case EVIOCSCLOCKID:
 558                 switch (*(int *)data) {
 559                 case CLOCK_REALTIME:
 560                         client->ec_clock_id = EV_CLOCK_REALTIME;
 561                         return (0);
 562                 case CLOCK_MONOTONIC:
 563                         client->ec_clock_id = EV_CLOCK_MONOTONIC;
 564                         return (0);
 565                 default:
 566                         return (EINVAL);
 567                 }
 568         }
 569
 570         /* evdev variable-length ioctls handling */
 571         switch (IOCBASECMD(cmd)) {
 572         case EVIOCGNAME(0):
 573                 strlcpy(data, evdev->ev_name, len);
 574                 return (0);
 575
 576         case EVIOCGPHYS(0):
 577                 if (evdev->ev_shortname[0] == 0)
 578                         return (ENOENT);
 579
 580                 strlcpy(data, evdev->ev_shortname, len);
 581                 return (0);
 582
 583         case EVIOCGUNIQ(0):
 584                 if (evdev->ev_serial[0] == 0)
 585                         return (ENOENT);
 586
 587                 strlcpy(data, evdev->ev_serial, len);
 588                 return (0);
 589
 590         case EVIOCGPROP(0):
 591                 limit = MIN(len, bitstr_size(INPUT_PROP_CNT));
 592                 memcpy(data, evdev->ev_prop_flags, limit);
 593                 return (0);
 594
 595         case EVIOCGMTSLOTS(0):
 596                 if (evdev->ev_mt == NULL)
 597                         return (EINVAL);
 598                 if (len < sizeof(uint32_t))
 599                         return (EINVAL);
 600                 code = *(uint32_t *)data;
 601                 if (!ABS_IS_MT(code))
 602                         return (EINVAL);
 603
 604                 nvalues =
 605                     MIN(len / sizeof(int32_t) - 1, MAXIMAL_MT_SLOT(evdev) + 1);
 606                 for (int i = 0; i < nvalues; i++)
 607                         ((int32_t *)data)[i + 1] =
 608                             evdev_get_mt_value(evdev, i, code);
 609                 return (0);
 610
 611         case EVIOCGKEY(0):
 612                 limit = MIN(len, bitstr_size(KEY_CNT));
 613                 EVDEV_LOCK(evdev);
 614                 evdev_client_filter_queue(client, EV_KEY);
 615                 memcpy(data, evdev->ev_key_states, limit);
 616                 EVDEV_UNLOCK(evdev);
 617                 return (0);
 618
 619         case EVIOCGLED(0):
 620                 limit = MIN(len, bitstr_size(LED_CNT));
 621                 EVDEV_LOCK(evdev);
 622                 evdev_client_filter_queue(client, EV_LED);
 623                 memcpy(data, evdev->ev_led_states, limit);
 624                 EVDEV_UNLOCK(evdev);
 625                 return (0);
 626
 627         case EVIOCGSND(0):
 628                 limit = MIN(len, bitstr_size(SND_CNT));
 629                 EVDEV_LOCK(evdev);
 630                 evdev_client_filter_queue(client, EV_SND);
 631                 memcpy(data, evdev->ev_snd_states, limit);
 632                 EVDEV_UNLOCK(evdev);
 633                 return (0);
 634
 635         case EVIOCGSW(0):
 636                 limit = MIN(len, bitstr_size(SW_CNT));
 637                 EVDEV_LOCK(evdev);
 638                 evdev_client_filter_queue(client, EV_SW);
 639                 memcpy(data, evdev->ev_sw_states, limit);
 640                 EVDEV_UNLOCK(evdev);
 641                 return (0);
 642
 643         case EVIOCGBIT(0, 0) ... EVIOCGBIT(EV_MAX, 0):
 644                 type_num = IOCBASECMD(cmd) - EVIOCGBIT(0, 0);
 645                 debugf(client, "EVIOCGBIT(%d): data=%p, len=%d", type_num,
 646                     data, len);
 647                 return (evdev_ioctl_eviocgbit(evdev, type_num, len, data));
 648         }
 649
 650         return (EINVAL);
 651 }
 652
 653 static int
 654 evdev_ioctl_eviocgbit(struct evdev_dev *evdev, int type, int len, caddr_t data)
 655 {
 656         unsigned long *bitmap;
 657         int limit;
 658
 659         switch (type) {
 660         case 0:
 661                 bitmap = evdev->ev_type_flags;
 662                 limit = EV_CNT;
 663                 break;
 664         case EV_KEY:
 665                 bitmap = evdev->ev_key_flags;
 666                 limit = KEY_CNT;
 667                 break;
 668         case EV_REL:
 669                 bitmap = evdev->ev_rel_flags;
 670                 limit = REL_CNT;
 671                 break;
 672         case EV_ABS:
 673                 bitmap = evdev->ev_abs_flags;
 674                 limit = ABS_CNT;
 675                 break;
 676         case EV_MSC:
 677                 bitmap = evdev->ev_msc_flags;
 678                 limit = MSC_CNT;
 679                 break;
 680         case EV_LED:
 681                 bitmap = evdev->ev_led_flags;
 682                 limit = LED_CNT;
 683                 break;
 684         case EV_SND:
 685                 bitmap = evdev->ev_snd_flags;
 686                 limit = SND_CNT;
 687                 break;
 688         case EV_SW:
 689                 bitmap = evdev->ev_sw_flags;
 690                 limit = SW_CNT;
 691                 break;
 692         case EV_FF:
 693                 /*
 694                  * We don't support EV_FF now, so let's
 695                  * just fake it returning only zeros.
 696                  */
 697                 bzero(data, len);
 698                 return (0);
 699         default:
 700                 return (ENOTTY);
 701         }
 702
 703         /*
 704          * Clear ioctl data buffer in case it's bigger than
 705          * bitmap size
 706          */
 707         bzero(data, len);
 708
 709         limit = bitstr_size(limit);
 710         len = MIN(limit, len);
 711         memcpy(data, bitmap, len);
 712         return (0);
 713 }
 714
 715 void
 716 evdev_revoke_client(struct evdev_client *client)
 717 {
 718
 719         EVDEV_LIST_LOCK_ASSERT(client->ec_evdev);
 720
 721         client->ec_revoked = true;
 722 }
 723
 724 void
 725 evdev_notify_event(struct evdev_client *client)
 726 {
 727
 728         EVDEV_CLIENT_LOCKQ_ASSERT(client);
 729
 730         if (client->ec_blocked) {
 731                 client->ec_blocked = false;
 732                 wakeup(client);
 733         }
 734         if (client->ec_selected) {
 735                 client->ec_selected = false;
 736                 selwakeup(&client->ec_selp);
 737         }
 738         KNOTE_LOCKED(&client->ec_selp.si_note, 0);
 739
 740         if (client->ec_async && client->ec_sigio != NULL)
 741                 pgsigio(&client->ec_sigio, SIGIO, 0);
 742 }
 743
 744 int
 745 evdev_cdev_create(struct evdev_dev *evdev)
 746 {
 747         struct make_dev_args mda;
 748         int ret, unit = 0;
 749
 750         make_dev_args_init(&mda);
 751         mda.mda_flags = MAKEDEV_WAITOK | MAKEDEV_CHECKNAME;
 752         mda.mda_devsw = &evdev_cdevsw;
 753         mda.mda_uid = UID_ROOT;
 754         mda.mda_gid = GID_WHEEL;
 755         mda.mda_mode = 0600;
 756         mda.mda_si_drv1 = evdev;
 757
 758         /* Try to coexist with cuse-backed input/event devices */
 759         while ((ret = make_dev_s(&mda, &evdev->ev_cdev, "input/event%d", unit))
 760             == EEXIST)
 761                 unit++;
 762
 763         if (ret == 0)
 764                 evdev->ev_unit = unit;
 765
 766         return (ret);
 767 }
 768
 769 int
 770 evdev_cdev_destroy(struct evdev_dev *evdev)
 771 {
 772
 773         destroy_dev(evdev->ev_cdev);
 774         return (0);
 775 }
 776
 777 static void
 778 evdev_client_gettime(struct evdev_client *client, struct timeval *tv)
 779 {
 780
 781         switch (client->ec_clock_id) {
 782         case EV_CLOCK_BOOTTIME:
 783                 /*
 784                  * XXX: FreeBSD does not support true POSIX monotonic clock.
 785                  *      So aliase EV_CLOCK_BOOTTIME to EV_CLOCK_MONOTONIC.
 786                  */
 787         case EV_CLOCK_MONOTONIC:
 788                 microuptime(tv);
 789                 break;
 790
 791         case EV_CLOCK_REALTIME:
 792         default:
 793                 microtime(tv);
 794                 break;
 795         }
 796 }
 797
 798 void
 799 evdev_client_push(struct evdev_client *client, uint16_t type, uint16_t code,
 800     int32_t value)
 801 {
 802         struct timeval time;
 803         size_t count, head, tail, ready;
 804
 805         EVDEV_CLIENT_LOCKQ_ASSERT(client);
 806         head = client->ec_buffer_head;
 807         tail = client->ec_buffer_tail;
 808         ready = client->ec_buffer_ready;
 809         count = client->ec_buffer_size;
 810
 811         /* If queue is full drop its content and place SYN_DROPPED event */
 812         if ((tail + 1) % count == head) {
 813                 debugf(client, "client %p: buffer overflow", client);
 814
 815                 head = (tail + count - 1) % count;
 816                 client->ec_buffer[head] = (struct input_event) {
 817                         .type = EV_SYN,
 818                         .code = SYN_DROPPED,
 819                         .value = 0
 820                 };
 821                 /*
 822                  * XXX: Here is a small race window from now till the end of
 823                  *      report. The queue is empty but client has been already
 824                  *      notified of data readyness. Can be fixed in two ways:
 825                  * 1. Implement bulk insert so queue lock would not be dropped
 826                  *    till the SYN_REPORT event.
 827                  * 2. Insert SYN_REPORT just now and skip remaining events
 828                  */
 829                 client->ec_buffer_head = head;
 830                 client->ec_buffer_ready = head;
 831         }
 832
 833         client->ec_buffer[tail].type = type;
 834         client->ec_buffer[tail].code = code;
 835         client->ec_buffer[tail].value = value;
 836         client->ec_buffer_tail = (tail + 1) % count;
 837
 838         /* Allow users to read events only after report has been completed */
 839         if (type == EV_SYN && code == SYN_REPORT) {
 840                 evdev_client_gettime(client, &time);
 841                 for (; ready != client->ec_buffer_tail;
 842                     ready = (ready + 1) % count)
 843                         client->ec_buffer[ready].time = time;
 844                 client->ec_buffer_ready = client->ec_buffer_tail;
 845         }
 846 }
 847
 848 void
 849 evdev_client_dumpqueue(struct evdev_client *client)
 850 {
 851         struct input_event *event;
 852         size_t i, head, tail, ready, size;
 853
 854         head = client->ec_buffer_head;
 855         tail = client->ec_buffer_tail;
 856         ready = client->ec_buffer_ready;
 857         size = client->ec_buffer_size;
 858
 859         printf("evdev client: %p\n", client);
 860         printf("event queue: head=%zu ready=%zu tail=%zu size=%zu\n",
 861             head, ready, tail, size);
 862
 863         printf("queue contents:\n");
 864
 865         for (i = 0; i < size; i++) {
 866                 event = &client->ec_buffer[i];
 867                 printf("%zu: ", i);
 868
 869                 if (i < head || i > tail)
 870                         printf("unused\n");
 871                 else
 872                         printf("type=%d code=%d value=%d ", event->type,
 873                             event->code, event->value);
 874
 875                 if (i == head)
 876                         printf("<- head\n");
 877                 else if (i == tail)
 878                         printf("<- tail\n");
 879                 else if (i == ready)
 880                         printf("<- ready\n");
 881                 else
 882                         printf("\n");
 883         }
 884 }
 885
 886 static void
 887 evdev_client_filter_queue(struct evdev_client *client, uint16_t type)
 888 {
 889         struct input_event *event;
 890         size_t head, tail, count, i;
 891         bool last_was_syn = false;
 892
 893         EVDEV_CLIENT_LOCKQ(client);
 894
 895         i = head = client->ec_buffer_head;
 896         tail = client->ec_buffer_tail;
 897         count = client->ec_buffer_size;
 898         client->ec_buffer_ready = client->ec_buffer_tail;
 899
 900         while (i != client->ec_buffer_tail) {
 901                 event = &client->ec_buffer[i];
 902                 i = (i + 1) % count;
 903
 904                 /* Skip event of given type */
 905                 if (event->type == type)
 906                         continue;
 907
 908                 /* Remove empty SYN_REPORT events */
 909                 if (event->type == EV_SYN && event->code == SYN_REPORT) {
 910                         if (last_was_syn)
 911                                 continue;
 912                         else
 913                                 client->ec_buffer_ready = (tail + 1) % count;
 914                 }
 915
 916                 /* Rewrite entry */
 917                 memcpy(&client->ec_buffer[tail], event,
 918                     sizeof(struct input_event));
 919
 920                 last_was_syn = (event->type == EV_SYN &&
 921                     event->code == SYN_REPORT);
 922
 923                 tail = (tail + 1) % count;
 924         }
 925
 926         client->ec_buffer_head = i;
 927         client->ec_buffer_tail = tail;
 928
 929         EVDEV_CLIENT_UNLOCKQ(client);
 930 }