drm_gem.c 19.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*
 * 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>
37
#include <linux/shmem_fs.h>
38
#include <linux/dma-buf.h>
39
#include <drm/drmP.h>
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

/** @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.
 */

J
Jesse Barnes 已提交
69 70 71 72
/*
 * We make up offsets for buffer objects so we can recognize them at
 * mmap time.
 */
73 74 75 76 77 78

/* 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
J
Jesse Barnes 已提交
79 80
#define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
#define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
81 82 83 84
#else
#define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
#define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
#endif
J
Jesse Barnes 已提交
85

86 87 88 89 90 91 92
/**
 * Initialize the GEM device fields
 */

int
drm_gem_init(struct drm_device *dev)
{
J
Jesse Barnes 已提交
93 94
	struct drm_gem_mm *mm;

95 96
	spin_lock_init(&dev->object_name_lock);
	idr_init(&dev->object_name_idr);
J
Jesse Barnes 已提交
97

98
	mm = kzalloc(sizeof(struct drm_gem_mm), GFP_KERNEL);
J
Jesse Barnes 已提交
99 100 101 102 103 104 105
	if (!mm) {
		DRM_ERROR("out of memory\n");
		return -ENOMEM;
	}

	dev->mm_private = mm;

106
	if (drm_ht_create(&mm->offset_hash, 12)) {
107
		kfree(mm);
J
Jesse Barnes 已提交
108 109 110 111 112 113
		return -ENOMEM;
	}

	if (drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
			DRM_FILE_PAGE_OFFSET_SIZE)) {
		drm_ht_remove(&mm->offset_hash);
114
		kfree(mm);
J
Jesse Barnes 已提交
115 116 117
		return -ENOMEM;
	}

118 119 120
	return 0;
}

J
Jesse Barnes 已提交
121 122 123 124 125 126 127
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);
128
	kfree(mm);
J
Jesse Barnes 已提交
129 130 131
	dev->mm_private = NULL;
}

132
/**
133
 * Initialize an already allocated GEM object of the specified size with
134 135 136 137 138 139 140 141 142 143
 * shmfs backing store.
 */
int drm_gem_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 = shmem_file_setup("drm mm object", size, VM_NORESERVE);
	if (IS_ERR(obj->filp))
144
		return PTR_ERR(obj->filp);
145 146

	kref_init(&obj->refcount);
147
	atomic_set(&obj->handle_count, 0);
148 149 150 151 152 153
	obj->size = size;

	return 0;
}
EXPORT_SYMBOL(drm_gem_object_init);

154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
/**
 * 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.
 */
int 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);
	atomic_set(&obj->handle_count, 0);
	obj->size = size;

	return 0;
}
EXPORT_SYMBOL(drm_gem_private_object_init);

175 176 177 178 179 180 181 182
/**
 * Allocate a GEM object of the specified size with shmfs backing store
 */
struct drm_gem_object *
drm_gem_object_alloc(struct drm_device *dev, size_t size)
{
	struct drm_gem_object *obj;

183
	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
184 185
	if (!obj)
		goto free;
186

187
	if (drm_gem_object_init(dev, obj, size) != 0)
188
		goto free;
189 190 191

	if (dev->driver->gem_init_object != NULL &&
	    dev->driver->gem_init_object(obj) != 0) {
192
		goto fput;
193 194
	}
	return obj;
195
fput:
196
	/* Object_init mangles the global counters - readjust them. */
197 198 199 200
	fput(obj->filp);
free:
	kfree(obj);
	return NULL;
201 202 203
}
EXPORT_SYMBOL(drm_gem_object_alloc);

204 205 206 207
static void
drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
{
	if (obj->import_attach) {
208
		drm_prime_remove_buf_handle(&filp->prime,
209 210 211
				obj->import_attach->dmabuf);
	}
	if (obj->export_dma_buf) {
212
		drm_prime_remove_buf_handle(&filp->prime,
213 214 215 216
				obj->export_dma_buf);
	}
}

217 218 219
/**
 * Removes the mapping from handle to filp for this object.
 */
220
int
221
drm_gem_handle_delete(struct drm_file *filp, u32 handle)
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
{
	struct drm_device *dev;
	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 */
	obj = idr_find(&filp->object_idr, handle);
	if (obj == NULL) {
		spin_unlock(&filp->table_lock);
		return -EINVAL;
	}
	dev = obj->dev;

	/* Release reference and decrement refcount. */
	idr_remove(&filp->object_idr, handle);
	spin_unlock(&filp->table_lock);

249
	drm_gem_remove_prime_handles(obj, filp);
250

251 252
	if (dev->driver->gem_close_object)
		dev->driver->gem_close_object(obj, filp);
253
	drm_gem_object_handle_unreference_unlocked(obj);
254 255 256

	return 0;
}
257
EXPORT_SYMBOL(drm_gem_handle_delete);
258 259 260 261 262 263 264 265 266

/**
 * 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,
267
		       u32 *handlep)
268
{
269 270
	struct drm_device *dev = obj->dev;
	int ret;
271 272

	/*
T
Tejun Heo 已提交
273 274
	 * Get the user-visible handle using idr.  Preload and perform
	 * allocation under our spinlock.
275
	 */
T
Tejun Heo 已提交
276
	idr_preload(GFP_KERNEL);
277
	spin_lock(&file_priv->table_lock);
T
Tejun Heo 已提交
278 279 280

	ret = idr_alloc(&file_priv->object_idr, obj, 1, 0, GFP_NOWAIT);

281
	spin_unlock(&file_priv->table_lock);
T
Tejun Heo 已提交
282 283
	idr_preload_end();
	if (ret < 0)
284
		return ret;
T
Tejun Heo 已提交
285
	*handlep = ret;
286 287

	drm_gem_object_handle_reference(obj);
288 289 290 291 292 293 294 295 296

	if (dev->driver->gem_open_object) {
		ret = dev->driver->gem_open_object(obj, file_priv);
		if (ret) {
			drm_gem_handle_delete(file_priv, *handlep);
			return ret;
		}
	}

297 298 299 300
	return 0;
}
EXPORT_SYMBOL(drm_gem_handle_create);

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

/**
 * 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().
 */
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_map_list *list = &obj->map_list;

	drm_ht_remove_item(&mm->offset_hash, &list->hash);
	drm_mm_put_block(list->file_offset_node);
	kfree(list->map);
	list->map = NULL;
}
EXPORT_SYMBOL(drm_gem_free_mmap_offset);

/**
 * 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.
 */
int
drm_gem_create_mmap_offset(struct drm_gem_object *obj)
{
	struct drm_device *dev = obj->dev;
	struct drm_gem_mm *mm = dev->mm_private;
	struct drm_map_list *list;
	struct drm_local_map *map;
340
	int ret;
341 342 343 344 345 346 347 348 349 350 351 352 353 354

	/* Set the object up for mmap'ing */
	list = &obj->map_list;
	list->map = kzalloc(sizeof(struct drm_map_list), GFP_KERNEL);
	if (!list->map)
		return -ENOMEM;

	map = list->map;
	map->type = _DRM_GEM;
	map->size = obj->size;
	map->handle = obj;

	/* Get a DRM GEM mmap offset allocated... */
	list->file_offset_node = drm_mm_search_free(&mm->offset_manager,
355
			obj->size / PAGE_SIZE, 0, false);
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

	if (!list->file_offset_node) {
		DRM_ERROR("failed to allocate offset for bo %d\n", obj->name);
		ret = -ENOSPC;
		goto out_free_list;
	}

	list->file_offset_node = drm_mm_get_block(list->file_offset_node,
			obj->size / PAGE_SIZE, 0);
	if (!list->file_offset_node) {
		ret = -ENOMEM;
		goto out_free_list;
	}

	list->hash.key = list->file_offset_node->start;
	ret = drm_ht_insert_item(&mm->offset_hash, &list->hash);
	if (ret) {
		DRM_ERROR("failed to add to map hash\n");
		goto out_free_mm;
	}

	return 0;

out_free_mm:
	drm_mm_put_block(list->file_offset_node);
out_free_list:
	kfree(list->map);
	list->map = NULL;

	return ret;
}
EXPORT_SYMBOL(drm_gem_create_mmap_offset);

389 390 391
/** Returns a reference to the object named by the handle. */
struct drm_gem_object *
drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp,
392
		      u32 handle)
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
{
	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);
	if (obj == NULL) {
		spin_unlock(&filp->table_lock);
		return NULL;
	}

	drm_gem_object_reference(obj);

	spin_unlock(&filp->table_lock);

	return obj;
}
EXPORT_SYMBOL(drm_gem_object_lookup);

/**
 * 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 (!(dev->driver->driver_features & DRIVER_GEM))
		return -ENODEV;

	ret = drm_gem_handle_delete(file_priv, args->handle);

	return ret;
}

/**
 * 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 (!(dev->driver->driver_features & DRIVER_GEM))
		return -ENODEV;

	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
	if (obj == NULL)
450
		return -ENOENT;
451

T
Tejun Heo 已提交
452
	idr_preload(GFP_KERNEL);
453
	spin_lock(&dev->object_name_lock);
454
	if (!obj->name) {
T
Tejun Heo 已提交
455 456
		ret = idr_alloc(&dev->object_name_idr, obj, 1, 0, GFP_NOWAIT);
		if (ret < 0)
457
			goto err;
458 459

		obj->name = ret;
460

461 462 463
		/* Allocate a reference for the name table.  */
		drm_gem_object_reference(obj);
	}
464

465 466 467
	args->name = (uint64_t) obj->name;
	ret = 0;

468
err:
469 470
	spin_unlock(&dev->object_name_lock);
	idr_preload_end();
471
	drm_gem_object_unreference_unlocked(obj);
472
	return ret;
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
}

/**
 * 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;
488
	u32 handle;
489 490 491 492 493 494 495 496 497 498 499 500 501

	if (!(dev->driver->driver_features & DRIVER_GEM))
		return -ENODEV;

	spin_lock(&dev->object_name_lock);
	obj = idr_find(&dev->object_name_idr, (int) args->name);
	if (obj)
		drm_gem_object_reference(obj);
	spin_unlock(&dev->object_name_lock);
	if (!obj)
		return -ENOENT;

	ret = drm_gem_handle_create(file_priv, obj, &handle);
502
	drm_gem_object_unreference_unlocked(obj);
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
	if (ret)
		return ret;

	args->handle = handle;
	args->size = obj->size;

	return 0;
}

/**
 * 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);
}

/**
 * Called at device close to release the file's
 * handle references on objects.
 */
static int
drm_gem_object_release_handle(int id, void *ptr, void *data)
{
530
	struct drm_file *file_priv = data;
531
	struct drm_gem_object *obj = ptr;
532 533
	struct drm_device *dev = obj->dev;

534
	drm_gem_remove_prime_handles(obj, file_priv);
535

536 537
	if (dev->driver->gem_close_object)
		dev->driver->gem_close_object(obj, file_priv);
538

539
	drm_gem_object_handle_unreference_unlocked(obj);
540 541 542 543 544 545 546 547 548 549 550 551 552

	return 0;
}

/**
 * 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,
553
		     &drm_gem_object_release_handle, file_private);
554 555 556
	idr_destroy(&file_private->object_idr);
}

557 558
void
drm_gem_object_release(struct drm_gem_object *obj)
559
{
560 561
	if (obj->filp)
	    fput(obj->filp);
562
}
563
EXPORT_SYMBOL(drm_gem_object_release);
564

565 566
/**
 * Called after the last reference to the object has been lost.
567
 * Must be called holding struct_ mutex
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
 *
 * Frees the object
 */
void
drm_gem_object_free(struct kref *kref)
{
	struct drm_gem_object *obj = (struct drm_gem_object *) kref;
	struct drm_device *dev = obj->dev;

	BUG_ON(!mutex_is_locked(&dev->struct_mutex));

	if (dev->driver->gem_free_object != NULL)
		dev->driver->gem_free_object(obj);
}
EXPORT_SYMBOL(drm_gem_object_free);

584 585 586 587 588
static void drm_gem_object_ref_bug(struct kref *list_kref)
{
	BUG();
}

589 590 591 592 593 594 595
/**
 * 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
 */
596
void drm_gem_object_handle_free(struct drm_gem_object *obj)
597 598 599 600 601 602 603
{
	struct drm_device *dev = obj->dev;

	/* Remove any name for this object */
	spin_lock(&dev->object_name_lock);
	if (obj->name) {
		idr_remove(&dev->object_name_idr, obj->name);
604
		obj->name = 0;
605 606 607 608
		spin_unlock(&dev->object_name_lock);
		/*
		 * The object name held a reference to this object, drop
		 * that now.
609 610
		*
		* This cannot be the last reference, since the handle holds one too.
611
		 */
612
		kref_put(&obj->refcount, drm_gem_object_ref_bug);
613 614 615 616 617 618
	} else
		spin_unlock(&dev->object_name_lock);

}
EXPORT_SYMBOL(drm_gem_object_handle_free);

619 620 621 622 623
void drm_gem_vm_open(struct vm_area_struct *vma)
{
	struct drm_gem_object *obj = vma->vm_private_data;

	drm_gem_object_reference(obj);
C
Chris Wilson 已提交
624 625

	mutex_lock(&obj->dev->struct_mutex);
626
	drm_vm_open_locked(obj->dev, vma);
C
Chris Wilson 已提交
627
	mutex_unlock(&obj->dev->struct_mutex);
628 629 630 631 632 633
}
EXPORT_SYMBOL(drm_gem_vm_open);

void drm_gem_vm_close(struct vm_area_struct *vma)
{
	struct drm_gem_object *obj = vma->vm_private_data;
634
	struct drm_device *dev = obj->dev;
635

636
	mutex_lock(&dev->struct_mutex);
637
	drm_vm_close_locked(obj->dev, vma);
C
Chris Wilson 已提交
638
	drm_gem_object_unreference(obj);
639
	mutex_unlock(&dev->struct_mutex);
640 641 642
}
EXPORT_SYMBOL(drm_gem_vm_close);

643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
/**
 * 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.
 *
660 661
 * NOTE: This function has to be protected with dev->struct_mutex
 *
662 663 664 665 666 667 668 669
 * 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;

670 671
	lockdep_assert_held(&dev->struct_mutex);

672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
	/* 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;
	vma->vm_page_prot =  pgprot_writecombine(vm_get_page_prot(vma->vm_flags));

	/* 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);

	drm_vm_open_locked(dev, vma);
	return 0;
}
EXPORT_SYMBOL(drm_gem_mmap_obj);
696

J
Jesse Barnes 已提交
697 698 699 700 701 702 703 704
/**
 * 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.
 *
705
 * Look up the GEM object based on the offset passed in (vma->vm_pgoff will
J
Jesse Barnes 已提交
706
 * contain the fake offset we created when the GTT map ioctl was called on
707
 * the object) and map it with a call to drm_gem_mmap_obj().
J
Jesse Barnes 已提交
708 709 710 711 712 713
 */
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;
	struct drm_gem_mm *mm = dev->mm_private;
714
	struct drm_local_map *map = NULL;
J
Jesse Barnes 已提交
715 716 717
	struct drm_hash_item *hash;
	int ret = 0;

718 719 720
	if (drm_device_is_unplugged(dev))
		return -ENODEV;

J
Jesse Barnes 已提交
721 722 723 724 725 726 727 728 729 730 731 732 733 734
	mutex_lock(&dev->struct_mutex);

	if (drm_ht_find_item(&mm->offset_hash, vma->vm_pgoff, &hash)) {
		mutex_unlock(&dev->struct_mutex);
		return drm_mmap(filp, vma);
	}

	map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
	if (!map ||
	    ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN))) {
		ret =  -EPERM;
		goto out_unlock;
	}

735
	ret = drm_gem_mmap_obj(map->handle, map->size, vma);
J
Jesse Barnes 已提交
736 737 738 739 740 741 742

out_unlock:
	mutex_unlock(&dev->struct_mutex);

	return ret;
}
EXPORT_SYMBOL(drm_gem_mmap);
反馈
建议
客服 返回
顶部