sys/dev/drm/drm_gem.c

   1 /*
   2  * Copyright © 2008 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *
  26  */
  27 /*-
  28  * Copyright (c) 2011 The FreeBSD Foundation
  29  * All rights reserved.
  30  *
  31  * This software was developed by Konstantin Belousov under sponsorship from
  32  * the FreeBSD Foundation.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions
  36  * are met:
  37  * 1. Redistributions of source code must retain the above copyright
  38  *    notice, this list of conditions and the following disclaimer.
  39  * 2. Redistributions in binary form must reproduce the above copyright
  40  *    notice, this list of conditions and the following disclaimer in the
  41  *    documentation and/or other materials provided with the distribution.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  */
  55
  56 #include "opt_vm.h"
  57
  58 #include <sys/param.h>
  59 #include <sys/systm.h>
  60 #include <sys/limits.h>
  61 #include <sys/lock.h>
  62 #include <sys/mutex.h>
  63 #include <sys/conf.h>
  64
  65 #include <vm/vm.h>
  66 #include <vm/vm_page.h>
  67
  68 #include <linux/types.h>
  69 #include <linux/mm.h>
  70 #include <linux/module.h>
  71 #include <drm/drmP.h>
  72 #include <drm/drm_vma_manager.h>
  73 #include <drm/drm_gem.h>
  74 #include "drm_internal.h"
  75
  76 /** @file drm_gem.c
  77  *
  78  * This file provides some of the base ioctls and library routines for
  79  * the graphics memory manager implemented by each device driver.
  80  *
  81  * Because various devices have different requirements in terms of
  82  * synchronization and migration strategies, implementing that is left up to
  83  * the driver, and all that the general API provides should be generic --
  84  * allocating objects, reading/writing data with the cpu, freeing objects.
  85  * Even there, platform-dependent optimizations for reading/writing data with
  86  * the CPU mean we'll likely hook those out to driver-specific calls.  However,
  87  * the DRI2 implementation wants to have at least allocate/mmap be generic.
  88  *
  89  * The goal was to have swap-backed object allocation managed through
  90  * struct file.  However, file descriptors as handles to a struct file have
  91  * two major failings:
  92  * - Process limits prevent more than 1024 or so being used at a time by
  93  *   default.
  94  * - Inability to allocate high fds will aggravate the X Server's select()
  95  *   handling, and likely that of many GL client applications as well.
  96  *
  97  * This led to a plan of using our own integer IDs (called handles, following
  98  * DRM terminology) to mimic fds, and implement the fd syscalls we need as
  99  * ioctls.  The objects themselves will still include the struct file so
 100  * that we can transition to fds if the required kernel infrastructure shows
 101  * up at a later date, and as our interface with shmfs for memory allocation.
 102  */
 103
 104 /*
 105  * We make up offsets for buffer objects so we can recognize them at
 106  * mmap time.
 107  */
 108
 109 /* pgoff in mmap is an unsigned long, so we need to make sure that
 110  * the faked up offset will fit
 111  */
 112
 113 #if BITS_PER_LONG == 64
 114 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
 115 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
 116 #else
 117 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
 118 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
 119 #endif
 120
 121 /**
 122  * drm_gem_init - Initialize the GEM device fields
 123  * @dev: drm_devic structure to initialize
 124  */
 125 int
 126 drm_gem_init(struct drm_device *dev)
 127 {
 128         struct drm_gem_mm *mm;
 129
 130         lockinit(&dev->object_name_lock, "objnam", 0, LK_CANRECURSE);
 131         idr_init(&dev->object_name_idr);
 132
 133         mm = kzalloc(sizeof(struct drm_gem_mm), GFP_KERNEL);
 134         if (!mm) {
 135                 DRM_ERROR("out of memory\n");
 136                 return -ENOMEM;
 137         }
 138
 139         dev->mm_private = mm;
 140
 141         if (drm_ht_create(&mm->offset_hash, 12)) {
 142                 kfree(mm);
 143                 return -ENOMEM;
 144         }
 145
 146         mm->idxunr = new_unrhdr(0, DRM_GEM_MAX_IDX, NULL);
 147         drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
 148                     DRM_FILE_PAGE_OFFSET_SIZE);
 149         drm_vma_offset_manager_init(&mm->vma_manager,
 150                                     DRM_FILE_PAGE_OFFSET_START,
 151                                     DRM_FILE_PAGE_OFFSET_SIZE);
 152
 153         return 0;
 154 }
 155
 156 void
 157 drm_gem_destroy(struct drm_device *dev)
 158 {
 159         struct drm_gem_mm *mm = dev->mm_private;
 160
 161         drm_mm_takedown(&mm->offset_manager);
 162         drm_ht_remove(&mm->offset_hash);
 163
 164         drm_vma_offset_manager_destroy(&mm->vma_manager);
 165         delete_unrhdr(mm->idxunr);
 166         kfree(mm);
 167         dev->mm_private = NULL;
 168 }
 169
 170 /**
 171  * Initialize an already allocated GEM object of the specified size with
 172  * shmfs backing store.
 173  */
 174 int drm_gem_object_init(struct drm_device *dev,
 175                         struct drm_gem_object *obj, size_t size)
 176 {
 177         drm_gem_private_object_init(dev, obj, size);
 178
 179         obj->filp = default_pager_alloc(NULL, size,
 180             VM_PROT_READ | VM_PROT_WRITE, 0);
 181
 182         return 0;
 183 }
 184 EXPORT_SYMBOL(drm_gem_object_init);
 185
 186 /**
 187  * drm_gem_object_init - initialize an allocated private GEM object
 188  * @dev: drm_device the object should be initialized for
 189  * @obj: drm_gem_object to initialize
 190  * @size: object size
 191  *
 192  * Initialize an already allocated GEM object of the specified size with
 193  * no GEM provided backing store. Instead the caller is responsible for
 194  * backing the object and handling it.
 195  */
 196 void drm_gem_private_object_init(struct drm_device *dev,
 197                                  struct drm_gem_object *obj, size_t size)
 198 {
 199         BUG_ON((size & (PAGE_SIZE - 1)) != 0);
 200
 201         obj->dev = dev;
 202         obj->filp = NULL;
 203
 204         kref_init(&obj->refcount);
 205         obj->handle_count = 0;
 206         obj->size = size;
 207         drm_vma_node_reset(&obj->vma_node);
 208 }
 209 EXPORT_SYMBOL(drm_gem_private_object_init);
 210
 211 static void
 212 drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
 213 {
 214         /*
 215          * Note: obj->dma_buf can't disappear as long as we still hold a
 216          * handle reference in obj->handle_count.
 217          */
 218         mutex_lock(&filp->prime.lock);
 219 #if 0
 220         if (obj->dma_buf) {
 221                 drm_prime_remove_buf_handle_locked(&filp->prime,
 222                                                    obj->dma_buf);
 223         }
 224 #endif
 225         mutex_unlock(&filp->prime.lock);
 226 }
 227
 228 /**
 229  * drm_gem_object_handle_free - release resources bound to userspace handles
 230  * @obj: GEM object to clean up.
 231  *
 232  * Called after the last handle to the object has been closed
 233  *
 234  * Removes any name for the object. Note that this must be
 235  * called before drm_gem_object_free or we'll be touching
 236  * freed memory
 237  */
 238 static void drm_gem_object_handle_free(struct drm_gem_object *obj)
 239 {
 240         struct drm_device *dev = obj->dev;
 241
 242         /* Remove any name for this object */
 243         if (obj->name) {
 244                 idr_remove(&dev->object_name_idr, obj->name);
 245                 obj->name = 0;
 246         }
 247 }
 248
 249 static void drm_gem_object_exported_dma_buf_free(struct drm_gem_object *obj)
 250 {
 251 #if 0
 252         /* Unbreak the reference cycle if we have an exported dma_buf. */
 253         if (obj->dma_buf) {
 254                 dma_buf_put(obj->dma_buf);
 255                 obj->dma_buf = NULL;
 256         }
 257 #endif
 258 }
 259
 260 static void
 261 drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
 262 {
 263         struct drm_device *dev = obj->dev;
 264         bool final = false;
 265
 266         if (WARN_ON(obj->handle_count == 0))
 267                 return;
 268
 269         /*
 270         * Must bump handle count first as this may be the last
 271         * ref, in which case the object would disappear before we
 272         * checked for a name
 273         */
 274
 275         mutex_lock(&dev->object_name_lock);
 276         if (--obj->handle_count == 0) {
 277                 drm_gem_object_handle_free(obj);
 278                 drm_gem_object_exported_dma_buf_free(obj);
 279                 final = true;
 280         }
 281         mutex_unlock(&dev->object_name_lock);
 282
 283         if (final)
 284                 drm_gem_object_unreference_unlocked(obj);
 285 }
 286
 287 /*
 288  * Called at device or object close to release the file's
 289  * handle references on objects.
 290  */
 291 static int
 292 drm_gem_object_release_handle(int id, void *ptr, void *data)
 293 {
 294         struct drm_file *file_priv = data;
 295         struct drm_gem_object *obj = ptr;
 296         struct drm_device *dev = obj->dev;
 297
 298         if (drm_core_check_feature(dev, DRIVER_PRIME))
 299                 drm_gem_remove_prime_handles(obj, file_priv);
 300         drm_vma_node_revoke(&obj->vma_node, file_priv->filp);
 301
 302         if (dev->driver->gem_close_object)
 303                 dev->driver->gem_close_object(obj, file_priv);
 304
 305         drm_gem_object_handle_unreference_unlocked(obj);
 306
 307         return 0;
 308 }
 309
 310 /**
 311  * drm_gem_handle_delete - deletes the given file-private handle
 312  * @filp: drm file-private structure to use for the handle look up
 313  * @handle: userspace handle to delete
 314  *
 315  * Removes the GEM handle from the @filp lookup table which has been added with
 316  * drm_gem_handle_create(). If this is the last handle also cleans up linked
 317  * resources like GEM names.
 318  */
 319 int
 320 drm_gem_handle_delete(struct drm_file *filp, u32 handle)
 321 {
 322         struct drm_device *dev;
 323         struct drm_gem_object *obj;
 324
 325         /* This is gross. The idr system doesn't let us try a delete and
 326          * return an error code.  It just spews if you fail at deleting.
 327          * So, we have to grab a lock around finding the object and then
 328          * doing the delete on it and dropping the refcount, or the user
 329          * could race us to double-decrement the refcount and cause a
 330          * use-after-free later.  Given the frequency of our handle lookups,
 331          * we may want to use ida for number allocation and a hash table
 332          * for the pointers, anyway.
 333          */
 334         lockmgr(&filp->table_lock, LK_EXCLUSIVE);
 335
 336         /* Check if we currently have a reference on the object */
 337         obj = idr_find(&filp->object_idr, handle);
 338         if (obj == NULL) {
 339                 lockmgr(&filp->table_lock, LK_RELEASE);
 340                 return -EINVAL;
 341         }
 342         dev = obj->dev;
 343
 344         /* Release reference and decrement refcount. */
 345         idr_remove(&filp->object_idr, handle);
 346         lockmgr(&filp->table_lock, LK_RELEASE);
 347
 348         drm_gem_remove_prime_handles(obj, filp);
 349
 350         if (dev->driver->gem_close_object)
 351                 dev->driver->gem_close_object(obj, filp);
 352         drm_gem_object_handle_unreference_unlocked(obj);
 353
 354         return 0;
 355 }
 356 EXPORT_SYMBOL(drm_gem_handle_delete);
 357
 358 /**
 359  * drm_gem_dumb_destroy - dumb fb callback helper for gem based drivers
 360  * @file: drm file-private structure to remove the dumb handle from
 361  * @dev: corresponding drm_device
 362  * @handle: the dumb handle to remove
 363  *
 364  * This implements the ->dumb_destroy kms driver callback for drivers which use
 365  * gem to manage their backing storage.
 366  */
 367 int drm_gem_dumb_destroy(struct drm_file *file,
 368                          struct drm_device *dev,
 369                          uint32_t handle)
 370 {
 371         return drm_gem_handle_delete(file, handle);
 372 }
 373 EXPORT_SYMBOL(drm_gem_dumb_destroy);
 374
 375 /**
 376  * drm_gem_handle_create_tail - internal functions to create a handle
 377  * @file_priv: drm file-private structure to register the handle for
 378  * @obj: object to register
 379  * @handlep: pointer to return the created handle to the caller
 380  *
 381  * This expects the dev->object_name_lock to be held already and will drop it
 382  * before returning. Used to avoid races in establishing new handles when
 383  * importing an object from either an flink name or a dma-buf.
 384  *
 385  * Handles must be release again through drm_gem_handle_delete(). This is done
 386  * when userspace closes @file_priv for all attached handles, or through the
 387  * GEM_CLOSE ioctl for individual handles.
 388  */
 389 int
 390 drm_gem_handle_create_tail(struct drm_file *file_priv,
 391                            struct drm_gem_object *obj,
 392                            u32 *handlep)
 393 {
 394         struct drm_device *dev = obj->dev;
 395         int ret;
 396
 397         *handlep = 0;           /* whack gcc warning */
 398         WARN_ON(!mutex_is_locked(&dev->object_name_lock));
 399
 400         /*
 401          * Get the user-visible handle using idr.  Preload and perform
 402          * allocation under our spinlock.
 403          */
 404         idr_preload(GFP_KERNEL);
 405         lockmgr(&file_priv->table_lock, LK_EXCLUSIVE);
 406
 407         ret = idr_alloc(&file_priv->object_idr, obj, 1, 0, GFP_NOWAIT);
 408         drm_gem_object_reference(obj);
 409         obj->handle_count++;
 410         lockmgr(&file_priv->table_lock, LK_RELEASE);
 411         idr_preload_end();
 412         mutex_unlock(&dev->object_name_lock);
 413         if (ret < 0) {
 414                 drm_gem_object_handle_unreference_unlocked(obj);
 415                 return ret;
 416         }
 417         *handlep = ret;
 418
 419 #if 0
 420         ret = drm_vma_node_allow(&obj->vma_node, file_priv->filp);
 421         if (ret) {
 422                 drm_gem_handle_delete(file_priv, *handlep);
 423                 return ret;
 424         }
 425 #endif
 426
 427         if (dev->driver->gem_open_object) {
 428                 ret = dev->driver->gem_open_object(obj, file_priv);
 429                 if (ret) {
 430                         drm_gem_handle_delete(file_priv, *handlep);
 431                         return ret;
 432                 }
 433         }
 434
 435         return 0;
 436 }
 437
 438 /**
 439  * drm_gem_handle_create - create a gem handle for an object
 440  * @file_priv: drm file-private structure to register the handle for
 441  * @obj: object to register
 442  * @handlep: pionter to return the created handle to the caller
 443  *
 444  * Create a handle for this object. This adds a handle reference
 445  * to the object, which includes a regular reference count. Callers
 446  * will likely want to dereference the object afterwards.
 447  */
 448 int drm_gem_handle_create(struct drm_file *file_priv,
 449                           struct drm_gem_object *obj,
 450                           u32 *handlep)
 451 {
 452         mutex_lock(&obj->dev->object_name_lock);
 453
 454         return drm_gem_handle_create_tail(file_priv, obj, handlep);
 455 }
 456 EXPORT_SYMBOL(drm_gem_handle_create);
 457
 458 /**
 459  * drm_gem_free_mmap_offset - release a fake mmap offset for an object
 460  * @obj: obj in question
 461  *
 462  * This routine frees fake offsets allocated by drm_gem_create_mmap_offset().
 463  *
 464  * Note that drm_gem_object_release() already calls this function, so drivers
 465  * don't have to take care of releasing the mmap offset themselves when freeing
 466  * the GEM object.
 467  */
 468 void
 469 drm_gem_free_mmap_offset(struct drm_gem_object *obj)
 470 {
 471         struct drm_device *dev = obj->dev;
 472         struct drm_gem_mm *mm = dev->mm_private;
 473         struct drm_hash_item *list;
 474
 475         if (!obj->on_map)
 476                 return;
 477         list = &obj->map_list;
 478
 479         drm_ht_remove_item(&mm->offset_hash, list);
 480         free_unr(mm->idxunr, list->key);
 481         obj->on_map = false;
 482
 483         drm_vma_offset_remove(&mm->vma_manager, &obj->vma_node);
 484 }
 485 EXPORT_SYMBOL(drm_gem_free_mmap_offset);
 486
 487 /**
 488  * drm_gem_create_mmap_offset_size - create a fake mmap offset for an object
 489  * @obj: obj in question
 490  * @size: the virtual size
 491  *
 492  * GEM memory mapping works by handing back to userspace a fake mmap offset
 493  * it can use in a subsequent mmap(2) call.  The DRM core code then looks
 494  * up the object based on the offset and sets up the various memory mapping
 495  * structures.
 496  *
 497  * This routine allocates and attaches a fake offset for @obj, in cases where
 498  * the virtual size differs from the physical size (ie. obj->size).  Otherwise
 499  * just use drm_gem_create_mmap_offset().
 500  *
 501  * This function is idempotent and handles an already allocated mmap offset
 502  * transparently. Drivers do not need to check for this case.
 503  */
 504 int
 505 drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size)
 506 {
 507         struct drm_device *dev = obj->dev;
 508         struct drm_gem_mm *mm = dev->mm_private;
 509         int ret = 0;
 510
 511         if (obj->on_map)
 512                 return (0);
 513
 514         obj->map_list.key = alloc_unr(mm->idxunr);
 515         ret = drm_ht_insert_item(&mm->offset_hash, &obj->map_list);
 516         if (ret != 0) {
 517                 DRM_ERROR("failed to add to map hash\n");
 518                 free_unr(mm->idxunr, obj->map_list.key);
 519                 return (ret);
 520         }
 521         obj->on_map = true;
 522         return 0;
 523
 524         return drm_vma_offset_add(&mm->vma_manager, &obj->vma_node,
 525                                   size / PAGE_SIZE);
 526 }
 527 EXPORT_SYMBOL(drm_gem_create_mmap_offset_size);
 528
 529 /**
 530  * drm_gem_create_mmap_offset - create a fake mmap offset for an object
 531  * @obj: obj in question
 532  *
 533  * GEM memory mapping works by handing back to userspace a fake mmap offset
 534  * it can use in a subsequent mmap(2) call.  The DRM core code then looks
 535  * up the object based on the offset and sets up the various memory mapping
 536  * structures.
 537  *
 538  * This routine allocates and attaches a fake offset for @obj.
 539  *
 540  * Drivers can call drm_gem_free_mmap_offset() before freeing @obj to release
 541  * the fake offset again.
 542  */
 543 int drm_gem_create_mmap_offset(struct drm_gem_object *obj)
 544 {
 545         return drm_gem_create_mmap_offset_size(obj, obj->size);
 546 }
 547 EXPORT_SYMBOL(drm_gem_create_mmap_offset);
 548
 549 /**
 550  * drm_gem_object_lookup - look up a GEM object from it's handle
 551  * @dev: DRM device
 552  * @filp: DRM file private date
 553  * @handle: userspace handle
 554  *
 555  * Returns:
 556  *
 557  * A reference to the object named by the handle if such exists on @filp, NULL
 558  * otherwise.
 559  */
 560 struct drm_gem_object *
 561 drm_gem_object_lookup(struct drm_file *filp, u32 handle)
 562 {
 563         struct drm_gem_object *obj;
 564
 565         lockmgr(&filp->table_lock, LK_EXCLUSIVE);
 566
 567         /* Check if we currently have a reference on the object */
 568         obj = idr_find(&filp->object_idr, handle);
 569         if (obj == NULL) {
 570                 lockmgr(&filp->table_lock, LK_RELEASE);
 571                 return NULL;
 572         }
 573
 574         drm_gem_object_reference(obj);
 575
 576         lockmgr(&filp->table_lock, LK_RELEASE);
 577
 578         return obj;
 579 }
 580 EXPORT_SYMBOL(drm_gem_object_lookup);
 581
 582 /**
 583  * drm_gem_close_ioctl - implementation of the GEM_CLOSE ioctl
 584  * @dev: drm_device
 585  * @data: ioctl data
 586  * @file_priv: drm file-private structure
 587  *
 588  * Releases the handle to an mm object.
 589  */
 590 int
 591 drm_gem_close_ioctl(struct drm_device *dev, void *data,
 592                     struct drm_file *file_priv)
 593 {
 594         struct drm_gem_close *args = data;
 595         int ret;
 596
 597         if (!drm_core_check_feature(dev, DRIVER_GEM))
 598                 return -ENODEV;
 599
 600         ret = drm_gem_handle_delete(file_priv, args->handle);
 601
 602         return ret;
 603 }
 604
 605 /**
 606  * Create a global name for an object, returning the name.
 607  *
 608  * Note that the name does not hold a reference; when the object
 609  * is freed, the name goes away.
 610  */
 611 int
 612 drm_gem_flink_ioctl(struct drm_device *dev, void *data,
 613                     struct drm_file *file_priv)
 614 {
 615         struct drm_gem_flink *args = data;
 616         struct drm_gem_object *obj;
 617         int ret;
 618
 619         if (!drm_core_check_feature(dev, DRIVER_GEM))
 620                 return -ENODEV;
 621
 622         obj = drm_gem_object_lookup(file_priv, args->handle);
 623         if (obj == NULL)
 624                 return -ENOENT;
 625
 626         idr_preload(GFP_KERNEL);
 627         lockmgr(&dev->object_name_lock, LK_EXCLUSIVE);
 628         /* prevent races with concurrent gem_close. */
 629         if (obj->handle_count == 0) {
 630                 ret = -ENOENT;
 631                 goto err;
 632         }
 633
 634         if (!obj->name) {
 635                 ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_NOWAIT);
 636                 if (ret < 0)
 637                         goto err;
 638
 639                 obj->name = ret;
 640
 641                 /* Allocate a reference for the name table.  */
 642                 drm_gem_object_reference(obj);
 643         }
 644
 645         args->name = (uint64_t) obj->name;
 646         ret = 0;
 647
 648 err:
 649         lockmgr(&dev->object_name_lock, LK_RELEASE);
 650         idr_preload_end();
 651         drm_gem_object_unreference_unlocked(obj);
 652         return ret;
 653 }
 654
 655 /**
 656  * drm_gem_open - implementation of the GEM_OPEN ioctl
 657  * @dev: drm_device
 658  * @data: ioctl data
 659  * @file_priv: drm file-private structure
 660  *
 661  * Open an object using the global name, returning a handle and the size.
 662  *
 663  * This handle (of course) holds a reference to the object, so the object
 664  * will not go away until the handle is deleted.
 665  */
 666 int
 667 drm_gem_open_ioctl(struct drm_device *dev, void *data,
 668                    struct drm_file *file_priv)
 669 {
 670         struct drm_gem_open *args = data;
 671         struct drm_gem_object *obj;
 672         int ret;
 673         u32 handle;
 674
 675         if (!drm_core_check_feature(dev, DRIVER_GEM))
 676                 return -ENODEV;
 677
 678         lockmgr(&dev->object_name_lock, LK_EXCLUSIVE);
 679         obj = idr_find(&dev->object_name_idr, (int) args->name);
 680         if (obj)
 681                 drm_gem_object_reference(obj);
 682         lockmgr(&dev->object_name_lock, LK_RELEASE);
 683         if (!obj)
 684                 return -ENOENT;
 685
 686         ret = drm_gem_handle_create(file_priv, obj, &handle);
 687         drm_gem_object_unreference_unlocked(obj);
 688         if (ret)
 689                 return ret;
 690
 691         args->handle = handle;
 692         args->size = obj->size;
 693
 694         return 0;
 695 }
 696
 697 /**
 698  * gem_gem_open - initalizes GEM file-private structures at devnode open time
 699  * @dev: drm_device which is being opened by userspace
 700  * @file_private: drm file-private structure to set up
 701  *
 702  * Called at device open time, sets up the structure for handling refcounting
 703  * of mm objects.
 704  */
 705 void
 706 drm_gem_open(struct drm_device *dev, struct drm_file *file_private)
 707 {
 708         idr_init(&file_private->object_idr);
 709         lockinit(&file_private->table_lock, "fptab", 0, LK_CANRECURSE);
 710 }
 711
 712 /**
 713  * drm_gem_release - release file-private GEM resources
 714  * @dev: drm_device which is being closed by userspace
 715  * @file_private: drm file-private structure to clean up
 716  *
 717  * Called at close time when the filp is going away.
 718  *
 719  * Releases any remaining references on objects by this filp.
 720  */
 721 void
 722 drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
 723 {
 724         idr_for_each(&file_private->object_idr,
 725                      &drm_gem_object_release_handle, file_private);
 726         idr_destroy(&file_private->object_idr);
 727 }
 728
 729 /**
 730  * drm_gem_object_release - release GEM buffer object resources
 731  * @obj: GEM buffer object
 732  *
 733  * This releases any structures and resources used by @obj and is the invers of
 734  * drm_gem_object_init().
 735  */
 736 void
 737 drm_gem_object_release(struct drm_gem_object *obj)
 738 {
 739
 740         /*
 741          * obj->vm_obj can be NULL for private gem objects.
 742          */
 743         vm_object_deallocate(obj->filp);
 744 }
 745 EXPORT_SYMBOL(drm_gem_object_release);
 746
 747 /**
 748  * drm_gem_object_free - free a GEM object
 749  * @kref: kref of the object to free
 750  *
 751  * Called after the last reference to the object has been lost.
 752  * Must be called holding struct_ mutex
 753  *
 754  * Frees the object
 755  */
 756 void
 757 drm_gem_object_free(struct kref *kref)
 758 {
 759         struct drm_gem_object *obj =
 760                 container_of(kref, struct drm_gem_object, refcount);
 761         struct drm_device *dev = obj->dev;
 762
 763         WARN_ON(!mutex_is_locked(&dev->struct_mutex));
 764
 765         if (dev->driver->gem_free_object != NULL)
 766                 dev->driver->gem_free_object(obj);
 767 }
 768 EXPORT_SYMBOL(drm_gem_object_free);
 769
 770 static struct drm_gem_object *
 771 drm_gem_object_from_offset(struct drm_device *dev, vm_ooffset_t offset)
 772 {
 773         struct drm_gem_object *obj;
 774         struct drm_gem_mm *mm = dev->mm_private;
 775         struct drm_hash_item *hash;
 776
 777         if ((offset & DRM_GEM_MAPPING_MASK) != DRM_GEM_MAPPING_KEY)
 778                 return (NULL);
 779         offset &= ~DRM_GEM_MAPPING_KEY;
 780
 781         if (drm_ht_find_item(&mm->offset_hash, DRM_GEM_MAPPING_IDX(offset),
 782             &hash) != 0) {
 783                 return (NULL);
 784         }
 785         obj = container_of(hash, struct drm_gem_object, map_list);
 786         return (obj);
 787 }
 788
 789 int
 790 drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size,
 791     struct vm_object **obj_res, int nprot)
 792 {
 793         struct drm_gem_object *gem_obj;
 794         struct vm_object *vm_obj;
 795
 796         DRM_LOCK(dev);
 797         gem_obj = drm_gem_object_from_offset(dev, *offset);
 798         if (gem_obj == NULL) {
 799                 DRM_UNLOCK(dev);
 800                 return (ENODEV);
 801         }
 802
 803         drm_gem_object_reference(gem_obj);
 804         DRM_UNLOCK(dev);
 805         vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
 806             dev->driver->gem_vm_ops, size, nprot,
 807             DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
 808         if (vm_obj == NULL) {
 809                 drm_gem_object_unreference_unlocked(gem_obj);
 810                 return (EINVAL);
 811         }
 812         *offset = DRM_GEM_MAPPING_MAPOFF(*offset);
 813         *obj_res = vm_obj;
 814         return (0);
 815 }