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 4037a3602f1..17fe69e7bfc 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;