drm: Replace DRM_IOCTL_ARGS with (dev, data, file_priv) and remove DRM_DEVICE.

The data is now in kernel space, copied in/out as appropriate according to t
This results in DRM_COPY_{TO,FROM}_USER going away, and error paths to deal
with those failures.  This also means that XFree86 4.2.0 support for i810 DR
is lost.

Signed-off-by: Dave Airlie <airlied@linux.ie>

1 files changed, 74 insertions, 103 deletions

diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index 1b5d0da6566d..d9be14624526 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -49,22 +49,17 @@
  *
  * Copies the bus id from drm_device::unique into user space.
  */
-int drm_getunique(struct inode *inode, struct drm_file *file_priv,
-                  unsigned int cmd, unsigned long arg)
+int drm_getunique(struct drm_device *dev, void *data,
+                  struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_unique __user *argp = (void __user *)arg;
-        struct drm_unique u;
+        struct drm_unique *u = data;
 
-        if (copy_from_user(&u, argp, sizeof(u)))
-                return -EFAULT;
-        if (u.unique_len >= dev->unique_len) {
-                if (copy_to_user(u.unique, dev->unique, dev->unique_len))
+        if (u->unique_len >= dev->unique_len) {
+                if (copy_to_user(u->unique, dev->unique, dev->unique_len))
                         return -EFAULT;
         }
-        u.unique_len = dev->unique_len;
-        if (copy_to_user(argp, &u, sizeof(u)))
-                return -EFAULT;
+        u->unique_len = dev->unique_len;
+
         return 0;
 }
 
@@ -82,27 +77,23 @@ int drm_getunique(struct inode *inode, struct drm_file *file_priv,
  * in interface version 1.1 and will return EBUSY when setversion has requested
  * version 1.1 or greater.
  */
-int drm_setunique(struct inode *inode, struct drm_file *file_priv,
-                  unsigned int cmd, unsigned long arg)
+int drm_setunique(struct drm_device *dev, void *data,
+                  struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_unique u;
+        struct drm_unique *u = data;
         int domain, bus, slot, func, ret;
 
         if (dev->unique_len || dev->unique)
                 return -EBUSY;
 
-        if (copy_from_user(&u, (struct drm_unique __user *) arg, sizeof(u)))
-                return -EFAULT;
-
-        if (!u.unique_len || u.unique_len > 1024)
+        if (!u->unique_len || u->unique_len > 1024)
                 return -EINVAL;
 
-        dev->unique_len = u.unique_len;
-        dev->unique = drm_alloc(u.unique_len + 1, DRM_MEM_DRIVER);
+        dev->unique_len = u->unique_len;
+        dev->unique = drm_alloc(u->unique_len + 1, DRM_MEM_DRIVER);
         if (!dev->unique)
                 return -ENOMEM;
-        if (copy_from_user(dev->unique, u.unique, dev->unique_len))
+        if (copy_from_user(dev->unique, u->unique, dev->unique_len))
                 return -EFAULT;
 
         dev->unique[dev->unique_len] = '\0';
@@ -179,20 +170,16 @@ static int drm_set_busid(struct drm_device * dev)
  * Searches for the mapping with the specified offset and copies its information
  * into userspace
  */
-int drm_getmap(struct inode *inode, struct drm_file *file_priv,
-               unsigned int cmd, unsigned long arg)
+int drm_getmap(struct drm_device *dev, void *data,
+               struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_map __user *argp = (void __user *)arg;
-        struct drm_map map;
+        struct drm_map *map = data;
         struct drm_map_list *r_list = NULL;
         struct list_head *list;
         int idx;
         int i;
 
-        if (copy_from_user(&map, argp, sizeof(map)))
-                return -EFAULT;
-        idx = map.offset;
+        idx = map->offset;
 
         mutex_lock(&dev->struct_mutex);
         if (idx < 0) {
@@ -213,16 +200,14 @@ int drm_getmap(struct inode *inode, struct drm_file *file_priv,
                 return -EINVAL;
         }
 
-        map.offset = r_list->map->offset;
-        map.size = r_list->map->size;
-        map.type = r_list->map->type;
-        map.flags = r_list->map->flags;
-        map.handle = (void *)(unsigned long)r_list->user_token;
-        map.mtrr = r_list->map->mtrr;
+        map->offset = r_list->map->offset;
+        map->size = r_list->map->size;
+        map->type = r_list->map->type;
+        map->flags = r_list->map->flags;
+        map->handle = (void *)(unsigned long) r_list->user_token;
+        map->mtrr = r_list->map->mtrr;
         mutex_unlock(&dev->struct_mutex);
 
-        if (copy_to_user(argp, &map, sizeof(map)))
-                return -EFAULT;
         return 0;
 }
 
@@ -239,19 +224,15 @@ int drm_getmap(struct inode *inode, struct drm_file *file_priv,
  * Searches for the client with the specified index and copies its information
  * into userspace
  */
-int drm_getclient(struct inode *inode, struct drm_file *file_priv,
-                  unsigned int cmd, unsigned long arg)
+int drm_getclient(struct drm_device *dev, void *data,
+                  struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_client __user *argp = (struct drm_client __user *)arg;
-        struct drm_client client;
+        struct drm_client *client = data;
         struct drm_file *pt;
         int idx;
         int i;
 
-        if (copy_from_user(&client, argp, sizeof(client)))
-                return -EFAULT;
-        idx = client.idx;
+        idx = client->idx;
         mutex_lock(&dev->struct_mutex);
         
         if (list_empty(&dev->filelist)) {
@@ -265,15 +246,13 @@ int drm_getclient(struct inode *inode, struct drm_file *file_priv,
                         break;
         }
 
-        client.auth = pt->authenticated;
-        client.pid = pt->pid;
-        client.uid = pt->uid;
-        client.magic = pt->magic;
-        client.iocs = pt->ioctl_count;
+        client->auth = pt->authenticated;
+        client->pid = pt->pid;
+        client->uid = pt->uid;
+        client->magic = pt->magic;
+        client->iocs = pt->ioctl_count;
         mutex_unlock(&dev->struct_mutex);
 
-        if (copy_to_user(argp, &client, sizeof(client)))
-                return -EFAULT;
         return 0;
 }
 
@@ -287,32 +266,29 @@ int drm_getclient(struct inode *inode, struct drm_file *file_priv,
  *
  * \return zero on success or a negative number on failure.
  */
-int drm_getstats(struct inode *inode, struct drm_file *file_priv,
-                 unsigned int cmd, unsigned long arg)
+int drm_getstats(struct drm_device *dev, void *data,
+                 struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_stats stats;
+        struct drm_stats *stats = data;
         int i;
 
-        memset(&stats, 0, sizeof(stats));
+        memset(stats, 0, sizeof(stats));
 
         mutex_lock(&dev->struct_mutex);
 
         for (i = 0; i < dev->counters; i++) {
                 if (dev->types[i] == _DRM_STAT_LOCK)
-                        stats.data[i].value
-                            = (dev->lock.hw_lock ? dev->lock.hw_lock->lock : 0);
+                        stats->data[i].value =
+                            (dev->lock.hw_lock ? dev->lock.hw_lock->lock : 0);
                 else
-                        stats.data[i].value = atomic_read(&dev->counts[i]);
-                stats.data[i].type = dev->types[i];
+                        stats->data[i].value = atomic_read(&dev->counts[i]);
+                stats->data[i].type = dev->types[i];
         }
 
-        stats.count = dev->counters;
+        stats->count = dev->counters;
 
         mutex_unlock(&dev->struct_mutex);
 
-        if (copy_to_user((struct drm_stats __user *) arg, &stats, sizeof(stats)))
-                return -EFAULT;
         return 0;
 }
 
@@ -327,57 +303,52 @@ int drm_getstats(struct inode *inode, struct drm_file *file_priv,
  *
  * Sets the requested interface version
  */
-int drm_setversion(DRM_IOCTL_ARGS)
+int drm_setversion(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        DRM_DEVICE;
-        struct drm_set_version sv;
-        struct drm_set_version retv;
-        int if_version;
-        struct drm_set_version __user *argp = (void __user *)data;
-        int ret;
-
-        if (copy_from_user(&sv, argp, sizeof(sv)))
-                return -EFAULT;
-
-        retv.drm_di_major = DRM_IF_MAJOR;
-        retv.drm_di_minor = DRM_IF_MINOR;
-        retv.drm_dd_major = dev->driver->major;
-        retv.drm_dd_minor = dev->driver->minor;
-
-        if (copy_to_user(argp, &retv, sizeof(retv)))
-                return -EFAULT;
-
-        if (sv.drm_di_major != -1) {
-                if (sv.drm_di_major != DRM_IF_MAJOR ||
-                    sv.drm_di_minor < 0 || sv.drm_di_minor > DRM_IF_MINOR)
-                        return -EINVAL;
-                if_version = DRM_IF_VERSION(sv.drm_di_major, sv.drm_di_minor);
+        struct drm_set_version *sv = data;
+        int if_version, retcode = 0;
+
+        if (sv->drm_di_major != -1) {
+                if (sv->drm_di_major != DRM_IF_MAJOR ||
+                    sv->drm_di_minor < 0 || sv->drm_di_minor > DRM_IF_MINOR) {
+                        retcode = -EINVAL;
+                        goto done;
+                }
+                if_version = DRM_IF_VERSION(sv->drm_di_major,
+                                            sv->drm_di_minor);
                 dev->if_version = max(if_version, dev->if_version);
-                if (sv.drm_di_minor >= 1) {
+                if (sv->drm_di_minor >= 1) {
                         /*
                          * Version 1.1 includes tying of DRM to specific device
                          */
-                        ret = drm_set_busid(dev);
-                        if (ret)
-                                return ret;
+                        drm_set_busid(dev);
                 }
         }
 
-        if (sv.drm_dd_major != -1) {
-                if (sv.drm_dd_major != dev->driver->major ||
-                    sv.drm_dd_minor < 0
-                    || sv.drm_dd_minor > dev->driver->minor)
-                        return -EINVAL;
+        if (sv->drm_dd_major != -1) {
+                if (sv->drm_dd_major != dev->driver->major ||
+                    sv->drm_dd_minor < 0 || sv->drm_dd_minor >
+                    dev->driver->minor) {
+                        retcode = -EINVAL;
+                        goto done;
+                }
 
                 if (dev->driver->set_version)
-                        dev->driver->set_version(dev, &sv);
+                        dev->driver->set_version(dev, sv);
         }
-        return 0;
+
+done:
+        sv->drm_di_major = DRM_IF_MAJOR;
+        sv->drm_di_minor = DRM_IF_MINOR;
+        sv->drm_dd_major = dev->driver->major;
+        sv->drm_dd_minor = dev->driver->minor;
+
+        return retcode;
 }
 
 /** No-op ioctl. */
-int drm_noop(struct inode *inode, struct drm_file *file_priv, unsigned int cmd,
-             unsigned long arg)
+int drm_noop(struct drm_device *dev, void *data,
+             struct drm_file *file_priv)
 {
         DRM_DEBUG("\n");
         return 0;