drm/gem: simplify object initialization
[profile/mobile/platform/kernel/linux-3.10-sc7730.git] / drivers / gpu / 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 #include <linux/types.h>
29 #include <linux/slab.h>
30 #include <linux/mm.h>
31 #include <linux/uaccess.h>
32 #include <linux/fs.h>
33 #include <linux/file.h>
34 #include <linux/module.h>
35 #include <linux/mman.h>
36 #include <linux/pagemap.h>
37 #include <linux/shmem_fs.h>
38 #include <linux/dma-buf.h>
39 #include <drm/drmP.h>
40
41 /** @file drm_gem.c
42  *
43  * This file provides some of the base ioctls and library routines for
44  * the graphics memory manager implemented by each device driver.
45  *
46  * Because various devices have different requirements in terms of
47  * synchronization and migration strategies, implementing that is left up to
48  * the driver, and all that the general API provides should be generic --
49  * allocating objects, reading/writing data with the cpu, freeing objects.
50  * Even there, platform-dependent optimizations for reading/writing data with
51  * the CPU mean we'll likely hook those out to driver-specific calls.  However,
52  * the DRI2 implementation wants to have at least allocate/mmap be generic.
53  *
54  * The goal was to have swap-backed object allocation managed through
55  * struct file.  However, file descriptors as handles to a struct file have
56  * two major failings:
57  * - Process limits prevent more than 1024 or so being used at a time by
58  *   default.
59  * - Inability to allocate high fds will aggravate the X Server's select()
60  *   handling, and likely that of many GL client applications as well.
61  *
62  * This led to a plan of using our own integer IDs (called handles, following
63  * DRM terminology) to mimic fds, and implement the fd syscalls we need as
64  * ioctls.  The objects themselves will still include the struct file so
65  * that we can transition to fds if the required kernel infrastructure shows
66  * up at a later date, and as our interface with shmfs for memory allocation.
67  */
68
69 /*
70  * We make up offsets for buffer objects so we can recognize them at
71  * mmap time.
72  */
73
74 /* pgoff in mmap is an unsigned long, so we need to make sure that
75  * the faked up offset will fit
76  */
77
78 #if BITS_PER_LONG == 64
79 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
80 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
81 #else
82 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
83 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
84 #endif
85
86 /**
87  * Initialize the GEM device fields
88  */
89
90 int
91 drm_gem_init(struct drm_device *dev)
92 {
93         struct drm_gem_mm *mm;
94
95         spin_lock_init(&dev->object_name_lock);
96         idr_init(&dev->object_name_idr);
97
98         mm = kzalloc(sizeof(struct drm_gem_mm), GFP_KERNEL);
99         if (!mm) {
100                 DRM_ERROR("out of memory\n");
101                 return -ENOMEM;
102         }
103
104         dev->mm_private = mm;
105
106         if (drm_ht_create(&mm->offset_hash, 12)) {
107                 kfree(mm);
108                 return -ENOMEM;
109         }
110
111         if (drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
112                         DRM_FILE_PAGE_OFFSET_SIZE)) {
113                 drm_ht_remove(&mm->offset_hash);
114                 kfree(mm);
115                 return -ENOMEM;
116         }
117
118         return 0;
119 }
120
121 void
122 drm_gem_destroy(struct drm_device *dev)
123 {
124         struct drm_gem_mm *mm = dev->mm_private;
125
126         drm_mm_takedown(&mm->offset_manager);
127         drm_ht_remove(&mm->offset_hash);
128         kfree(mm);
129         dev->mm_private = NULL;
130 }
131
132 /**
133  * Initialize an already allocated GEM object of the specified size with
134  * shmfs backing store.
135  */
136 int drm_gem_object_init(struct drm_device *dev,
137                         struct drm_gem_object *obj, size_t size)
138 {
139         struct file *filp;
140
141         filp = shmem_file_setup("drm mm object", size, VM_NORESERVE);
142         if (IS_ERR(filp))
143                 return PTR_ERR(filp);
144
145         drm_gem_private_object_init(dev, obj, size);
146         obj->filp = filp;
147
148         return 0;
149 }
150 EXPORT_SYMBOL(drm_gem_object_init);
151
152 /**
153  * Initialize an already allocated GEM object of the specified size with
154  * no GEM provided backing store. Instead the caller is responsible for
155  * backing the object and handling it.
156  */
157 void drm_gem_private_object_init(struct drm_device *dev,
158                                  struct drm_gem_object *obj, size_t size)
159 {
160         BUG_ON((size & (PAGE_SIZE - 1)) != 0);
161
162         obj->dev = dev;
163         obj->filp = NULL;
164
165         kref_init(&obj->refcount);
166         atomic_set(&obj->handle_count, 0);
167         obj->size = size;
168 }
169 EXPORT_SYMBOL(drm_gem_private_object_init);
170
171 /**
172  * Allocate a GEM object of the specified size with shmfs backing store
173  */
174 struct drm_gem_object *
175 drm_gem_object_alloc(struct drm_device *dev, size_t size)
176 {
177         struct drm_gem_object *obj;
178
179         obj = kzalloc(sizeof(*obj), GFP_KERNEL);
180         if (!obj)
181                 goto free;
182
183         if (drm_gem_object_init(dev, obj, size) != 0)
184                 goto free;
185
186         if (dev->driver->gem_init_object != NULL &&
187             dev->driver->gem_init_object(obj) != 0) {
188                 goto fput;
189         }
190         return obj;
191 fput:
192         /* Object_init mangles the global counters - readjust them. */
193         fput(obj->filp);
194 free:
195         kfree(obj);
196         return NULL;
197 }
198 EXPORT_SYMBOL(drm_gem_object_alloc);
199
200 static void
201 drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
202 {
203         if (obj->import_attach) {
204                 drm_prime_remove_buf_handle(&filp->prime,
205                                 obj->import_attach->dmabuf);
206         }
207         if (obj->export_dma_buf) {
208                 drm_prime_remove_buf_handle(&filp->prime,
209                                 obj->export_dma_buf);
210         }
211 }
212
213 /**
214  * Removes the mapping from handle to filp for this object.
215  */
216 int
217 drm_gem_handle_delete(struct drm_file *filp, u32 handle)
218 {
219         struct drm_device *dev;
220         struct drm_gem_object *obj;
221
222         /* This is gross. The idr system doesn't let us try a delete and
223          * return an error code.  It just spews if you fail at deleting.
224          * So, we have to grab a lock around finding the object and then
225          * doing the delete on it and dropping the refcount, or the user
226          * could race us to double-decrement the refcount and cause a
227          * use-after-free later.  Given the frequency of our handle lookups,
228          * we may want to use ida for number allocation and a hash table
229          * for the pointers, anyway.
230          */
231         spin_lock(&filp->table_lock);
232
233         /* Check if we currently have a reference on the object */
234         obj = idr_find(&filp->object_idr, handle);
235         if (obj == NULL) {
236                 spin_unlock(&filp->table_lock);
237                 return -EINVAL;
238         }
239         dev = obj->dev;
240
241         DRM_DEBUG("%s:hdl[%d]obj[0x%x]\n", __func__, handle, (int)obj);
242
243         /* Release reference and decrement refcount. */
244         idr_remove(&filp->object_idr, handle);
245         spin_unlock(&filp->table_lock);
246
247         drm_gem_remove_prime_handles(obj, filp);
248
249         if (dev->driver->gem_close_object)
250                 dev->driver->gem_close_object(obj, filp);
251         drm_gem_object_handle_unreference_unlocked(obj);
252
253         return 0;
254 }
255 EXPORT_SYMBOL(drm_gem_handle_delete);
256
257 /**
258  * Create a handle for this object. This adds a handle reference
259  * to the object, which includes a regular reference count. Callers
260  * will likely want to dereference the object afterwards.
261  */
262 int
263 drm_gem_handle_create(struct drm_file *file_priv,
264                        struct drm_gem_object *obj,
265                        u32 *handlep)
266 {
267         struct drm_device *dev = obj->dev;
268         int ret;
269
270         /*
271          * Get the user-visible handle using idr.  Preload and perform
272          * allocation under our spinlock.
273          */
274         idr_preload(GFP_KERNEL);
275         spin_lock(&file_priv->table_lock);
276
277         ret = idr_alloc(&file_priv->object_idr, obj, 1, 0, GFP_NOWAIT);
278
279         spin_unlock(&file_priv->table_lock);
280         idr_preload_end();
281         if (ret < 0)
282                 return ret;
283         *handlep = ret;
284
285         drm_gem_object_handle_reference(obj);
286
287         if (dev->driver->gem_open_object) {
288                 ret = dev->driver->gem_open_object(obj, file_priv);
289                 if (ret) {
290                         drm_gem_handle_delete(file_priv, *handlep);
291                         return ret;
292                 }
293         }
294
295         return 0;
296 }
297 EXPORT_SYMBOL(drm_gem_handle_create);
298
299
300 /**
301  * drm_gem_free_mmap_offset - release a fake mmap offset for an object
302  * @obj: obj in question
303  *
304  * This routine frees fake offsets allocated by drm_gem_create_mmap_offset().
305  */
306 void
307 drm_gem_free_mmap_offset(struct drm_gem_object *obj)
308 {
309         struct drm_device *dev = obj->dev;
310         struct drm_gem_mm *mm = dev->mm_private;
311         struct drm_map_list *list = &obj->map_list;
312
313         drm_ht_remove_item(&mm->offset_hash, &list->hash);
314         drm_mm_put_block(list->file_offset_node);
315         kfree(list->map);
316         list->map = NULL;
317 }
318 EXPORT_SYMBOL(drm_gem_free_mmap_offset);
319
320 /**
321  * drm_gem_create_mmap_offset - create a fake mmap offset for an object
322  * @obj: obj in question
323  *
324  * GEM memory mapping works by handing back to userspace a fake mmap offset
325  * it can use in a subsequent mmap(2) call.  The DRM core code then looks
326  * up the object based on the offset and sets up the various memory mapping
327  * structures.
328  *
329  * This routine allocates and attaches a fake offset for @obj.
330  */
331 int
332 drm_gem_create_mmap_offset(struct drm_gem_object *obj)
333 {
334         struct drm_device *dev = obj->dev;
335         struct drm_gem_mm *mm = dev->mm_private;
336         struct drm_map_list *list;
337         struct drm_local_map *map;
338         int ret;
339
340         /* Set the object up for mmap'ing */
341         list = &obj->map_list;
342         list->map = kzalloc(sizeof(struct drm_map_list), GFP_KERNEL);
343         if (!list->map)
344                 return -ENOMEM;
345
346         map = list->map;
347         map->type = _DRM_GEM;
348         map->size = obj->size;
349         map->handle = obj;
350
351         /* Get a DRM GEM mmap offset allocated... */
352         list->file_offset_node = drm_mm_search_free(&mm->offset_manager,
353                         obj->size / PAGE_SIZE, 0, false);
354
355         if (!list->file_offset_node) {
356                 DRM_ERROR("failed to allocate offset for bo %d\n", obj->name);
357                 ret = -ENOSPC;
358                 goto out_free_list;
359         }
360
361         list->file_offset_node = drm_mm_get_block(list->file_offset_node,
362                         obj->size / PAGE_SIZE, 0);
363         if (!list->file_offset_node) {
364                 ret = -ENOMEM;
365                 goto out_free_list;
366         }
367
368         list->hash.key = list->file_offset_node->start;
369         ret = drm_ht_insert_item(&mm->offset_hash, &list->hash);
370         if (ret) {
371                 DRM_ERROR("failed to add to map hash\n");
372                 goto out_free_mm;
373         }
374
375         return 0;
376
377 out_free_mm:
378         drm_mm_put_block(list->file_offset_node);
379 out_free_list:
380         kfree(list->map);
381         list->map = NULL;
382
383         return ret;
384 }
385 EXPORT_SYMBOL(drm_gem_create_mmap_offset);
386
387 /** Returns a reference to the object named by the handle. */
388 struct drm_gem_object *
389 drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp,
390                       u32 handle)
391 {
392         struct drm_gem_object *obj;
393
394         spin_lock(&filp->table_lock);
395
396         /* Check if we currently have a reference on the object */
397         obj = idr_find(&filp->object_idr, handle);
398         if (obj == NULL) {
399                 spin_unlock(&filp->table_lock);
400                 return NULL;
401         }
402
403         drm_gem_object_reference(obj);
404
405         spin_unlock(&filp->table_lock);
406
407         return obj;
408 }
409 EXPORT_SYMBOL(drm_gem_object_lookup);
410
411 /**
412  * Releases the handle to an mm object.
413  */
414 int
415 drm_gem_close_ioctl(struct drm_device *dev, void *data,
416                     struct drm_file *file_priv)
417 {
418         struct drm_gem_close *args = data;
419         int ret;
420
421         if (!(dev->driver->driver_features & DRIVER_GEM))
422                 return -ENODEV;
423
424         ret = drm_gem_handle_delete(file_priv, args->handle);
425
426         return ret;
427 }
428
429 /**
430  * Create a global name for an object, returning the name.
431  *
432  * Note that the name does not hold a reference; when the object
433  * is freed, the name goes away.
434  */
435 int
436 drm_gem_flink_ioctl(struct drm_device *dev, void *data,
437                     struct drm_file *file_priv)
438 {
439         struct drm_gem_flink *args = data;
440         struct drm_gem_object *obj;
441         int ret;
442
443         if (!(dev->driver->driver_features & DRIVER_GEM))
444                 return -ENODEV;
445
446         obj = drm_gem_object_lookup(dev, file_priv, args->handle);
447         if (obj == NULL)
448                 return -ENOENT;
449
450         idr_preload(GFP_KERNEL);
451         spin_lock(&dev->object_name_lock);
452         if (!obj->name) {
453                 ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_NOWAIT);
454                 if (ret < 0)
455                         goto err;
456
457                 obj->name = ret;
458
459                 /* Allocate a reference for the name table.  */
460                 drm_gem_object_reference(obj);
461         }
462
463         args->name = (uint64_t) obj->name;
464         ret = 0;
465
466 err:
467         spin_unlock(&dev->object_name_lock);
468         idr_preload_end();
469         drm_gem_object_unreference_unlocked(obj);
470
471         DRM_DEBUG("%s:hdl[%d]obj[0x%x]name[%d]\n",
472                 __func__, (int) args->handle, (int)obj, args->name);
473
474         return ret;
475 }
476
477 /**
478  * Open an object using the global name, returning a handle and the size.
479  *
480  * This handle (of course) holds a reference to the object, so the object
481  * will not go away until the handle is deleted.
482  */
483 int
484 drm_gem_open_ioctl(struct drm_device *dev, void *data,
485                    struct drm_file *file_priv)
486 {
487         struct drm_gem_open *args = data;
488         struct drm_gem_object *obj;
489         int ret;
490         u32 handle;
491
492         if (!(dev->driver->driver_features & DRIVER_GEM))
493                 return -ENODEV;
494
495         spin_lock(&dev->object_name_lock);
496         obj = idr_find(&dev->object_name_idr, (int) args->name);
497         if (obj)
498                 drm_gem_object_reference(obj);
499         spin_unlock(&dev->object_name_lock);
500         if (!obj)
501                 return -ENOENT;
502
503         ret = drm_gem_handle_create(file_priv, obj, &handle);
504         drm_gem_object_unreference_unlocked(obj);
505         if (ret)
506                 return ret;
507
508         args->handle = handle;
509         args->size = obj->size;
510
511         DRM_DEBUG("%s:name[%d]obj[0x%x]hdl[%d]sz[%d]\n",
512                 __func__, (int) args->name, (int)obj,
513                 args->handle, (int)args->size);
514
515         return 0;
516 }
517
518 /**
519  * Called at device open time, sets up the structure for handling refcounting
520  * of mm objects.
521  */
522 void
523 drm_gem_open(struct drm_device *dev, struct drm_file *file_private)
524 {
525         idr_init(&file_private->object_idr);
526         spin_lock_init(&file_private->table_lock);
527 }
528
529 /**
530  * Called at device close to release the file's
531  * handle references on objects.
532  */
533 static int
534 drm_gem_object_release_handle(int id, void *ptr, void *data)
535 {
536         struct drm_file *file_priv = data;
537         struct drm_gem_object *obj = ptr;
538         struct drm_device *dev = obj->dev;
539
540         drm_gem_remove_prime_handles(obj, file_priv);
541
542         if (dev->driver->gem_close_object)
543                 dev->driver->gem_close_object(obj, file_priv);
544
545         drm_gem_object_handle_unreference_unlocked(obj);
546
547         return 0;
548 }
549
550 /**
551  * Called at close time when the filp is going away.
552  *
553  * Releases any remaining references on objects by this filp.
554  */
555 void
556 drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
557 {
558         idr_for_each(&file_private->object_idr,
559                      &drm_gem_object_release_handle, file_private);
560         idr_destroy(&file_private->object_idr);
561 }
562
563 void
564 drm_gem_object_release(struct drm_gem_object *obj)
565 {
566         if (obj->filp)
567             fput(obj->filp);
568 }
569 EXPORT_SYMBOL(drm_gem_object_release);
570
571 /**
572  * Called after the last reference to the object has been lost.
573  * Must be called holding struct_ mutex
574  *
575  * Frees the object
576  */
577 void
578 drm_gem_object_free(struct kref *kref)
579 {
580         struct drm_gem_object *obj = (struct drm_gem_object *) kref;
581         struct drm_device *dev = obj->dev;
582
583         BUG_ON(!mutex_is_locked(&dev->struct_mutex));
584
585         if (dev->driver->gem_free_object != NULL)
586                 dev->driver->gem_free_object(obj);
587 }
588 EXPORT_SYMBOL(drm_gem_object_free);
589
590 static void drm_gem_object_ref_bug(struct kref *list_kref)
591 {
592         BUG();
593 }
594
595 /**
596  * Called after the last handle to the object has been closed
597  *
598  * Removes any name for the object. Note that this must be
599  * called before drm_gem_object_free or we'll be touching
600  * freed memory
601  */
602 void drm_gem_object_handle_free(struct drm_gem_object *obj)
603 {
604         struct drm_device *dev = obj->dev;
605
606         /* Remove any name for this object */
607         spin_lock(&dev->object_name_lock);
608         if (obj->name) {
609                 idr_remove(&dev->object_name_idr, obj->name);
610                 obj->name = 0;
611                 spin_unlock(&dev->object_name_lock);
612                 /*
613                  * The object name held a reference to this object, drop
614                  * that now.
615                 *
616                 * This cannot be the last reference, since the handle holds one too.
617                  */
618                 kref_put(&obj->refcount, drm_gem_object_ref_bug);
619         } else
620                 spin_unlock(&dev->object_name_lock);
621
622 }
623 EXPORT_SYMBOL(drm_gem_object_handle_free);
624
625 void drm_gem_vm_open(struct vm_area_struct *vma)
626 {
627         struct drm_gem_object *obj = vma->vm_private_data;
628
629         drm_gem_object_reference(obj);
630
631         mutex_lock(&obj->dev->struct_mutex);
632         drm_vm_open_locked(obj->dev, vma);
633         mutex_unlock(&obj->dev->struct_mutex);
634 }
635 EXPORT_SYMBOL(drm_gem_vm_open);
636
637 void drm_gem_vm_close(struct vm_area_struct *vma)
638 {
639         struct drm_gem_object *obj = vma->vm_private_data;
640         struct drm_device *dev = obj->dev;
641
642         mutex_lock(&dev->struct_mutex);
643         drm_vm_close_locked(obj->dev, vma);
644         drm_gem_object_unreference(obj);
645         mutex_unlock(&dev->struct_mutex);
646 }
647 EXPORT_SYMBOL(drm_gem_vm_close);
648
649 /**
650  * drm_gem_mmap_obj - memory map a GEM object
651  * @obj: the GEM object to map
652  * @obj_size: the object size to be mapped, in bytes
653  * @vma: VMA for the area to be mapped
654  *
655  * Set up the VMA to prepare mapping of the GEM object using the gem_vm_ops
656  * provided by the driver. Depending on their requirements, drivers can either
657  * provide a fault handler in their gem_vm_ops (in which case any accesses to
658  * the object will be trapped, to perform migration, GTT binding, surface
659  * register allocation, or performance monitoring), or mmap the buffer memory
660  * synchronously after calling drm_gem_mmap_obj.
661  *
662  * This function is mainly intended to implement the DMABUF mmap operation, when
663  * the GEM object is not looked up based on its fake offset. To implement the
664  * DRM mmap operation, drivers should use the drm_gem_mmap() function.
665  *
666  * NOTE: This function has to be protected with dev->struct_mutex
667  *
668  * Return 0 or success or -EINVAL if the object size is smaller than the VMA
669  * size, or if no gem_vm_ops are provided.
670  */
671 int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
672                      struct vm_area_struct *vma)
673 {
674         struct drm_device *dev = obj->dev;
675
676         lockdep_assert_held(&dev->struct_mutex);
677
678         /* Check for valid size. */
679         if (obj_size < vma->vm_end - vma->vm_start)
680                 return -EINVAL;
681
682         if (!dev->driver->gem_vm_ops)
683                 return -EINVAL;
684
685         vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP;
686         vma->vm_ops = dev->driver->gem_vm_ops;
687         vma->vm_private_data = obj;
688         vma->vm_page_prot =  pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
689
690         /* Take a ref for this mapping of the object, so that the fault
691          * handler can dereference the mmap offset's pointer to the object.
692          * This reference is cleaned up by the corresponding vm_close
693          * (which should happen whether the vma was created by this call, or
694          * by a vm_open due to mremap or partial unmap or whatever).
695          */
696         drm_gem_object_reference(obj);
697
698         drm_vm_open_locked(dev, vma);
699         return 0;
700 }
701 EXPORT_SYMBOL(drm_gem_mmap_obj);
702
703 /**
704  * drm_gem_mmap - memory map routine for GEM objects
705  * @filp: DRM file pointer
706  * @vma: VMA for the area to be mapped
707  *
708  * If a driver supports GEM object mapping, mmap calls on the DRM file
709  * descriptor will end up here.
710  *
711  * Look up the GEM object based on the offset passed in (vma->vm_pgoff will
712  * contain the fake offset we created when the GTT map ioctl was called on
713  * the object) and map it with a call to drm_gem_mmap_obj().
714  */
715 int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
716 {
717         struct drm_file *priv = filp->private_data;
718         struct drm_device *dev = priv->minor->dev;
719         struct drm_gem_mm *mm = dev->mm_private;
720         struct drm_local_map *map = NULL;
721         struct drm_hash_item *hash;
722         int ret = 0;
723
724         if (drm_device_is_unplugged(dev))
725                 return -ENODEV;
726
727         mutex_lock(&dev->struct_mutex);
728
729         if (drm_ht_find_item(&mm->offset_hash, vma->vm_pgoff, &hash)) {
730                 mutex_unlock(&dev->struct_mutex);
731                 return drm_mmap(filp, vma);
732         }
733
734         map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
735         if (!map ||
736             ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN))) {
737                 ret =  -EPERM;
738                 goto out_unlock;
739         }
740
741         ret = drm_gem_mmap_obj(map->handle, map->size, vma);
742
743 out_unlock:
744         mutex_unlock(&dev->struct_mutex);
745
746         return ret;
747 }
748 EXPORT_SYMBOL(drm_gem_mmap);