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