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

Commit 502e95c6 authored by Zach Reizner's avatar Zach Reizner Committed by Dave Airlie
Browse files

drm/vgem: implement virtual GEM 



This patch implements the virtual GEM driver with PRIME sharing which
allows vgem to import a gem object from other drivers for the purpose
of mmap-ing them to userspace. The mmap is done using the mmap
operation exported by other drivers.

v2: remove platform_device and do not attach to dma bufs
v3: use drm helpers for get/put pages
v4: correct dumb create pitch

Reviewed-by: Rob Clark <robdclark@gmail.com> (v3)
Reviewed-by: Stéphane Marchesin <marcheu@chromium.org> (v3)
Signed-off-by: default avatarAdam Jackson <ajax@redhat.com>
Signed-off-by: default avatarBen Widawsky <ben@bwidawsk.net>
Signed-off-by: default avatarZach Reizner <zachr@google.com>
Signed-off-by: default avatarDave Airlie <airlied@redhat.com>
parent 564b687b

drivers/gpu/drm/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -165,6 +165,15 @@ config DRM_SAVAGE 
	  Choose this option if you have a Savage3D/4/SuperSavage/Pro/Twister

	  chipset. If M is selected the module will be called savage.



config DRM_VGEM

	tristate "Virtual GEM provider"

	depends on DRM

	help

	  Choose this option to get a virtual graphics memory manager,

	  as used by Mesa's software renderer for enhanced performance.

	  If M is selected the module will be called vgem.





source "drivers/gpu/drm/exynos/Kconfig"



source "drivers/gpu/drm/rockchip/Kconfig"

drivers/gpu/drm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -48,6 +48,7 @@ obj-$(CONFIG_DRM_SIS) += sis/ 
obj-$(CONFIG_DRM_SAVAGE)+= savage/

obj-$(CONFIG_DRM_VMWGFX)+= vmwgfx/

obj-$(CONFIG_DRM_VIA)	+=via/

obj-$(CONFIG_DRM_VGEM)	+= vgem/

obj-$(CONFIG_DRM_NOUVEAU) +=nouveau/

obj-$(CONFIG_DRM_EXYNOS) +=exynos/

obj-$(CONFIG_DRM_ROCKCHIP) +=rockchip/

drivers/gpu/drm/vgem/Makefile

0 → 100644
+4 −0
Original line number Diff line number Diff line 
ccflags-y := -Iinclude/drm

vgem-y := vgem_drv.o vgem_dma_buf.o



obj-$(CONFIG_DRM_VGEM)	+= vgem.o

drivers/gpu/drm/vgem/vgem_dma_buf.c

0 → 100644
+94 −0
Original line number Diff line number Diff line 
/*

 * Copyright © 2012 Intel Corporation

 * Copyright © 2014 The Chromium OS Authors

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 *

 * Authors:

 *    Ben Widawsky <ben@bwidawsk.net>

 *

 */



#include <linux/dma-buf.h>

#include "vgem_drv.h"



struct sg_table *vgem_gem_prime_get_sg_table(struct drm_gem_object *gobj)

{

	struct drm_vgem_gem_object *obj = to_vgem_bo(gobj);

	BUG_ON(obj->pages == NULL);



	return drm_prime_pages_to_sg(obj->pages, obj->base.size / PAGE_SIZE);

}



int vgem_gem_prime_pin(struct drm_gem_object *gobj)

{

	struct drm_vgem_gem_object *obj = to_vgem_bo(gobj);

	return vgem_gem_get_pages(obj);

}



void vgem_gem_prime_unpin(struct drm_gem_object *gobj)

{

	struct drm_vgem_gem_object *obj = to_vgem_bo(gobj);

	vgem_gem_put_pages(obj);

}



void *vgem_gem_prime_vmap(struct drm_gem_object *gobj)

{

	struct drm_vgem_gem_object *obj = to_vgem_bo(gobj);

	BUG_ON(obj->pages == NULL);



	return vmap(obj->pages, obj->base.size / PAGE_SIZE, 0, PAGE_KERNEL);

}



void vgem_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr)

{

	vunmap(vaddr);

}



struct drm_gem_object *vgem_gem_prime_import(struct drm_device *dev,

					     struct dma_buf *dma_buf)

{

	struct drm_vgem_gem_object *obj = NULL;

	int ret;



	obj = kzalloc(sizeof(*obj), GFP_KERNEL);

	if (obj == NULL) {

		ret = -ENOMEM;

		goto fail;

	}



	ret = drm_gem_object_init(dev, &obj->base, dma_buf->size);

	if (ret) {

		ret = -ENOMEM;

		goto fail_free;

	}



	get_dma_buf(dma_buf);



	obj->base.dma_buf = dma_buf;

	obj->use_dma_buf = true;



	return &obj->base;



fail_free:

	kfree(obj);

fail:

	return ERR_PTR(ret);

}

drivers/gpu/drm/vgem/vgem_drv.c

0 → 100644
+364 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2011 Red Hat, Inc.

 * Copyright © 2014 The Chromium OS Authors

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software")

 * to deal in the software without restriction, including without limitation

 * on the rights to use, copy, modify, merge, publish, distribute, sub

 * license, and/or sell copies of the Software, and to permit persons to whom

 * them Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTIBILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER

 * IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 * Authors:

 *	Adam Jackson <ajax@redhat.com>

 *	Ben Widawsky <ben@bwidawsk.net>

 */



/**

 * This is vgem, a (non-hardware-backed) GEM service.  This is used by Mesa's

 * software renderer and the X server for efficient buffer sharing.

 */



#include <linux/module.h>

#include <linux/ramfs.h>

#include <linux/shmem_fs.h>

#include <linux/dma-buf.h>

#include "vgem_drv.h"



#define DRIVER_NAME	"vgem"

#define DRIVER_DESC	"Virtual GEM provider"

#define DRIVER_DATE	"20120112"

#define DRIVER_MAJOR	1

#define DRIVER_MINOR	0



void vgem_gem_put_pages(struct drm_vgem_gem_object *obj)

{

	drm_gem_put_pages(&obj->base, obj->pages, false, false);

	obj->pages = NULL;

}



static void vgem_gem_free_object(struct drm_gem_object *obj)

{

	struct drm_vgem_gem_object *vgem_obj = to_vgem_bo(obj);



	drm_gem_free_mmap_offset(obj);



	if (vgem_obj->use_dma_buf && obj->dma_buf) {

		dma_buf_put(obj->dma_buf);

		obj->dma_buf = NULL;

	}



	drm_gem_object_release(obj);



	if (vgem_obj->pages)

		vgem_gem_put_pages(vgem_obj);



	vgem_obj->pages = NULL;



	kfree(vgem_obj);

}



int vgem_gem_get_pages(struct drm_vgem_gem_object *obj)

{

	struct page **pages;



	if (obj->pages || obj->use_dma_buf)

		return 0;



	pages = drm_gem_get_pages(&obj->base);

	if (IS_ERR(pages)) {

		return PTR_ERR(pages);

	}



	obj->pages = pages;



	return 0;

}



static int vgem_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)

{

	struct drm_vgem_gem_object *obj = vma->vm_private_data;

	struct drm_device *dev = obj->base.dev;

	loff_t num_pages;

	pgoff_t page_offset;

	int ret;



	/* We don't use vmf->pgoff since that has the fake offset */

	page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >>

		PAGE_SHIFT;



	num_pages = DIV_ROUND_UP(obj->base.size, PAGE_SIZE);



	if (page_offset > num_pages)

		return VM_FAULT_SIGBUS;



	mutex_lock(&dev->struct_mutex);



	ret = vm_insert_page(vma, (unsigned long)vmf->virtual_address,

			     obj->pages[page_offset]);



	mutex_unlock(&dev->struct_mutex);

	switch (ret) {

	case 0:

		return VM_FAULT_NOPAGE;

	case -ENOMEM:

		return VM_FAULT_OOM;

	case -EBUSY:

		return VM_FAULT_RETRY;

	case -EFAULT:

	case -EINVAL:

		return VM_FAULT_SIGBUS;

	default:

		WARN_ON(1);

		return VM_FAULT_SIGBUS;

	}

}



static struct vm_operations_struct vgem_gem_vm_ops = {

	.fault = vgem_gem_fault,

	.open = drm_gem_vm_open,

	.close = drm_gem_vm_close,

};



/* ioctls */



static struct drm_gem_object *vgem_gem_create(struct drm_device *dev,

					      struct drm_file *file,

					      unsigned int *handle,

					      unsigned long size)

{

	struct drm_vgem_gem_object *obj;

	struct drm_gem_object *gem_object;

	int err;



	size = roundup(size, PAGE_SIZE);



	obj = kzalloc(sizeof(*obj), GFP_KERNEL);

	if (!obj)

		return ERR_PTR(-ENOMEM);



	gem_object = &obj->base;



	err = drm_gem_object_init(dev, gem_object, size);

	if (err)

		goto out;



	err = drm_gem_handle_create(file, gem_object, handle);

	if (err)

		goto handle_out;



	drm_gem_object_unreference_unlocked(gem_object);



	return gem_object;



handle_out:

	drm_gem_object_release(gem_object);

out:

	kfree(obj);

	return ERR_PTR(err);

}



static int vgem_gem_dumb_create(struct drm_file *file, struct drm_device *dev,

				struct drm_mode_create_dumb *args)

{

	struct drm_gem_object *gem_object;

	uint64_t size;

	uint64_t pitch = args->width * DIV_ROUND_UP(args->bpp, 8);



	size = args->height * pitch;

	if (size == 0)

		return -EINVAL;



	gem_object = vgem_gem_create(dev, file, &args->handle, size);



	if (IS_ERR(gem_object)) {

		DRM_DEBUG_DRIVER("object creation failed\n");

		return PTR_ERR(gem_object);

	}



	args->size = gem_object->size;

	args->pitch = pitch;



	DRM_DEBUG_DRIVER("Created object of size %lld\n", size);



	return 0;

}



int vgem_gem_dumb_map(struct drm_file *file, struct drm_device *dev,

		      uint32_t handle, uint64_t *offset)

{

	int ret = 0;

	struct drm_gem_object *obj;



	mutex_lock(&dev->struct_mutex);

	obj = drm_gem_object_lookup(dev, file, handle);

	if (!obj) {

		ret = -ENOENT;

		goto unlock;

	}



	if (!drm_vma_node_has_offset(&obj->vma_node)) {

		ret = drm_gem_create_mmap_offset(obj);

		if (ret)

			goto unref;

	}



	BUG_ON(!obj->filp);



	obj->filp->private_data = obj;



	ret = vgem_gem_get_pages(to_vgem_bo(obj));

	if (ret)

		goto fail_get_pages;



	*offset = drm_vma_node_offset_addr(&obj->vma_node);



	goto unref;



fail_get_pages:

	drm_gem_free_mmap_offset(obj);

unref:

	drm_gem_object_unreference(obj);

unlock:

	mutex_unlock(&dev->struct_mutex);

	return ret;

}



int vgem_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)

{

	struct drm_file *priv = filp->private_data;

	struct drm_device *dev = priv->minor->dev;

	struct drm_vma_offset_node *node;

	struct drm_gem_object *obj;

	struct drm_vgem_gem_object *vgem_obj;

	int ret = 0;



	mutex_lock(&dev->struct_mutex);



	node = drm_vma_offset_exact_lookup(dev->vma_offset_manager,

					   vma->vm_pgoff,

					   vma_pages(vma));

	if (!node) {

		ret = -EINVAL;

		goto out_unlock;

	} else if (!drm_vma_node_is_allowed(node, filp)) {

		ret = -EACCES;

		goto out_unlock;

	}



	obj = container_of(node, struct drm_gem_object, vma_node);



	vgem_obj = to_vgem_bo(obj);



	if (obj->dma_buf && vgem_obj->use_dma_buf) {

		ret = dma_buf_mmap(obj->dma_buf, vma, 0);

		goto out_unlock;

	}



	if (!obj->dev->driver->gem_vm_ops) {

		ret = -EINVAL;

		goto out_unlock;

	}



	vma->vm_flags |= VM_IO | VM_MIXEDMAP | VM_DONTEXPAND | VM_DONTDUMP;

	vma->vm_ops = obj->dev->driver->gem_vm_ops;

	vma->vm_private_data = vgem_obj;

	vma->vm_page_prot =

		pgprot_writecombine(vm_get_page_prot(vma->vm_flags));



	mutex_unlock(&dev->struct_mutex);

	drm_gem_vm_open(vma);

	return ret;



out_unlock:

	mutex_unlock(&dev->struct_mutex);



	return ret;

}





static struct drm_ioctl_desc vgem_ioctls[] = {

};



static const struct file_operations vgem_driver_fops = {

	.owner		= THIS_MODULE,

	.open		= drm_open,

	.mmap		= vgem_drm_gem_mmap,

	.poll		= drm_poll,

	.read		= drm_read,

	.unlocked_ioctl = drm_ioctl,

	.release	= drm_release,

};



static struct drm_driver vgem_driver = {

	.driver_features		= DRIVER_GEM | DRIVER_PRIME,

	.gem_free_object		= vgem_gem_free_object,

	.gem_vm_ops			= &vgem_gem_vm_ops,

	.ioctls				= vgem_ioctls,

	.fops				= &vgem_driver_fops,

	.dumb_create			= vgem_gem_dumb_create,

	.dumb_map_offset		= vgem_gem_dumb_map,

	.prime_handle_to_fd		= drm_gem_prime_handle_to_fd,

	.prime_fd_to_handle		= drm_gem_prime_fd_to_handle,

	.gem_prime_export		= drm_gem_prime_export,

	.gem_prime_import		= vgem_gem_prime_import,

	.gem_prime_pin			= vgem_gem_prime_pin,

	.gem_prime_unpin		= vgem_gem_prime_unpin,

	.gem_prime_get_sg_table		= vgem_gem_prime_get_sg_table,

	.gem_prime_vmap			= vgem_gem_prime_vmap,

	.gem_prime_vunmap		= vgem_gem_prime_vunmap,

	.name	= DRIVER_NAME,

	.desc	= DRIVER_DESC,

	.date	= DRIVER_DATE,

	.major	= DRIVER_MAJOR,

	.minor	= DRIVER_MINOR,

};



struct drm_device *vgem_device;



static int __init vgem_init(void)

{

	int ret;



	vgem_device = drm_dev_alloc(&vgem_driver, NULL);

	if (!vgem_device) {

		ret = -ENOMEM;

		goto out;

	}



	ret  = drm_dev_register(vgem_device, 0);



	if (ret)

		goto out_unref;



	return 0;



out_unref:

	drm_dev_unref(vgem_device);

out:

	return ret;

}



static void __exit vgem_exit(void)

{

	drm_dev_unregister(vgem_device);

	drm_dev_unref(vgem_device);

}



module_init(vgem_init);

module_exit(vgem_exit);



MODULE_AUTHOR("Red Hat, Inc.");

MODULE_DESCRIPTION(DRIVER_DESC);

MODULE_LICENSE("GPL and additional rights");