cregit-Linux how code gets into the kernel

Release 4.11 drivers/input/misc/uinput.c

/*
 *  User level driver support for input subsystem
 *
 * Heavily based on evdev.c by Vojtech Pavlik
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
 *
 * Changes/Revisions:
 *      0.4     01/09/2014 (Benjamin Tissoires <benjamin.tissoires@redhat.com>)
 *              - add UI_GET_SYSNAME ioctl
 *      0.3     09/04/2006 (Anssi Hannula <anssi.hannula@gmail.com>)
 *              - updated ff support for the changes in kernel interface
 *              - added MODULE_VERSION
 *      0.2     16/10/2004 (Micah Dowty <micah@navi.cx>)
 *              - added force feedback support
 *              - added UI_SET_PHYS
 *      0.1     20/06/2002
 *              - first public version
 */
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/uinput.h>
#include <linux/input/mt.h>
#include "../input-compat.h"


static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { struct uinput_device *udev = input_get_drvdata(dev); udev->buff[udev->head].type = type; udev->buff[udev->head].code = code; udev->buff[udev->head].value = value; do_gettimeofday(&udev->buff[udev->head].time); udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE; wake_up_interruptible(&udev->waitq); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Vojtech Pavlik9282.88%133.33%
Neil Brown1412.61%133.33%
Dmitry Torokhov54.50%133.33%
Total111100.00%3100.00%

/* Atomically allocate an ID for the given request. Returns 0 on success. */
static bool uinput_request_alloc_id(struct uinput_device *udev, struct uinput_request *request) { unsigned int id; bool reserved = false; spin_lock(&udev->requests_lock); for (id = 0; id < UINPUT_NUM_REQUESTS; id++) { if (!udev->requests[id]) { request->id = id; udev->requests[id] = request; reserved = true; break; } } spin_unlock(&udev->requests_lock); return reserved; }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty3538.46%112.50%
Vojtech Pavlik2628.57%112.50%
Dmitry Torokhov2527.47%450.00%
Zach Welch33.30%112.50%
Aristeu Sergio Rozanski Filho22.20%112.50%
Total91100.00%8100.00%


static struct uinput_request *uinput_request_find(struct uinput_device *udev, unsigned int id) { /* Find an input request, by ID. Returns NULL if the ID isn't valid. */ if (id >= UINPUT_NUM_REQUESTS) return NULL; return udev->requests[id]; }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty1954.29%133.33%
Vojtech Pavlik1542.86%133.33%
Dmitry Torokhov12.86%133.33%
Total35100.00%3100.00%


static int uinput_request_reserve_slot(struct uinput_device *udev, struct uinput_request *request) { /* Allocate slot. If none are available right away, wait. */ return wait_event_interruptible(udev->requests_waitq, uinput_request_alloc_id(udev, request)); }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov1546.88%133.33%
Vojtech Pavlik1237.50%133.33%
Micah Dowty515.62%133.33%
Total32100.00%3100.00%


static void uinput_request_done(struct uinput_device *udev, struct uinput_request *request) { /* Mark slot as available */ udev->requests[request->id] = NULL; wake_up(&udev->requests_waitq); complete(&request->done); }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov3375.00%360.00%
Micah Dowty715.91%120.00%
Vojtech Pavlik49.09%120.00%
Total44100.00%5100.00%


static int uinput_request_send(struct uinput_device *udev, struct uinput_request *request) { int retval; retval = mutex_lock_interruptible(&udev->mutex); if (retval) return retval; if (udev->state != UIST_CREATED) { retval = -ENODEV; goto out; } init_completion(&request->done); /* * Tell our userspace application about this new request * by queueing an input event. */ uinput_dev_event(udev->dev, EV_UINPUT, request->code, request->id); out: mutex_unlock(&udev->mutex); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho5053.76%116.67%
Micah Dowty2425.81%116.67%
Dmitry Torokhov1313.98%350.00%
Vojtech Pavlik66.45%116.67%
Total93100.00%6100.00%


static int uinput_request_submit(struct uinput_device *udev, struct uinput_request *request) { int error; error = uinput_request_reserve_slot(udev, request); if (error) return error; error = uinput_request_send(udev, request); if (error) { uinput_request_done(udev, request); return error; } wait_for_completion(&request->done); return request->retval; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov73100.00%1100.00%
Total73100.00%1100.00%

/* * Fail all outstanding requests so handlers don't wait for the userspace * to finish processing them. */
static void uinput_flush_requests(struct uinput_device *udev) { struct uinput_request *request; int i; spin_lock(&udev->requests_lock); for (i = 0; i < UINPUT_NUM_REQUESTS; i++) { request = udev->requests[i]; if (request) { request->retval = -ENODEV; uinput_request_done(udev, request); } } spin_unlock(&udev->requests_lock); }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho7594.94%125.00%
Micah Dowty22.53%125.00%
Dmitry Torokhov11.27%125.00%
Vojtech Pavlik11.27%125.00%
Total79100.00%4100.00%


static void uinput_dev_set_gain(struct input_dev *dev, u16 gain) { uinput_dev_event(dev, EV_FF, FF_GAIN, gain); }

Contributors

PersonTokensPropCommitsCommitProp
Anssi Hannula25100.00%1100.00%
Total25100.00%1100.00%


static void uinput_dev_set_autocenter(struct input_dev *dev, u16 magnitude) { uinput_dev_event(dev, EV_FF, FF_AUTOCENTER, magnitude); }

Contributors

PersonTokensPropCommitsCommitProp
Anssi Hannula25100.00%1100.00%
Total25100.00%1100.00%


static int uinput_dev_playback(struct input_dev *dev, int effect_id, int value) { return uinput_dev_event(dev, EV_FF, effect_id, value); }

Contributors

PersonTokensPropCommitsCommitProp
Anssi Hannula29100.00%1100.00%
Total29100.00%1100.00%


static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old) { struct uinput_device *udev = input_get_drvdata(dev); struct uinput_request request; /* * uinput driver does not currently support periodic effects with * custom waveform since it does not have a way to pass buffer of * samples (custom_data) to userspace. If ever there is a device * supporting custom waveforms we would need to define an additional * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out. */ if (effect->type == FF_PERIODIC && effect->u.periodic.waveform == FF_CUSTOM) return -EINVAL; request.code = UI_FF_UPLOAD; request.u.upload.effect = effect; request.u.upload.old = old; return uinput_request_submit(udev, &request); }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale2324.73%112.50%
Micah Dowty1819.35%112.50%
Anssi Hannula1718.28%112.50%
Aristeu Sergio Rozanski Filho1212.90%112.50%
Dmitry Torokhov1212.90%337.50%
Zach Welch1111.83%112.50%
Total93100.00%8100.00%


static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id) { struct uinput_device *udev = input_get_drvdata(dev); struct uinput_request request; if (!test_bit(EV_FF, dev->evbit)) return -ENOSYS; request.code = UI_FF_ERASE; request.u.effect_id = effect_id; return uinput_request_submit(udev, &request); }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty3450.75%116.67%
Aristeu Sergio Rozanski Filho1217.91%116.67%
Dmitry Torokhov1217.91%350.00%
Zach Welch913.43%116.67%
Total67100.00%6100.00%


static void uinput_destroy_device(struct uinput_device *udev) { const char *name, *phys; struct input_dev *dev = udev->dev; enum uinput_state old_state = udev->state; udev->state = UIST_NEW_DEVICE; if (dev) { name = dev->name; phys = dev->phys; if (old_state == UIST_CREATED) { uinput_flush_requests(udev); input_unregister_device(dev); } else { input_free_device(dev); } kfree(name); kfree(phys); udev->dev = NULL; } }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov3837.25%116.67%
Aristeu Sergio Rozanski Filho3332.35%116.67%
Micah Dowty2019.61%116.67%
Vojtech Pavlik76.86%116.67%
Zach Welch21.96%116.67%
Randy Dunlap21.96%116.67%
Total102100.00%6100.00%


static int uinput_create_device(struct uinput_device *udev) { struct input_dev *dev = udev->dev; int error, nslot; if (udev->state != UIST_SETUP_COMPLETE) { printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME); return -EINVAL; } if (test_bit(EV_ABS, dev->evbit)) { input_alloc_absinfo(dev); if (!dev->absinfo) { error = -EINVAL; goto fail1; } if (test_bit(ABS_MT_SLOT, dev->absbit)) { nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1; error = input_mt_init_slots(dev, nslot, 0); if (error) goto fail1; } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { input_set_events_per_packet(dev, 60); } } if (test_bit(EV_FF, dev->evbit) && !udev->ff_effects_max) { printk(KERN_DEBUG "%s: ff_effects_max should be non-zero when FF_BIT is set\n", UINPUT_NAME); error = -EINVAL; goto fail1; } if (udev->ff_effects_max) { error = input_ff_create(dev, udev->ff_effects_max); if (error) goto fail1; dev->ff->upload = uinput_dev_upload_effect; dev->ff->erase = uinput_dev_erase_effect; dev->ff->playback = uinput_dev_playback; dev->ff->set_gain = uinput_dev_set_gain; dev->ff->set_autocenter = uinput_dev_set_autocenter; } error = input_register_device(udev->dev); if (error) goto fail2; udev->state = UIST_CREATED; return 0; fail2: input_ff_destroy(dev); fail1: uinput_destroy_device(udev); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Anssi Hannula9232.06%112.50%
David Herrmann6522.65%112.50%
Dmitry Torokhov5519.16%225.00%
Elias Vanderstuyft3411.85%112.50%
Micah Dowty3411.85%112.50%
Randy Dunlap62.09%112.50%
Vojtech Pavlik10.35%112.50%
Total287100.00%8100.00%


static int uinput_open(struct inode *inode, struct file *file) { struct uinput_device *newdev; newdev = kzalloc(sizeof(struct uinput_device), GFP_KERNEL); if (!newdev) return -ENOMEM; mutex_init(&newdev->mutex); spin_lock_init(&newdev->requests_lock); init_waitqueue_head(&newdev->requests_waitq); init_waitqueue_head(&newdev->waitq); newdev->state = UIST_NEW_DEVICE; file->private_data = newdev; nonseekable_open(inode, file); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty4748.45%112.50%
Dmitry Torokhov2525.77%450.00%
Vojtech Pavlik1818.56%112.50%
Zach Welch55.15%112.50%
Randy Dunlap22.06%112.50%
Total97100.00%8100.00%


static int uinput_validate_absinfo(struct input_dev *dev, unsigned int code, const struct input_absinfo *abs) { int min, max; min = abs->minimum; max = abs->maximum; if ((min != 0 || max != 0) && max <= min) { printk(KERN_DEBUG "%s: invalid abs[%02x] min:%d max:%d\n", UINPUT_NAME, code, min, max); return -EINVAL; } if (abs->flat > max - min) { printk(KERN_DEBUG "%s: abs_flat #%02x out of range: %d (min:%d/max:%d)\n", UINPUT_NAME, code, abs->flat, min, max); return -EINVAL; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
David Herrmann4036.04%228.57%
Micah Dowty3027.03%114.29%
Peter Hutterer2623.42%114.29%
Vojtech Pavlik1210.81%228.57%
Daniel Mack32.70%114.29%
Total111100.00%7100.00%


static int uinput_validate_absbits(struct input_dev *dev) { unsigned int cnt; int error; if (!test_bit(EV_ABS, dev->evbit)) return 0; /* * Check if absmin/absmax/absfuzz/absflat are sane. */ for_each_set_bit(cnt, dev->absbit, ABS_CNT) { if (!dev->absinfo) return -EINVAL; error = uinput_validate_absinfo(dev, cnt, &dev->absinfo[cnt]); if (error) return error; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
David Herrmann7895.12%240.00%
Zach Welch22.44%120.00%
Vojtech Pavlik11.22%120.00%
Micah Dowty11.22%120.00%
Total82100.00%5100.00%


static int uinput_allocate_device(struct uinput_device *udev) { udev->dev = input_allocate_device(); if (!udev->dev) return -ENOMEM; udev->dev->event = uinput_dev_event; input_set_drvdata(udev->dev, udev); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov3265.31%250.00%
Vojtech Pavlik1020.41%125.00%
Micah Dowty714.29%125.00%
Total49100.00%4100.00%


static int uinput_dev_setup(struct uinput_device *udev, struct uinput_setup __user *arg) { struct uinput_setup setup; struct input_dev *dev; if (udev->state == UIST_CREATED) return -EINVAL; if (copy_from_user(&setup, arg, sizeof(setup))) return -EFAULT; if (!setup.name[0]) return -EINVAL; dev = udev->dev; dev->id = setup.id; udev->ff_effects_max = setup.ff_effects_max; kfree(dev->name); dev->name = kstrndup(setup.name, UINPUT_MAX_NAME_SIZE, GFP_KERNEL); if (!dev->name) return -ENOMEM; udev->state = UIST_SETUP_COMPLETE; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Benjamin Tissoires13398.52%150.00%
Dmitry Torokhov21.48%150.00%
Total135100.00%2100.00%


static int uinput_abs_setup(struct uinput_device *udev, struct uinput_setup __user *arg, size_t size) { struct uinput_abs_setup setup = {}; struct input_dev *dev; int error; if (size > sizeof(setup)) return -E2BIG; if (udev->state == UIST_CREATED) return -EINVAL; if (copy_from_user(&setup, arg, size)) return -EFAULT; if (setup.code > ABS_MAX) return -ERANGE; dev = udev->dev; error = uinput_validate_absinfo(dev, setup.code, &setup.absinfo); if (error) return error; input_alloc_absinfo(dev); if (!dev->absinfo) return -ENOMEM; set_bit(setup.code, dev->absbit); dev->absinfo[setup.code] = setup.absinfo; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Benjamin Tissoires13383.65%150.00%
David Herrmann2616.35%150.00%
Total159100.00%2100.00%

/* legacy setup via write() */
static int uinput_setup_device_legacy(struct uinput_device *udev, const char __user *buffer, size_t count) { struct uinput_user_dev *user_dev; struct input_dev *dev; int i; int retval; if (count != sizeof(struct uinput_user_dev)) return -EINVAL; if (!udev->dev) { retval = uinput_allocate_device(udev); if (retval) return retval; } dev = udev->dev; user_dev = memdup_user(buffer, sizeof(struct uinput_user_dev)); if (IS_ERR(user_dev)) return PTR_ERR(user_dev); udev->ff_effects_max = user_dev->ff_effects_max; /* Ensure name is filled in */ if (!user_dev->name[0]) { retval = -EINVAL; goto exit; } kfree(dev->name); dev->name = kstrndup(user_dev->name, UINPUT_MAX_NAME_SIZE, GFP_KERNEL); if (!dev->name) { retval = -ENOMEM; goto exit; } dev->id.bustype = user_dev->id.bustype; dev->id.vendor = user_dev->id.vendor; dev->id.product = user_dev->id.product; dev->id.version = user_dev->id.version; for (i = 0; i < ABS_CNT; i++) { input_abs_set_max(dev, i, user_dev->absmax[i]); input_abs_set_min(dev, i, user_dev->absmin[i]); input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]); input_abs_set_flat(dev, i, user_dev->absflat[i]); } retval = uinput_validate_absbits(dev); if (retval < 0) goto exit; udev->state = UIST_SETUP_COMPLETE; retval = count; exit: kfree(user_dev); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov13741.77%440.00%
Micah Dowty13641.46%110.00%
Daniel Mack278.23%110.00%
David Herrmann154.57%110.00%
Anssi Hannula82.44%110.00%
Benjamin Tissoires30.91%110.00%
Ian Campbell20.61%110.00%
Total328100.00%10100.00%


static ssize_t uinput_inject_events(struct uinput_device *udev, const char __user *buffer, size_t count) { struct input_event ev; size_t bytes = 0; if (count != 0 && count < input_event_size()) return -EINVAL; while (bytes + input_event_size() <= count) { /* * Note that even if some events were fetched successfully * we are still going to return EFAULT instead of partial * count to let userspace know that it got it's buffers * all wrong. */ if (input_event_from_user(buffer + bytes, &ev)) return -EFAULT; input_event(udev->dev, ev.type, ev.code, ev.value); bytes += input_event_size(); } return bytes; }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty5252.53%125.00%
Ryan Mallon2929.29%125.00%
Dmitry Torokhov1010.10%125.00%
Philip Langdale88.08%125.00%
Total99100.00%4100.00%


static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) { struct uinput_device *udev = file->private_data; int retval; if (count == 0) return 0; retval = mutex_lock_interruptible(&udev->mutex); if (retval) return retval; retval = udev->state == UIST_CREATED ? uinput_inject_events(udev, buffer, count) : uinput_setup_device_legacy(udev, buffer, count); mutex_unlock(&udev->mutex); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov8585.86%350.00%
Micah Dowty1212.12%116.67%
Ryan Mallon11.01%116.67%
Benjamin Tissoires11.01%116.67%
Total99100.00%6100.00%


static bool uinput_fetch_next_event(struct uinput_device *udev, struct input_event *event) { bool have_event; spin_lock_irq(&udev->dev->event_lock); have_event = udev->head != udev->tail; if (have_event) { *event = udev->buff[udev->tail]; udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE; } spin_unlock_irq(&udev->dev->event_lock); return have_event; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov84100.00%1100.00%
Total84100.00%1100.00%


static ssize_t uinput_events_to_user(struct uinput_device *udev, char __user *buffer, size_t count) { struct input_event event; size_t read = 0; while (read + input_event_size() <= count && uinput_fetch_next_event(udev, &event)) { if (input_event_to_user(buffer + read, &event)) return -EFAULT; read += input_event_size(); } return read; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov71100.00%2100.00%
Total71100.00%2100.00%


static ssize_t uinput_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos) { struct uinput_device *udev = file->private_data; ssize_t retval; if (count != 0 && count < input_event_size()) return -EINVAL; do { retval = mutex_lock_interruptible(&udev->mutex); if (retval) return retval; if (udev->state != UIST_CREATED) retval = -ENODEV; else if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK)) retval = -EAGAIN; else retval = uinput_events_to_user(udev, buffer, count); mutex_unlock(&udev->mutex); if (retval || count == 0) break; if (!(file->f_flags & O_NONBLOCK)) retval = wait_event_interruptible(udev->waitq, udev->head != udev->tail || udev->state != UIST_CREATED); } while (retval == 0); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov8748.33%466.67%
Micah Dowty7843.33%116.67%
David Herrmann158.33%116.67%
Total180100.00%6100.00%


static unsigned int uinput_poll(struct file *file, poll_table *wait) { struct uinput_device *udev = file->private_data; poll_wait(file, &udev->waitq, wait); if (udev->head != udev->tail) return POLLIN | POLLRDNORM; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty4887.27%150.00%
Vojtech Pavlik712.73%150.00%
Total55100.00%2100.00%


static int uinput_release(struct inode *inode, struct file *file) { struct uinput_device *udev = file->private_data; uinput_destroy_device(udev); kfree(udev); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov2052.63%250.00%
Micah Dowty1334.21%125.00%
Vojtech Pavlik513.16%125.00%
Total38100.00%4100.00%

#ifdef CONFIG_COMPAT struct uinput_ff_upload_compat { __u32 request_id; __s32 retval; struct ff_effect_compat effect; struct ff_effect_compat old; };
static int uinput_ff_upload_to_user(char __user *buffer, const struct uinput_ff_upload *ff_up) { if (in_compat_syscall()) { struct uinput_ff_upload_compat ff_up_compat; ff_up_compat.request_id = ff_up->request_id; ff_up_compat.retval = ff_up->retval; /* * It so happens that the pointer that gives us the trouble * is the last field in the structure. Since we don't support * custom waveforms in uinput anyway we can just copy the whole * thing (to the compat size) and ignore the pointer. */ memcpy(&ff_up_compat.effect, &ff_up->effect, sizeof(struct ff_effect_compat)); memcpy(&ff_up_compat.old, &ff_up->old, sizeof(struct ff_effect_compat)); if (copy_to_user(buffer, &ff_up_compat, sizeof(struct uinput_ff_upload_compat))) return -EFAULT; } else { if (copy_to_user(buffer, ff_up, sizeof(struct uinput_ff_upload))) return -EFAULT; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale9876.56%116.67%
Micah Dowty1310.16%116.67%
Dmitry Torokhov107.81%116.67%
Zach Welch43.12%116.67%
Andrew Morton21.56%116.67%
Vojtech Pavlik10.78%116.67%
Total128100.00%6100.00%


static int uinput_ff_upload_from_user(const char __user *buffer, struct uinput_ff_upload *ff_up) { if (in_compat_syscall()) { struct uinput_ff_upload_compat ff_up_compat; if (copy_from_user(&ff_up_compat, buffer, sizeof(struct uinput_ff_upload_compat))) return -EFAULT; ff_up->request_id = ff_up_compat.request_id; ff_up->retval = ff_up_compat.retval; memcpy(&ff_up->effect, &ff_up_compat.effect, sizeof(struct ff_effect_compat)); memcpy(&ff_up->old, &ff_up_compat.old, sizeof(struct ff_effect_compat)); } else { if (copy_from_user(ff_up, buffer, sizeof(struct uinput_ff_upload))) return -EFAULT; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale12598.43%150.00%
Andrew Morton21.57%150.00%
Total127100.00%2100.00%

#else
static int uinput_ff_upload_to_user(char __user *buffer, const struct uinput_ff_upload *ff_up) { if (copy_to_user(buffer, ff_up, sizeof(struct uinput_ff_upload))) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale39100.00%1100.00%
Total39100.00%1100.00%


static int uinput_ff_upload_from_user(const char __user *buffer, struct uinput_ff_upload *ff_up) { if (copy_from_user(ff_up, buffer, sizeof(struct uinput_ff_upload))) return -EFAULT; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale39100.00%1100.00%
Total39100.00%1100.00%

#endif #define uinput_set_bit(_arg, _bit, _max) \ ({ \ int __ret = 0; \ if (udev->state == UIST_CREATED) \ __ret = -EINVAL; \ else if ((_arg) > (_max)) \ __ret = -EINVAL; \ else set_bit((_arg), udev->dev->_bit); \ __ret; \ })
static int uinput_str_to_user(void __user *dest, const char *str, unsigned int maxlen) { char __user *p = dest; int len, ret; if (!str) return -ENOENT; if (maxlen == 0) return -EINVAL; len = strlen(str) + 1; if (len > maxlen) len = maxlen; ret = copy_to_user(p, str, len); if (ret) return -EFAULT; /* force terminating '\0' */ ret = put_user(0, p + len - 1); return ret ? -EFAULT : len; }

Contributors

PersonTokensPropCommitsCommitProp
Benjamin Tissoires111100.00%1100.00%
Total111100.00%1100.00%


static long uinput_ioctl_handler(struct file *file, unsigned int cmd, unsigned long arg, void __user *p) { int retval; struct uinput_device *udev = file->private_data; struct uinput_ff_upload ff_up; struct uinput_ff_erase ff_erase; struct uinput_request *req; char *phys; const char *name; unsigned int size; retval = mutex_lock_interruptible(&udev->mutex); if (retval) return retval; if (!udev->dev) { retval = uinput_allocate_device(udev); if (retval) goto out; } switch (cmd) { case UI_GET_VERSION: if (put_user(UINPUT_VERSION, (unsigned int __user *)p)) retval = -EFAULT; goto out; case UI_DEV_CREATE: retval = uinput_create_device(udev); goto out; case UI_DEV_DESTROY: uinput_destroy_device(udev); goto out; case UI_DEV_SETUP: retval = uinput_dev_setup(udev, p); goto out; /* UI_ABS_SETUP is handled in the variable size ioctls */ case UI_SET_EVBIT: retval = uinput_set_bit(arg, evbit, EV_MAX); goto out; case UI_SET_KEYBIT: retval = uinput_set_bit(arg, keybit, KEY_MAX); goto out; case UI_SET_RELBIT: retval = uinput_set_bit(arg, relbit, REL_MAX); goto out; case UI_SET_ABSBIT: retval = uinput_set_bit(arg, absbit, ABS_MAX); goto out; case UI_SET_MSCBIT: retval = uinput_set_bit(arg, mscbit, MSC_MAX); goto out; case UI_SET_LEDBIT: retval = uinput_set_bit(arg, ledbit, LED_MAX); goto out; case UI_SET_SNDBIT: retval = uinput_set_bit(arg, sndbit, SND_MAX); goto out; case UI_SET_FFBIT: retval = uinput_set_bit(arg, ffbit, FF_MAX); goto out; case UI_SET_SWBIT: retval = uinput_set_bit(arg, swbit, SW_MAX); goto out; case UI_SET_PROPBIT: retval = uinput_set_bit(arg, propbit, INPUT_PROP_MAX); goto out; case UI_SET_PHYS: if (udev->state == UIST_CREATED) { retval = -EINVAL; goto out; } phys = strndup_user(p, 1024); if (IS_ERR(phys)) { retval = PTR_ERR(phys); goto out; } kfree(udev->dev->phys); udev->dev->phys = phys; goto out; case UI_BEGIN_FF_UPLOAD: retval = uinput_ff_upload_from_user(p, &ff_up); if (retval) goto out; req = uinput_request_find(udev, ff_up.request_id); if (!req || req->code != UI_FF_UPLOAD || !req->u.upload.effect) { retval = -EINVAL; goto out; } ff_up.retval = 0; ff_up.effect = *req->u.upload.effect; if (req->u.upload.old) ff_up.old = *req->u.upload.old; else memset(&ff_up.old, 0, sizeof(struct ff_effect)); retval = uinput_ff_upload_to_user(p, &ff_up); goto out; case UI_BEGIN_FF_ERASE: if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) { retval = -EFAULT; goto out; } req = uinput_request_find(udev, ff_erase.request_id); if (!req || req->code != UI_FF_ERASE) { retval = -EINVAL; goto out; } ff_erase.retval = 0; ff_erase.effect_id = req->u.effect_id; if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) { retval = -EFAULT; goto out; } goto out; case UI_END_FF_UPLOAD: retval = uinput_ff_upload_from_user(p, &ff_up); if (retval) goto out; req = uinput_request_find(udev, ff_up.request_id); if (!req || req->code != UI_FF_UPLOAD || !req->u.upload.effect) { retval = -EINVAL; goto out; } req->retval = ff_up.retval; uinput_request_done(udev, req); goto out; case UI_END_FF_ERASE: if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) { retval = -EFAULT; goto out; } req = uinput_request_find(udev, ff_erase.request_id); if (!req || req->code != UI_FF_ERASE) { retval = -EINVAL; goto out; } req->retval = ff_erase.retval; uinput_request_done(udev, req); goto out; } size = _IOC_SIZE(cmd); /* Now check variable-length commands */ switch (cmd & ~IOCSIZE_MASK) { case UI_GET_SYSNAME(0): if (udev->state != UIST_CREATED) { retval = -ENOENT; goto out; } name = dev_name(&udev->dev->dev); retval = uinput_str_to_user(p, name, size); goto out; case UI_ABS_SETUP & ~IOCSIZE_MASK: retval = uinput_abs_setup(udev, p, size); goto out; } retval = -EINVAL; out: mutex_unlock(&udev->mutex); return retval; }

Contributors

PersonTokensPropCommitsCommitProp
Micah Dowty27530.15%15.56%
Benjamin Tissoires19120.94%316.67%
Philip Langdale14816.23%15.56%
Dmitry Torokhov869.43%633.33%
Vojtech Pavlik647.02%211.11%
Andrew Morton616.69%15.56%
Anssi Hannula424.61%15.56%
David Herrmann262.85%15.56%
Henrik Rydberg141.54%15.56%
Zach Welch50.55%15.56%
Total912100.00%18100.00%


static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { return uinput_ioctl_handler(file, cmd, arg, (void __user *)arg); }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale36100.00%1100.00%
Total36100.00%1100.00%

#ifdef CONFIG_COMPAT #define UI_SET_PHYS_COMPAT _IOW(UINPUT_IOCTL_BASE, 108, compat_uptr_t)
static long uinput_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { if (cmd == UI_SET_PHYS_COMPAT) cmd = UI_SET_PHYS; return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg)); }

Contributors

PersonTokensPropCommitsCommitProp
Philip Langdale3477.27%150.00%
Ricky Liang1022.73%150.00%
Total44100.00%2100.00%

#endif static const struct file_operations uinput_fops = { .owner = THIS_MODULE, .open = uinput_open, .release = uinput_release, .read = uinput_read, .write = uinput_write, .poll = uinput_poll, .unlocked_ioctl = uinput_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = uinput_compat_ioctl, #endif .llseek = no_llseek, }; static struct miscdevice uinput_misc = { .fops = &uinput_fops, .minor = UINPUT_MINOR, .name = UINPUT_NAME, }; module_misc_device(uinput_misc); MODULE_ALIAS_MISCDEV(UINPUT_MINOR); MODULE_ALIAS("devname:" UINPUT_NAME); MODULE_AUTHOR("Aristeu Sergio Rozanski Filho"); MODULE_DESCRIPTION("User level driver support for input subsystem"); MODULE_LICENSE("GPL"); MODULE_VERSION("0.3");

Overall Contributors

PersonTokensPropCommitsCommitProp
Dmitry Torokhov93721.26%1833.96%
Micah Dowty91320.72%11.89%
Philip Langdale60013.61%11.89%
Benjamin Tissoires57413.02%35.66%
Vojtech Pavlik3818.65%47.55%
David Herrmann2656.01%59.43%
Anssi Hannula2435.51%11.89%
Aristeu Sergio Rozanski Filho1854.20%11.89%
Andrew Morton651.47%23.77%
Zach Welch410.93%11.89%
Elias Vanderstuyft340.77%11.89%
Ryan Mallon300.68%11.89%
Daniel Mack300.68%11.89%
Peter Hutterer260.59%11.89%
Henrik Rydberg170.39%23.77%
Neil Brown140.32%11.89%
Ricky Liang140.32%11.89%
Kay Sievers110.25%11.89%
Randy Dunlap100.23%11.89%
Arnd Bergmann50.11%11.89%
PrasannaKumar Muralidharan50.11%11.89%
Alexey Dobriyan30.07%11.89%
Ian Campbell20.05%11.89%
Arjan van de Ven10.02%11.89%
Adrian Bunk10.02%11.89%
Total4407100.00%53100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.