text: /*
   * 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>
   *
   */
  /*-
   * Copyright (c) 2011 The FreeBSD Foundation
   * All rights reserved.
   *
   * This software was developed by Konstantin Belousov under sponsorship from
   * the FreeBSD Foundation.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in the
   *    documentation and/or other materials provided with the distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   */
  
  #include "opt_vm.h"
  
  #include <sys/param.h>
  #include <sys/systm.h>
  #include <sys/limits.h>
  #include <sys/lock.h>
  #include <sys/conf.h>
  
  #include <vm/vm.h>
  #include <vm/vm_page.h>
  
  #include <linux/types.h>
  #include <linux/mm.h>
  #include <linux/module.h>
  #include <drm/drmP.h>
  #include <drm/drm_vma_manager.h>
  #include <drm/drm_gem.h>
  #include "drm_internal.h"
  
  /** @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.
   */
  
  /*
   * We make up offsets for buffer objects so we can recognize them at
   * mmap time.
   */
  
  /* 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
  #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
  #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
  #else
  #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
  #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
  #endif
  
  /**
   * drm_gem_init - Initialize the GEM device fields
   * @dev: drm_devic structure to initialize
   */
  int
  drm_gem_init(struct drm_device *dev)
  {
  	struct drm_gem_mm *mm;
  
  	lockinit(&dev->object_name_lock, "objnam", 0, LK_CANRECURSE);
  	idr_init(&dev->object_name_idr);
  
  	mm = kzalloc(sizeof(struct drm_gem_mm), GFP_KERNEL);
  	if (!mm) {
  		DRM_ERROR("out of memory\n");
  		return -ENOMEM;
  	}
  
  	dev->mm_private = mm;
  
  	if (drm_ht_create(&mm->offset_hash, 12)) {
  		kfree(mm);
  		return -ENOMEM;
  	}
  
  	mm->idxunr = new_unrhdr(0, DRM_GEM_MAX_IDX, NULL);
  	drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
  		    DRM_FILE_PAGE_OFFSET_SIZE);
  	drm_vma_offset_manager_init(&mm->vma_manager,
  				    DRM_FILE_PAGE_OFFSET_START,
  				    DRM_FILE_PAGE_OFFSET_SIZE);
  
  	return 0;
  }
  
  void
  drm_gem_destroy(struct drm_device *dev)
  {
  	struct drm_gem_mm *mm = dev->mm_private;
  
  	drm_mm_takedown(&mm->offset_manager);
  	drm_ht_remove(&mm->offset_hash);
  
  	drm_vma_offset_manager_destroy(&mm->vma_manager);
  	delete_unrhdr(mm->idxunr);
  	kfree(mm);
  	dev->mm_private = NULL;
  }
  
  /**
   * Initialize an already allocated GEM object of the specified size with
   * shmfs backing store.
   */
  int drm_gem_object_init(struct drm_device *dev,
  			struct drm_gem_object *obj, size_t size)
  {
  	drm_gem_private_object_init(dev, obj, size);
  
  	obj->filp = default_pager_alloc(NULL, size,
  	    VM_PROT_READ | VM_PROT_WRITE, 0);
  
  	return 0;
  }
  EXPORT_SYMBOL(drm_gem_object_init);
  
  /**
   * drm_gem_object_init - initialize an allocated private GEM object
   * @dev: drm_device the object should be initialized for
   * @obj: drm_gem_object to initialize
   * @size: object size
   *
   * 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.
   */
  void drm_gem_private_object_init(struct drm_device *dev,
  				 struct drm_gem_object *obj, size_t size)
  {
  	BUG_ON((size & (PAGE_SIZE - 1)) != 0);
  
  	obj->dev = dev;
  	obj->filp = NULL;
  
  	kref_init(&obj->refcount);
  	obj->handle_count = 0;
  	obj->size = size;
  	drm_vma_node_reset(&obj->vma_node);
  }
  EXPORT_SYMBOL(drm_gem_private_object_init);
  
  static void
  drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
  {
  	/*
  	 * Note: obj->dma_buf can't disappear as long as we still hold a
  	 * handle reference in obj->handle_count.
  	 */
  	mutex_lock(&filp->prime.lock);
  #if 0
  	if (obj->dma_buf) {
  		drm_prime_remove_buf_handle_locked(&filp->prime,
  						   obj->dma_buf);
  	}
  #endif
  	mutex_unlock(&filp->prime.lock);
  }
  
  /**
   * drm_gem_object_handle_free - release resources bound to userspace handles
   * @obj: GEM object to clean up.
   *
   * 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;
  	}
  }
  
  static void drm_gem_object_exported_dma_buf_free(struct drm_gem_object *obj)
  {
  #if 0
  	/* 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;
  	}
  #endif
  }
  
  static void
  drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
  {
  	struct drm_device *dev = obj->dev;
  	bool final = false;
  
  	if (WARN_ON(obj->handle_count == 0))
  		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
  	*/
  
  	mutex_lock(&dev->object_name_lock);
  	if (--obj->handle_count == 0) {
  		drm_gem_object_handle_free(obj);
  		drm_gem_object_exported_dma_buf_free(obj);
  		final = true;
  	}
  	mutex_unlock(&dev->object_name_lock);
  
  	if (final)
  		drm_gem_object_unreference_unlocked(obj);
  }
  
  /*
   * 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);
  
  	if (dev->driver->gem_close_object)
  		dev->driver->gem_close_object(obj, file_priv);
  
  	drm_gem_object_handle_unreference_unlocked(obj);
  
  	return 0;
  }
  
  /**
   * 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
   *
   * 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.
   */
  int
  drm_gem_handle_delete(struct drm_file *filp, u32 handle)
  {
  	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.
  	 */
  	lockmgr(&filp->table_lock, LK_EXCLUSIVE);
  
  	/* Check if we currently have a reference on the object */
  	obj = idr_replace(&filp->object_idr, NULL, handle);
  	lockmgr(&filp->table_lock, LK_RELEASE);
  	if (IS_ERR_OR_NULL(obj))
  		return -EINVAL;
  
  	/* Release driver's reference and decrement refcount. */
  	drm_gem_object_release_handle(handle, obj, filp);
  
  	/* And finally make the handle available for future allocations. */
  	lockmgr(&filp->table_lock, LK_EXCLUSIVE);
  	idr_remove(&filp->object_idr, handle);
  	lockmgr(&filp->table_lock, LK_RELEASE);
  
  	return 0;
  }
  EXPORT_SYMBOL(drm_gem_handle_delete);
  
  /**
   * drm_gem_dumb_destroy - dumb fb callback helper for gem based drivers
   * @file: drm file-private structure to remove the dumb handle from
   * @dev: corresponding drm_device
   * @handle: the dumb handle to remove
   * 
   * 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);
  
  /**
   * drm_gem_handle_create_tail - internal functions to create a handle
   * @file_priv: drm file-private structure to register the handle for
   * @obj: object to register
   * @handlep: pointer to return the created handle to the caller
   * 
   * 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.
   *
   * 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.
   */
  int
  drm_gem_handle_create_tail(struct drm_file *file_priv,
  			   struct drm_gem_object *obj,
  			   u32 *handlep)
  {
  	struct drm_device *dev = obj->dev;
  	u32 handle;
  	int ret;
  
  	WARN_ON(!mutex_is_locked(&dev->object_name_lock));
  	if (obj->handle_count++ == 0)
  		drm_gem_object_reference(obj);
  
  	/*
  	 * Get the user-visible handle using idr.  Preload and perform
  	 * allocation under our spinlock.
  	 */
  	idr_preload(GFP_KERNEL);
  	lockmgr(&file_priv->table_lock, LK_EXCLUSIVE);
  
  	ret = idr_alloc(&file_priv->object_idr, obj, 1, 0, GFP_NOWAIT);
  
  	lockmgr(&file_priv->table_lock, LK_RELEASE);
  	idr_preload_end();
  
  	mutex_unlock(&dev->object_name_lock);
  	if (ret < 0)
  		goto err_unref;
  
  	handle = ret;
  
  	ret = drm_vma_node_allow(&obj->vma_node, file_priv);
  	if (ret)
  		goto err_remove;
  
  	if (dev->driver->gem_open_object) {
  		ret = dev->driver->gem_open_object(obj, file_priv);
  		if (ret)
  			goto err_revoke;
  	}
  
  	*handlep = handle;
  	return 0;
  
  err_revoke:
  	drm_vma_node_revoke(&obj->vma_node, file_priv);
  err_remove:
  	lockmgr(&file_priv->table_lock, LK_EXCLUSIVE);
  	idr_remove(&file_priv->object_idr, handle);
  	lockmgr(&file_priv->table_lock, LK_RELEASE);
  err_unref:
  	drm_gem_object_handle_unreference_unlocked(obj);
  	return ret;
  }
  
  /**
   * drm_gem_handle_create - create a gem handle for an object
   * @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
   *
   * 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.
   */
  int drm_gem_handle_create(struct drm_file *file_priv,
  			  struct drm_gem_object *obj,
  			  u32 *handlep)
  {
  	mutex_lock(&obj->dev->object_name_lock);
  
  	return drm_gem_handle_create_tail(file_priv, obj, handlep);
  }
  EXPORT_SYMBOL(drm_gem_handle_create);
  
  /**
   * 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().
   *
   * 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.
   */
  void
  drm_gem_free_mmap_offset(struct drm_gem_object *obj)
  {
  	struct drm_device *dev = obj->dev;
  	struct drm_gem_mm *mm = dev->mm_private;
  	struct drm_hash_item *list;
  
  	if (!obj->on_map)
  		return;
  	list = &obj->map_list;
  
  	drm_ht_remove_item(&mm->offset_hash, list);
  	free_unr(mm->idxunr, list->key);
  	obj->on_map = false;
  
  	drm_vma_offset_remove(&mm->vma_manager, &obj->vma_node);
  }
  EXPORT_SYMBOL(drm_gem_free_mmap_offset);
  
  /**
   * drm_gem_create_mmap_offset_size - create a fake mmap offset for an object
   * @obj: obj in question
   * @size: the virtual size
   *
   * 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, in cases where
   * the virtual size differs from the physical size (ie. obj->size).  Otherwise
   * just use drm_gem_create_mmap_offset().
   *
   * This function is idempotent and handles an already allocated mmap offset
   * transparently. Drivers do not need to check for this case.
   */
  int
  drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size)
  {
  	struct drm_device *dev = obj->dev;
  	struct drm_gem_mm *mm = dev->mm_private;
  	int ret = 0;
  
  	if (obj->on_map)
  		return (0);
  
  	obj->map_list.key = alloc_unr(mm->idxunr);
  	ret = drm_ht_insert_item(&mm->offset_hash, &obj->map_list);
  	if (ret != 0) {
  		DRM_ERROR("failed to add to map hash\n");
  		free_unr(mm->idxunr, obj->map_list.key);
  		return (ret);
  	}
  	obj->on_map = true;
  	return 0;
  
  	return drm_vma_offset_add(&mm->vma_manager, &obj->vma_node,
  				  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.
   *
   * Drivers can call drm_gem_free_mmap_offset() before freeing @obj to release
   * the fake offset again.
   */
  int drm_gem_create_mmap_offset(struct drm_gem_object *obj)
  {
  	return drm_gem_create_mmap_offset_size(obj, obj->size);
  }
  EXPORT_SYMBOL(drm_gem_create_mmap_offset);
  
  /**
   * 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.
   */
  struct drm_gem_object *
  drm_gem_object_lookup(struct drm_file *filp, u32 handle)
  {
  	struct drm_gem_object *obj;
  
  	lockmgr(&filp->table_lock, LK_EXCLUSIVE);
  
  	/* Check if we currently have a reference on the object */
  	obj = idr_find(&filp->object_idr, handle);
  	if (obj)
  		drm_gem_object_reference(obj);
  
  	lockmgr(&filp->table_lock, LK_RELEASE);
  
  	return obj;
  }
  EXPORT_SYMBOL(drm_gem_object_lookup);
  
  /**
   * drm_gem_close_ioctl - implementation of the GEM_CLOSE ioctl
   * @dev: drm_device
   * @data: ioctl data
   * @file_priv: drm file-private structure
   *
   * 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;
  
  	if (!drm_core_check_feature(dev, DRIVER_GEM))
  		return -ENODEV;
  
  	ret = drm_gem_handle_delete(file_priv, args->handle);
  
  	return ret;
  }
  
  /**
   * drm_gem_flink_ioctl - implementation of the GEM_FLINK ioctl
   * @dev: drm_device
   * @data: ioctl data
   * @file_priv: drm file-private structure
   *
   * 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;
  
  	if (!drm_core_check_feature(dev, DRIVER_GEM))
  		return -ENODEV;
  
  	obj = drm_gem_object_lookup(file_priv, args->handle);
  	if (obj == NULL)
  		return -ENOENT;
  
  	mutex_lock(&dev->object_name_lock);
  	/* prevent races with concurrent gem_close. */
  	if (obj->handle_count == 0) {
  		ret = -ENOENT;
  		goto err;
  	}
  
  	if (!obj->name) {
  		ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_KERNEL);
  		if (ret < 0)
  			goto err;
  
  		obj->name = ret;
  	}
  
  	args->name = (uint64_t) obj->name;
  	ret = 0;
  
  err:
  	mutex_unlock(&dev->object_name_lock);
  	drm_gem_object_unreference_unlocked(obj);
  	return ret;
  }
  
  /**
   * drm_gem_open - implementation of the GEM_OPEN ioctl
   * @dev: drm_device
   * @data: ioctl data
   * @file_priv: drm file-private structure
   *
   * 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;
  	u32 handle;
  
  	if (!drm_core_check_feature(dev, DRIVER_GEM))
  		return -ENODEV;
  
  	mutex_lock(&dev->object_name_lock);
  	obj = idr_find(&dev->object_name_idr, (int) args->name);
  	if (obj) {
  		drm_gem_object_reference(obj);
  	} else {
  		mutex_unlock(&dev->object_name_lock);
  		return -ENOENT;
  	}
  
  	/* drm_gem_handle_create_tail unlocks dev->object_name_lock. */
  	ret = drm_gem_handle_create_tail(file_priv, obj, &handle);
  	drm_gem_object_unreference_unlocked(obj);
  	if (ret)
  		return ret;
  
  	args->handle = handle;
  	args->size = obj->size;
  
  	return 0;
  }
  
  /**
   * 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
   *
   * 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);
  	lockinit(&file_private->table_lock, "fptab", 0, LK_CANRECURSE);
  }
  
  /**
   * 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
   *
   * 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,
  		     &drm_gem_object_release_handle, file_private);
  	idr_destroy(&file_private->object_idr);
  }
  
  /**
   * 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().
   */
  void
  drm_gem_object_release(struct drm_gem_object *obj)
  {
  
  	/*
  	 * obj->vm_obj can be NULL for private gem objects.
  	 */
  	vm_object_deallocate(obj->filp);
  }
  EXPORT_SYMBOL(drm_gem_object_release);
  
  /**
   * drm_gem_object_free - free a GEM object
   * @kref: kref of the object to free
   *
   * Called after the last reference to the object has been lost.
   * Must be called holding &drm_device->struct_mutex.
   *
   * Frees the object
   */
  void
  drm_gem_object_free(struct kref *kref)
  {
  	struct drm_gem_object *obj =
  		container_of(kref, struct drm_gem_object, refcount);
  	struct drm_device *dev = obj->dev;
  
  	if (dev->driver->gem_free_object_unlocked) {
  		dev->driver->gem_free_object_unlocked(obj);
  	} else if (dev->driver->gem_free_object) {
  		WARN_ON(!mutex_is_locked(&dev->struct_mutex));
  
  		dev->driver->gem_free_object(obj);
  	}
  }
  EXPORT_SYMBOL(drm_gem_object_free);
  
  /**
   * 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);
  
  static struct drm_gem_object *
  drm_gem_object_from_offset(struct drm_device *dev, vm_ooffset_t offset)
  {
  	struct drm_gem_object *obj;
  	struct drm_gem_mm *mm = dev->mm_private;
  	struct drm_hash_item *hash;
  
  	if ((offset & DRM_GEM_MAPPING_MASK) != DRM_GEM_MAPPING_KEY)
  		return (NULL);
  	offset &= ~DRM_GEM_MAPPING_KEY;
  
  	if (drm_ht_find_item(&mm->offset_hash, DRM_GEM_MAPPING_IDX(offset),
  	    &hash) != 0) {
  		return (NULL);
  	}
  	obj = container_of(hash, struct drm_gem_object, map_list);
  	return (obj);
  }
  
  int
  drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size,
      struct vm_object **obj_res, int nprot)
  {
  	struct drm_gem_object *gem_obj;
  	struct vm_object *vm_obj;
  
  	DRM_LOCK(dev);
  	gem_obj = drm_gem_object_from_offset(dev, *offset);
  	if (gem_obj == NULL) {
  		DRM_UNLOCK(dev);
  		return (ENODEV);
  	}
  
  	drm_gem_object_reference(gem_obj);
  	DRM_UNLOCK(dev);
  	vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
  	    dev->driver->gem_vm_ops, size, nprot,
  	    DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
  	if (vm_obj == NULL) {
  		drm_gem_object_unreference_unlocked(gem_obj);
  		return (EINVAL);
  	}
  	*offset = DRM_GEM_MAPPING_MAPOFF(*offset);
  	*obj_res = vm_obj;
  	return (0);
  }
  