2008-07-31 02:06:12 +07:00
|
|
|
/*
|
|
|
|
* Copyright © 2008 Intel Corporation
|
|
|
|
*
|
|
|
|
* 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:
|
|
|
|
* Eric Anholt <eric@anholt.net>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/pagemap.h>
|
2011-06-28 06:18:18 +07:00
|
|
|
#include <linux/shmem_fs.h>
|
2011-11-25 22:21:02 +07:00
|
|
|
#include <linux/dma-buf.h>
|
2012-10-03 00:01:07 +07:00
|
|
|
#include <drm/drmP.h>
|
2013-07-25 02:07:52 +07:00
|
|
|
#include <drm/drm_vma_manager.h>
|
2014-09-23 20:46:53 +07:00
|
|
|
#include <drm/drm_gem.h>
|
2014-09-10 17:43:53 +07:00
|
|
|
#include "drm_internal.h"
|
2008-07-31 02:06:12 +07:00
|
|
|
|
|
|
|
/** @file drm_gem.c
|
|
|
|
*
|
|
|
|
* This file provides some of the base ioctls and library routines for
|
|
|
|
* the graphics memory manager implemented by each device driver.
|
|
|
|
*
|
|
|
|
* Because various devices have different requirements in terms of
|
|
|
|
* synchronization and migration strategies, implementing that is left up to
|
|
|
|
* the driver, and all that the general API provides should be generic --
|
|
|
|
* allocating objects, reading/writing data with the cpu, freeing objects.
|
|
|
|
* Even there, platform-dependent optimizations for reading/writing data with
|
|
|
|
* the CPU mean we'll likely hook those out to driver-specific calls. However,
|
|
|
|
* the DRI2 implementation wants to have at least allocate/mmap be generic.
|
|
|
|
*
|
|
|
|
* The goal was to have swap-backed object allocation managed through
|
|
|
|
* struct file. However, file descriptors as handles to a struct file have
|
|
|
|
* two major failings:
|
|
|
|
* - Process limits prevent more than 1024 or so being used at a time by
|
|
|
|
* default.
|
|
|
|
* - Inability to allocate high fds will aggravate the X Server's select()
|
|
|
|
* handling, and likely that of many GL client applications as well.
|
|
|
|
*
|
|
|
|
* This led to a plan of using our own integer IDs (called handles, following
|
|
|
|
* DRM terminology) to mimic fds, and implement the fd syscalls we need as
|
|
|
|
* ioctls. The objects themselves will still include the struct file so
|
|
|
|
* that we can transition to fds if the required kernel infrastructure shows
|
|
|
|
* up at a later date, and as our interface with shmfs for memory allocation.
|
|
|
|
*/
|
|
|
|
|
2008-11-06 01:31:53 +07:00
|
|
|
/*
|
|
|
|
* We make up offsets for buffer objects so we can recognize them at
|
|
|
|
* mmap time.
|
|
|
|
*/
|
2010-05-28 02:40:27 +07:00
|
|
|
|
|
|
|
/* pgoff in mmap is an unsigned long, so we need to make sure that
|
|
|
|
* the faked up offset will fit
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if BITS_PER_LONG == 64
|
2008-11-06 01:31:53 +07:00
|
|
|
#define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
|
|
|
|
#define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
|
2010-05-28 02:40:27 +07:00
|
|
|
#else
|
|
|
|
#define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
|
|
|
|
#define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
|
|
|
|
#endif
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_init - Initialize the GEM device fields
|
|
|
|
* @dev: drm_devic structure to initialize
|
2008-07-31 02:06:12 +07:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
drm_gem_init(struct drm_device *dev)
|
|
|
|
{
|
2013-12-11 20:24:46 +07:00
|
|
|
struct drm_vma_offset_manager *vma_offset_manager;
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2013-08-15 05:02:44 +07:00
|
|
|
mutex_init(&dev->object_name_lock);
|
2008-07-31 02:06:12 +07:00
|
|
|
idr_init(&dev->object_name_idr);
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2013-12-11 20:24:46 +07:00
|
|
|
vma_offset_manager = kzalloc(sizeof(*vma_offset_manager), GFP_KERNEL);
|
|
|
|
if (!vma_offset_manager) {
|
2008-11-06 01:31:53 +07:00
|
|
|
DRM_ERROR("out of memory\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2013-12-11 20:24:46 +07:00
|
|
|
dev->vma_offset_manager = vma_offset_manager;
|
|
|
|
drm_vma_offset_manager_init(vma_offset_manager,
|
2013-07-25 02:07:52 +07:00
|
|
|
DRM_FILE_PAGE_OFFSET_START,
|
|
|
|
DRM_FILE_PAGE_OFFSET_SIZE);
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-06 01:31:53 +07:00
|
|
|
void
|
|
|
|
drm_gem_destroy(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
|
2013-12-11 20:24:46 +07:00
|
|
|
drm_vma_offset_manager_destroy(dev->vma_offset_manager);
|
|
|
|
kfree(dev->vma_offset_manager);
|
|
|
|
dev->vma_offset_manager = NULL;
|
2008-11-06 01:31:53 +07:00
|
|
|
}
|
|
|
|
|
2010-04-10 02:05:04 +07:00
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_object_init - initialize an allocated shmem-backed GEM object
|
|
|
|
* @dev: drm_device the object should be initialized for
|
|
|
|
* @obj: drm_gem_object to initialize
|
|
|
|
* @size: object size
|
|
|
|
*
|
2011-06-07 20:17:51 +07:00
|
|
|
* Initialize an already allocated GEM object of the specified size with
|
2010-04-10 02:05:04 +07:00
|
|
|
* shmfs backing store.
|
|
|
|
*/
|
|
|
|
int drm_gem_object_init(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, size_t size)
|
|
|
|
{
|
2013-07-11 16:56:32 +07:00
|
|
|
struct file *filp;
|
2010-04-10 02:05:04 +07:00
|
|
|
|
2014-01-20 14:21:54 +07:00
|
|
|
drm_gem_private_object_init(dev, obj, size);
|
|
|
|
|
2013-07-11 16:56:32 +07:00
|
|
|
filp = shmem_file_setup("drm mm object", size, VM_NORESERVE);
|
|
|
|
if (IS_ERR(filp))
|
|
|
|
return PTR_ERR(filp);
|
2010-04-10 02:05:04 +07:00
|
|
|
|
2013-07-11 16:56:32 +07:00
|
|
|
obj->filp = filp;
|
2010-04-10 02:05:04 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_object_init);
|
|
|
|
|
2011-06-07 20:17:51 +07:00
|
|
|
/**
|
2014-08-28 19:34:36 +07:00
|
|
|
* drm_gem_private_object_init - initialize an allocated private GEM object
|
2014-01-21 18:39:00 +07:00
|
|
|
* @dev: drm_device the object should be initialized for
|
|
|
|
* @obj: drm_gem_object to initialize
|
|
|
|
* @size: object size
|
|
|
|
*
|
2011-06-07 20:17:51 +07:00
|
|
|
* Initialize an already allocated GEM object of the specified size with
|
|
|
|
* no GEM provided backing store. Instead the caller is responsible for
|
|
|
|
* backing the object and handling it.
|
|
|
|
*/
|
2013-07-11 16:56:32 +07:00
|
|
|
void drm_gem_private_object_init(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, size_t size)
|
2011-06-07 20:17:51 +07:00
|
|
|
{
|
|
|
|
BUG_ON((size & (PAGE_SIZE - 1)) != 0);
|
|
|
|
|
|
|
|
obj->dev = dev;
|
|
|
|
obj->filp = NULL;
|
|
|
|
|
|
|
|
kref_init(&obj->refcount);
|
2013-08-15 05:02:37 +07:00
|
|
|
obj->handle_count = 0;
|
2011-06-07 20:17:51 +07:00
|
|
|
obj->size = size;
|
2013-08-25 23:28:57 +07:00
|
|
|
drm_vma_node_reset(&obj->vma_node);
|
2011-06-07 20:17:51 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_private_object_init);
|
|
|
|
|
2012-05-20 23:31:16 +07:00
|
|
|
static void
|
|
|
|
drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
|
|
|
|
{
|
2013-08-15 05:02:46 +07:00
|
|
|
/*
|
|
|
|
* Note: obj->dma_buf can't disappear as long as we still hold a
|
|
|
|
* handle reference in obj->handle_count.
|
|
|
|
*/
|
2013-08-15 05:02:49 +07:00
|
|
|
mutex_lock(&filp->prime.lock);
|
2013-08-15 05:02:46 +07:00
|
|
|
if (obj->dma_buf) {
|
2013-08-15 05:02:49 +07:00
|
|
|
drm_prime_remove_buf_handle_locked(&filp->prime,
|
|
|
|
obj->dma_buf);
|
2012-05-20 23:31:16 +07:00
|
|
|
}
|
2013-08-15 05:02:49 +07:00
|
|
|
mutex_unlock(&filp->prime.lock);
|
2012-05-20 23:31:16 +07:00
|
|
|
}
|
|
|
|
|
2013-08-15 05:02:34 +07:00
|
|
|
/**
|
2014-10-02 19:45:55 +07:00
|
|
|
* drm_gem_object_handle_free - release resources bound to userspace handles
|
2014-01-21 18:39:00 +07:00
|
|
|
* @obj: GEM object to clean up.
|
|
|
|
*
|
2013-08-15 05:02:34 +07:00
|
|
|
* Called after the last handle to the object has been closed
|
|
|
|
*
|
|
|
|
* Removes any name for the object. Note that this must be
|
|
|
|
* called before drm_gem_object_free or we'll be touching
|
|
|
|
* freed memory
|
|
|
|
*/
|
|
|
|
static void drm_gem_object_handle_free(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
|
|
|
|
/* Remove any name for this object */
|
|
|
|
if (obj->name) {
|
|
|
|
idr_remove(&dev->object_name_idr, obj->name);
|
|
|
|
obj->name = 0;
|
2013-08-15 05:02:37 +07:00
|
|
|
}
|
2013-08-15 05:02:34 +07:00
|
|
|
}
|
|
|
|
|
2013-08-15 05:02:46 +07:00
|
|
|
static void drm_gem_object_exported_dma_buf_free(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
/* Unbreak the reference cycle if we have an exported dma_buf. */
|
|
|
|
if (obj->dma_buf) {
|
|
|
|
dma_buf_put(obj->dma_buf);
|
|
|
|
obj->dma_buf = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-15 05:02:39 +07:00
|
|
|
static void
|
2013-08-15 05:02:34 +07:00
|
|
|
drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
|
|
|
|
{
|
2016-01-04 17:11:00 +07:00
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
bool final = false;
|
|
|
|
|
2013-08-15 05:02:37 +07:00
|
|
|
if (WARN_ON(obj->handle_count == 0))
|
2013-08-15 05:02:34 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must bump handle count first as this may be the last
|
|
|
|
* ref, in which case the object would disappear before we
|
|
|
|
* checked for a name
|
|
|
|
*/
|
|
|
|
|
2016-01-04 17:11:00 +07:00
|
|
|
mutex_lock(&dev->object_name_lock);
|
2013-08-15 05:02:46 +07:00
|
|
|
if (--obj->handle_count == 0) {
|
2013-08-15 05:02:34 +07:00
|
|
|
drm_gem_object_handle_free(obj);
|
2013-08-15 05:02:46 +07:00
|
|
|
drm_gem_object_exported_dma_buf_free(obj);
|
2016-01-04 17:11:00 +07:00
|
|
|
final = true;
|
2013-08-15 05:02:46 +07:00
|
|
|
}
|
2016-01-04 17:11:00 +07:00
|
|
|
mutex_unlock(&dev->object_name_lock);
|
2013-08-15 05:02:37 +07:00
|
|
|
|
2016-01-04 17:11:00 +07:00
|
|
|
if (final)
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2013-08-15 05:02:34 +07:00
|
|
|
}
|
|
|
|
|
2016-01-05 16:42:31 +07:00
|
|
|
/*
|
|
|
|
* Called at device or object close to release the file's
|
|
|
|
* handle references on objects.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
drm_gem_object_release_handle(int id, void *ptr, void *data)
|
|
|
|
{
|
|
|
|
struct drm_file *file_priv = data;
|
|
|
|
struct drm_gem_object *obj = ptr;
|
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
|
|
|
|
if (drm_core_check_feature(dev, DRIVER_PRIME))
|
|
|
|
drm_gem_remove_prime_handles(obj, file_priv);
|
|
|
|
drm_vma_node_revoke(&obj->vma_node, file_priv->filp);
|
|
|
|
|
|
|
|
if (dev->driver->gem_close_object)
|
|
|
|
dev->driver->gem_close_object(obj, file_priv);
|
|
|
|
|
|
|
|
drm_gem_object_handle_unreference_unlocked(obj);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_handle_delete - deletes the given file-private handle
|
|
|
|
* @filp: drm file-private structure to use for the handle look up
|
|
|
|
* @handle: userspace handle to delete
|
|
|
|
*
|
2015-10-23 00:11:29 +07:00
|
|
|
* Removes the GEM handle from the @filp lookup table which has been added with
|
|
|
|
* drm_gem_handle_create(). If this is the last handle also cleans up linked
|
|
|
|
* resources like GEM names.
|
2008-07-31 02:06:12 +07:00
|
|
|
*/
|
2011-02-07 09:16:14 +07:00
|
|
|
int
|
2009-08-23 16:40:55 +07:00
|
|
|
drm_gem_handle_delete(struct drm_file *filp, u32 handle)
|
2008-07-31 02:06:12 +07:00
|
|
|
{
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
|
|
|
|
/* This is gross. The idr system doesn't let us try a delete and
|
|
|
|
* return an error code. It just spews if you fail at deleting.
|
|
|
|
* So, we have to grab a lock around finding the object and then
|
|
|
|
* doing the delete on it and dropping the refcount, or the user
|
|
|
|
* could race us to double-decrement the refcount and cause a
|
|
|
|
* use-after-free later. Given the frequency of our handle lookups,
|
|
|
|
* we may want to use ida for number allocation and a hash table
|
|
|
|
* for the pointers, anyway.
|
|
|
|
*/
|
|
|
|
spin_lock(&filp->table_lock);
|
|
|
|
|
|
|
|
/* Check if we currently have a reference on the object */
|
drm: Release driver references to handle before making it available again
When userspace closes a handle, we remove it from the file->object_idr
and then tell the driver to drop its references to that file/handle.
However, as the file/handle is already available again for reuse, it may
be reallocated back to userspace and active on a new object before the
driver has had a chance to drop the old file/handle references.
Whilst calling back into the driver, we have to drop the
file->table_lock spinlock and so to prevent reusing the closed handle we
mark that handle as stale in the idr, perform the callback and then
remove the handle. We set the stale handle to point to the NULL object,
then any idr_find() whilst the driver is removing the handle will return
NULL, just as if the handle is already removed from idr.
Note: This will be used to have a direct handle -> vma lookup table,
instead of first a handle -> obj lookup, and then an (obj, vm) -> vma
lookup.
v2: Use NULL rather than an ERR_PTR to avoid having to adjust callers.
idr_alloc() tracks existing handles using an internal bitmap, so we are
free to use the NULL object as our stale identifier.
v3: Needed to update the return value check after changing from using
the stale error pointer to NULL.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: dri-devel@lists.freedesktop.org
Cc: David Airlie <airlied@linux.ie>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Rob Clark <robdclark@gmail.com>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Cc: Thierry Reding <treding@nvidia.com>
[danvet: Add note about the use-case.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1460721308-32405-1-git-send-email-chris@chris-wilson.co.uk
2016-04-15 18:55:08 +07:00
|
|
|
obj = idr_replace(&filp->object_idr, NULL, handle);
|
|
|
|
spin_unlock(&filp->table_lock);
|
|
|
|
if (IS_ERR_OR_NULL(obj))
|
2008-07-31 02:06:12 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
drm: Release driver references to handle before making it available again
When userspace closes a handle, we remove it from the file->object_idr
and then tell the driver to drop its references to that file/handle.
However, as the file/handle is already available again for reuse, it may
be reallocated back to userspace and active on a new object before the
driver has had a chance to drop the old file/handle references.
Whilst calling back into the driver, we have to drop the
file->table_lock spinlock and so to prevent reusing the closed handle we
mark that handle as stale in the idr, perform the callback and then
remove the handle. We set the stale handle to point to the NULL object,
then any idr_find() whilst the driver is removing the handle will return
NULL, just as if the handle is already removed from idr.
Note: This will be used to have a direct handle -> vma lookup table,
instead of first a handle -> obj lookup, and then an (obj, vm) -> vma
lookup.
v2: Use NULL rather than an ERR_PTR to avoid having to adjust callers.
idr_alloc() tracks existing handles using an internal bitmap, so we are
free to use the NULL object as our stale identifier.
v3: Needed to update the return value check after changing from using
the stale error pointer to NULL.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Cc: dri-devel@lists.freedesktop.org
Cc: David Airlie <airlied@linux.ie>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Rob Clark <robdclark@gmail.com>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
Cc: Thierry Reding <treding@nvidia.com>
[danvet: Add note about the use-case.]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/1460721308-32405-1-git-send-email-chris@chris-wilson.co.uk
2016-04-15 18:55:08 +07:00
|
|
|
/* Release driver's reference and decrement refcount. */
|
|
|
|
drm_gem_object_release_handle(handle, obj, filp);
|
|
|
|
|
|
|
|
/* And finally make the handle available for future allocations. */
|
|
|
|
spin_lock(&filp->table_lock);
|
2008-07-31 02:06:12 +07:00
|
|
|
idr_remove(&filp->object_idr, handle);
|
|
|
|
spin_unlock(&filp->table_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-02-07 09:16:14 +07:00
|
|
|
EXPORT_SYMBOL(drm_gem_handle_delete);
|
2008-07-31 02:06:12 +07:00
|
|
|
|
2013-07-16 14:12:04 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_dumb_destroy - dumb fb callback helper for gem based drivers
|
2014-01-21 18:39:00 +07:00
|
|
|
* @file: drm file-private structure to remove the dumb handle from
|
|
|
|
* @dev: corresponding drm_device
|
|
|
|
* @handle: the dumb handle to remove
|
2013-07-16 14:12:04 +07:00
|
|
|
*
|
|
|
|
* This implements the ->dumb_destroy kms driver callback for drivers which use
|
|
|
|
* gem to manage their backing storage.
|
|
|
|
*/
|
|
|
|
int drm_gem_dumb_destroy(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle)
|
|
|
|
{
|
|
|
|
return drm_gem_handle_delete(file, handle);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_dumb_destroy);
|
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
/**
|
2013-08-15 05:02:45 +07:00
|
|
|
* drm_gem_handle_create_tail - internal functions to create a handle
|
2014-01-21 18:39:00 +07:00
|
|
|
* @file_priv: drm file-private structure to register the handle for
|
|
|
|
* @obj: object to register
|
2014-11-03 19:20:52 +07:00
|
|
|
* @handlep: pointer to return the created handle to the caller
|
2013-08-15 05:02:45 +07:00
|
|
|
*
|
|
|
|
* This expects the dev->object_name_lock to be held already and will drop it
|
|
|
|
* before returning. Used to avoid races in establishing new handles when
|
|
|
|
* importing an object from either an flink name or a dma-buf.
|
2015-10-23 00:11:29 +07:00
|
|
|
*
|
|
|
|
* Handles must be release again through drm_gem_handle_delete(). This is done
|
|
|
|
* when userspace closes @file_priv for all attached handles, or through the
|
|
|
|
* GEM_CLOSE ioctl for individual handles.
|
2008-07-31 02:06:12 +07:00
|
|
|
*/
|
|
|
|
int
|
2013-08-15 05:02:45 +07:00
|
|
|
drm_gem_handle_create_tail(struct drm_file *file_priv,
|
|
|
|
struct drm_gem_object *obj,
|
|
|
|
u32 *handlep)
|
2008-07-31 02:06:12 +07:00
|
|
|
{
|
2011-06-09 07:24:59 +07:00
|
|
|
struct drm_device *dev = obj->dev;
|
2016-01-05 16:42:30 +07:00
|
|
|
u32 handle;
|
2011-06-09 07:24:59 +07:00
|
|
|
int ret;
|
2008-07-31 02:06:12 +07:00
|
|
|
|
2013-08-15 05:02:45 +07:00
|
|
|
WARN_ON(!mutex_is_locked(&dev->object_name_lock));
|
2016-01-04 17:11:00 +07:00
|
|
|
if (obj->handle_count++ == 0)
|
|
|
|
drm_gem_object_reference(obj);
|
2013-08-15 05:02:45 +07:00
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
/*
|
2013-02-28 08:04:08 +07:00
|
|
|
* Get the user-visible handle using idr. Preload and perform
|
|
|
|
* allocation under our spinlock.
|
2008-07-31 02:06:12 +07:00
|
|
|
*/
|
2013-02-28 08:04:08 +07:00
|
|
|
idr_preload(GFP_KERNEL);
|
2008-07-31 02:06:12 +07:00
|
|
|
spin_lock(&file_priv->table_lock);
|
2013-02-28 08:04:08 +07:00
|
|
|
|
|
|
|
ret = idr_alloc(&file_priv->object_idr, obj, 1, 0, GFP_NOWAIT);
|
2016-01-04 17:11:00 +07:00
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
spin_unlock(&file_priv->table_lock);
|
2013-02-28 08:04:08 +07:00
|
|
|
idr_preload_end();
|
2016-01-04 17:11:00 +07:00
|
|
|
|
2013-08-15 05:02:44 +07:00
|
|
|
mutex_unlock(&dev->object_name_lock);
|
2016-01-04 17:10:59 +07:00
|
|
|
if (ret < 0)
|
|
|
|
goto err_unref;
|
|
|
|
|
2016-01-05 16:42:30 +07:00
|
|
|
handle = ret;
|
2008-07-31 02:06:12 +07:00
|
|
|
|
2013-08-25 23:28:58 +07:00
|
|
|
ret = drm_vma_node_allow(&obj->vma_node, file_priv->filp);
|
2016-01-04 17:10:59 +07:00
|
|
|
if (ret)
|
|
|
|
goto err_remove;
|
2011-06-09 07:24:59 +07:00
|
|
|
|
|
|
|
if (dev->driver->gem_open_object) {
|
|
|
|
ret = dev->driver->gem_open_object(obj, file_priv);
|
2016-01-04 17:10:59 +07:00
|
|
|
if (ret)
|
|
|
|
goto err_revoke;
|
2011-06-09 07:24:59 +07:00
|
|
|
}
|
|
|
|
|
2016-01-05 16:42:30 +07:00
|
|
|
*handlep = handle;
|
2008-07-31 02:06:12 +07:00
|
|
|
return 0;
|
2016-01-04 17:10:59 +07:00
|
|
|
|
|
|
|
err_revoke:
|
|
|
|
drm_vma_node_revoke(&obj->vma_node, file_priv->filp);
|
|
|
|
err_remove:
|
|
|
|
spin_lock(&file_priv->table_lock);
|
2016-01-05 16:42:30 +07:00
|
|
|
idr_remove(&file_priv->object_idr, handle);
|
2016-01-04 17:10:59 +07:00
|
|
|
spin_unlock(&file_priv->table_lock);
|
|
|
|
err_unref:
|
|
|
|
drm_gem_object_handle_unreference_unlocked(obj);
|
|
|
|
return ret;
|
2008-07-31 02:06:12 +07:00
|
|
|
}
|
2013-08-15 05:02:45 +07:00
|
|
|
|
|
|
|
/**
|
2014-11-03 19:20:52 +07:00
|
|
|
* drm_gem_handle_create - create a gem handle for an object
|
2014-01-21 18:39:00 +07:00
|
|
|
* @file_priv: drm file-private structure to register the handle for
|
|
|
|
* @obj: object to register
|
|
|
|
* @handlep: pionter to return the created handle to the caller
|
|
|
|
*
|
2013-08-15 05:02:45 +07:00
|
|
|
* Create a handle for this object. This adds a handle reference
|
|
|
|
* to the object, which includes a regular reference count. Callers
|
|
|
|
* will likely want to dereference the object afterwards.
|
|
|
|
*/
|
2014-11-03 19:20:52 +07:00
|
|
|
int drm_gem_handle_create(struct drm_file *file_priv,
|
|
|
|
struct drm_gem_object *obj,
|
|
|
|
u32 *handlep)
|
2013-08-15 05:02:45 +07:00
|
|
|
{
|
|
|
|
mutex_lock(&obj->dev->object_name_lock);
|
|
|
|
|
|
|
|
return drm_gem_handle_create_tail(file_priv, obj, handlep);
|
|
|
|
}
|
2008-07-31 02:06:12 +07:00
|
|
|
EXPORT_SYMBOL(drm_gem_handle_create);
|
|
|
|
|
2011-08-10 20:09:07 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_gem_free_mmap_offset - release a fake mmap offset for an object
|
|
|
|
* @obj: obj in question
|
|
|
|
*
|
|
|
|
* This routine frees fake offsets allocated by drm_gem_create_mmap_offset().
|
2016-03-30 16:40:52 +07:00
|
|
|
*
|
|
|
|
* Note that drm_gem_object_release() already calls this function, so drivers
|
|
|
|
* don't have to take care of releasing the mmap offset themselves when freeing
|
|
|
|
* the GEM object.
|
2011-08-10 20:09:07 +07:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
drm_gem_free_mmap_offset(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
|
2013-12-11 20:24:46 +07:00
|
|
|
drm_vma_offset_remove(dev->vma_offset_manager, &obj->vma_node);
|
2011-08-10 20:09:07 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_free_mmap_offset);
|
|
|
|
|
|
|
|
/**
|
2013-08-08 00:41:23 +07:00
|
|
|
* drm_gem_create_mmap_offset_size - create a fake mmap offset for an object
|
2011-08-10 20:09:07 +07:00
|
|
|
* @obj: obj in question
|
2013-08-08 00:41:23 +07:00
|
|
|
* @size: the virtual size
|
2011-08-10 20:09:07 +07:00
|
|
|
*
|
|
|
|
* GEM memory mapping works by handing back to userspace a fake mmap offset
|
|
|
|
* it can use in a subsequent mmap(2) call. The DRM core code then looks
|
|
|
|
* up the object based on the offset and sets up the various memory mapping
|
|
|
|
* structures.
|
|
|
|
*
|
2013-08-08 00:41:23 +07:00
|
|
|
* This routine allocates and attaches a fake offset for @obj, in cases where
|
|
|
|
* the virtual size differs from the physical size (ie. obj->size). Otherwise
|
|
|
|
* just use drm_gem_create_mmap_offset().
|
2016-03-30 16:40:52 +07:00
|
|
|
*
|
|
|
|
* This function is idempotent and handles an already allocated mmap offset
|
|
|
|
* transparently. Drivers do not need to check for this case.
|
2011-08-10 20:09:07 +07:00
|
|
|
*/
|
|
|
|
int
|
2013-08-08 00:41:23 +07:00
|
|
|
drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size)
|
2011-08-10 20:09:07 +07:00
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
|
2013-12-11 20:24:46 +07:00
|
|
|
return drm_vma_offset_add(dev->vma_offset_manager, &obj->vma_node,
|
2013-08-08 00:41:23 +07:00
|
|
|
size / PAGE_SIZE);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_create_mmap_offset_size);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_gem_create_mmap_offset - create a fake mmap offset for an object
|
|
|
|
* @obj: obj in question
|
|
|
|
*
|
|
|
|
* GEM memory mapping works by handing back to userspace a fake mmap offset
|
|
|
|
* it can use in a subsequent mmap(2) call. The DRM core code then looks
|
|
|
|
* up the object based on the offset and sets up the various memory mapping
|
|
|
|
* structures.
|
|
|
|
*
|
|
|
|
* This routine allocates and attaches a fake offset for @obj.
|
2016-03-30 16:40:52 +07:00
|
|
|
*
|
|
|
|
* Drivers can call drm_gem_free_mmap_offset() before freeing @obj to release
|
|
|
|
* the fake offset again.
|
2013-08-08 00:41:23 +07:00
|
|
|
*/
|
|
|
|
int drm_gem_create_mmap_offset(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
return drm_gem_create_mmap_offset_size(obj, obj->size);
|
2011-08-10 20:09:07 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_create_mmap_offset);
|
|
|
|
|
2013-08-08 00:41:24 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_get_pages - helper to allocate backing pages for a GEM object
|
|
|
|
* from shmem
|
|
|
|
* @obj: obj in question
|
drm/gem: remove misleading gfp parameter to get_pages()
drm_gem_get_pages() currently allows passing a 'gfp' parameter that is
passed to shmem combined with mapping_gfp_mask(). Given that the default
mapping_gfp_mask() is GFP_HIGHUSER, it is _very_ unlikely that anyone will
ever make use of that parameter. In fact, all drivers currently pass
redundant flags or 0.
This patch removes the 'gfp' parameter. The only reason to keep it is to
remove flags like __GFP_WAIT. But in its current form, it can only be used
to add flags. So to remove __GFP_WAIT, you'd have to drop it from the
mapping_gfp_mask, which again is stupid as this mask is used by shmem-core
for other allocations, too.
If any driver ever requires that parameter, we can introduce a new helper
that takes the raw 'gfp' parameter. The caller'd be responsible to combine
it with mapping_gfp_mask() in a suitable way. The current
drm_gem_get_pages() helper would then simply use mapping_gfp_mask() and
call the new helper. This is what shmem_read_mapping_pages{_gfp,} does
right now.
Moreover, the gfp-zone flag-usage is not obvious: If you pass a modified
zone, shmem core will WARN() or even BUG(). In other words, the following
must be true for 'gfp' passed to shmem_read_mapping_pages_gfp():
gfp_zone(mapping_gfp_mask(mapping)) == gfp_zone(gfp)
Add a comment to drm_gem_read_pages() explaining that constraint.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-05-25 17:59:47 +07:00
|
|
|
*
|
|
|
|
* This reads the page-array of the shmem-backing storage of the given gem
|
|
|
|
* object. An array of pages is returned. If a page is not allocated or
|
|
|
|
* swapped-out, this will allocate/swap-in the required pages. Note that the
|
|
|
|
* whole object is covered by the page-array and pinned in memory.
|
|
|
|
*
|
|
|
|
* Use drm_gem_put_pages() to release the array and unpin all pages.
|
|
|
|
*
|
|
|
|
* This uses the GFP-mask set on the shmem-mapping (see mapping_set_gfp_mask()).
|
|
|
|
* If you require other GFP-masks, you have to do those allocations yourself.
|
|
|
|
*
|
|
|
|
* Note that you are not allowed to change gfp-zones during runtime. That is,
|
|
|
|
* shmem_read_mapping_page_gfp() must be called with the same gfp_zone(gfp) as
|
|
|
|
* set during initialization. If you have special zone constraints, set them
|
|
|
|
* after drm_gem_init_object() via mapping_set_gfp_mask(). shmem-core takes care
|
|
|
|
* to keep pages in the required zone during swap-in.
|
2013-08-08 00:41:24 +07:00
|
|
|
*/
|
drm/gem: remove misleading gfp parameter to get_pages()
drm_gem_get_pages() currently allows passing a 'gfp' parameter that is
passed to shmem combined with mapping_gfp_mask(). Given that the default
mapping_gfp_mask() is GFP_HIGHUSER, it is _very_ unlikely that anyone will
ever make use of that parameter. In fact, all drivers currently pass
redundant flags or 0.
This patch removes the 'gfp' parameter. The only reason to keep it is to
remove flags like __GFP_WAIT. But in its current form, it can only be used
to add flags. So to remove __GFP_WAIT, you'd have to drop it from the
mapping_gfp_mask, which again is stupid as this mask is used by shmem-core
for other allocations, too.
If any driver ever requires that parameter, we can introduce a new helper
that takes the raw 'gfp' parameter. The caller'd be responsible to combine
it with mapping_gfp_mask() in a suitable way. The current
drm_gem_get_pages() helper would then simply use mapping_gfp_mask() and
call the new helper. This is what shmem_read_mapping_pages{_gfp,} does
right now.
Moreover, the gfp-zone flag-usage is not obvious: If you pass a modified
zone, shmem core will WARN() or even BUG(). In other words, the following
must be true for 'gfp' passed to shmem_read_mapping_pages_gfp():
gfp_zone(mapping_gfp_mask(mapping)) == gfp_zone(gfp)
Add a comment to drm_gem_read_pages() explaining that constraint.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-05-25 17:59:47 +07:00
|
|
|
struct page **drm_gem_get_pages(struct drm_gem_object *obj)
|
2013-08-08 00:41:24 +07:00
|
|
|
{
|
|
|
|
struct address_space *mapping;
|
|
|
|
struct page *p, **pages;
|
|
|
|
int i, npages;
|
|
|
|
|
|
|
|
/* This is the shared memory object that backs the GEM resource */
|
2015-12-05 11:45:44 +07:00
|
|
|
mapping = obj->filp->f_mapping;
|
2013-08-08 00:41:24 +07:00
|
|
|
|
|
|
|
/* We already BUG_ON() for non-page-aligned sizes in
|
|
|
|
* drm_gem_object_init(), so we should never hit this unless
|
|
|
|
* driver author is doing something really wrong:
|
|
|
|
*/
|
|
|
|
WARN_ON((obj->size & (PAGE_SIZE - 1)) != 0);
|
|
|
|
|
|
|
|
npages = obj->size >> PAGE_SHIFT;
|
|
|
|
|
|
|
|
pages = drm_malloc_ab(npages, sizeof(struct page *));
|
|
|
|
if (pages == NULL)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
for (i = 0; i < npages; i++) {
|
drm/gem: remove misleading gfp parameter to get_pages()
drm_gem_get_pages() currently allows passing a 'gfp' parameter that is
passed to shmem combined with mapping_gfp_mask(). Given that the default
mapping_gfp_mask() is GFP_HIGHUSER, it is _very_ unlikely that anyone will
ever make use of that parameter. In fact, all drivers currently pass
redundant flags or 0.
This patch removes the 'gfp' parameter. The only reason to keep it is to
remove flags like __GFP_WAIT. But in its current form, it can only be used
to add flags. So to remove __GFP_WAIT, you'd have to drop it from the
mapping_gfp_mask, which again is stupid as this mask is used by shmem-core
for other allocations, too.
If any driver ever requires that parameter, we can introduce a new helper
that takes the raw 'gfp' parameter. The caller'd be responsible to combine
it with mapping_gfp_mask() in a suitable way. The current
drm_gem_get_pages() helper would then simply use mapping_gfp_mask() and
call the new helper. This is what shmem_read_mapping_pages{_gfp,} does
right now.
Moreover, the gfp-zone flag-usage is not obvious: If you pass a modified
zone, shmem core will WARN() or even BUG(). In other words, the following
must be true for 'gfp' passed to shmem_read_mapping_pages_gfp():
gfp_zone(mapping_gfp_mask(mapping)) == gfp_zone(gfp)
Add a comment to drm_gem_read_pages() explaining that constraint.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-05-25 17:59:47 +07:00
|
|
|
p = shmem_read_mapping_page(mapping, i);
|
2013-08-08 00:41:24 +07:00
|
|
|
if (IS_ERR(p))
|
|
|
|
goto fail;
|
|
|
|
pages[i] = p;
|
|
|
|
|
2014-05-25 19:34:08 +07:00
|
|
|
/* Make sure shmem keeps __GFP_DMA32 allocated pages in the
|
|
|
|
* correct region during swapin. Note that this requires
|
|
|
|
* __GFP_DMA32 to be set in mapping_gfp_mask(inode->i_mapping)
|
|
|
|
* so shmem can relocate pages during swapin if required.
|
2013-08-08 00:41:24 +07:00
|
|
|
*/
|
2015-11-07 07:28:49 +07:00
|
|
|
BUG_ON(mapping_gfp_constraint(mapping, __GFP_DMA32) &&
|
2013-08-08 00:41:24 +07:00
|
|
|
(page_to_pfn(p) >= 0x00100000UL));
|
|
|
|
}
|
|
|
|
|
|
|
|
return pages;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
while (i--)
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 19:29:47 +07:00
|
|
|
put_page(pages[i]);
|
2013-08-08 00:41:24 +07:00
|
|
|
|
|
|
|
drm_free_large(pages);
|
|
|
|
return ERR_CAST(p);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_get_pages);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_gem_put_pages - helper to free backing pages for a GEM object
|
|
|
|
* @obj: obj in question
|
|
|
|
* @pages: pages to free
|
|
|
|
* @dirty: if true, pages will be marked as dirty
|
|
|
|
* @accessed: if true, the pages will be marked as accessed
|
|
|
|
*/
|
|
|
|
void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages,
|
|
|
|
bool dirty, bool accessed)
|
|
|
|
{
|
|
|
|
int i, npages;
|
|
|
|
|
|
|
|
/* We already BUG_ON() for non-page-aligned sizes in
|
|
|
|
* drm_gem_object_init(), so we should never hit this unless
|
|
|
|
* driver author is doing something really wrong:
|
|
|
|
*/
|
|
|
|
WARN_ON((obj->size & (PAGE_SIZE - 1)) != 0);
|
|
|
|
|
|
|
|
npages = obj->size >> PAGE_SHIFT;
|
|
|
|
|
|
|
|
for (i = 0; i < npages; i++) {
|
|
|
|
if (dirty)
|
|
|
|
set_page_dirty(pages[i]);
|
|
|
|
|
|
|
|
if (accessed)
|
|
|
|
mark_page_accessed(pages[i]);
|
|
|
|
|
|
|
|
/* Undo the reference we took when populating the table */
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 19:29:47 +07:00
|
|
|
put_page(pages[i]);
|
2013-08-08 00:41:24 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
drm_free_large(pages);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_put_pages);
|
|
|
|
|
2015-10-23 00:11:29 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_object_lookup - look up a GEM object from it's handle
|
|
|
|
* @filp: DRM file private date
|
|
|
|
* @handle: userspace handle
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* A reference to the object named by the handle if such exists on @filp, NULL
|
|
|
|
* otherwise.
|
|
|
|
*/
|
2008-07-31 02:06:12 +07:00
|
|
|
struct drm_gem_object *
|
2016-05-09 17:04:54 +07:00
|
|
|
drm_gem_object_lookup(struct drm_file *filp, u32 handle)
|
2008-07-31 02:06:12 +07:00
|
|
|
{
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
|
|
|
|
spin_lock(&filp->table_lock);
|
|
|
|
|
|
|
|
/* Check if we currently have a reference on the object */
|
|
|
|
obj = idr_find(&filp->object_idr, handle);
|
2016-05-09 17:04:54 +07:00
|
|
|
if (obj)
|
|
|
|
drm_gem_object_reference(obj);
|
2008-07-31 02:06:12 +07:00
|
|
|
|
|
|
|
spin_unlock(&filp->table_lock);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_object_lookup);
|
|
|
|
|
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_close_ioctl - implementation of the GEM_CLOSE ioctl
|
|
|
|
* @dev: drm_device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: drm file-private structure
|
|
|
|
*
|
2008-07-31 02:06:12 +07:00
|
|
|
* Releases the handle to an mm object.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
drm_gem_close_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_gem_close *args = data;
|
|
|
|
int ret;
|
|
|
|
|
2014-09-30 21:49:56 +07:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_GEM))
|
2008-07-31 02:06:12 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
ret = drm_gem_handle_delete(file_priv, args->handle);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_flink_ioctl - implementation of the GEM_FLINK ioctl
|
|
|
|
* @dev: drm_device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: drm file-private structure
|
|
|
|
*
|
2008-07-31 02:06:12 +07:00
|
|
|
* Create a global name for an object, returning the name.
|
|
|
|
*
|
|
|
|
* Note that the name does not hold a reference; when the object
|
|
|
|
* is freed, the name goes away.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
drm_gem_flink_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_gem_flink *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
int ret;
|
|
|
|
|
2014-09-30 21:49:56 +07:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_GEM))
|
2008-07-31 02:06:12 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2016-05-09 17:04:54 +07:00
|
|
|
obj = drm_gem_object_lookup(file_priv, args->handle);
|
2008-07-31 02:06:12 +07:00
|
|
|
if (obj == NULL)
|
2010-08-04 20:19:46 +07:00
|
|
|
return -ENOENT;
|
2008-07-31 02:06:12 +07:00
|
|
|
|
2013-08-15 05:02:44 +07:00
|
|
|
mutex_lock(&dev->object_name_lock);
|
2013-08-15 05:02:37 +07:00
|
|
|
/* prevent races with concurrent gem_close. */
|
|
|
|
if (obj->handle_count == 0) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2009-02-11 21:26:28 +07:00
|
|
|
if (!obj->name) {
|
2016-01-04 17:11:01 +07:00
|
|
|
ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_KERNEL);
|
2013-02-28 08:04:08 +07:00
|
|
|
if (ret < 0)
|
2009-02-11 21:26:28 +07:00
|
|
|
goto err;
|
2013-06-27 06:58:33 +07:00
|
|
|
|
|
|
|
obj->name = ret;
|
2009-02-11 21:26:28 +07:00
|
|
|
}
|
2009-02-09 18:31:41 +07:00
|
|
|
|
2013-06-27 06:58:33 +07:00
|
|
|
args->name = (uint64_t) obj->name;
|
|
|
|
ret = 0;
|
|
|
|
|
2009-02-09 18:31:41 +07:00
|
|
|
err:
|
2013-08-15 05:02:44 +07:00
|
|
|
mutex_unlock(&dev->object_name_lock);
|
2010-02-09 12:49:12 +07:00
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2009-02-09 18:31:41 +07:00
|
|
|
return ret;
|
2008-07-31 02:06:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_open - implementation of the GEM_OPEN ioctl
|
|
|
|
* @dev: drm_device
|
|
|
|
* @data: ioctl data
|
|
|
|
* @file_priv: drm file-private structure
|
|
|
|
*
|
2008-07-31 02:06:12 +07:00
|
|
|
* Open an object using the global name, returning a handle and the size.
|
|
|
|
*
|
|
|
|
* This handle (of course) holds a reference to the object, so the object
|
|
|
|
* will not go away until the handle is deleted.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
drm_gem_open_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
struct drm_gem_open *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
int ret;
|
2009-08-23 16:40:55 +07:00
|
|
|
u32 handle;
|
2008-07-31 02:06:12 +07:00
|
|
|
|
2014-09-30 21:49:56 +07:00
|
|
|
if (!drm_core_check_feature(dev, DRIVER_GEM))
|
2008-07-31 02:06:12 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2013-08-15 05:02:44 +07:00
|
|
|
mutex_lock(&dev->object_name_lock);
|
2008-07-31 02:06:12 +07:00
|
|
|
obj = idr_find(&dev->object_name_idr, (int) args->name);
|
2013-08-15 05:02:45 +07:00
|
|
|
if (obj) {
|
2008-07-31 02:06:12 +07:00
|
|
|
drm_gem_object_reference(obj);
|
2013-08-15 05:02:45 +07:00
|
|
|
} else {
|
|
|
|
mutex_unlock(&dev->object_name_lock);
|
2008-07-31 02:06:12 +07:00
|
|
|
return -ENOENT;
|
2013-08-15 05:02:45 +07:00
|
|
|
}
|
2008-07-31 02:06:12 +07:00
|
|
|
|
2013-08-15 05:02:45 +07:00
|
|
|
/* drm_gem_handle_create_tail unlocks dev->object_name_lock. */
|
|
|
|
ret = drm_gem_handle_create_tail(file_priv, obj, &handle);
|
2010-02-09 12:49:12 +07:00
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2008-07-31 02:06:12 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
args->handle = handle;
|
|
|
|
args->size = obj->size;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* gem_gem_open - initalizes GEM file-private structures at devnode open time
|
|
|
|
* @dev: drm_device which is being opened by userspace
|
|
|
|
* @file_private: drm file-private structure to set up
|
|
|
|
*
|
2008-07-31 02:06:12 +07:00
|
|
|
* Called at device open time, sets up the structure for handling refcounting
|
|
|
|
* of mm objects.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
drm_gem_open(struct drm_device *dev, struct drm_file *file_private)
|
|
|
|
{
|
|
|
|
idr_init(&file_private->object_idr);
|
|
|
|
spin_lock_init(&file_private->table_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_release - release file-private GEM resources
|
|
|
|
* @dev: drm_device which is being closed by userspace
|
|
|
|
* @file_private: drm file-private structure to clean up
|
|
|
|
*
|
2008-07-31 02:06:12 +07:00
|
|
|
* Called at close time when the filp is going away.
|
|
|
|
*
|
|
|
|
* Releases any remaining references on objects by this filp.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
|
|
|
|
{
|
|
|
|
idr_for_each(&file_private->object_idr,
|
2011-06-09 07:24:59 +07:00
|
|
|
&drm_gem_object_release_handle, file_private);
|
2008-07-31 02:06:12 +07:00
|
|
|
idr_destroy(&file_private->object_idr);
|
|
|
|
}
|
|
|
|
|
2016-03-30 16:40:52 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_object_release - release GEM buffer object resources
|
|
|
|
* @obj: GEM buffer object
|
|
|
|
*
|
|
|
|
* This releases any structures and resources used by @obj and is the invers of
|
|
|
|
* drm_gem_object_init().
|
|
|
|
*/
|
2010-04-10 02:05:05 +07:00
|
|
|
void
|
|
|
|
drm_gem_object_release(struct drm_gem_object *obj)
|
2010-02-09 12:49:11 +07:00
|
|
|
{
|
2013-08-15 05:02:46 +07:00
|
|
|
WARN_ON(obj->dma_buf);
|
|
|
|
|
2011-06-07 20:17:51 +07:00
|
|
|
if (obj->filp)
|
2014-01-21 02:07:49 +07:00
|
|
|
fput(obj->filp);
|
2014-01-21 02:05:43 +07:00
|
|
|
|
|
|
|
drm_gem_free_mmap_offset(obj);
|
2010-02-09 12:49:11 +07:00
|
|
|
}
|
2010-04-10 02:05:05 +07:00
|
|
|
EXPORT_SYMBOL(drm_gem_object_release);
|
2010-02-09 12:49:11 +07:00
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
/**
|
2014-01-21 18:39:00 +07:00
|
|
|
* drm_gem_object_free - free a GEM object
|
|
|
|
* @kref: kref of the object to free
|
|
|
|
*
|
2008-07-31 02:06:12 +07:00
|
|
|
* Called after the last reference to the object has been lost.
|
2016-06-02 04:40:36 +07:00
|
|
|
* Must be called holding &drm_device->struct_mutex.
|
2008-07-31 02:06:12 +07:00
|
|
|
*
|
|
|
|
* Frees the object
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
drm_gem_object_free(struct kref *kref)
|
|
|
|
{
|
2015-10-15 14:36:26 +07:00
|
|
|
struct drm_gem_object *obj =
|
|
|
|
container_of(kref, struct drm_gem_object, refcount);
|
2008-07-31 02:06:12 +07:00
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
|
2016-05-04 19:10:44 +07:00
|
|
|
if (dev->driver->gem_free_object_unlocked) {
|
2016-05-02 15:40:51 +07:00
|
|
|
dev->driver->gem_free_object_unlocked(obj);
|
2016-05-04 19:10:44 +07:00
|
|
|
} else if (dev->driver->gem_free_object) {
|
|
|
|
WARN_ON(!mutex_is_locked(&dev->struct_mutex));
|
|
|
|
|
2008-07-31 02:06:12 +07:00
|
|
|
dev->driver->gem_free_object(obj);
|
2016-05-04 19:10:44 +07:00
|
|
|
}
|
2008-07-31 02:06:12 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_object_free);
|
|
|
|
|
2016-05-02 15:40:51 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_object_unreference_unlocked - release a GEM BO reference
|
|
|
|
* @obj: GEM buffer object
|
|
|
|
*
|
|
|
|
* This releases a reference to @obj. Callers must not hold the
|
|
|
|
* dev->struct_mutex lock when calling this function.
|
|
|
|
*
|
|
|
|
* See also __drm_gem_object_unreference().
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_device *dev;
|
|
|
|
|
|
|
|
if (!obj)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev = obj->dev;
|
|
|
|
might_lock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
if (dev->driver->gem_free_object_unlocked)
|
|
|
|
kref_put(&obj->refcount, drm_gem_object_free);
|
|
|
|
else if (kref_put_mutex(&obj->refcount, drm_gem_object_free,
|
|
|
|
&dev->struct_mutex))
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_object_unreference_unlocked);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_gem_object_unreference - release a GEM BO reference
|
|
|
|
* @obj: GEM buffer object
|
|
|
|
*
|
|
|
|
* This releases a reference to @obj. Callers must hold the dev->struct_mutex
|
|
|
|
* lock when calling this function, even when the driver doesn't use
|
|
|
|
* dev->struct_mutex for anything.
|
|
|
|
*
|
|
|
|
* For drivers not encumbered with legacy locking use
|
|
|
|
* drm_gem_object_unreference_unlocked() instead.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
drm_gem_object_unreference(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
if (obj) {
|
|
|
|
WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex));
|
|
|
|
|
|
|
|
kref_put(&obj->refcount, drm_gem_object_free);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_object_unreference);
|
|
|
|
|
2015-10-23 00:11:29 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_vm_open - vma->ops->open implementation for GEM
|
|
|
|
* @vma: VM area structure
|
|
|
|
*
|
|
|
|
* This function implements the #vm_operations_struct open() callback for GEM
|
|
|
|
* drivers. This must be used together with drm_gem_vm_close().
|
|
|
|
*/
|
2009-02-12 05:01:46 +07:00
|
|
|
void drm_gem_vm_open(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct drm_gem_object *obj = vma->vm_private_data;
|
|
|
|
|
|
|
|
drm_gem_object_reference(obj);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_vm_open);
|
|
|
|
|
2015-10-23 00:11:29 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_vm_close - vma->ops->close implementation for GEM
|
|
|
|
* @vma: VM area structure
|
|
|
|
*
|
|
|
|
* This function implements the #vm_operations_struct close() callback for GEM
|
|
|
|
* drivers. This must be used together with drm_gem_vm_open().
|
|
|
|
*/
|
2009-02-12 05:01:46 +07:00
|
|
|
void drm_gem_vm_close(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct drm_gem_object *obj = vma->vm_private_data;
|
|
|
|
|
2015-07-10 04:32:33 +07:00
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2009-02-12 05:01:46 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_vm_close);
|
|
|
|
|
2013-04-16 19:14:52 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_mmap_obj - memory map a GEM object
|
|
|
|
* @obj: the GEM object to map
|
|
|
|
* @obj_size: the object size to be mapped, in bytes
|
|
|
|
* @vma: VMA for the area to be mapped
|
|
|
|
*
|
|
|
|
* Set up the VMA to prepare mapping of the GEM object using the gem_vm_ops
|
|
|
|
* provided by the driver. Depending on their requirements, drivers can either
|
|
|
|
* provide a fault handler in their gem_vm_ops (in which case any accesses to
|
|
|
|
* the object will be trapped, to perform migration, GTT binding, surface
|
|
|
|
* register allocation, or performance monitoring), or mmap the buffer memory
|
|
|
|
* synchronously after calling drm_gem_mmap_obj.
|
|
|
|
*
|
|
|
|
* This function is mainly intended to implement the DMABUF mmap operation, when
|
|
|
|
* the GEM object is not looked up based on its fake offset. To implement the
|
|
|
|
* DRM mmap operation, drivers should use the drm_gem_mmap() function.
|
|
|
|
*
|
2013-08-25 23:28:58 +07:00
|
|
|
* drm_gem_mmap_obj() assumes the user is granted access to the buffer while
|
|
|
|
* drm_gem_mmap() prevents unprivileged users from mapping random objects. So
|
|
|
|
* callers must verify access restrictions before calling this helper.
|
|
|
|
*
|
2013-04-16 19:14:52 +07:00
|
|
|
* Return 0 or success or -EINVAL if the object size is smaller than the VMA
|
|
|
|
* size, or if no gem_vm_ops are provided.
|
|
|
|
*/
|
|
|
|
int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->dev;
|
|
|
|
|
|
|
|
/* Check for valid size. */
|
|
|
|
if (obj_size < vma->vm_end - vma->vm_start)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!dev->driver->gem_vm_ops)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP;
|
|
|
|
vma->vm_ops = dev->driver->gem_vm_ops;
|
|
|
|
vma->vm_private_data = obj;
|
2014-01-21 02:07:49 +07:00
|
|
|
vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
|
2013-04-16 19:14:52 +07:00
|
|
|
|
|
|
|
/* Take a ref for this mapping of the object, so that the fault
|
|
|
|
* handler can dereference the mmap offset's pointer to the object.
|
|
|
|
* This reference is cleaned up by the corresponding vm_close
|
|
|
|
* (which should happen whether the vma was created by this call, or
|
|
|
|
* by a vm_open due to mremap or partial unmap or whatever).
|
|
|
|
*/
|
|
|
|
drm_gem_object_reference(obj);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_mmap_obj);
|
2009-02-12 05:01:46 +07:00
|
|
|
|
2008-11-06 01:31:53 +07:00
|
|
|
/**
|
|
|
|
* drm_gem_mmap - memory map routine for GEM objects
|
|
|
|
* @filp: DRM file pointer
|
|
|
|
* @vma: VMA for the area to be mapped
|
|
|
|
*
|
|
|
|
* If a driver supports GEM object mapping, mmap calls on the DRM file
|
|
|
|
* descriptor will end up here.
|
|
|
|
*
|
2013-04-16 19:14:52 +07:00
|
|
|
* Look up the GEM object based on the offset passed in (vma->vm_pgoff will
|
2008-11-06 01:31:53 +07:00
|
|
|
* contain the fake offset we created when the GTT map ioctl was called on
|
2013-04-16 19:14:52 +07:00
|
|
|
* the object) and map it with a call to drm_gem_mmap_obj().
|
2013-08-25 23:28:58 +07:00
|
|
|
*
|
|
|
|
* If the caller is not granted access to the buffer object, the mmap will fail
|
|
|
|
* with EACCES. Please see the vma manager for more information.
|
2008-11-06 01:31:53 +07:00
|
|
|
*/
|
|
|
|
int 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;
|
2015-10-15 16:33:43 +07:00
|
|
|
struct drm_gem_object *obj = NULL;
|
2013-07-25 02:07:52 +07:00
|
|
|
struct drm_vma_offset_node *node;
|
2014-01-21 02:15:38 +07:00
|
|
|
int ret;
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2012-02-20 21:18:07 +07:00
|
|
|
if (drm_device_is_unplugged(dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2015-10-15 16:33:43 +07:00
|
|
|
drm_vma_offset_lock_lookup(dev->vma_offset_manager);
|
|
|
|
node = drm_vma_offset_exact_lookup_locked(dev->vma_offset_manager,
|
|
|
|
vma->vm_pgoff,
|
|
|
|
vma_pages(vma));
|
|
|
|
if (likely(node)) {
|
|
|
|
obj = container_of(node, struct drm_gem_object, vma_node);
|
|
|
|
/*
|
|
|
|
* When the object is being freed, after it hits 0-refcnt it
|
|
|
|
* proceeds to tear down the object. In the process it will
|
|
|
|
* attempt to remove the VMA offset and so acquire this
|
|
|
|
* mgr->vm_lock. Therefore if we find an object with a 0-refcnt
|
|
|
|
* that matches our range, we know it is in the process of being
|
|
|
|
* destroyed and will be freed as soon as we release the lock -
|
|
|
|
* so we have to check for the 0-refcnted object and treat it as
|
|
|
|
* invalid.
|
|
|
|
*/
|
|
|
|
if (!kref_get_unless_zero(&obj->refcount))
|
|
|
|
obj = NULL;
|
|
|
|
}
|
|
|
|
drm_vma_offset_unlock_lookup(dev->vma_offset_manager);
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2015-10-15 16:33:43 +07:00
|
|
|
if (!obj)
|
2014-09-23 20:46:48 +07:00
|
|
|
return -EINVAL;
|
2015-10-15 16:33:43 +07:00
|
|
|
|
|
|
|
if (!drm_vma_node_is_allowed(node, filp)) {
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2013-08-25 23:28:58 +07:00
|
|
|
return -EACCES;
|
2008-11-06 01:31:53 +07:00
|
|
|
}
|
|
|
|
|
2015-10-15 16:33:43 +07:00
|
|
|
ret = drm_gem_mmap_obj(obj, drm_vma_node_size(node) << PAGE_SHIFT,
|
|
|
|
vma);
|
2008-11-06 01:31:53 +07:00
|
|
|
|
2015-10-15 16:33:43 +07:00
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
2008-11-06 01:31:53 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_gem_mmap);
|