sys/dev/evdev/uinput.c

   1 /*-
   2  * Copyright (c) 2014 Jakub Wojciech Klama <jceel@FreeBSD.org>
   3  * Copyright (c) 2015-2016 Vladimir Kondratyev <wulf@cicgroup.ru>
   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/types.h>
  33 #include <sys/systm.h>
  34 #include <sys/param.h>
  35 #include <sys/fcntl.h>
  36 #include <sys/kernel.h>
  37 #include <sys/module.h>
  38 #include <sys/conf.h>
  39 #include <sys/uio.h>
  40 #include <sys/proc.h>
  41 #include <sys/poll.h>
  42 #include <sys/selinfo.h>
  43 #include <sys/malloc.h>
  44 #include <sys/lock.h>
  45 #include <sys/sx.h>
  46
  47 #include <dev/evdev/input.h>
  48 #include <dev/evdev/uinput.h>
  49 #include <dev/evdev/evdev.h>
  50 #include <dev/evdev/evdev_private.h>
  51
  52 #ifdef UINPUT_DEBUG
  53 #define debugf(state, fmt, args...)     printf("uinput: " fmt "\n", ##args)
  54 #else
  55 #define debugf(state, fmt, args...)
  56 #endif
  57
  58 #define UINPUT_BUFFER_SIZE      16
  59
  60 #define UINPUT_LOCK(state)              sx_xlock(&(state)->ucs_lock)
  61 #define UINPUT_UNLOCK(state)            sx_unlock(&(state)->ucs_lock)
  62 #define UINPUT_LOCK_ASSERT(state)       sx_assert(&(state)->ucs_lock, SA_LOCKED)
  63 #define UINPUT_EMPTYQ(state) \
  64     ((state)->ucs_buffer_head == (state)->ucs_buffer_tail)
  65
  66 enum uinput_state
  67 {
  68         UINPUT_NEW = 0,
  69         UINPUT_CONFIGURED,
  70         UINPUT_RUNNING
  71 };
  72
  73 static evdev_event_t    uinput_ev_event;
  74
  75 static d_open_t         uinput_open;
  76 static d_read_t         uinput_read;
  77 static d_write_t        uinput_write;
  78 static d_ioctl_t        uinput_ioctl;
  79 static d_poll_t         uinput_poll;
  80 static d_kqfilter_t     uinput_kqfilter;
  81 static void uinput_dtor(void *);
  82
  83 static int uinput_kqread(struct knote *kn, long hint);
  84 static void uinput_kqdetach(struct knote *kn);
  85
  86 static struct cdevsw uinput_cdevsw = {
  87         .d_version = D_VERSION,
  88         .d_open = uinput_open,
  89         .d_read = uinput_read,
  90         .d_write = uinput_write,
  91         .d_ioctl = uinput_ioctl,
  92         .d_poll = uinput_poll,
  93         .d_kqfilter = uinput_kqfilter,
  94         .d_name = "uinput",
  95 };
  96
  97 static struct cdev *uinput_cdev;
  98
  99 static struct evdev_methods uinput_ev_methods = {
 100         .ev_open = NULL,
 101         .ev_close = NULL,
 102         .ev_event = uinput_ev_event,
 103 };
 104
 105 static struct filterops uinput_filterops = {
 106         .f_isfd = 1,
 107         .f_attach = NULL,
 108         .f_detach = uinput_kqdetach,
 109         .f_event = uinput_kqread,
 110 };
 111
 112 struct uinput_cdev_state
 113 {
 114         enum uinput_state       ucs_state;
 115         struct evdev_dev *      ucs_evdev;
 116         struct sx               ucs_lock;
 117         size_t                  ucs_buffer_head;
 118         size_t                  ucs_buffer_tail;
 119         struct selinfo          ucs_selp;
 120         bool                    ucs_blocked;
 121         bool                    ucs_selected;
 122         struct input_event      ucs_buffer[UINPUT_BUFFER_SIZE];
 123 };
 124
 125 static void uinput_enqueue_event(struct uinput_cdev_state *, uint16_t,
 126     uint16_t, int32_t);
 127 static int uinput_setup_provider(struct uinput_cdev_state *,
 128     struct uinput_user_dev *);
 129 static int uinput_cdev_create(void);
 130 static void uinput_notify(struct uinput_cdev_state *);
 131
 132 static void
 133 uinput_knllock(void *arg)
 134 {
 135         struct sx *sx = arg;
 136
 137         sx_xlock(sx);
 138 }
 139
 140 static void
 141 uinput_knlunlock(void *arg)
 142 {
 143         struct sx *sx = arg;
 144
 145         sx_unlock(sx);
 146 }
 147
 148 static void
 149 uinput_knl_assert_locked(void *arg)
 150 {
 151
 152         sx_assert((struct sx*)arg, SA_XLOCKED);
 153 }
 154
 155 static void
 156 uinput_knl_assert_unlocked(void *arg)
 157 {
 158
 159         sx_assert((struct sx*)arg, SA_UNLOCKED);
 160 }
 161
 162 static void
 163 uinput_ev_event(struct evdev_dev *evdev, void *softc, uint16_t type,
 164     uint16_t code, int32_t value)
 165 {
 166         struct uinput_cdev_state *state = softc;
 167
 168         if (type == EV_LED)
 169                 evdev_push_event(evdev, type, code, value);
 170
 171         UINPUT_LOCK(state);
 172         if (state->ucs_state == UINPUT_RUNNING) {
 173                 uinput_enqueue_event(state, type, code, value);
 174                 uinput_notify(state);
 175         }
 176         UINPUT_UNLOCK(state);
 177 }
 178
 179 static void
 180 uinput_enqueue_event(struct uinput_cdev_state *state, uint16_t type,
 181     uint16_t code, int32_t value)
 182 {
 183         size_t head, tail;
 184
 185         UINPUT_LOCK_ASSERT(state);
 186
 187         head = state->ucs_buffer_head;
 188         tail = (state->ucs_buffer_tail + 1) % UINPUT_BUFFER_SIZE;
 189
 190         microtime(&state->ucs_buffer[tail].time);
 191         state->ucs_buffer[tail].type = type;
 192         state->ucs_buffer[tail].code = code;
 193         state->ucs_buffer[tail].value = value;
 194         state->ucs_buffer_tail = tail;
 195
 196         /* If queue is full remove oldest event */
 197         if (tail == head) {
 198                 debugf(state, "state %p: buffer overflow", state);
 199
 200                 head = (head + 1) % UINPUT_BUFFER_SIZE;
 201                 state->ucs_buffer_head = head;
 202         }
 203 }
 204
 205 static int
 206 uinput_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 207 {
 208         struct uinput_cdev_state *state;
 209
 210         state = malloc(sizeof(struct uinput_cdev_state), M_EVDEV,
 211             M_WAITOK | M_ZERO);
 212         state->ucs_evdev = evdev_alloc();
 213
 214         sx_init(&state->ucs_lock, "uinput");
 215         knlist_init(&state->ucs_selp.si_note, &state->ucs_lock, uinput_knllock,
 216             uinput_knlunlock, uinput_knl_assert_locked,
 217             uinput_knl_assert_unlocked);
 218
 219         devfs_set_cdevpriv(state, uinput_dtor);
 220         return (0);
 221 }
 222
 223 static void
 224 uinput_dtor(void *data)
 225 {
 226         struct uinput_cdev_state *state = (struct uinput_cdev_state *)data;
 227
 228         evdev_free(state->ucs_evdev);
 229
 230         knlist_clear(&state->ucs_selp.si_note, 0);
 231         seldrain(&state->ucs_selp);
 232         knlist_destroy(&state->ucs_selp.si_note);
 233         sx_destroy(&state->ucs_lock);
 234         free(data, M_EVDEV);
 235 }
 236
 237 static int
 238 uinput_read(struct cdev *dev, struct uio *uio, int ioflag)
 239 {
 240         struct uinput_cdev_state *state;
 241         struct input_event *event;
 242         int remaining, ret;
 243
 244         ret = devfs_get_cdevpriv((void **)&state);
 245         if (ret != 0)
 246                 return (ret);
 247
 248         debugf(state, "read %zd bytes by thread %d", uio->uio_resid,
 249             uio->uio_td->td_tid);
 250
 251         /* Zero-sized reads are allowed for error checking */
 252         if (uio->uio_resid != 0 && uio->uio_resid < sizeof(struct input_event))
 253                 return (EINVAL);
 254
 255         remaining = uio->uio_resid / sizeof(struct input_event);
 256
 257         UINPUT_LOCK(state);
 258
 259         if (state->ucs_state != UINPUT_RUNNING)
 260                 ret = EINVAL;
 261
 262         if (ret == 0 && UINPUT_EMPTYQ(state)) {
 263                 if (ioflag & O_NONBLOCK)
 264                         ret = EWOULDBLOCK;
 265                 else {
 266                         if (remaining != 0) {
 267                                 state->ucs_blocked = true;
 268                                 ret = sx_sleep(state, &state->ucs_lock,
 269                                     PCATCH, "uiread", 0);
 270                         }
 271                 }
 272         }
 273
 274         while (ret == 0 && !UINPUT_EMPTYQ(state) && remaining > 0) {
 275                 event = &state->ucs_buffer[state->ucs_buffer_head];
 276                 state->ucs_buffer_head = (state->ucs_buffer_head + 1) %
 277                     UINPUT_BUFFER_SIZE;
 278                 remaining--;
 279                 ret = uiomove(event, sizeof(struct input_event), uio);
 280         }
 281
 282         UINPUT_UNLOCK(state);
 283
 284         return (ret);
 285 }
 286
 287 static int
 288 uinput_write(struct cdev *dev, struct uio *uio, int ioflag)
 289 {
 290         struct uinput_cdev_state *state;
 291         struct uinput_user_dev userdev;
 292         struct input_event event;
 293         int ret = 0;
 294
 295         ret = devfs_get_cdevpriv((void **)&state);
 296         if (ret != 0)
 297                 return (ret);
 298
 299         debugf(state, "write %zd bytes by thread %d", uio->uio_resid,
 300             uio->uio_td->td_tid);
 301
 302         UINPUT_LOCK(state);
 303
 304         if (state->ucs_state != UINPUT_RUNNING) {
 305                 /* Process written struct uinput_user_dev */
 306                 if (uio->uio_resid != sizeof(struct uinput_user_dev)) {
 307                         debugf(state, "write size not multiple of "
 308                             "struct uinput_user_dev size");
 309                         ret = EINVAL;
 310                 } else {
 311                         ret = uiomove(&userdev, sizeof(struct uinput_user_dev),
 312                             uio);
 313                         if (ret == 0)
 314                                 uinput_setup_provider(state, &userdev);
 315                 }
 316         } else {
 317                 /* Process written event */
 318                 if (uio->uio_resid % sizeof(struct input_event) != 0) {
 319                         debugf(state, "write size not multiple of "
 320                             "struct input_event size");
 321                         ret = EINVAL;
 322                 }
 323
 324                 while (ret == 0 && uio->uio_resid > 0) {
 325                         uiomove(&event, sizeof(struct input_event), uio);
 326                         ret = evdev_push_event(state->ucs_evdev, event.type,
 327                             event.code, event.value);
 328                 }
 329         }
 330
 331         UINPUT_UNLOCK(state);
 332
 333         return (ret);
 334 }
 335
 336 static int
 337 uinput_setup_dev(struct uinput_cdev_state *state, struct input_id *id,
 338     char *name, uint32_t ff_effects_max)
 339 {
 340
 341         if (name[0] == 0)
 342                 return (EINVAL);
 343
 344         evdev_set_name(state->ucs_evdev, name);
 345         evdev_set_id(state->ucs_evdev, id->bustype, id->vendor, id->product,
 346             id->version);
 347         state->ucs_state = UINPUT_CONFIGURED;
 348
 349         return (0);
 350 }
 351
 352 static int
 353 uinput_setup_provider(struct uinput_cdev_state *state,
 354     struct uinput_user_dev *udev)
 355 {
 356         struct input_absinfo absinfo;
 357         int i, ret;
 358
 359         debugf(state, "setup_provider called, udev=%p", udev);
 360
 361         ret = uinput_setup_dev(state, &udev->id, udev->name,
 362             udev->ff_effects_max);
 363         if (ret)
 364                 return (ret);
 365
 366         bzero(&absinfo, sizeof(struct input_absinfo));
 367         for (i = 0; i < ABS_CNT; i++) {
 368                 if (!bit_test(state->ucs_evdev->ev_abs_flags, i))
 369                         continue;
 370
 371                 absinfo.minimum = udev->absmin[i];
 372                 absinfo.maximum = udev->absmax[i];
 373                 absinfo.fuzz = udev->absfuzz[i];
 374                 absinfo.flat = udev->absflat[i];
 375                 evdev_set_absinfo(state->ucs_evdev, i, &absinfo);
 376         }
 377
 378         return (0);
 379 }
 380
 381 static int
 382 uinput_poll(struct cdev *dev, int events, struct thread *td)
 383 {
 384         struct uinput_cdev_state *state;
 385         int revents = 0;
 386
 387         if (devfs_get_cdevpriv((void **)&state) != 0)
 388                 return (POLLNVAL);
 389
 390         debugf(state, "poll by thread %d", td->td_tid);
 391
 392         /* Always allow write */
 393         if (events & (POLLOUT | POLLWRNORM))
 394                 revents |= (events & (POLLOUT | POLLWRNORM));
 395
 396         if (events & (POLLIN | POLLRDNORM)) {
 397                 UINPUT_LOCK(state);
 398                 if (!UINPUT_EMPTYQ(state))
 399                         revents = events & (POLLIN | POLLRDNORM);
 400                 else {
 401                         state->ucs_selected = true;
 402                         selrecord(td, &state->ucs_selp);
 403                 }
 404                 UINPUT_UNLOCK(state);
 405         }
 406
 407         return (revents);
 408 }
 409
 410 static int
 411 uinput_kqfilter(struct cdev *dev, struct knote *kn)
 412 {
 413         struct uinput_cdev_state *state;
 414         int ret;
 415
 416         ret = devfs_get_cdevpriv((void **)&state);
 417         if (ret != 0)
 418                 return (ret);
 419
 420         switch(kn->kn_filter) {
 421         case EVFILT_READ:
 422                 kn->kn_fop = &uinput_filterops;
 423                 break;
 424         default:
 425                 return(EINVAL);
 426         }
 427         kn->kn_hook = (caddr_t)state;
 428
 429         knlist_add(&state->ucs_selp.si_note, kn, 0);
 430         return (0);
 431 }
 432
 433 static int
 434 uinput_kqread(struct knote *kn, long hint)
 435 {
 436         struct uinput_cdev_state *state;
 437         int ret;
 438
 439         state = (struct uinput_cdev_state *)kn->kn_hook;
 440
 441         UINPUT_LOCK_ASSERT(state);
 442
 443         ret = !UINPUT_EMPTYQ(state);
 444         return (ret);
 445 }
 446
 447 static void
 448 uinput_kqdetach(struct knote *kn)
 449 {
 450         struct uinput_cdev_state *state;
 451
 452         state = (struct uinput_cdev_state *)kn->kn_hook;
 453         knlist_remove(&state->ucs_selp.si_note, kn, 0);
 454 }
 455
 456 static void
 457 uinput_notify(struct uinput_cdev_state *state)
 458 {
 459
 460         UINPUT_LOCK_ASSERT(state);
 461
 462         if (state->ucs_blocked) {
 463                 state->ucs_blocked = false;
 464                 wakeup(state);
 465         }
 466         if (state->ucs_selected) {
 467                 state->ucs_selected = false;
 468                 selwakeup(&state->ucs_selp);
 469         }
 470         KNOTE_LOCKED(&state->ucs_selp.si_note, 0);
 471 }
 472
 473 static int
 474 uinput_ioctl_sub(struct uinput_cdev_state *state, u_long cmd, caddr_t data)
 475 {
 476         struct uinput_setup *us;
 477         struct uinput_abs_setup *uabs;
 478         int ret, len, intdata;
 479         char buf[NAMELEN];
 480
 481         UINPUT_LOCK_ASSERT(state);
 482
 483         len = IOCPARM_LEN(cmd);
 484         if ((cmd & IOC_DIRMASK) == IOC_VOID && len == sizeof(int))
 485                 intdata = *(int *)data;
 486
 487         switch (IOCBASECMD(cmd)) {
 488         case UI_GET_SYSNAME(0):
 489                 if (state->ucs_state != UINPUT_RUNNING)
 490                         return (ENOENT);
 491                 if (len == 0)
 492                         return (EINVAL);
 493                 snprintf(data, len, "event%d", state->ucs_evdev->ev_unit);
 494                 return (0);
 495         }
 496
 497         switch (cmd) {
 498         case UI_DEV_CREATE:
 499                 if (state->ucs_state != UINPUT_CONFIGURED)
 500                         return (EINVAL);
 501
 502                 evdev_set_methods(state->ucs_evdev, state, &uinput_ev_methods);
 503                 evdev_set_flag(state->ucs_evdev, EVDEV_FLAG_SOFTREPEAT);
 504                 ret = evdev_register(state->ucs_evdev);
 505                 if (ret == 0)
 506                         state->ucs_state = UINPUT_RUNNING;
 507                 return (ret);
 508
 509         case UI_DEV_DESTROY:
 510                 if (state->ucs_state != UINPUT_RUNNING)
 511                         return (0);
 512
 513                 evdev_unregister(state->ucs_evdev);
 514                 bzero(state->ucs_evdev, sizeof(struct evdev_dev));
 515                 state->ucs_state = UINPUT_NEW;
 516                 return (0);
 517
 518         case UI_DEV_SETUP:
 519                 if (state->ucs_state == UINPUT_RUNNING)
 520                         return (EINVAL);
 521
 522                 us = (struct uinput_setup *)data;
 523                 return (uinput_setup_dev(state, &us->id, us->name,
 524                     us->ff_effects_max));
 525
 526         case UI_ABS_SETUP:
 527                 if (state->ucs_state == UINPUT_RUNNING)
 528                         return (EINVAL);
 529
 530                 uabs = (struct uinput_abs_setup *)data;
 531                 if (uabs->code > ABS_MAX)
 532                         return (EINVAL);
 533
 534                 evdev_support_abs(state->ucs_evdev, uabs->code,
 535                     uabs->absinfo.value, uabs->absinfo.minimum,
 536                     uabs->absinfo.maximum, uabs->absinfo.fuzz,
 537                     uabs->absinfo.flat, uabs->absinfo.resolution);
 538                 return (0);
 539
 540         case UI_SET_EVBIT:
 541                 if (state->ucs_state == UINPUT_RUNNING ||
 542                     intdata > EV_MAX || intdata < 0)
 543                         return (EINVAL);
 544                 evdev_support_event(state->ucs_evdev, intdata);
 545                 return (0);
 546
 547         case UI_SET_KEYBIT:
 548                 if (state->ucs_state == UINPUT_RUNNING ||
 549                     intdata > KEY_MAX || intdata < 0)
 550                         return (EINVAL);
 551                 evdev_support_key(state->ucs_evdev, intdata);
 552                 return (0);
 553
 554         case UI_SET_RELBIT:
 555                 if (state->ucs_state == UINPUT_RUNNING ||
 556                     intdata > REL_MAX || intdata < 0)
 557                         return (EINVAL);
 558                 evdev_support_rel(state->ucs_evdev, intdata);
 559                 return (0);
 560
 561         case UI_SET_ABSBIT:
 562                 if (state->ucs_state == UINPUT_RUNNING ||
 563                     intdata > ABS_MAX || intdata < 0)
 564                         return (EINVAL);
 565                 evdev_set_abs_bit(state->ucs_evdev, intdata);
 566                 return (0);
 567
 568         case UI_SET_MSCBIT:
 569                 if (state->ucs_state == UINPUT_RUNNING ||
 570                     intdata > MSC_MAX || intdata < 0)
 571                         return (EINVAL);
 572                 evdev_support_msc(state->ucs_evdev, intdata);
 573                 return (0);
 574
 575         case UI_SET_LEDBIT:
 576                 if (state->ucs_state == UINPUT_RUNNING ||
 577                     intdata > LED_MAX || intdata < 0)
 578                         return (EINVAL);
 579                 evdev_support_led(state->ucs_evdev, intdata);
 580                 return (0);
 581
 582         case UI_SET_SNDBIT:
 583                 if (state->ucs_state == UINPUT_RUNNING ||
 584                     intdata > SND_MAX || intdata < 0)
 585                         return (EINVAL);
 586                 evdev_support_snd(state->ucs_evdev, intdata);
 587                 return (0);
 588
 589         case UI_SET_FFBIT:
 590                 if (state->ucs_state == UINPUT_RUNNING ||
 591                     intdata > FF_MAX || intdata < 0)
 592                         return (EINVAL);
 593                 /* Fake unsupported ioctl */
 594                 return (0);
 595
 596         case UI_SET_PHYS:
 597                 if (state->ucs_state == UINPUT_RUNNING)
 598                         return (EINVAL);
 599                 ret = copyinstr(*(void **)data, buf, sizeof(buf), NULL);
 600                 /* Linux returns EINVAL when string does not fit the buffer */
 601                 if (ret == ENAMETOOLONG)
 602                         ret = EINVAL;
 603                 if (ret != 0)
 604                         return (ret);
 605                 evdev_set_phys(state->ucs_evdev, buf);
 606                 return (0);
 607
 608         case UI_SET_SWBIT:
 609                 if (state->ucs_state == UINPUT_RUNNING ||
 610                     intdata > SW_MAX || intdata < 0)
 611                         return (EINVAL);
 612                 evdev_support_sw(state->ucs_evdev, intdata);
 613                 return (0);
 614
 615         case UI_SET_PROPBIT:
 616                 if (state->ucs_state == UINPUT_RUNNING ||
 617                     intdata > INPUT_PROP_MAX || intdata < 0)
 618                         return (EINVAL);
 619                 evdev_support_prop(state->ucs_evdev, intdata);
 620                 return (0);
 621
 622         case UI_BEGIN_FF_UPLOAD:
 623         case UI_END_FF_UPLOAD:
 624         case UI_BEGIN_FF_ERASE:
 625         case UI_END_FF_ERASE:
 626                 if (state->ucs_state == UINPUT_RUNNING)
 627                         return (EINVAL);
 628                 /* Fake unsupported ioctl */
 629                 return (0);
 630
 631         case UI_GET_VERSION:
 632                 *(unsigned int *)data = UINPUT_VERSION;
 633                 return (0);
 634         }
 635
 636         return (EINVAL);
 637 }
 638
 639 static int
 640 uinput_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
 641     struct thread *td)
 642 {
 643         struct uinput_cdev_state *state;
 644         int ret;
 645
 646         ret = devfs_get_cdevpriv((void **)&state);
 647         if (ret != 0)
 648                 return (ret);
 649
 650         debugf(state, "ioctl called: cmd=0x%08lx, data=%p", cmd, data);
 651
 652         UINPUT_LOCK(state);
 653         ret = uinput_ioctl_sub(state, cmd, data);
 654         UINPUT_UNLOCK(state);
 655
 656         return (ret);
 657 }
 658
 659 static int
 660 uinput_cdev_create(void)
 661 {
 662         struct make_dev_args mda;
 663         int ret;
 664
 665         make_dev_args_init(&mda);
 666         mda.mda_flags = MAKEDEV_WAITOK | MAKEDEV_CHECKNAME;
 667         mda.mda_devsw = &uinput_cdevsw;
 668         mda.mda_uid = UID_ROOT;
 669         mda.mda_gid = GID_WHEEL;
 670         mda.mda_mode = 0600;
 671
 672         ret = make_dev_s(&mda, &uinput_cdev, "uinput");
 673
 674         return (ret);
 675 }
 676
 677 static int
 678 uinput_cdev_destroy(void)
 679 {
 680
 681         destroy_dev(uinput_cdev);
 682
 683         return (0);
 684 }
 685
 686 static int
 687 uinput_modevent(module_t mod __unused, int cmd, void *data)
 688 {
 689         int ret = 0;
 690
 691         switch (cmd) {
 692         case MOD_LOAD:
 693                 ret = uinput_cdev_create();
 694                 break;
 695
 696         case MOD_UNLOAD:
 697                 ret = uinput_cdev_destroy();
 698                 break;
 699
 700         case MOD_SHUTDOWN:
 701                 break;
 702
 703         default:
 704                 ret = EINVAL;
 705                 break;
 706         }
 707
 708         return (ret);
 709 }
 710
 711 DEV_MODULE(uinput, uinput_modevent, NULL);
 712 MODULE_VERSION(uinput, 1);
 713 MODULE_DEPEND(uinput, evdev, 1, 1, 1);