drivers/input/misc/uinput.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  User level driver support for input subsystem
   4  *
   5  * Heavily based on evdev.c by Vojtech Pavlik
   6  *
   7  * Author: Aristeu Sergio Rozanski Filho <[email protected]>
   8  *
   9  * Changes/Revisions:
  10  *      0.4     01/09/2014 (Benjamin Tissoires <[email protected]>)
  11  *              - add UI_GET_SYSNAME ioctl
  12  *      0.3     09/04/2006 (Anssi Hannula <[email protected]>)
  13  *              - updated ff support for the changes in kernel interface
  14  *              - added MODULE_VERSION
  15  *      0.2     16/10/2004 (Micah Dowty <[email protected]>)
  16  *              - added force feedback support
  17  *              - added UI_SET_PHYS
  18  *      0.1     20/06/2002
  19  *              - first public version
  20  */
  21 #include <uapi/linux/uinput.h>
  22 #include <linux/poll.h>
  23 #include <linux/sched.h>
  24 #include <linux/slab.h>
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/fs.h>
  28 #include <linux/miscdevice.h>
  29 #include <linux/overflow.h>
  30 #include <linux/input/mt.h>
  31 #include "../input-compat.h"
  32
  33 #define UINPUT_NAME             "uinput"
  34 #define UINPUT_BUFFER_SIZE      16
  35 #define UINPUT_NUM_REQUESTS     16
  36 #define UINPUT_TIMESTAMP_ALLOWED_OFFSET_SECS 10
  37
  38 enum uinput_state { UIST_NEW_DEVICE, UIST_SETUP_COMPLETE, UIST_CREATED };
  39
  40 struct uinput_request {
  41         unsigned int            id;
  42         unsigned int            code;   /* UI_FF_UPLOAD, UI_FF_ERASE */
  43
  44         int                     retval;
  45         struct completion       done;
  46
  47         union {
  48                 unsigned int    effect_id;
  49                 struct {
  50                         struct ff_effect *effect;
  51                         struct ff_effect *old;
  52                 } upload;
  53         } u;
  54 };
  55
  56 struct uinput_device {
  57         struct input_dev        *dev;
  58         struct mutex            mutex;
  59         enum uinput_state       state;
  60         wait_queue_head_t       waitq;
  61         unsigned char           ready;
  62         unsigned char           head;
  63         unsigned char           tail;
  64         struct input_event      buff[UINPUT_BUFFER_SIZE];
  65         unsigned int            ff_effects_max;
  66
  67         struct uinput_request   *requests[UINPUT_NUM_REQUESTS];
  68         wait_queue_head_t       requests_waitq;
  69         spinlock_t              requests_lock;
  70 };
  71
  72 static int uinput_dev_event(struct input_dev *dev,
  73                             unsigned int type, unsigned int code, int value)
  74 {
  75         struct uinput_device    *udev = input_get_drvdata(dev);
  76         struct timespec64       ts;
  77
  78         ktime_get_ts64(&ts);
  79
  80         udev->buff[udev->head] = (struct input_event) {
  81                 .input_event_sec = ts.tv_sec,
  82                 .input_event_usec = ts.tv_nsec / NSEC_PER_USEC,
  83                 .type = type,
  84                 .code = code,
  85                 .value = value,
  86         };
  87
  88         udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE;
  89
  90         wake_up_interruptible(&udev->waitq);
  91
  92         return 0;
  93 }
  94
  95 /* Atomically allocate an ID for the given request. Returns 0 on success. */
  96 static bool uinput_request_alloc_id(struct uinput_device *udev,
  97                                     struct uinput_request *request)
  98 {
  99         unsigned int id;
 100         bool reserved = false;
 101
 102         spin_lock(&udev->requests_lock);
 103
 104         for (id = 0; id < UINPUT_NUM_REQUESTS; id++) {
 105                 if (!udev->requests[id]) {
 106                         request->id = id;
 107                         udev->requests[id] = request;
 108                         reserved = true;
 109                         break;
 110                 }
 111         }
 112
 113         spin_unlock(&udev->requests_lock);
 114         return reserved;
 115 }
 116
 117 static struct uinput_request *uinput_request_find(struct uinput_device *udev,
 118                                                   unsigned int id)
 119 {
 120         /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
 121         if (id >= UINPUT_NUM_REQUESTS)
 122                 return NULL;
 123
 124         return udev->requests[id];
 125 }
 126
 127 static int uinput_request_reserve_slot(struct uinput_device *udev,
 128                                        struct uinput_request *request)
 129 {
 130         /* Allocate slot. If none are available right away, wait. */
 131         return wait_event_interruptible(udev->requests_waitq,
 132                                         uinput_request_alloc_id(udev, request));
 133 }
 134
 135 static void uinput_request_release_slot(struct uinput_device *udev,
 136                                         unsigned int id)
 137 {
 138         /* Mark slot as available */
 139         spin_lock(&udev->requests_lock);
 140         udev->requests[id] = NULL;
 141         spin_unlock(&udev->requests_lock);
 142
 143         wake_up(&udev->requests_waitq);
 144 }
 145
 146 static int uinput_request_send(struct uinput_device *udev,
 147                                struct uinput_request *request)
 148 {
 149         int retval;
 150
 151         retval = mutex_lock_interruptible(&udev->mutex);
 152         if (retval)
 153                 return retval;
 154
 155         if (udev->state != UIST_CREATED) {
 156                 retval = -ENODEV;
 157                 goto out;
 158         }
 159
 160         init_completion(&request->done);
 161
 162         /*
 163          * Tell our userspace application about this new request
 164          * by queueing an input event.
 165          */
 166         uinput_dev_event(udev->dev, EV_UINPUT, request->code, request->id);
 167
 168  out:
 169         mutex_unlock(&udev->mutex);
 170         return retval;
 171 }
 172
 173 static int uinput_request_submit(struct uinput_device *udev,
 174                                  struct uinput_request *request)
 175 {
 176         int retval;
 177
 178         retval = uinput_request_reserve_slot(udev, request);
 179         if (retval)
 180                 return retval;
 181
 182         retval = uinput_request_send(udev, request);
 183         if (retval)
 184                 goto out;
 185
 186         if (!wait_for_completion_timeout(&request->done, 30 * HZ)) {
 187                 retval = -ETIMEDOUT;
 188                 goto out;
 189         }
 190
 191         retval = request->retval;
 192
 193  out:
 194         uinput_request_release_slot(udev, request->id);
 195         return retval;
 196 }
 197
 198 /*
 199  * Fail all outstanding requests so handlers don't wait for the userspace
 200  * to finish processing them.
 201  */
 202 static void uinput_flush_requests(struct uinput_device *udev)
 203 {
 204         struct uinput_request *request;
 205         int i;
 206
 207         spin_lock(&udev->requests_lock);
 208
 209         for (i = 0; i < UINPUT_NUM_REQUESTS; i++) {
 210                 request = udev->requests[i];
 211                 if (request) {
 212                         request->retval = -ENODEV;
 213                         complete(&request->done);
 214                 }
 215         }
 216
 217         spin_unlock(&udev->requests_lock);
 218 }
 219
 220 static void uinput_dev_set_gain(struct input_dev *dev, u16 gain)
 221 {
 222         uinput_dev_event(dev, EV_FF, FF_GAIN, gain);
 223 }
 224
 225 static void uinput_dev_set_autocenter(struct input_dev *dev, u16 magnitude)
 226 {
 227         uinput_dev_event(dev, EV_FF, FF_AUTOCENTER, magnitude);
 228 }
 229
 230 static int uinput_dev_playback(struct input_dev *dev, int effect_id, int value)
 231 {
 232         return uinput_dev_event(dev, EV_FF, effect_id, value);
 233 }
 234
 235 static int uinput_dev_upload_effect(struct input_dev *dev,
 236                                     struct ff_effect *effect,
 237                                     struct ff_effect *old)
 238 {
 239         struct uinput_device *udev = input_get_drvdata(dev);
 240         struct uinput_request request;
 241
 242         /*
 243          * uinput driver does not currently support periodic effects with
 244          * custom waveform since it does not have a way to pass buffer of
 245          * samples (custom_data) to userspace. If ever there is a device
 246          * supporting custom waveforms we would need to define an additional
 247          * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out.
 248          */
 249         if (effect->type == FF_PERIODIC &&
 250                         effect->u.periodic.waveform == FF_CUSTOM)
 251                 return -EINVAL;
 252
 253         request.code = UI_FF_UPLOAD;
 254         request.u.upload.effect = effect;
 255         request.u.upload.old = old;
 256
 257         return uinput_request_submit(udev, &request);
 258 }
 259
 260 static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
 261 {
 262         struct uinput_device *udev = input_get_drvdata(dev);
 263         struct uinput_request request;
 264
 265         if (!test_bit(EV_FF, dev->evbit))
 266                 return -ENOSYS;
 267
 268         request.code = UI_FF_ERASE;
 269         request.u.effect_id = effect_id;
 270
 271         return uinput_request_submit(udev, &request);
 272 }
 273
 274 static int uinput_dev_flush(struct input_dev *dev, struct file *file)
 275 {
 276         /*
 277          * If we are called with file == NULL that means we are tearing
 278          * down the device, and therefore we can not handle FF erase
 279          * requests: either we are handling UI_DEV_DESTROY (and holding
 280          * the udev->mutex), or the file descriptor is closed and there is
 281          * nobody on the other side anymore.
 282          */
 283         return file ? input_ff_flush(dev, file) : 0;
 284 }
 285
 286 static void uinput_destroy_device(struct uinput_device *udev)
 287 {
 288         const char *name, *phys;
 289         struct input_dev *dev = udev->dev;
 290         enum uinput_state old_state = udev->state;
 291
 292         udev->state = UIST_NEW_DEVICE;
 293
 294         if (dev) {
 295                 name = dev->name;
 296                 phys = dev->phys;
 297                 if (old_state == UIST_CREATED) {
 298                         uinput_flush_requests(udev);
 299                         input_unregister_device(dev);
 300                 } else {
 301                         input_free_device(dev);
 302                 }
 303                 kfree(name);
 304                 kfree(phys);
 305                 udev->dev = NULL;
 306         }
 307 }
 308
 309 static int uinput_create_device(struct uinput_device *udev)
 310 {
 311         struct input_dev *dev = udev->dev;
 312         int error, nslot;
 313
 314         if (udev->state != UIST_SETUP_COMPLETE) {
 315                 printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME);
 316                 return -EINVAL;
 317         }
 318
 319         if (test_bit(EV_ABS, dev->evbit)) {
 320                 input_alloc_absinfo(dev);
 321                 if (!dev->absinfo) {
 322                         error = -EINVAL;
 323                         goto fail1;
 324                 }
 325
 326                 if (test_bit(ABS_MT_SLOT, dev->absbit)) {
 327                         nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1;
 328                         error = input_mt_init_slots(dev, nslot, 0);
 329                         if (error)
 330                                 goto fail1;
 331                 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
 332                         input_set_events_per_packet(dev, 60);
 333                 }
 334         }
 335
 336         if (test_bit(EV_FF, dev->evbit) && !udev->ff_effects_max) {
 337                 printk(KERN_DEBUG "%s: ff_effects_max should be non-zero when FF_BIT is set\n",
 338                         UINPUT_NAME);
 339                 error = -EINVAL;
 340                 goto fail1;
 341         }
 342
 343         if (udev->ff_effects_max) {
 344                 error = input_ff_create(dev, udev->ff_effects_max);
 345                 if (error)
 346                         goto fail1;
 347
 348                 dev->ff->upload = uinput_dev_upload_effect;
 349                 dev->ff->erase = uinput_dev_erase_effect;
 350                 dev->ff->playback = uinput_dev_playback;
 351                 dev->ff->set_gain = uinput_dev_set_gain;
 352                 dev->ff->set_autocenter = uinput_dev_set_autocenter;
 353                 /*
 354                  * The standard input_ff_flush() implementation does
 355                  * not quite work for uinput as we can't reasonably
 356                  * handle FF requests during device teardown.
 357                  */
 358                 dev->flush = uinput_dev_flush;
 359         }
 360
 361         dev->event = uinput_dev_event;
 362
 363         input_set_drvdata(udev->dev, udev);
 364
 365         error = input_register_device(udev->dev);
 366         if (error)
 367                 goto fail2;
 368
 369         udev->state = UIST_CREATED;
 370
 371         return 0;
 372
 373  fail2: input_ff_destroy(dev);
 374  fail1: uinput_destroy_device(udev);
 375         return error;
 376 }
 377
 378 static int uinput_open(struct inode *inode, struct file *file)
 379 {
 380         struct uinput_device *newdev;
 381
 382         newdev = kzalloc(sizeof(*newdev), GFP_KERNEL);
 383         if (!newdev)
 384                 return -ENOMEM;
 385
 386         mutex_init(&newdev->mutex);
 387         spin_lock_init(&newdev->requests_lock);
 388         init_waitqueue_head(&newdev->requests_waitq);
 389         init_waitqueue_head(&newdev->waitq);
 390         newdev->state = UIST_NEW_DEVICE;
 391
 392         file->private_data = newdev;
 393         stream_open(inode, file);
 394
 395         return 0;
 396 }
 397
 398 static int uinput_validate_absinfo(struct input_dev *dev, unsigned int code,
 399                                    const struct input_absinfo *abs)
 400 {
 401         int min, max, range;
 402
 403         min = abs->minimum;
 404         max = abs->maximum;
 405
 406         if ((min != 0 || max != 0) && max < min) {
 407                 printk(KERN_DEBUG
 408                        "%s: invalid abs[%02x] min:%d max:%d\n",
 409                        UINPUT_NAME, code, min, max);
 410                 return -EINVAL;
 411         }
 412
 413         if (!check_sub_overflow(max, min, &range) && abs->flat > range) {
 414                 printk(KERN_DEBUG
 415                        "%s: abs_flat #%02x out of range: %d (min:%d/max:%d)\n",
 416                        UINPUT_NAME, code, abs->flat, min, max);
 417                 return -EINVAL;
 418         }
 419
 420         /*
 421          * Limit number of contacts to a reasonable value (100). This
 422          * ensures that we need less than 2 pages for struct input_mt
 423          * (we are not using in-kernel slot assignment so not going to
 424          * allocate memory for the "red" table), and we should have no
 425          * trouble getting this much memory.
 426          */
 427         if (code == ABS_MT_SLOT && max > 99) {
 428                 printk(KERN_DEBUG
 429                        "%s: unreasonably large number of slots requested: %d\n",
 430                        UINPUT_NAME, max);
 431                 return -EINVAL;
 432         }
 433
 434         return 0;
 435 }
 436
 437 static int uinput_validate_absbits(struct input_dev *dev)
 438 {
 439         unsigned int cnt;
 440         int error;
 441
 442         if (!test_bit(EV_ABS, dev->evbit))
 443                 return 0;
 444
 445         /*
 446          * Check if absmin/absmax/absfuzz/absflat are sane.
 447          */
 448
 449         for_each_set_bit(cnt, dev->absbit, ABS_CNT) {
 450                 if (!dev->absinfo)
 451                         return -EINVAL;
 452
 453                 error = uinput_validate_absinfo(dev, cnt, &dev->absinfo[cnt]);
 454                 if (error)
 455                         return error;
 456         }
 457
 458         return 0;
 459 }
 460
 461 static int uinput_dev_setup(struct uinput_device *udev,
 462                             struct uinput_setup __user *arg)
 463 {
 464         struct uinput_setup setup;
 465         struct input_dev *dev;
 466
 467         if (udev->state == UIST_CREATED)
 468                 return -EINVAL;
 469
 470         if (copy_from_user(&setup, arg, sizeof(setup)))
 471                 return -EFAULT;
 472
 473         if (!setup.name[0])
 474                 return -EINVAL;
 475
 476         dev = udev->dev;
 477         dev->id = setup.id;
 478         udev->ff_effects_max = setup.ff_effects_max;
 479
 480         kfree(dev->name);
 481         dev->name = kstrndup(setup.name, UINPUT_MAX_NAME_SIZE, GFP_KERNEL);
 482         if (!dev->name)
 483                 return -ENOMEM;
 484
 485         udev->state = UIST_SETUP_COMPLETE;
 486         return 0;
 487 }
 488
 489 static int uinput_abs_setup(struct uinput_device *udev,
 490                             struct uinput_setup __user *arg, size_t size)
 491 {
 492         struct uinput_abs_setup setup = {};
 493         struct input_dev *dev;
 494         int error;
 495
 496         if (size > sizeof(setup))
 497                 return -E2BIG;
 498
 499         if (udev->state == UIST_CREATED)
 500                 return -EINVAL;
 501
 502         if (copy_from_user(&setup, arg, size))
 503                 return -EFAULT;
 504
 505         if (setup.code > ABS_MAX)
 506                 return -ERANGE;
 507
 508         dev = udev->dev;
 509
 510         error = uinput_validate_absinfo(dev, setup.code, &setup.absinfo);
 511         if (error)
 512                 return error;
 513
 514         input_alloc_absinfo(dev);
 515         if (!dev->absinfo)
 516                 return -ENOMEM;
 517
 518         set_bit(setup.code, dev->absbit);
 519         dev->absinfo[setup.code] = setup.absinfo;
 520         return 0;
 521 }
 522
 523 /* legacy setup via write() */
 524 static int uinput_setup_device_legacy(struct uinput_device *udev,
 525                                       const char __user *buffer, size_t count)
 526 {
 527         struct uinput_user_dev  *user_dev;
 528         struct input_dev        *dev;
 529         int                     i;
 530         int                     retval;
 531
 532         if (count != sizeof(struct uinput_user_dev))
 533                 return -EINVAL;
 534
 535         if (!udev->dev) {
 536                 udev->dev = input_allocate_device();
 537                 if (!udev->dev)
 538                         return -ENOMEM;
 539         }
 540
 541         dev = udev->dev;
 542
 543         user_dev = memdup_user(buffer, sizeof(struct uinput_user_dev));
 544         if (IS_ERR(user_dev))
 545                 return PTR_ERR(user_dev);
 546
 547         udev->ff_effects_max = user_dev->ff_effects_max;
 548
 549         /* Ensure name is filled in */
 550         if (!user_dev->name[0]) {
 551                 retval = -EINVAL;
 552                 goto exit;
 553         }
 554
 555         kfree(dev->name);
 556         dev->name = kstrndup(user_dev->name, UINPUT_MAX_NAME_SIZE,
 557                              GFP_KERNEL);
 558         if (!dev->name) {
 559                 retval = -ENOMEM;
 560                 goto exit;
 561         }
 562
 563         dev->id.bustype = user_dev->id.bustype;
 564         dev->id.vendor  = user_dev->id.vendor;
 565         dev->id.product = user_dev->id.product;
 566         dev->id.version = user_dev->id.version;
 567
 568         for (i = 0; i < ABS_CNT; i++) {
 569                 input_abs_set_max(dev, i, user_dev->absmax[i]);
 570                 input_abs_set_min(dev, i, user_dev->absmin[i]);
 571                 input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]);
 572                 input_abs_set_flat(dev, i, user_dev->absflat[i]);
 573         }
 574
 575         retval = uinput_validate_absbits(dev);
 576         if (retval < 0)
 577                 goto exit;
 578
 579         udev->state = UIST_SETUP_COMPLETE;
 580         retval = count;
 581
 582  exit:
 583         kfree(user_dev);
 584         return retval;
 585 }
 586
 587 /*
 588  * Returns true if the given timestamp is valid (i.e., if all the following
 589  * conditions are satisfied), false otherwise.
 590  * 1) given timestamp is positive
 591  * 2) it's within the allowed offset before the current time
 592  * 3) it's not in the future
 593  */
 594 static bool is_valid_timestamp(const ktime_t timestamp)
 595 {
 596         ktime_t zero_time;
 597         ktime_t current_time;
 598         ktime_t min_time;
 599         ktime_t offset;
 600
 601         zero_time = ktime_set(0, 0);
 602         if (ktime_compare(zero_time, timestamp) >= 0)
 603                 return false;
 604
 605         current_time = ktime_get();
 606         offset = ktime_set(UINPUT_TIMESTAMP_ALLOWED_OFFSET_SECS, 0);
 607         min_time = ktime_sub(current_time, offset);
 608
 609         if (ktime_after(min_time, timestamp) || ktime_after(timestamp, current_time))
 610                 return false;
 611
 612         return true;
 613 }
 614
 615 static ssize_t uinput_inject_events(struct uinput_device *udev,
 616                                     const char __user *buffer, size_t count)
 617 {
 618         struct input_event ev;
 619         size_t bytes = 0;
 620         ktime_t timestamp;
 621
 622         if (count != 0 && count < input_event_size())
 623                 return -EINVAL;
 624
 625         while (bytes + input_event_size() <= count) {
 626                 /*
 627                  * Note that even if some events were fetched successfully
 628                  * we are still going to return EFAULT instead of partial
 629                  * count to let userspace know that it got it's buffers
 630                  * all wrong.
 631                  */
 632                 if (input_event_from_user(buffer + bytes, &ev))
 633                         return -EFAULT;
 634
 635                 timestamp = ktime_set(ev.input_event_sec, ev.input_event_usec * NSEC_PER_USEC);
 636                 if (is_valid_timestamp(timestamp))
 637                         input_set_timestamp(udev->dev, timestamp);
 638
 639                 input_event(udev->dev, ev.type, ev.code, ev.value);
 640                 bytes += input_event_size();
 641                 cond_resched();
 642         }
 643
 644         return bytes;
 645 }
 646
 647 static ssize_t uinput_write(struct file *file, const char __user *buffer,
 648                             size_t count, loff_t *ppos)
 649 {
 650         struct uinput_device *udev = file->private_data;
 651         int retval;
 652
 653         if (count == 0)
 654                 return 0;
 655
 656         retval = mutex_lock_interruptible(&udev->mutex);
 657         if (retval)
 658                 return retval;
 659
 660         retval = udev->state == UIST_CREATED ?
 661                         uinput_inject_events(udev, buffer, count) :
 662                         uinput_setup_device_legacy(udev, buffer, count);
 663
 664         mutex_unlock(&udev->mutex);
 665
 666         return retval;
 667 }
 668
 669 static bool uinput_fetch_next_event(struct uinput_device *udev,
 670                                     struct input_event *event)
 671 {
 672         bool have_event;
 673
 674         spin_lock_irq(&udev->dev->event_lock);
 675
 676         have_event = udev->head != udev->tail;
 677         if (have_event) {
 678                 *event = udev->buff[udev->tail];
 679                 udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
 680         }
 681
 682         spin_unlock_irq(&udev->dev->event_lock);
 683
 684         return have_event;
 685 }
 686
 687 static ssize_t uinput_events_to_user(struct uinput_device *udev,
 688                                      char __user *buffer, size_t count)
 689 {
 690         struct input_event event;
 691         size_t read = 0;
 692
 693         while (read + input_event_size() <= count &&
 694                uinput_fetch_next_event(udev, &event)) {
 695
 696                 if (input_event_to_user(buffer + read, &event))
 697                         return -EFAULT;
 698
 699                 read += input_event_size();
 700         }
 701
 702         return read;
 703 }
 704
 705 static ssize_t uinput_read(struct file *file, char __user *buffer,
 706                            size_t count, loff_t *ppos)
 707 {
 708         struct uinput_device *udev = file->private_data;
 709         ssize_t retval;
 710
 711         if (count != 0 && count < input_event_size())
 712                 return -EINVAL;
 713
 714         do {
 715                 retval = mutex_lock_interruptible(&udev->mutex);
 716                 if (retval)
 717                         return retval;
 718
 719                 if (udev->state != UIST_CREATED)
 720                         retval = -ENODEV;
 721                 else if (udev->head == udev->tail &&
 722                          (file->f_flags & O_NONBLOCK))
 723                         retval = -EAGAIN;
 724                 else
 725                         retval = uinput_events_to_user(udev, buffer, count);
 726
 727                 mutex_unlock(&udev->mutex);
 728
 729                 if (retval || count == 0)
 730                         break;
 731
 732                 if (!(file->f_flags & O_NONBLOCK))
 733                         retval = wait_event_interruptible(udev->waitq,
 734                                                   udev->head != udev->tail ||
 735                                                   udev->state != UIST_CREATED);
 736         } while (retval == 0);
 737
 738         return retval;
 739 }
 740
 741 static __poll_t uinput_poll(struct file *file, poll_table *wait)
 742 {
 743         struct uinput_device *udev = file->private_data;
 744         __poll_t mask = EPOLLOUT | EPOLLWRNORM; /* uinput is always writable */
 745
 746         poll_wait(file, &udev->waitq, wait);
 747
 748         if (udev->head != udev->tail)
 749                 mask |= EPOLLIN | EPOLLRDNORM;
 750
 751         return mask;
 752 }
 753
 754 static int uinput_release(struct inode *inode, struct file *file)
 755 {
 756         struct uinput_device *udev = file->private_data;
 757
 758         uinput_destroy_device(udev);
 759         kfree(udev);
 760
 761         return 0;
 762 }
 763
 764 #ifdef CONFIG_COMPAT
 765 struct uinput_ff_upload_compat {
 766         __u32                   request_id;
 767         __s32                   retval;
 768         struct ff_effect_compat effect;
 769         struct ff_effect_compat old;
 770 };
 771
 772 static int uinput_ff_upload_to_user(char __user *buffer,
 773                                     const struct uinput_ff_upload *ff_up)
 774 {
 775         if (in_compat_syscall()) {
 776                 struct uinput_ff_upload_compat ff_up_compat;
 777
 778                 ff_up_compat.request_id = ff_up->request_id;
 779                 ff_up_compat.retval = ff_up->retval;
 780                 /*
 781                  * It so happens that the pointer that gives us the trouble
 782                  * is the last field in the structure. Since we don't support
 783                  * custom waveforms in uinput anyway we can just copy the whole
 784                  * thing (to the compat size) and ignore the pointer.
 785                  */
 786                 memcpy(&ff_up_compat.effect, &ff_up->effect,
 787                         sizeof(struct ff_effect_compat));
 788                 memcpy(&ff_up_compat.old, &ff_up->old,
 789                         sizeof(struct ff_effect_compat));
 790
 791                 if (copy_to_user(buffer, &ff_up_compat,
 792                                  sizeof(struct uinput_ff_upload_compat)))
 793                         return -EFAULT;
 794         } else {
 795                 if (copy_to_user(buffer, ff_up,
 796                                  sizeof(struct uinput_ff_upload)))
 797                         return -EFAULT;
 798         }
 799
 800         return 0;
 801 }
 802
 803 static int uinput_ff_upload_from_user(const char __user *buffer,
 804                                       struct uinput_ff_upload *ff_up)
 805 {
 806         if (in_compat_syscall()) {
 807                 struct uinput_ff_upload_compat ff_up_compat;
 808
 809                 if (copy_from_user(&ff_up_compat, buffer,
 810                                    sizeof(struct uinput_ff_upload_compat)))
 811                         return -EFAULT;
 812
 813                 ff_up->request_id = ff_up_compat.request_id;
 814                 ff_up->retval = ff_up_compat.retval;
 815                 memcpy(&ff_up->effect, &ff_up_compat.effect,
 816                         sizeof(struct ff_effect_compat));
 817                 memcpy(&ff_up->old, &ff_up_compat.old,
 818                         sizeof(struct ff_effect_compat));
 819
 820         } else {
 821                 if (copy_from_user(ff_up, buffer,
 822                                    sizeof(struct uinput_ff_upload)))
 823                         return -EFAULT;
 824         }
 825
 826         return 0;
 827 }
 828
 829 #else
 830
 831 static int uinput_ff_upload_to_user(char __user *buffer,
 832                                     const struct uinput_ff_upload *ff_up)
 833 {
 834         if (copy_to_user(buffer, ff_up, sizeof(struct uinput_ff_upload)))
 835                 return -EFAULT;
 836
 837         return 0;
 838 }
 839
 840 static int uinput_ff_upload_from_user(const char __user *buffer,
 841                                       struct uinput_ff_upload *ff_up)
 842 {
 843         if (copy_from_user(ff_up, buffer, sizeof(struct uinput_ff_upload)))
 844                 return -EFAULT;
 845
 846         return 0;
 847 }
 848
 849 #endif
 850
 851 #define uinput_set_bit(_arg, _bit, _max)                \
 852 ({                                                      \
 853         int __ret = 0;                                  \
 854         if (udev->state == UIST_CREATED)                \
 855                 __ret =  -EINVAL;                       \
 856         else if ((_arg) > (_max))                       \
 857                 __ret = -EINVAL;                        \
 858         else set_bit((_arg), udev->dev->_bit);          \
 859         __ret;                                          \
 860 })
 861
 862 static int uinput_str_to_user(void __user *dest, const char *str,
 863                               unsigned int maxlen)
 864 {
 865         char __user *p = dest;
 866         int len, ret;
 867
 868         if (!str)
 869                 return -ENOENT;
 870
 871         if (maxlen == 0)
 872                 return -EINVAL;
 873
 874         len = strlen(str) + 1;
 875         if (len > maxlen)
 876                 len = maxlen;
 877
 878         ret = copy_to_user(p, str, len);
 879         if (ret)
 880                 return -EFAULT;
 881
 882         /* force terminating '\0' */
 883         ret = put_user(0, p + len - 1);
 884         return ret ? -EFAULT : len;
 885 }
 886
 887 static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
 888                                  unsigned long arg, void __user *p)
 889 {
 890         int                     retval;
 891         struct uinput_device    *udev = file->private_data;
 892         struct uinput_ff_upload ff_up;
 893         struct uinput_ff_erase  ff_erase;
 894         struct uinput_request   *req;
 895         char                    *phys;
 896         const char              *name;
 897         unsigned int            size;
 898
 899         retval = mutex_lock_interruptible(&udev->mutex);
 900         if (retval)
 901                 return retval;
 902
 903         if (!udev->dev) {
 904                 udev->dev = input_allocate_device();
 905                 if (!udev->dev) {
 906                         retval = -ENOMEM;
 907                         goto out;
 908                 }
 909         }
 910
 911         switch (cmd) {
 912         case UI_GET_VERSION:
 913                 if (put_user(UINPUT_VERSION, (unsigned int __user *)p))
 914                         retval = -EFAULT;
 915                 goto out;
 916
 917         case UI_DEV_CREATE:
 918                 retval = uinput_create_device(udev);
 919                 goto out;
 920
 921         case UI_DEV_DESTROY:
 922                 uinput_destroy_device(udev);
 923                 goto out;
 924
 925         case UI_DEV_SETUP:
 926                 retval = uinput_dev_setup(udev, p);
 927                 goto out;
 928
 929         /* UI_ABS_SETUP is handled in the variable size ioctls */
 930
 931         case UI_SET_EVBIT:
 932                 retval = uinput_set_bit(arg, evbit, EV_MAX);
 933                 goto out;
 934
 935         case UI_SET_KEYBIT:
 936                 retval = uinput_set_bit(arg, keybit, KEY_MAX);
 937                 goto out;
 938
 939         case UI_SET_RELBIT:
 940                 retval = uinput_set_bit(arg, relbit, REL_MAX);
 941                 goto out;
 942
 943         case UI_SET_ABSBIT:
 944                 retval = uinput_set_bit(arg, absbit, ABS_MAX);
 945                 goto out;
 946
 947         case UI_SET_MSCBIT:
 948                 retval = uinput_set_bit(arg, mscbit, MSC_MAX);
 949                 goto out;
 950
 951         case UI_SET_LEDBIT:
 952                 retval = uinput_set_bit(arg, ledbit, LED_MAX);
 953                 goto out;
 954
 955         case UI_SET_SNDBIT:
 956                 retval = uinput_set_bit(arg, sndbit, SND_MAX);
 957                 goto out;
 958
 959         case UI_SET_FFBIT:
 960                 retval = uinput_set_bit(arg, ffbit, FF_MAX);
 961                 goto out;
 962
 963         case UI_SET_SWBIT:
 964                 retval = uinput_set_bit(arg, swbit, SW_MAX);
 965                 goto out;
 966
 967         case UI_SET_PROPBIT:
 968                 retval = uinput_set_bit(arg, propbit, INPUT_PROP_MAX);
 969                 goto out;
 970
 971         case UI_SET_PHYS:
 972                 if (udev->state == UIST_CREATED) {
 973                         retval = -EINVAL;
 974                         goto out;
 975                 }
 976
 977                 phys = strndup_user(p, 1024);
 978                 if (IS_ERR(phys)) {
 979                         retval = PTR_ERR(phys);
 980                         goto out;
 981                 }
 982
 983                 kfree(udev->dev->phys);
 984                 udev->dev->phys = phys;
 985                 goto out;
 986
 987         case UI_BEGIN_FF_UPLOAD:
 988                 retval = uinput_ff_upload_from_user(p, &ff_up);
 989                 if (retval)
 990                         goto out;
 991
 992                 req = uinput_request_find(udev, ff_up.request_id);
 993                 if (!req || req->code != UI_FF_UPLOAD ||
 994                     !req->u.upload.effect) {
 995                         retval = -EINVAL;
 996                         goto out;
 997                 }
 998
 999                 ff_up.retval = 0;
1000                 ff_up.effect = *req->u.upload.effect;
1001                 if (req->u.upload.old)
1002                         ff_up.old = *req->u.upload.old;
1003                 else
1004                         memset(&ff_up.old, 0, sizeof(struct ff_effect));
1005
1006                 retval = uinput_ff_upload_to_user(p, &ff_up);
1007                 goto out;
1008
1009         case UI_BEGIN_FF_ERASE:
1010                 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
1011                         retval = -EFAULT;
1012                         goto out;
1013                 }
1014
1015                 req = uinput_request_find(udev, ff_erase.request_id);
1016                 if (!req || req->code != UI_FF_ERASE) {
1017                         retval = -EINVAL;
1018                         goto out;
1019                 }
1020
1021                 ff_erase.retval = 0;
1022                 ff_erase.effect_id = req->u.effect_id;
1023                 if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) {
1024                         retval = -EFAULT;
1025                         goto out;
1026                 }
1027
1028                 goto out;
1029
1030         case UI_END_FF_UPLOAD:
1031                 retval = uinput_ff_upload_from_user(p, &ff_up);
1032                 if (retval)
1033                         goto out;
1034
1035                 req = uinput_request_find(udev, ff_up.request_id);
1036                 if (!req || req->code != UI_FF_UPLOAD ||
1037                     !req->u.upload.effect) {
1038                         retval = -EINVAL;
1039                         goto out;
1040                 }
1041
1042                 req->retval = ff_up.retval;
1043                 complete(&req->done);
1044                 goto out;
1045
1046         case UI_END_FF_ERASE:
1047                 if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
1048                         retval = -EFAULT;
1049                         goto out;
1050                 }
1051
1052                 req = uinput_request_find(udev, ff_erase.request_id);
1053                 if (!req || req->code != UI_FF_ERASE) {
1054                         retval = -EINVAL;
1055                         goto out;
1056                 }
1057
1058                 req->retval = ff_erase.retval;
1059                 complete(&req->done);
1060                 goto out;
1061         }
1062
1063         size = _IOC_SIZE(cmd);
1064
1065         /* Now check variable-length commands */
1066         switch (cmd & ~IOCSIZE_MASK) {
1067         case UI_GET_SYSNAME(0):
1068                 if (udev->state != UIST_CREATED) {
1069                         retval = -ENOENT;
1070                         goto out;
1071                 }
1072                 name = dev_name(&udev->dev->dev);
1073                 retval = uinput_str_to_user(p, name, size);
1074                 goto out;
1075
1076         case UI_ABS_SETUP & ~IOCSIZE_MASK:
1077                 retval = uinput_abs_setup(udev, p, size);
1078                 goto out;
1079         }
1080
1081         retval = -EINVAL;
1082  out:
1083         mutex_unlock(&udev->mutex);
1084         return retval;
1085 }
1086
1087 static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1088 {
1089         return uinput_ioctl_handler(file, cmd, arg, (void __user *)arg);
1090 }
1091
1092 #ifdef CONFIG_COMPAT
1093
1094 /*
1095  * These IOCTLs change their size and thus their numbers between
1096  * 32 and 64 bits.
1097  */
1098 #define UI_SET_PHYS_COMPAT              \
1099         _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t)
1100 #define UI_BEGIN_FF_UPLOAD_COMPAT       \
1101         _IOWR(UINPUT_IOCTL_BASE, 200, struct uinput_ff_upload_compat)
1102 #define UI_END_FF_UPLOAD_COMPAT         \
1103         _IOW(UINPUT_IOCTL_BASE, 201, struct uinput_ff_upload_compat)
1104
1105 static long uinput_compat_ioctl(struct file *file,
1106                                 unsigned int cmd, unsigned long arg)
1107 {
1108         switch (cmd) {
1109         case UI_SET_PHYS_COMPAT:
1110                 cmd = UI_SET_PHYS;
1111                 break;
1112         case UI_BEGIN_FF_UPLOAD_COMPAT:
1113                 cmd = UI_BEGIN_FF_UPLOAD;
1114                 break;
1115         case UI_END_FF_UPLOAD_COMPAT:
1116                 cmd = UI_END_FF_UPLOAD;
1117                 break;
1118         }
1119
1120         return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg));
1121 }
1122 #endif
1123
1124 static const struct file_operations uinput_fops = {
1125         .owner          = THIS_MODULE,
1126         .open           = uinput_open,
1127         .release        = uinput_release,
1128         .read           = uinput_read,
1129         .write          = uinput_write,
1130         .poll           = uinput_poll,
1131         .unlocked_ioctl = uinput_ioctl,
1132 #ifdef CONFIG_COMPAT
1133         .compat_ioctl   = uinput_compat_ioctl,
1134 #endif
1135 };
1136
1137 static struct miscdevice uinput_misc = {
1138         .fops           = &uinput_fops,
1139         .minor          = UINPUT_MINOR,
1140         .name           = UINPUT_NAME,
1141 };
1142 module_misc_device(uinput_misc);
1143
1144 MODULE_ALIAS_MISCDEV(UINPUT_MINOR);
1145 MODULE_ALIAS("devname:" UINPUT_NAME);
1146
1147 MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
1148 MODULE_DESCRIPTION("User level driver support for input subsystem");
1149 MODULE_LICENSE("GPL");