Input: extend the number of event (and other) devices

Extend the amount of character devices, such as eventX, mouseX and jsX,
from a hard limit of 32 per input handler to about 1024 shared across
all handlers.

To be compatible with legacy installations input handlers will start
creating char devices with minors in their legacy range, however once
legacy range is exhausted they will start allocating minors from the
dynamic range 256-1024.

Reviewed-by: David Herrmann <dh.herrmann@googlemail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>

1 files changed, 33 insertions, 66 deletions

diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 118d0300f1fb..6ae2ac47c9c8 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -23,11 +23,11 @@
 #include <linux/input/mt.h>
 #include <linux/major.h>
 #include <linux/device.h>
+#include <linux/cdev.h>
 #include "input-compat.h"
 
 struct evdev {
         int open;
-        int minor;
         struct input_handle handle;
         wait_queue_head_t wait;
         struct evdev_client __rcu *grab;
@@ -35,6 +35,7 @@ struct evdev {
         spinlock_t client_lock; /* protects client_list */
         struct mutex mutex;
         struct device dev;
+        struct cdev cdev;
         bool exist;
 };
 
@@ -51,9 +52,6 @@ struct evdev_client {
         struct input_event buffer[];
 };
 
-static struct evdev *evdev_table[EVDEV_MINORS];
-static DEFINE_MUTEX(evdev_table_mutex);
-
 static void __pass_event(struct evdev_client *client,
                          const struct input_event *event)
 {
@@ -310,35 +308,16 @@ static unsigned int evdev_compute_buffer_size(struct input_dev *dev)
 
 static int evdev_open(struct inode *inode, struct file *file)
 {
-        struct evdev *evdev;
+        struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev);
+        unsigned int bufsize = evdev_compute_buffer_size(evdev->handle.dev);
         struct evdev_client *client;
-        int i = iminor(inode) - EVDEV_MINOR_BASE;
-        unsigned int bufsize;
         int error;
 
-        if (i >= EVDEV_MINORS)
-                return -ENODEV;
-
-        error = mutex_lock_interruptible(&evdev_table_mutex);
-        if (error)
-                return error;
-        evdev = evdev_table[i];
-        if (evdev)
-                get_device(&evdev->dev);
-        mutex_unlock(&evdev_table_mutex);
-
-        if (!evdev)
-                return -ENODEV;
-
-        bufsize = evdev_compute_buffer_size(evdev->handle.dev);
-
         client = kzalloc(sizeof(struct evdev_client) +
                                 bufsize * sizeof(struct input_event),
                          GFP_KERNEL);
-        if (!client) {
-                error = -ENOMEM;
-                goto err_put_evdev;
-        }
+        if (!client)
+                return -ENOMEM;
 
         client->bufsize = bufsize;
         spin_lock_init(&client->buffer_lock);
@@ -352,13 +331,12 @@ static int evdev_open(struct inode *inode, struct file *file)
         file->private_data = client;
         nonseekable_open(inode, file);
 
+        get_device(&evdev->dev);
         return 0;
 
  err_free_client:
         evdev_detach_client(evdev, client);
         kfree(client);
- err_put_evdev:
-        put_device(&evdev->dev);
         return error;
 }
 
@@ -942,26 +920,6 @@ static const struct file_operations evdev_fops = {
         .llseek         = no_llseek,
 };
 
-static int evdev_install_chrdev(struct evdev *evdev)
-{
-        /*
-         * No need to do any locking here as calls to connect and
-         * disconnect are serialized by the input core
-         */
-        evdev_table[evdev->minor] = evdev;
-        return 0;
-}
-
-static void evdev_remove_chrdev(struct evdev *evdev)
-{
-        /*
-         * Lock evdev table to prevent race with evdev_open()
-         */
-        mutex_lock(&evdev_table_mutex);
-        evdev_table[evdev->minor] = NULL;
-        mutex_unlock(&evdev_table_mutex);
-}
-
 /*
  * Mark device non-existent. This disables writes, ioctls and
  * prevents new users from opening the device. Already posted
@@ -980,7 +938,8 @@ static void evdev_cleanup(struct evdev *evdev)
 
         evdev_mark_dead(evdev);
         evdev_hangup(evdev);
-        evdev_remove_chrdev(evdev);
+
+        cdev_del(&evdev->cdev);
 
         /* evdev is marked dead so no one else accesses evdev->open */
         if (evdev->open) {
@@ -991,43 +950,47 @@ static void evdev_cleanup(struct evdev *evdev)
 
 /*
  * Create new evdev device. Note that input core serializes calls
- * to connect and disconnect so we don't need to lock evdev_table here.
+ * to connect and disconnect.
  */
 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
                          const struct input_device_id *id)
 {
         struct evdev *evdev;
         int minor;
+        int dev_no;
         int error;
 
-        for (minor = 0; minor < EVDEV_MINORS; minor++)
-                if (!evdev_table[minor])
-                        break;
-
-        if (minor == EVDEV_MINORS) {
-                pr_err("no more free evdev devices\n");
-                return -ENFILE;
+        minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);
+        if (minor < 0) {
+                error = minor;
+                pr_err("failed to reserve new minor: %d\n", error);
+                return error;
         }
 
         evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
-        if (!evdev)
-                return -ENOMEM;
+        if (!evdev) {
+                error = -ENOMEM;
+                goto err_free_minor;
+        }
 
         INIT_LIST_HEAD(&evdev->client_list);
         spin_lock_init(&evdev->client_lock);
         mutex_init(&evdev->mutex);
         init_waitqueue_head(&evdev->wait);
-
-        dev_set_name(&evdev->dev, "event%d", minor);
         evdev->exist = true;
-        evdev->minor = minor;
+
+        dev_no = minor;
+        /* Normalize device number if it falls into legacy range */
+        if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS)
+                dev_no -= EVDEV_MINOR_BASE;
+        dev_set_name(&evdev->dev, "event%d", dev_no);
 
         evdev->handle.dev = input_get_device(dev);
         evdev->handle.name = dev_name(&evdev->dev);
         evdev->handle.handler = handler;
         evdev->handle.private = evdev;
 
-        evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
+        evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
         evdev->dev.class = &input_class;
         evdev->dev.parent = &dev->dev;
         evdev->dev.release = evdev_free;
@@ -1037,7 +1000,8 @@ static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
         if (error)
                 goto err_free_evdev;
 
-        error = evdev_install_chrdev(evdev);
+        cdev_init(&evdev->cdev, &evdev_fops);
+        error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);
         if (error)
                 goto err_unregister_handle;
 
@@ -1053,6 +1017,8 @@ static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
         input_unregister_handle(&evdev->handle);
  err_free_evdev:
         put_device(&evdev->dev);
+ err_free_minor:
+        input_free_minor(minor);
         return error;
 }
 
@@ -1062,6 +1028,7 @@ static void evdev_disconnect(struct input_handle *handle)
 
         device_del(&evdev->dev);
         evdev_cleanup(evdev);
+        input_free_minor(MINOR(evdev->dev.devt));
         input_unregister_handle(handle);
         put_device(&evdev->dev);
 }
@@ -1078,7 +1045,7 @@ static struct input_handler evdev_handler = {
         .events         = evdev_events,
         .connect        = evdev_connect,
         .disconnect     = evdev_disconnect,
-        .fops           = &evdev_fops,
+        .legacy_minors  = true,
         .minor          = EVDEV_MINOR_BASE,
         .name           = "evdev",
         .id_table       = evdev_ids,