vmwgfx prime implementation
Subsystems (4)
cover vmwgfx prime implementation
Adds a prime implementation to the vmwgfx driver mostly for inter-process sharing of buffers.
For now, the dma_bufs we export can't be consumed by another device and also we don't import any dma_bufs other than the ones we've created ourselves. This is because there are no other virtual devices that import / export dma_bufs yet.
Basically this also means we don't have to implement the dma_buf ops
PATCH 1/4 drm/ttm: Add a minimal prime implementation for ttm base objects
--- drivers/gpu/drm/ttm/ttm_object.c | 254 +++++++++++++++++++++++++++++++++++++- include/drm/ttm/ttm_object.h | 61 ++++++++- 2 files changed, 307 insertions(+), 8 deletions(-)
drivers/gpu/drm/ttm/ttm_object.c +248 -6
@@ -1,6 +1,6 @@/************************************************************************** * -* Copyright (c) 2009 VMware, Inc., Palo Alto, CA., USA +* Copyright (c) 2009-2013 VMware, Inc., Palo Alto, CA., USA * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a
@@ -26,6 +26,12 @@**************************************************************************/ /* * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com> +* +* While no substantial code is shared, the prime code is inspired by +* drm_prime.c, with +* Authors: +* Dave Airlie <[email protected]> +* Rob Clark <[email protected]> */ /** @file ttm_ref_object.c *
@@ -34,6 +40,7 @@* and release on file close. */ +/** * struct ttm_object_file *
@@ -84,6 +91,9 @@ struct ttm_object_device {struct drm_open_hash object_hash;atomic_t object_count;struct ttm_mem_global *mem_glob; +struct dma_buf_ops ops; +void (*dmabuf_release)(struct dma_buf *dma_buf); +size_t dma_buf_size; };/**
@@ -116,6 +126,8 @@ struct ttm_ref_object {struct ttm_object_file *tfile; }; +static void ttm_prime_dmabuf_release (struct dma_buf *dma_buf); +static inline struct ttm_object_file *ttm_object_file_ref (struct ttm_object_file *tfile) {
@@ -416,9 +428,10 @@ out_err: }EXPORT_SYMBOL (ttm_object_file_init); -struct ttm_object_device *ttm_object_device_init (struct ttm_mem_global - *mem_glob, -unsigned int hash_order) +struct ttm_object_device * +ttm_object_device_init (struct ttm_mem_global *mem_glob, +unsigned int hash_order, +const struct dma_buf_ops *ops) {struct ttm_object_device *tdev =kmalloc (sizeof (*tdev),GFP_KERNEL );int ret;
@@ -430,10 +443,17 @@ struct ttm_object_device *ttm_object_device_init(struct ttm_mem_globalspin_lock_init (&tdev->object_lock);atomic_set (&tdev->object_count,0 ); ret =drm_ht_create (&tdev->object_hash, hash_order); +if (ret !=0 ) + goto out_no_object_hash; -if (likely (ret ==0 )) -return tdev; + tdev->ops = *ops; + tdev->dmabuf_release = tdev->ops.release; + tdev->ops.release = ttm_prime_dmabuf_release; + tdev->dma_buf_size =ttm_round_pot (sizeof (struct dma_buf )) + +ttm_round_pot (sizeof (struct file )); +return tdev; +out_no_object_hash:kfree (tdev);return NULL ; }
@@ -452,3 +472,225 @@ void ttm_object_device_release(struct ttm_object_device **p_tdev)kfree (tdev); }EXPORT_SYMBOL (ttm_object_device_release); + +/** +* get_dma_buf_unless_doomed - get a dma_buf reference if possible. +* +* @dma_buf: Non-refcounted pointer to a struct dma-buf. +* +* Obtain a file reference from a lookup structure that doesn't refcount +* the file, but synchronizes with its release method to make sure it has +* not been freed yet. See for example kref_get_unless_zero documentation. +* Returns true if refcounting succeeds, false otherwise. +* +* Nobody really wants this as a public API yet, so let it mature here +* for some time... +*/ +static bool __must_check get_dma_buf_unless_doomed (struct dma_buf *dmabuf) +{ +return atomic_long_inc_not_zero (&dmabuf->file->f_count) !=0L ; +} + +/** +* ttm_prime_refcount_release - refcount release method for a prime object. +* +* @p_base: Pointer to ttm_base_object pointer. +* +* This is a wrapper that calls the refcount_release founction of the +* underlying object. At the same time it cleans up the prime object. +* This function is called when all references to the base object we +* derive from are gone. +*/ +static void ttm_prime_refcount_release (struct ttm_base_object **p_base) +{ +struct ttm_base_object *base = *p_base; +struct ttm_prime_object *prime; + + *p_base =NULL ; + prime = container_of(base, struct ttm_prime_object, base); +BUG_ON (prime->dma_buf !=NULL ); +mutex_destroy (&prime->mutex); +if (prime->refcount_release) + prime->refcount_release (&base); +} + +/** +* ttm_prime_dmabuf_release - Release method for the dma-bufs we export +* +* @dma_buf: +* +* This function first calls the dma_buf release method the driver +* provides. Then it cleans up our dma_buf pointer used for lookup, +* and finally releases the reference the dma_buf has on our base +* object. +*/ +static void ttm_prime_dmabuf_release (struct dma_buf *dma_buf) +{ +struct ttm_prime_object *prime = + (struct ttm_prime_object *) dma_buf->priv; +struct ttm_base_object *base = &prime->base; +struct ttm_object_device *tdev = base->tfile->tdev; + +if (tdev->dmabuf_release) + tdev->dmabuf_release (dma_buf); +mutex_lock (&prime->mutex); +if (prime->dma_buf == dma_buf) + prime->dma_buf =NULL ; +mutex_unlock (&prime->mutex); +ttm_mem_global_free (tdev->mem_glob, tdev->dma_buf_size); +ttm_base_object_unref (&base); +} + +/** +* ttm_prime_fd_to_handle - Get a base object handle from a prime fd +* +* @tfile: A struct ttm_object_file identifying the caller. +* @fd: The prime / dmabuf fd. +* @handle: The returned handle. +* +* This function returns a handle to an object that previously exported +* a dma-buf. Note that we don't handle imports yet, because we simply +* have no consumers of that implementation. +*/ +int ttm_prime_fd_to_handle (struct ttm_object_file *tfile, +int fd,u32 *handle) +{ +struct ttm_object_device *tdev = tfile->tdev; +struct dma_buf *dma_buf; +struct ttm_prime_object *prime; +struct ttm_base_object *base; +int ret; + + dma_buf =dma_buf_get (fd); +if (IS_ERR (dma_buf)) +return PTR_ERR (dma_buf); + +if (dma_buf->ops != &tdev->ops) +return -ENOSYS ; + + prime = (struct ttm_prime_object *) dma_buf->priv; + base = &prime->base; + *handle = base->hash.key; + ret =ttm_ref_object_add (tfile, base,TTM_REF_USAGE ,NULL ); + +dma_buf_put (dma_buf); + +return ret; +} +EXPORT_SYMBOL_GPL (ttm_prime_fd_to_handle); + +/** +* ttm_prime_handle_to_fd - Return a dma_buf fd from a ttm prime object +* +* @tfile: Struct ttm_object_file identifying the caller. +* @handle: Handle to the object we're exporting from. +* @flags: flags for dma-buf creation. We just pass them on. +* @prime_fd: The returned file descriptor. +* +*/ +int ttm_prime_handle_to_fd (struct ttm_object_file *tfile, +uint32_t handle,uint32_t flags, +int *prime_fd) +{ +struct ttm_object_device *tdev = tfile->tdev; +struct ttm_base_object *base; +struct dma_buf *dma_buf; +struct ttm_prime_object *prime; +int ret; + + base =ttm_base_object_lookup (tfile, handle); +if (unlikely (base ==NULL || + base->object_type != ttm_prime_type)) { + ret = -ENOENT ; + goto out_unref; + } + + prime = container_of(base, struct ttm_prime_object, base); +if (unlikely (!base->shareable)) { + ret = -EPERM ; + goto out_unref; + } + + ret =mutex_lock_interruptible (&prime->mutex); +if (unlikely (ret !=0 )) { + ret = -ERESTARTSYS ; + goto out_unref; + } + + dma_buf = prime->dma_buf; +if (!dma_buf || !get_dma_buf_unless_doomed (dma_buf)) { + +/* +* Need to create a new dma_buf, with memory accounting. +*/ + ret =ttm_mem_global_alloc (tdev->mem_glob, tdev->dma_buf_size, + false, true); +if (unlikely (ret !=0 )) { +mutex_unlock (&prime->mutex); + goto out_unref; + } + + dma_buf =dma_buf_export (prime, &tdev->ops, + prime->size, flags); +if (IS_ERR (dma_buf)) { + ret =PTR_ERR (dma_buf); +ttm_mem_global_free (tdev->mem_glob, + tdev->dma_buf_size); +mutex_unlock (&prime->mutex); + goto out_unref; + } + +/* +* dma_buf has taken the base object reference +*/ + base =NULL ; + prime->dma_buf = dma_buf; + } +mutex_unlock (&prime->mutex); + + ret =dma_buf_fd (dma_buf, flags); +if (ret >=0 ) { + *prime_fd = ret; + ret =0 ; + }else +dma_buf_put (dma_buf); + +out_unref: +if (base) +ttm_base_object_unref (&base); +return ret; +} +EXPORT_SYMBOL_GPL (ttm_prime_handle_to_fd); + +/** +* ttm_prime_object_init - Initialize a ttm_prime_object +* +* @tfile: struct ttm_object_file identifying the caller +* @size: The size of the dma_bufs we export. +* @prime: The object to be initialized. +* @shareable: See ttm_base_object_init +* @type: See ttm_base_object_init +* @refcount_release: See ttm_base_object_init +* @ref_obj_release: See ttm_base_object_init +* +* Initializes an object which is compatible with the drm_prime model +* for data sharing between processes and devices. +*/ +int ttm_prime_object_init (struct ttm_object_file *tfile,size_t size, +struct ttm_prime_object *prime,bool shareable, +enum ttm_object_type type, +void (*refcount_release) (struct ttm_base_object **), +void (*ref_obj_release) (struct ttm_base_object *, +enum ttm_ref_type ref_type)) +{ +mutex_init (&prime->mutex); + prime->size =PAGE_ALIGN (size); + prime->real_type = type; + prime->dma_buf =NULL ; + prime->refcount_release = refcount_release; +return ttm_base_object_init (tfile, &prime->base, shareable, + ttm_prime_type, + ttm_prime_refcount_release, + ref_obj_release); +} +EXPORT_SYMBOL (ttm_prime_object_init);
include/drm/ttm/ttm_object.h +59 -2
95 lines not on this page · raw message
Signature · 1 line
1.7.10.4
PATCH 2/4 drm/vmwgfx: Hook up the prime ioctls
In reply to Thomas HellstromAlso provide a completely dumb dma-buf ops implementation. Once we have other virtual dma-buf aware devices, we need to provide something better.
--- drivers/gpu/drm/vmwgfx/Makefile | 2 +- drivers/gpu/drm/vmwgfx/vmwgfx_drv.c | 7 +- drivers/gpu/drm/vmwgfx/vmwgfx_drv.h | 14 ++++ drivers/gpu/drm/vmwgfx/vmwgfx_prime.c | 137 +++++++++++++++++++++++++++++++++ 4 files changed, 157 insertions(+), 3 deletions(-) create mode 100644 drivers/gpu/drm/vmwgfx/vmwgfx_prime.c
drivers/gpu/drm/vmwgfx/Makefile +1 -1
@@ -6,6 +6,6 @@ vmwgfx-y := vmwgfx_execbuf.o vmwgfx_gmr.o vmwgfx_kms.o vmwgfx_drv.o \ vmwgfx_fifo.o vmwgfx_irq.o vmwgfx_ldu.o vmwgfx_ttm_glue.o \ vmwgfx_overlay.o vmwgfx_marker.o vmwgfx_gmrid_manager.o \ vmwgfx_fence.o vmwgfx_dmabuf.o vmwgfx_scrn.o vmwgfx_context.o \ - vmwgfx_surface.o + vmwgfx_surface.o vmwgfx_prime.o obj-$(CONFIG_DRM_VMWGFX) := vmwgfx.o
drivers/gpu/drm/vmwgfx/vmwgfx_drv.c +5 -2
@@ -677,7 +677,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset) } dev_priv->tdev =ttm_object_device_init - (dev_priv->mem_global_ref.object,12 ); + (dev_priv->mem_global_ref.object,12 , &vmw_prime_dmabuf_ops);if (unlikely (dev_priv->tdev ==NULL )) {DRM_ERROR ("Unable to initialize TTM object management.\n" );
@@ -1203,7 +1203,7 @@ static const struct file_operations vmwgfx_driver_fops = {static struct drm_driver driver = { .driver_features =DRIVER_HAVE_IRQ |DRIVER_IRQ_SHARED | -DRIVER_MODESET , +DRIVER_MODESET |DRIVER_PRIME , .load = vmw_driver_load, .unload = vmw_driver_unload, .lastclose = vmw_lastclose,
@@ -1228,6 +1228,9 @@ static struct drm_driver driver = { .dumb_map_offset = vmw_dumb_map_offset, .dumb_destroy = vmw_dumb_destroy, + .prime_fd_to_handle = vmw_prime_fd_to_handle, + .prime_handle_to_fd = vmw_prime_handle_to_fd, + .fops = &vmwgfx_driver_fops, .name = VMWGFX_DRIVER_NAME, .desc = VMWGFX_DRIVER_DESC,
drivers/gpu/drm/vmwgfx/vmwgfx_drv.h +14 -0
@@ -819,6 +819,20 @@ int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv);extern const struct ttm_mem_type_manager_func vmw_gmrid_manager_func;/** +* Prime - vmwgfx_prime.c +*/ + +extern const struct dma_buf_ops vmw_prime_dmabuf_ops; +extern int vmw_prime_fd_to_handle (struct drm_device *dev, +struct drm_file *file_priv, +int fd,u32 *handle); +extern int vmw_prime_handle_to_fd (struct drm_device *dev, +struct drm_file *file_priv, +uint32_t handle,uint32_t flags, +int *prime_fd); + + +/** * Inline helper functions */
drivers/gpu/drm/vmwgfx/vmwgfx_prime.c new file +137 -0
137 lines not on this page · raw message
Signature · 5 lines
1.7.10.4 _______________________________________________ dri-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH 3/4 drm/vmwgfx: Make surfaces prime-aware
In reply to Thomas HellstromAdd prime exporting and imporing operations to surfaces
--- drivers/gpu/drm/vmwgfx/vmwgfx_resource.c | 2 +- drivers/gpu/drm/vmwgfx/vmwgfx_surface.c | 30 ++++++++++++++++-------------- 2 files changed, 17 insertions(+), 15 deletions(-)
drivers/gpu/drm/vmwgfx/vmwgfx_resource.c +1 -1
@@ -297,7 +297,7 @@ int vmw_user_resource_lookup_handle(struct vmw_private *dev_priv,if (unlikely (base ==NULL ))return -EINVAL ; -if (unlikely (base->object_type != converter->object_type)) +if (unlikely (ttm_base_object_type (base) != converter->object_type)) goto out_bad_resource; res = converter->base_obj_to_res (base);
drivers/gpu/drm/vmwgfx/vmwgfx_surface.c +16 -14
@@ -38,7 +38,7 @@* @size: TTM accounting size for the surface. */ struct vmw_user_surface { -struct ttm_base_object base; +struct ttm_prime_object prime;struct vmw_surface srf;uint32_t size;uint32_t backup_handle;
@@ -580,7 +580,8 @@ static int vmw_surface_init(struct vmw_private *dev_priv,static struct vmw_resource *vmw_user_surface_base_to_res (struct ttm_base_object *base) { - return &(container_of(base, struct vmw_user_surface, base)->srf.res); + return &(container_of(base, struct vmw_user_surface, + prime.base)->srf.res); }/**
@@ -599,7 +600,7 @@ static void vmw_user_surface_free(struct vmw_resource *res)kfree (srf->offsets);kfree (srf->sizes);kfree (srf->snooper.image); -ttm_base_object_kfree (user_srf, base); +ttm_prime_object_kfree (user_srf, prime);ttm_mem_global_free (vmw_mem_glob (dev_priv), size); }
@@ -616,7 +617,7 @@ static void vmw_user_surface_base_release(struct ttm_base_object **p_base) {struct ttm_base_object *base = *p_base;struct vmw_user_surface *user_srf = - container_of(base, struct vmw_user_surface, base); + container_of(base, struct vmw_user_surface, prime.base);struct vmw_resource *res = &user_srf->srf.res; *p_base =NULL ;
@@ -790,8 +791,8 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data, } srf->snooper.crtc =NULL ; - user_srf->base.shareable = false; - user_srf->base.tfile =NULL ; + user_srf->prime.base.shareable = false; + user_srf->prime.base.tfile =NULL ;/** * From this point, the generic resource management functions
@@ -803,9 +804,9 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data, goto out_unlock; tmp =vmw_resource_reference (&srf->res); - ret =ttm_base_object_init (tfile, &user_srf->base, - req->shareable,VMW_RES_SURFACE , - &vmw_user_surface_base_release,NULL ); + ret =ttm_prime_object_init (tfile, res->backup_size, &user_srf->prime, + req->shareable,VMW_RES_SURFACE , + &vmw_user_surface_base_release,NULL );if (unlikely (ret !=0 )) {vmw_resource_unreference (&tmp);
@@ -813,7 +814,7 @@ int vmw_surface_define_ioctl(struct drm_device *dev, void *data, goto out_unlock; } - rep->sid = user_srf->base.hash.key; + rep->sid = user_srf->prime.base.hash.key;vmw_resource_unreference (&res);ttm_read_unlock (&vmaster->lock);
@@ -823,7 +824,7 @@ out_no_copy: out_no_offsets:kfree (srf->sizes); out_no_sizes: -ttm_base_object_kfree (user_srf, base); +ttm_prime_object_kfree (user_srf, prime); out_no_user_srf:ttm_mem_global_free (vmw_mem_glob (dev_priv), size); out_unlock:
@@ -859,13 +860,14 @@ int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,return -EINVAL ; } -if (unlikely (base->object_type !=VMW_RES_SURFACE )) +if (unlikely (ttm_base_object_type (base) !=VMW_RES_SURFACE )) goto out_bad_resource; - user_srf = container_of(base, struct vmw_user_surface, base); + user_srf = container_of(base, struct vmw_user_surface, prime.base); srf = &user_srf->srf; - ret =ttm_ref_object_add (tfile, &user_srf->base,TTM_REF_USAGE ,NULL ); + ret =ttm_ref_object_add (tfile, &user_srf->prime.base, +TTM_REF_USAGE ,NULL );if (unlikely (ret !=0 )) {DRM_ERROR ("Could not add a reference to a surface.\n" ); goto out_no_reference;
Signature · 1 line
1.7.10.4
PATCH 4/4 drm/vmwgfx: Make vmwgfx dma buffers prime aware
In reply to Thomas HellstromShould we need to share dma buffers using prime, let's make them prime aware.
--- drivers/gpu/drm/vmwgfx/vmwgfx_resource.c | 45 +++++++++++++++++------------- 1 file changed, 25 insertions(+), 20 deletions(-)
drivers/gpu/drm/vmwgfx/vmwgfx_resource.c +25 -20
@@ -35,7 +35,7 @@#define VMW_RES_EVICT_ERR_COUNT 10struct vmw_user_dma_buffer { -struct ttm_base_object base; +struct ttm_prime_object prime;struct vmw_dma_buffer dma; };
@@ -387,7 +387,7 @@ static void vmw_user_dmabuf_destroy(struct ttm_buffer_object *bo) {struct vmw_user_dma_buffer *vmw_user_bo =vmw_user_dma_buffer (bo); -ttm_base_object_kfree (vmw_user_bo, base); +ttm_prime_object_kfree (vmw_user_bo, prime); }static void vmw_user_dmabuf_release (struct ttm_base_object **p_base)
@@ -401,7 +401,8 @@ static void vmw_user_dmabuf_release(struct ttm_base_object **p_base)if (unlikely (base ==NULL ))return ; - vmw_user_bo = container_of(base, struct vmw_user_dma_buffer, base); + vmw_user_bo = container_of(base, struct vmw_user_dma_buffer, + prime.base); bo = &vmw_user_bo->dma.base;ttm_bo_unref (&bo); }
@@ -442,18 +443,19 @@ int vmw_user_dmabuf_alloc(struct vmw_private *dev_priv,return ret; tmp =ttm_bo_reference (&user_bo->dma.base); - ret =ttm_base_object_init (tfile, - &user_bo->base, - shareable, - ttm_buffer_type, - &vmw_user_dmabuf_release,NULL ); + ret =ttm_prime_object_init (tfile, + size, + &user_bo->prime, + shareable, + ttm_buffer_type, + &vmw_user_dmabuf_release,NULL );if (unlikely (ret !=0 )) {ttm_bo_unref (&tmp); goto out_no_base_object; } *p_dma_buf = &user_bo->dma; - *handle = user_bo->base.hash.key; + *handle = user_bo->prime.base.hash.key; out_no_base_object:return ret;
@@ -475,8 +477,8 @@ int vmw_user_dmabuf_verify_access(struct ttm_buffer_object *bo,return -EPERM ; vmw_user_bo =vmw_user_dma_buffer (bo); -return (vmw_user_bo->base.tfile == tfile || - vmw_user_bo->base.shareable) ?0 : -EPERM ; +return (vmw_user_bo->prime.base.tfile == tfile || + vmw_user_bo->prime.base.shareable) ?0 : -EPERM ; } int vmw_dmabuf_alloc_ioctl(struct drm_device *dev, void *data,
@@ -538,14 +540,15 @@ int vmw_user_dmabuf_lookup(struct ttm_object_file *tfile,return -ESRCH ; } -if (unlikely (base->object_type != ttm_buffer_type)) { +if (unlikely (ttm_base_object_type (base) != ttm_buffer_type)) {ttm_base_object_unref (&base);printk (KERN_ERR "Invalid buffer object handle 0x%08lx.\n" , (unsigned long )handle);return -EINVAL ; } - vmw_user_bo = container_of(base, struct vmw_user_dma_buffer, base); + vmw_user_bo = container_of(base, struct vmw_user_dma_buffer, + prime.base); (void )ttm_bo_reference (&vmw_user_bo->dma.base);ttm_base_object_unref (&base); *out = &vmw_user_bo->dma;
@@ -562,7 +565,8 @@ int vmw_user_dmabuf_reference(struct ttm_object_file *tfile,return -EINVAL ; user_bo = container_of(dma_buf, struct vmw_user_dma_buffer, dma); -return ttm_ref_object_add (tfile, &user_bo->base,TTM_REF_USAGE ,NULL ); +return ttm_ref_object_add (tfile, &user_bo->prime.base, +TTM_REF_USAGE ,NULL ); }/*
@@ -807,15 +811,16 @@ int vmw_dumb_create(struct drm_file *file_priv, goto out_no_dmabuf; tmp =ttm_bo_reference (&vmw_user_bo->dma.base); - ret =ttm_base_object_init (vmw_fpriv (file_priv)->tfile, - &vmw_user_bo->base, - false, - ttm_buffer_type, - &vmw_user_dmabuf_release,NULL ); + ret =ttm_prime_object_init (vmw_fpriv (file_priv)->tfile, + args->size, + &vmw_user_bo->prime, + false, + ttm_buffer_type, + &vmw_user_dmabuf_release,NULL );if (unlikely (ret !=0 )) goto out_no_base_object; - args->handle = vmw_user_bo->base.hash.key; + args->handle = vmw_user_bo->prime.base.hash.key; out_no_base_object:ttm_bo_unref (&tmp);
Signature · 1 line
1.7.10.4