Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit aeba0390 authored by Al Viro's avatar Al Viro
Browse files

mga: switch compat ioctls to drm_ioctl_kernel() 



Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent ff32d39b

drivers/gpu/drm/drm_ioctl.c

+1 −0
Original line number Original line Diff line number Diff line
@@ -719,6 +719,7 @@ long drm_ioctl_kernel(struct file *file, drm_ioctl_t *func, void *kdata, 
	}

	}

	return retcode;

	return retcode;

}

}

EXPORT_SYMBOL(drm_ioctl_kernel);





/**

/**

 * drm_ioctl - ioctl callback implementation for DRM drivers

 * drm_ioctl - ioctl callback implementation for DRM drivers

drivers/gpu/drm/mga/mga_drv.h

+2 −0
Original line number Original line Diff line number Diff line
@@ -159,6 +159,8 @@ extern int mga_dma_bootstrap(struct drm_device *dev, void *data, 
			     struct drm_file *file_priv);

			     struct drm_file *file_priv);

extern int mga_dma_init(struct drm_device *dev, void *data,

extern int mga_dma_init(struct drm_device *dev, void *data,

			struct drm_file *file_priv);

			struct drm_file *file_priv);

extern int mga_getparam(struct drm_device *dev, void *data,

			struct drm_file *file_priv);

extern int mga_dma_flush(struct drm_device *dev, void *data,

extern int mga_dma_flush(struct drm_device *dev, void *data,

			 struct drm_file *file_priv);

			 struct drm_file *file_priv);

extern int mga_dma_reset(struct drm_device *dev, void *data,

extern int mga_dma_reset(struct drm_device *dev, void *data,

drivers/gpu/drm/mga/mga_ioc32.c

+60 −89
Original line number Original line Diff line number Diff line
@@ -61,46 +61,25 @@ static int compat_mga_init(struct file *file, unsigned int cmd, 
			   unsigned long arg)

			   unsigned long arg)

{

{

	drm_mga_init32_t init32;

	drm_mga_init32_t init32;

	drm_mga_init_t __user *init;

	drm_mga_init_t init;

	int err = 0, i;





	if (copy_from_user(&init32, (void __user *)arg, sizeof(init32)))

	if (copy_from_user(&init32, (void __user *)arg, sizeof(init32)))

		return -EFAULT;

		return -EFAULT;





	init = compat_alloc_user_space(sizeof(*init));

	init.func = init32.func;

	if (!access_ok(VERIFY_WRITE, init, sizeof(*init))

	init.sarea_priv_offset = init32.sarea_priv_offset;

	    || __put_user(init32.func, &init->func)

	memcpy(&init.chipset, &init32.chipset,

	    || __put_user(init32.sarea_priv_offset, &init->sarea_priv_offset)

		offsetof(drm_mga_init_t, fb_offset) -

	    || __put_user(init32.chipset, &init->chipset)

		offsetof(drm_mga_init_t, chipset));

	    || __put_user(init32.sgram, &init->sgram)

	init.fb_offset = init32.fb_offset;

	    || __put_user(init32.maccess, &init->maccess)

	init.mmio_offset = init32.mmio_offset;

	    || __put_user(init32.fb_cpp, &init->fb_cpp)

	init.status_offset = init32.status_offset;

	    || __put_user(init32.front_offset, &init->front_offset)

	init.warp_offset = init32.warp_offset;

	    || __put_user(init32.front_pitch, &init->front_pitch)

	init.primary_offset = init32.primary_offset;

	    || __put_user(init32.back_offset, &init->back_offset)

	init.buffers_offset = init32.buffers_offset;

	    || __put_user(init32.back_pitch, &init->back_pitch)



	    || __put_user(init32.depth_cpp, &init->depth_cpp)

	return drm_ioctl_kernel(file, mga_dma_init, &init,

	    || __put_user(init32.depth_offset, &init->depth_offset)

				DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);

	    || __put_user(init32.depth_pitch, &init->depth_pitch)

	    || __put_user(init32.fb_offset, &init->fb_offset)

	    || __put_user(init32.mmio_offset, &init->mmio_offset)

	    || __put_user(init32.status_offset, &init->status_offset)

	    || __put_user(init32.warp_offset, &init->warp_offset)

	    || __put_user(init32.primary_offset, &init->primary_offset)

	    || __put_user(init32.buffers_offset, &init->buffers_offset))

		return -EFAULT;



	for (i = 0; i < MGA_NR_TEX_HEAPS; i++) {

		err |=

		    __put_user(init32.texture_offset[i],

			       &init->texture_offset[i]);

		err |=

		    __put_user(init32.texture_size[i], &init->texture_size[i]);

	}

	if (err)

		return -EFAULT;



	return drm_ioctl(file, DRM_IOCTL_MGA_INIT, (unsigned long)init);

}

}





typedef struct drm_mga_getparam32 {

typedef struct drm_mga_getparam32 {
@@ -112,19 +91,14 @@ static int compat_mga_getparam(struct file *file, unsigned int cmd, 
			       unsigned long arg)

			       unsigned long arg)

{

{

	drm_mga_getparam32_t getparam32;

	drm_mga_getparam32_t getparam32;

	drm_mga_getparam_t __user *getparam;

	drm_mga_getparam_t getparam;





	if (copy_from_user(&getparam32, (void __user *)arg, sizeof(getparam32)))

	if (copy_from_user(&getparam32, (void __user *)arg, sizeof(getparam32)))

		return -EFAULT;

		return -EFAULT;





	getparam = compat_alloc_user_space(sizeof(*getparam));

	getparam.param = getparam32.param;

	if (!access_ok(VERIFY_WRITE, getparam, sizeof(*getparam))

	getparam.value = compat_ptr(getparam32.value);

	    || __put_user(getparam32.param, &getparam->param)

	return drm_ioctl_kernel(file, mga_getparam, &getparam, DRM_AUTH);

	    || __put_user((void __user *)(unsigned long)getparam32.value,

			  &getparam->value))

		return -EFAULT;



	return drm_ioctl(file, DRM_IOCTL_MGA_GETPARAM, (unsigned long)getparam);

}

}





typedef struct drm_mga_drm_bootstrap32 {

typedef struct drm_mga_drm_bootstrap32 {
@@ -141,48 +115,33 @@ static int compat_mga_dma_bootstrap(struct file *file, unsigned int cmd, 
				    unsigned long arg)

				    unsigned long arg)

{

{

	drm_mga_dma_bootstrap32_t dma_bootstrap32;

	drm_mga_dma_bootstrap32_t dma_bootstrap32;

	drm_mga_dma_bootstrap_t __user *dma_bootstrap;

	drm_mga_dma_bootstrap_t __user dma_bootstrap;

	int err;

	int err;





	if (copy_from_user(&dma_bootstrap32, (void __user *)arg,

	if (copy_from_user(&dma_bootstrap32, (void __user *)arg,

			   sizeof(dma_bootstrap32)))

			   sizeof(dma_bootstrap32)))

		return -EFAULT;

		return -EFAULT;





	dma_bootstrap = compat_alloc_user_space(sizeof(*dma_bootstrap));

	dma_bootstrap.texture_handle = dma_bootstrap32.texture_handle;

	if (!access_ok(VERIFY_WRITE, dma_bootstrap, sizeof(*dma_bootstrap))

	dma_bootstrap.texture_size = dma_bootstrap32.texture_size;

	    || __put_user(dma_bootstrap32.texture_handle,

	dma_bootstrap.primary_size = dma_bootstrap32.primary_size;

			  &dma_bootstrap->texture_handle)

	dma_bootstrap.secondary_bin_count = dma_bootstrap32.secondary_bin_count;

	    || __put_user(dma_bootstrap32.texture_size,

	dma_bootstrap.secondary_bin_size = dma_bootstrap32.secondary_bin_size;

			  &dma_bootstrap->texture_size)

	dma_bootstrap.agp_mode = dma_bootstrap32.agp_mode;

	    || __put_user(dma_bootstrap32.primary_size,

	dma_bootstrap.agp_size = dma_bootstrap32.agp_size;

			  &dma_bootstrap->primary_size)

	    || __put_user(dma_bootstrap32.secondary_bin_count,

			  &dma_bootstrap->secondary_bin_count)

	    || __put_user(dma_bootstrap32.secondary_bin_size,

			  &dma_bootstrap->secondary_bin_size)

	    || __put_user(dma_bootstrap32.agp_mode, &dma_bootstrap->agp_mode)

	    || __put_user(dma_bootstrap32.agp_size, &dma_bootstrap->agp_size))

		return -EFAULT;





	err = drm_ioctl(file, DRM_IOCTL_MGA_DMA_BOOTSTRAP,

	err = drm_ioctl_kernel(file, mga_dma_bootstrap, &dma_bootstrap,

			(unsigned long)dma_bootstrap);

				DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY);

	if (err)

	if (err)

		return err;

		return err;





	if (__get_user(dma_bootstrap32.texture_handle,

	dma_bootstrap32.texture_handle = dma_bootstrap.texture_handle;

		       &dma_bootstrap->texture_handle)

	dma_bootstrap32.texture_size = dma_bootstrap.texture_size;

	    || __get_user(dma_bootstrap32.texture_size,

	dma_bootstrap32.primary_size = dma_bootstrap.primary_size;

			  &dma_bootstrap->texture_size)

	dma_bootstrap32.secondary_bin_count = dma_bootstrap.secondary_bin_count;

	    || __get_user(dma_bootstrap32.primary_size,

	dma_bootstrap32.secondary_bin_size = dma_bootstrap.secondary_bin_size;

			  &dma_bootstrap->primary_size)

	dma_bootstrap32.agp_mode = dma_bootstrap.agp_mode;

	    || __get_user(dma_bootstrap32.secondary_bin_count,

	dma_bootstrap32.agp_size = dma_bootstrap.agp_size;

			  &dma_bootstrap->secondary_bin_count)

	    || __get_user(dma_bootstrap32.secondary_bin_size,

			  &dma_bootstrap->secondary_bin_size)

	    || __get_user(dma_bootstrap32.agp_mode, &dma_bootstrap->agp_mode)

	    || __get_user(dma_bootstrap32.agp_size, &dma_bootstrap->agp_size))

		return -EFAULT;



	if (copy_to_user((void __user *)arg, &dma_bootstrap32,

	if (copy_to_user((void __user *)arg, &dma_bootstrap32,

			 sizeof(dma_bootstrap32)))

			 sizeof(dma_bootstrap32)))

		return -EFAULT;

		return -EFAULT;
@@ -190,10 +149,14 @@ static int compat_mga_dma_bootstrap(struct file *file, unsigned int cmd, 
	return 0;

	return 0;

}

}





drm_ioctl_compat_t *mga_compat_ioctls[] = {

static struct {

	[DRM_MGA_INIT] = compat_mga_init,

	drm_ioctl_compat_t *fn;

	[DRM_MGA_GETPARAM] = compat_mga_getparam,

	char *name;

	[DRM_MGA_DMA_BOOTSTRAP] = compat_mga_dma_bootstrap,

} mga_compat_ioctls[] = {

#define DRM_IOCTL32_DEF(n, f)[DRM_##n] = {.fn = f, .name = #n}

	DRM_IOCTL32_DEF(MGA_INIT, compat_mga_init),

	DRM_IOCTL32_DEF(MGA_GETPARAM, compat_mga_getparam),

	DRM_IOCTL32_DEF(MGA_DMA_BOOTSTRAP, compat_mga_dma_bootstrap),

};

};





/**

/**
@@ -208,19 +171,27 @@ drm_ioctl_compat_t *mga_compat_ioctls[] = { 
long mga_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

long mga_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

{

	unsigned int nr = DRM_IOCTL_NR(cmd);

	unsigned int nr = DRM_IOCTL_NR(cmd);

	struct drm_file *file_priv = filp->private_data;

	drm_ioctl_compat_t *fn = NULL;

	drm_ioctl_compat_t *fn = NULL;

	int ret;

	int ret;





	if (nr < DRM_COMMAND_BASE)

	if (nr < DRM_COMMAND_BASE)

		return drm_compat_ioctl(filp, cmd, arg);

		return drm_compat_ioctl(filp, cmd, arg);





	if (nr < DRM_COMMAND_BASE + ARRAY_SIZE(mga_compat_ioctls))

	if (nr >= DRM_COMMAND_BASE + ARRAY_SIZE(mga_compat_ioctls))

		fn = mga_compat_ioctls[nr - DRM_COMMAND_BASE];

		return drm_ioctl(filp, cmd, arg);





	if (fn != NULL)

	fn = mga_compat_ioctls[nr - DRM_COMMAND_BASE].fn;

		ret = (*fn) (filp, cmd, arg);

	if (!fn)

	else

		return drm_ioctl(filp, cmd, arg);

		ret = drm_ioctl(filp, cmd, arg);





	DRM_DEBUG("pid=%d, dev=0x%lx, auth=%d, %s\n",

		  task_pid_nr(current),

		  (long)old_encode_dev(file_priv->minor->kdev->devt),

		  file_priv->authenticated,

		  mga_compat_ioctls[nr - DRM_COMMAND_BASE].name);

	ret = (*fn) (filp, cmd, arg);

	if (ret)

		DRM_DEBUG("ret = %d\n", ret);

	return ret;

	return ret;

}
 
}

drivers/gpu/drm/mga/mga_state.c

+1 −1
Original line number Original line Diff line number Diff line
@@ -1005,7 +1005,7 @@ static int mga_dma_blit(struct drm_device *dev, void *data, struct drm_file *fil 
	return 0;

	return 0;

}

}





static int mga_getparam(struct drm_device *dev, void *data, struct drm_file *file_priv)

int mga_getparam(struct drm_device *dev, void *data, struct drm_file *file_priv)

{

{

	drm_mga_private_t *dev_priv = dev->dev_private;

	drm_mga_private_t *dev_priv = dev->dev_private;

	drm_mga_getparam_t *param = data;

	drm_mga_getparam_t *param = data;