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, 53 insertions, 98 deletions

diff --git a/drivers/char/drm/drm_context.c b/drivers/char/drm/drm_context.c
index 4037a3602f1e..17fe69e7bfc1 100644
--- a/drivers/char/drm/drm_context.c
+++ b/drivers/char/drm/drm_context.c
@@ -139,21 +139,16 @@ void drm_ctxbitmap_cleanup(struct drm_device * dev)
  * Gets the map from drm_device::ctx_idr with the handle specified and
  * returns its handle.
  */
-int drm_getsareactx(struct inode *inode, struct drm_file *file_priv,
-                    unsigned int cmd, unsigned long arg)
+int drm_getsareactx(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_ctx_priv_map __user *argp = (void __user *)arg;
-        struct drm_ctx_priv_map request;
+        struct drm_ctx_priv_map *request = data;
         struct drm_map *map;
         struct drm_map_list *_entry;
 
-        if (copy_from_user(&request, argp, sizeof(request)))
-                return -EFAULT;
-
         mutex_lock(&dev->struct_mutex);
 
-        map = idr_find(&dev->ctx_idr, request.ctx_id);
+        map = idr_find(&dev->ctx_idr, request->ctx_id);
         if (!map) {
                 mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
@@ -161,19 +156,17 @@ int drm_getsareactx(struct inode *inode, struct drm_file *file_priv,
 
         mutex_unlock(&dev->struct_mutex);
 
-        request.handle = NULL;
+        request->handle = NULL;
         list_for_each_entry(_entry, &dev->maplist, head) {
                 if (_entry->map == map) {
-                        request.handle =
+                        request->handle = 
                             (void *)(unsigned long)_entry->user_token;
                         break;
                 }
         }
-        if (request.handle == NULL)
+        if (request->handle == NULL)
                 return -EINVAL;
 
-        if (copy_to_user(argp, &request, sizeof(request)))
-                return -EFAULT;
         return 0;
 }
 
@@ -189,23 +182,17 @@ int drm_getsareactx(struct inode *inode, struct drm_file *file_priv,
  * Searches the mapping specified in \p arg and update the entry in
  * drm_device::ctx_idr with it.
  */
-int drm_setsareactx(struct inode *inode, struct drm_file *file_priv,
-                    unsigned int cmd, unsigned long arg)
+int drm_setsareactx(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_ctx_priv_map request;
+        struct drm_ctx_priv_map *request = data;
         struct drm_map *map = NULL;
         struct drm_map_list *r_list = NULL;
 
-        if (copy_from_user(&request,
-                           (struct drm_ctx_priv_map __user *) arg,
-                           sizeof(request)))
-                return -EFAULT;
-
         mutex_lock(&dev->struct_mutex);
         list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map
-                    && r_list->user_token == (unsigned long)request.handle)
+                    && r_list->user_token == (unsigned long) request->handle)
                         goto found;
         }
       bad:
@@ -217,10 +204,11 @@ int drm_setsareactx(struct inode *inode, struct drm_file *file_priv,
         if (!map)
                 goto bad;
 
-        if (IS_ERR(idr_replace(&dev->ctx_idr, map, request.ctx_id)))
+        if (IS_ERR(idr_replace(&dev->ctx_idr, map, request->ctx_id)))
                 goto bad;
 
         mutex_unlock(&dev->struct_mutex);
+
         return 0;
 }
 
@@ -295,29 +283,23 @@ static int drm_context_switch_complete(struct drm_device * dev, int new)
  * \param arg user argument pointing to a drm_ctx_res structure.
  * \return zero on success or a negative number on failure.
  */
-int drm_resctx(struct inode *inode, struct drm_file *file_priv,
-               unsigned int cmd, unsigned long arg)
+int drm_resctx(struct drm_device *dev, void *data,
+               struct drm_file *file_priv)
 {
-        struct drm_ctx_res res;
-        struct drm_ctx_res __user *argp = (void __user *)arg;
+        struct drm_ctx_res *res = data;
         struct drm_ctx ctx;
         int i;
 
-        if (copy_from_user(&res, argp, sizeof(res)))
-                return -EFAULT;
-
-        if (res.count >= DRM_RESERVED_CONTEXTS) {
+        if (res->count >= DRM_RESERVED_CONTEXTS) {
                 memset(&ctx, 0, sizeof(ctx));
                 for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
                         ctx.handle = i;
-                        if (copy_to_user(&res.contexts[i], &ctx, sizeof(ctx)))
+                        if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx)))
                                 return -EFAULT;
                 }
         }
-        res.count = DRM_RESERVED_CONTEXTS;
+        res->count = DRM_RESERVED_CONTEXTS;
 
-        if (copy_to_user(argp, &res, sizeof(res)))
-                return -EFAULT;
         return 0;
 }
 
@@ -332,32 +314,27 @@ int drm_resctx(struct inode *inode, struct drm_file *file_priv,
  *
  * Get a new handle for the context and copy to userspace.
  */
-int drm_addctx(struct inode *inode, struct drm_file *file_priv,
-               unsigned int cmd, unsigned long arg)
+int drm_addctx(struct drm_device *dev, void *data,
+               struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
         struct drm_ctx_list *ctx_entry;
-        struct drm_ctx __user *argp = (void __user *)arg;
-        struct drm_ctx ctx;
-
-        if (copy_from_user(&ctx, argp, sizeof(ctx)))
-                return -EFAULT;
+        struct drm_ctx *ctx = data;
 
-        ctx.handle = drm_ctxbitmap_next(dev);
-        if (ctx.handle == DRM_KERNEL_CONTEXT) {
+        ctx->handle = drm_ctxbitmap_next(dev);
+        if (ctx->handle == DRM_KERNEL_CONTEXT) {
                 /* Skip kernel's context and get a new one. */
-                ctx.handle = drm_ctxbitmap_next(dev);
+                ctx->handle = drm_ctxbitmap_next(dev);
         }
-        DRM_DEBUG("%d\n", ctx.handle);
-        if (ctx.handle == -1) {
+        DRM_DEBUG("%d\n", ctx->handle);
+        if (ctx->handle == -1) {
                 DRM_DEBUG("Not enough free contexts.\n");
                 /* Should this return -EBUSY instead? */
                 return -ENOMEM;
         }
 
-        if (ctx.handle != DRM_KERNEL_CONTEXT) {
+        if (ctx->handle != DRM_KERNEL_CONTEXT) {
                 if (dev->driver->context_ctor)
-                        if (!dev->driver->context_ctor(dev, ctx.handle)) {
+                        if (!dev->driver->context_ctor(dev, ctx->handle)) {
                                 DRM_DEBUG("Running out of ctxs or memory.\n");
                                 return -ENOMEM;
                         }
@@ -370,7 +347,7 @@ int drm_addctx(struct inode *inode, struct drm_file *file_priv,
         }
 
         INIT_LIST_HEAD(&ctx_entry->head);
-        ctx_entry->handle = ctx.handle;
+        ctx_entry->handle = ctx->handle;
         ctx_entry->tag = file_priv;
 
         mutex_lock(&dev->ctxlist_mutex);
@@ -378,13 +355,10 @@ int drm_addctx(struct inode *inode, struct drm_file *file_priv,
         ++dev->ctx_count;
         mutex_unlock(&dev->ctxlist_mutex);
 
-        if (copy_to_user(argp, &ctx, sizeof(ctx)))
-                return -EFAULT;
         return 0;
 }
 
-int drm_modctx(struct inode *inode, struct drm_file *file_priv,
-               unsigned int cmd, unsigned long arg)
+int drm_modctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
         /* This does nothing */
         return 0;
@@ -399,20 +373,13 @@ int drm_modctx(struct inode *inode, struct drm_file *file_priv,
  * \param arg user argument pointing to a drm_ctx structure.
  * \return zero on success or a negative number on failure.
  */
-int drm_getctx(struct inode *inode, struct drm_file *file_priv,
-               unsigned int cmd, unsigned long arg)
+int drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
-        struct drm_ctx __user *argp = (void __user *)arg;
-        struct drm_ctx ctx;
-
-        if (copy_from_user(&ctx, argp, sizeof(ctx)))
-                return -EFAULT;
+        struct drm_ctx *ctx = data;
 
         /* This is 0, because we don't handle any context flags */
-        ctx.flags = 0;
+        ctx->flags = 0;
 
-        if (copy_to_user(argp, &ctx, sizeof(ctx)))
-                return -EFAULT;
         return 0;
 }
 
@@ -427,17 +394,13 @@ int drm_getctx(struct inode *inode, struct drm_file *file_priv,
  *
  * Calls context_switch().
  */
-int drm_switchctx(struct inode *inode, struct drm_file *file_priv,
-                  unsigned int cmd, unsigned long arg)
+int drm_switchctx(struct drm_device *dev, void *data,
+                  struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_ctx ctx;
+        struct drm_ctx *ctx = data;
 
-        if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
-                return -EFAULT;
-
-        DRM_DEBUG("%d\n", ctx.handle);
-        return drm_context_switch(dev, dev->last_context, ctx.handle);
+        DRM_DEBUG("%d\n", ctx->handle);
+        return drm_context_switch(dev, dev->last_context, ctx->handle);
 }
 
 /**
@@ -451,17 +414,13 @@ int drm_switchctx(struct inode *inode, struct drm_file *file_priv,
  *
  * Calls context_switch_complete().
  */
-int drm_newctx(struct inode *inode, struct drm_file *file_priv,
-               unsigned int cmd, unsigned long arg)
+int drm_newctx(struct drm_device *dev, void *data,
+               struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_ctx ctx;
+        struct drm_ctx *ctx = data;
 
-        if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
-                return -EFAULT;
-
-        DRM_DEBUG("%d\n", ctx.handle);
-        drm_context_switch_complete(dev, ctx.handle);
+        DRM_DEBUG("%d\n", ctx->handle);
+        drm_context_switch_complete(dev, ctx->handle);
 
         return 0;
 }
@@ -477,23 +436,19 @@ int drm_newctx(struct inode *inode, struct drm_file *file_priv,
  *
  * If not the special kernel context, calls ctxbitmap_free() to free the specified context.
  */
-int drm_rmctx(struct inode *inode, struct drm_file *file_priv,
-              unsigned int cmd, unsigned long arg)
+int drm_rmctx(struct drm_device *dev, void *data,
+              struct drm_file *file_priv)
 {
-        struct drm_device *dev = file_priv->head->dev;
-        struct drm_ctx ctx;
-
-        if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
-                return -EFAULT;
+        struct drm_ctx *ctx = data;
 
-        DRM_DEBUG("%d\n", ctx.handle);
-        if (ctx.handle == DRM_KERNEL_CONTEXT + 1) {
+        DRM_DEBUG("%d\n", ctx->handle);
+        if (ctx->handle == DRM_KERNEL_CONTEXT + 1) {
                 file_priv->remove_auth_on_close = 1;
         }
-        if (ctx.handle != DRM_KERNEL_CONTEXT) {
+        if (ctx->handle != DRM_KERNEL_CONTEXT) {
                 if (dev->driver->context_dtor)
-                        dev->driver->context_dtor(dev, ctx.handle);
-                drm_ctxbitmap_free(dev, ctx.handle);
+                        dev->driver->context_dtor(dev, ctx->handle);
+                drm_ctxbitmap_free(dev, ctx->handle);
         }
 
         mutex_lock(&dev->ctxlist_mutex);
@@ -501,7 +456,7 @@ int drm_rmctx(struct inode *inode, struct drm_file *file_priv,
                 struct drm_ctx_list *pos, *n;
 
                 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
-                        if (pos->handle == ctx.handle) {
+                        if (pos->handle == ctx->handle) {
                                 list_del(&pos->head);
                                 drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST);
                                 --dev->ctx_count;