1/* 2 * \author Rickard E. (Rik) Faith <faith@valinux.com> 3 * \author Daryll Strauss <daryll@valinux.com> 4 * \author Gareth Hughes <gareth@valinux.com> 5 */ 6 7/* 8 * Created: Mon Jan 4 08:58:31 1999 by faith@valinux.com 9 * 10 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. 11 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 12 * All Rights Reserved. 13 * 14 * Permission is hereby granted, free of charge, to any person obtaining a 15 * copy of this software and associated documentation files (the "Software"), 16 * to deal in the Software without restriction, including without limitation 17 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 18 * and/or sell copies of the Software, and to permit persons to whom the 19 * Software is furnished to do so, subject to the following conditions: 20 * 21 * The above copyright notice and this permission notice (including the next 22 * paragraph) shall be included in all copies or substantial portions of the 23 * Software. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 28 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 29 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 30 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 31 * OTHER DEALINGS IN THE SOFTWARE. 32 */ 33 34#include <linux/anon_inodes.h> 35#include <linux/dma-fence.h> 36#include <linux/file.h> 37#include <linux/module.h> 38#include <linux/pci.h> 39#include <linux/poll.h> 40#include <linux/slab.h> 41 42#include <drm/drm_client.h> 43#include <drm/drm_drv.h> 44#include <drm/drm_file.h> 45#include <drm/drm_print.h> 46 47#include "drm_crtc_internal.h" 48#include "drm_internal.h" 49#include "drm_legacy.h" 50 51#if defined(CONFIG_MMU) && defined(CONFIG_TRANSPARENT_HUGEPAGE) 52#include <uapi/asm/mman.h> 53#include <drm/drm_vma_manager.h> 54#endif 55 56/* from BKL pushdown */ 57DEFINE_MUTEX(drm_global_mutex); 58 59bool drm_dev_needs_global_mutex(struct drm_device *dev) 60{ 61 /* 62 * Legacy drivers rely on all kinds of BKL locking semantics, don't 63 * bother. They also still need BKL locking for their ioctls, so better 64 * safe than sorry. 65 */ 66 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 67 return true; 68 69 /* 70 * The deprecated ->load callback must be called after the driver is 71 * already registered. This means such drivers rely on the BKL to make 72 * sure an open can't proceed until the driver is actually fully set up. 73 * Similar hilarity holds for the unload callback. 74 */ 75 if (dev->driver->load || dev->driver->unload) 76 return true; 77 78 /* 79 * Drivers with the lastclose callback assume that it's synchronized 80 * against concurrent opens, which again needs the BKL. The proper fix 81 * is to use the drm_client infrastructure with proper locking for each 82 * client. 83 */ 84 if (dev->driver->lastclose) 85 return true; 86 87 return false; 88} 89 90/** 91 * DOC: file operations 92 * 93 * Drivers must define the file operations structure that forms the DRM 94 * userspace API entry point, even though most of those operations are 95 * implemented in the DRM core. The resulting &struct file_operations must be 96 * stored in the &drm_driver.fops field. The mandatory functions are drm_open(), 97 * drm_read(), drm_ioctl() and drm_compat_ioctl() if CONFIG_COMPAT is enabled 98 * Note that drm_compat_ioctl will be NULL if CONFIG_COMPAT=n, so there's no 99 * need to sprinkle #ifdef into the code. Drivers which implement private ioctls 100 * that require 32/64 bit compatibility support must provide their own 101 * &file_operations.compat_ioctl handler that processes private ioctls and calls 102 * drm_compat_ioctl() for core ioctls. 103 * 104 * In addition drm_read() and drm_poll() provide support for DRM events. DRM 105 * events are a generic and extensible means to send asynchronous events to 106 * userspace through the file descriptor. They are used to send vblank event and 107 * page flip completions by the KMS API. But drivers can also use it for their 108 * own needs, e.g. to signal completion of rendering. 109 * 110 * For the driver-side event interface see drm_event_reserve_init() and 111 * drm_send_event() as the main starting points. 112 * 113 * The memory mapping implementation will vary depending on how the driver 114 * manages memory. Legacy drivers will use the deprecated drm_legacy_mmap() 115 * function, modern drivers should use one of the provided memory-manager 116 * specific implementations. For GEM-based drivers this is drm_gem_mmap(), and 117 * for drivers which use the CMA GEM helpers it's drm_gem_cma_mmap(). 118 * 119 * No other file operations are supported by the DRM userspace API. Overall the 120 * following is an example &file_operations structure:: 121 * 122 * static const example_drm_fops = { 123 * .owner = THIS_MODULE, 124 * .open = drm_open, 125 * .release = drm_release, 126 * .unlocked_ioctl = drm_ioctl, 127 * .compat_ioctl = drm_compat_ioctl, // NULL if CONFIG_COMPAT=n 128 * .poll = drm_poll, 129 * .read = drm_read, 130 * .llseek = no_llseek, 131 * .mmap = drm_gem_mmap, 132 * }; 133 * 134 * For plain GEM based drivers there is the DEFINE_DRM_GEM_FOPS() macro, and for 135 * CMA based drivers there is the DEFINE_DRM_GEM_CMA_FOPS() macro to make this 136 * simpler. 137 * 138 * The driver's &file_operations must be stored in &drm_driver.fops. 139 * 140 * For driver-private IOCTL handling see the more detailed discussion in 141 * :ref:`IOCTL support in the userland interfaces chapter<drm_driver_ioctl>`. 142 */ 143 144/** 145 * drm_file_alloc - allocate file context 146 * @minor: minor to allocate on 147 * 148 * This allocates a new DRM file context. It is not linked into any context and 149 * can be used by the caller freely. Note that the context keeps a pointer to 150 * @minor, so it must be freed before @minor is. 151 * 152 * RETURNS: 153 * Pointer to newly allocated context, ERR_PTR on failure. 154 */ 155struct drm_file *drm_file_alloc(struct drm_minor *minor) 156{ 157 struct drm_device *dev = minor->dev; 158 struct drm_file *file; 159 int ret; 160 161 file = kzalloc(sizeof(*file), GFP_KERNEL); 162 if (!file) 163 return ERR_PTR(-ENOMEM); 164 165 file->pid = get_pid(task_pid(current)); 166 file->minor = minor; 167 168 /* for compatibility root is always authenticated */ 169 file->authenticated = capable(CAP_SYS_ADMIN); 170 171 INIT_LIST_HEAD(&file->lhead); 172 INIT_LIST_HEAD(&file->fbs); 173 mutex_init(&file->fbs_lock); 174 INIT_LIST_HEAD(&file->blobs); 175 INIT_LIST_HEAD(&file->pending_event_list); 176 INIT_LIST_HEAD(&file->event_list); 177 init_waitqueue_head(&file->event_wait); 178 file->event_space = 4096; /* set aside 4k for event buffer */ 179 180 spin_lock_init(&file->master_lookup_lock); 181 mutex_init(&file->event_read_lock); 182 183 if (drm_core_check_feature(dev, DRIVER_GEM)) 184 drm_gem_open(dev, file); 185 186 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 187 drm_syncobj_open(file); 188 189 drm_prime_init_file_private(&file->prime); 190 191 if (dev->driver->open) { 192 ret = dev->driver->open(dev, file); 193 if (ret < 0) 194 goto out_prime_destroy; 195 } 196 197 return file; 198 199out_prime_destroy: 200 drm_prime_destroy_file_private(&file->prime); 201 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 202 drm_syncobj_release(file); 203 if (drm_core_check_feature(dev, DRIVER_GEM)) 204 drm_gem_release(dev, file); 205 put_pid(file->pid); 206 kfree(file); 207 208 return ERR_PTR(ret); 209} 210 211static void drm_events_release(struct drm_file *file_priv) 212{ 213 struct drm_device *dev = file_priv->minor->dev; 214 struct drm_pending_event *e, *et; 215 unsigned long flags; 216 217 spin_lock_irqsave(&dev->event_lock, flags); 218 219 /* Unlink pending events */ 220 list_for_each_entry_safe(e, et, &file_priv->pending_event_list, 221 pending_link) { 222 list_del(&e->pending_link); 223 e->file_priv = NULL; 224 } 225 226 /* Remove unconsumed events */ 227 list_for_each_entry_safe(e, et, &file_priv->event_list, link) { 228 list_del(&e->link); 229 kfree(e); 230 } 231 232 spin_unlock_irqrestore(&dev->event_lock, flags); 233} 234 235/** 236 * drm_file_free - free file context 237 * @file: context to free, or NULL 238 * 239 * This destroys and deallocates a DRM file context previously allocated via 240 * drm_file_alloc(). The caller must make sure to unlink it from any contexts 241 * before calling this. 242 * 243 * If NULL is passed, this is a no-op. 244 * 245 * RETURNS: 246 * 0 on success, or error code on failure. 247 */ 248void drm_file_free(struct drm_file *file) 249{ 250 struct drm_device *dev; 251 252 if (!file) 253 return; 254 255 dev = file->minor->dev; 256 257 DRM_DEBUG("comm=\"%s\", pid=%d, dev=0x%lx, open_count=%d\n", 258 current->comm, task_pid_nr(current), 259 (long)old_encode_dev(file->minor->kdev->devt), 260 atomic_read(&dev->open_count)); 261 262 if (drm_core_check_feature(dev, DRIVER_LEGACY) && 263 dev->driver->preclose) 264 dev->driver->preclose(dev, file); 265 266 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 267 drm_legacy_lock_release(dev, file->filp); 268 269 if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)) 270 drm_legacy_reclaim_buffers(dev, file); 271 272 drm_events_release(file); 273 274 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 275 drm_fb_release(file); 276 drm_property_destroy_user_blobs(dev, file); 277 } 278 279 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 280 drm_syncobj_release(file); 281 282 if (drm_core_check_feature(dev, DRIVER_GEM)) 283 drm_gem_release(dev, file); 284 285 drm_legacy_ctxbitmap_flush(dev, file); 286 287 if (drm_is_primary_client(file)) 288 drm_master_release(file); 289 290 if (dev->driver->postclose) 291 dev->driver->postclose(dev, file); 292 293 drm_prime_destroy_file_private(&file->prime); 294 295 WARN_ON(!list_empty(&file->event_list)); 296 297 put_pid(file->pid); 298 kfree(file); 299} 300 301static void drm_close_helper(struct file *filp) 302{ 303 struct drm_file *file_priv = filp->private_data; 304 struct drm_device *dev = file_priv->minor->dev; 305 306 mutex_lock(&dev->filelist_mutex); 307 list_del(&file_priv->lhead); 308 mutex_unlock(&dev->filelist_mutex); 309 310 drm_file_free(file_priv); 311} 312 313/* 314 * Check whether DRI will run on this CPU. 315 * 316 * \return non-zero if the DRI will run on this CPU, or zero otherwise. 317 */ 318static int drm_cpu_valid(void) 319{ 320#if defined(__sparc__) && !defined(__sparc_v9__) 321 return 0; /* No cmpxchg before v9 sparc. */ 322#endif 323 return 1; 324} 325 326/* 327 * Called whenever a process opens a drm node 328 * 329 * \param filp file pointer. 330 * \param minor acquired minor-object. 331 * \return zero on success or a negative number on failure. 332 * 333 * Creates and initializes a drm_file structure for the file private data in \p 334 * filp and add it into the double linked list in \p dev. 335 */ 336static int drm_open_helper(struct file *filp, struct drm_minor *minor) 337{ 338 struct drm_device *dev = minor->dev; 339 struct drm_file *priv; 340 int ret; 341 342 if (filp->f_flags & O_EXCL) 343 return -EBUSY; /* No exclusive opens */ 344 if (!drm_cpu_valid()) 345 return -EINVAL; 346 if (dev->switch_power_state != DRM_SWITCH_POWER_ON && 347 dev->switch_power_state != DRM_SWITCH_POWER_DYNAMIC_OFF) 348 return -EINVAL; 349 350 DRM_DEBUG("comm=\"%s\", pid=%d, minor=%d\n", current->comm, 351 task_pid_nr(current), minor->index); 352 353 priv = drm_file_alloc(minor); 354 if (IS_ERR(priv)) 355 return PTR_ERR(priv); 356 357 if (drm_is_primary_client(priv)) { 358 ret = drm_master_open(priv); 359 if (ret) { 360 drm_file_free(priv); 361 return ret; 362 } 363 } 364 365 filp->private_data = priv; 366 filp->f_mode |= FMODE_UNSIGNED_OFFSET; 367 priv->filp = filp; 368 369 mutex_lock(&dev->filelist_mutex); 370 list_add(&priv->lhead, &dev->filelist); 371 mutex_unlock(&dev->filelist_mutex); 372 373#ifdef __alpha__ 374 /* 375 * Default the hose 376 */ 377 if (!dev->hose) { 378 struct pci_dev *pci_dev; 379 380 pci_dev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, NULL); 381 if (pci_dev) { 382 dev->hose = pci_dev->sysdata; 383 pci_dev_put(pci_dev); 384 } 385 if (!dev->hose) { 386 struct pci_bus *b = list_entry(pci_root_buses.next, 387 struct pci_bus, node); 388 if (b) 389 dev->hose = b->sysdata; 390 } 391 } 392#endif 393 394 return 0; 395} 396 397/** 398 * drm_open - open method for DRM file 399 * @inode: device inode 400 * @filp: file pointer. 401 * 402 * This function must be used by drivers as their &file_operations.open method. 403 * It looks up the correct DRM device and instantiates all the per-file 404 * resources for it. It also calls the &drm_driver.open driver callback. 405 * 406 * RETURNS: 407 * 408 * 0 on success or negative errno value on falure. 409 */ 410int drm_open(struct inode *inode, struct file *filp) 411{ 412 struct drm_device *dev; 413 struct drm_minor *minor; 414 int retcode = 0; 415 int need_setup = 0; 416 417 minor = drm_minor_acquire(iminor(inode)); 418 if (IS_ERR(minor)) 419 return PTR_ERR(minor); 420 421 dev = minor->dev; 422 if (drm_dev_needs_global_mutex(dev)) 423 mutex_lock(&drm_global_mutex); 424 425 if (!atomic_fetch_inc(&dev->open_count)) 426 need_setup = 1; 427 428 /* share address_space across all char-devs of a single device */ 429 filp->f_mapping = dev->anon_inode->i_mapping; 430 431 retcode = drm_open_helper(filp, minor); 432 if (retcode) 433 goto err_undo; 434 if (need_setup) { 435 retcode = drm_legacy_setup(dev); 436 if (retcode) { 437 drm_close_helper(filp); 438 goto err_undo; 439 } 440 } 441 442 if (drm_dev_needs_global_mutex(dev)) 443 mutex_unlock(&drm_global_mutex); 444 445 return 0; 446 447err_undo: 448 atomic_dec(&dev->open_count); 449 if (drm_dev_needs_global_mutex(dev)) 450 mutex_unlock(&drm_global_mutex); 451 drm_minor_release(minor); 452 return retcode; 453} 454EXPORT_SYMBOL(drm_open); 455 456void drm_lastclose(struct drm_device * dev) 457{ 458 DRM_DEBUG("\n"); 459 460 if (dev->driver->lastclose) 461 dev->driver->lastclose(dev); 462 DRM_DEBUG("driver lastclose completed\n"); 463 464 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 465 drm_legacy_dev_reinit(dev); 466 467 drm_client_dev_restore(dev); 468} 469 470/** 471 * drm_release - release method for DRM file 472 * @inode: device inode 473 * @filp: file pointer. 474 * 475 * This function must be used by drivers as their &file_operations.release 476 * method. It frees any resources associated with the open file, and calls the 477 * &drm_driver.postclose driver callback. If this is the last open file for the 478 * DRM device also proceeds to call the &drm_driver.lastclose driver callback. 479 * 480 * RETURNS: 481 * 482 * Always succeeds and returns 0. 483 */ 484int drm_release(struct inode *inode, struct file *filp) 485{ 486 struct drm_file *file_priv = filp->private_data; 487 struct drm_minor *minor = file_priv->minor; 488 struct drm_device *dev = minor->dev; 489 490 if (drm_dev_needs_global_mutex(dev)) 491 mutex_lock(&drm_global_mutex); 492 493 DRM_DEBUG("open_count = %d\n", atomic_read(&dev->open_count)); 494 495 drm_close_helper(filp); 496 497 if (atomic_dec_and_test(&dev->open_count)) 498 drm_lastclose(dev); 499 500 if (drm_dev_needs_global_mutex(dev)) 501 mutex_unlock(&drm_global_mutex); 502 503 drm_minor_release(minor); 504 505 return 0; 506} 507EXPORT_SYMBOL(drm_release); 508 509/** 510 * drm_release_noglobal - release method for DRM file 511 * @inode: device inode 512 * @filp: file pointer. 513 * 514 * This function may be used by drivers as their &file_operations.release 515 * method. It frees any resources associated with the open file prior to taking 516 * the drm_global_mutex, which then calls the &drm_driver.postclose driver 517 * callback. If this is the last open file for the DRM device also proceeds to 518 * call the &drm_driver.lastclose driver callback. 519 * 520 * RETURNS: 521 * 522 * Always succeeds and returns 0. 523 */ 524int drm_release_noglobal(struct inode *inode, struct file *filp) 525{ 526 struct drm_file *file_priv = filp->private_data; 527 struct drm_minor *minor = file_priv->minor; 528 struct drm_device *dev = minor->dev; 529 530 drm_close_helper(filp); 531 532 if (atomic_dec_and_mutex_lock(&dev->open_count, &drm_global_mutex)) { 533 drm_lastclose(dev); 534 mutex_unlock(&drm_global_mutex); 535 } 536 537 drm_minor_release(minor); 538 539 return 0; 540} 541EXPORT_SYMBOL(drm_release_noglobal); 542 543/** 544 * drm_read - read method for DRM file 545 * @filp: file pointer 546 * @buffer: userspace destination pointer for the read 547 * @count: count in bytes to read 548 * @offset: offset to read 549 * 550 * This function must be used by drivers as their &file_operations.read 551 * method iff they use DRM events for asynchronous signalling to userspace. 552 * Since events are used by the KMS API for vblank and page flip completion this 553 * means all modern display drivers must use it. 554 * 555 * @offset is ignored, DRM events are read like a pipe. Therefore drivers also 556 * must set the &file_operation.llseek to no_llseek(). Polling support is 557 * provided by drm_poll(). 558 * 559 * This function will only ever read a full event. Therefore userspace must 560 * supply a big enough buffer to fit any event to ensure forward progress. Since 561 * the maximum event space is currently 4K it's recommended to just use that for 562 * safety. 563 * 564 * RETURNS: 565 * 566 * Number of bytes read (always aligned to full events, and can be 0) or a 567 * negative error code on failure. 568 */ 569ssize_t drm_read(struct file *filp, char __user *buffer, 570 size_t count, loff_t *offset) 571{ 572 struct drm_file *file_priv = filp->private_data; 573 struct drm_device *dev = file_priv->minor->dev; 574 ssize_t ret; 575 576 ret = mutex_lock_interruptible(&file_priv->event_read_lock); 577 if (ret) 578 return ret; 579 580 for (;;) { 581 struct drm_pending_event *e = NULL; 582 583 spin_lock_irq(&dev->event_lock); 584 if (!list_empty(&file_priv->event_list)) { 585 e = list_first_entry(&file_priv->event_list, 586 struct drm_pending_event, link); 587 file_priv->event_space += e->event->length; 588 list_del(&e->link); 589 } 590 spin_unlock_irq(&dev->event_lock); 591 592 if (e == NULL) { 593 if (ret) 594 break; 595 596 if (filp->f_flags & O_NONBLOCK) { 597 ret = -EAGAIN; 598 break; 599 } 600 601 mutex_unlock(&file_priv->event_read_lock); 602 ret = wait_event_interruptible(file_priv->event_wait, 603 !list_empty(&file_priv->event_list)); 604 if (ret >= 0) 605 ret = mutex_lock_interruptible(&file_priv->event_read_lock); 606 if (ret) 607 return ret; 608 } else { 609 unsigned length = e->event->length; 610 611 if (length > count - ret) { 612put_back_event: 613 spin_lock_irq(&dev->event_lock); 614 file_priv->event_space -= length; 615 list_add(&e->link, &file_priv->event_list); 616 spin_unlock_irq(&dev->event_lock); 617 wake_up_interruptible_poll(&file_priv->event_wait, 618 EPOLLIN | EPOLLRDNORM); 619 break; 620 } 621 622 if (copy_to_user(buffer + ret, e->event, length)) { 623 if (ret == 0) 624 ret = -EFAULT; 625 goto put_back_event; 626 } 627 628 ret += length; 629 kfree(e); 630 } 631 } 632 mutex_unlock(&file_priv->event_read_lock); 633 634 return ret; 635} 636EXPORT_SYMBOL(drm_read); 637 638/** 639 * drm_poll - poll method for DRM file 640 * @filp: file pointer 641 * @wait: poll waiter table 642 * 643 * This function must be used by drivers as their &file_operations.read method 644 * iff they use DRM events for asynchronous signalling to userspace. Since 645 * events are used by the KMS API for vblank and page flip completion this means 646 * all modern display drivers must use it. 647 * 648 * See also drm_read(). 649 * 650 * RETURNS: 651 * 652 * Mask of POLL flags indicating the current status of the file. 653 */ 654__poll_t drm_poll(struct file *filp, struct poll_table_struct *wait) 655{ 656 struct drm_file *file_priv = filp->private_data; 657 __poll_t mask = 0; 658 659 poll_wait(filp, &file_priv->event_wait, wait); 660 661 if (!list_empty(&file_priv->event_list)) 662 mask |= EPOLLIN | EPOLLRDNORM; 663 664 return mask; 665} 666EXPORT_SYMBOL(drm_poll); 667 668/** 669 * drm_event_reserve_init_locked - init a DRM event and reserve space for it 670 * @dev: DRM device 671 * @file_priv: DRM file private data 672 * @p: tracking structure for the pending event 673 * @e: actual event data to deliver to userspace 674 * 675 * This function prepares the passed in event for eventual delivery. If the event 676 * doesn't get delivered (because the IOCTL fails later on, before queuing up 677 * anything) then the even must be cancelled and freed using 678 * drm_event_cancel_free(). Successfully initialized events should be sent out 679 * using drm_send_event() or drm_send_event_locked() to signal completion of the 680 * asynchronous event to userspace. 681 * 682 * If callers embedded @p into a larger structure it must be allocated with 683 * kmalloc and @p must be the first member element. 684 * 685 * This is the locked version of drm_event_reserve_init() for callers which 686 * already hold &drm_device.event_lock. 687 * 688 * RETURNS: 689 * 690 * 0 on success or a negative error code on failure. 691 */ 692int drm_event_reserve_init_locked(struct drm_device *dev, 693 struct drm_file *file_priv, 694 struct drm_pending_event *p, 695 struct drm_event *e) 696{ 697 if (file_priv->event_space < e->length) 698 return -ENOMEM; 699 700 file_priv->event_space -= e->length; 701 702 p->event = e; 703 list_add(&p->pending_link, &file_priv->pending_event_list); 704 p->file_priv = file_priv; 705 706 return 0; 707} 708EXPORT_SYMBOL(drm_event_reserve_init_locked); 709 710/** 711 * drm_event_reserve_init - init a DRM event and reserve space for it 712 * @dev: DRM device 713 * @file_priv: DRM file private data 714 * @p: tracking structure for the pending event 715 * @e: actual event data to deliver to userspace 716 * 717 * This function prepares the passed in event for eventual delivery. If the event 718 * doesn't get delivered (because the IOCTL fails later on, before queuing up 719 * anything) then the even must be cancelled and freed using 720 * drm_event_cancel_free(). Successfully initialized events should be sent out 721 * using drm_send_event() or drm_send_event_locked() to signal completion of the 722 * asynchronous event to userspace. 723 * 724 * If callers embedded @p into a larger structure it must be allocated with 725 * kmalloc and @p must be the first member element. 726 * 727 * Callers which already hold &drm_device.event_lock should use 728 * drm_event_reserve_init_locked() instead. 729 * 730 * RETURNS: 731 * 732 * 0 on success or a negative error code on failure. 733 */ 734int drm_event_reserve_init(struct drm_device *dev, 735 struct drm_file *file_priv, 736 struct drm_pending_event *p, 737 struct drm_event *e) 738{ 739 unsigned long flags; 740 int ret; 741 742 spin_lock_irqsave(&dev->event_lock, flags); 743 ret = drm_event_reserve_init_locked(dev, file_priv, p, e); 744 spin_unlock_irqrestore(&dev->event_lock, flags); 745 746 return ret; 747} 748EXPORT_SYMBOL(drm_event_reserve_init); 749 750/** 751 * drm_event_cancel_free - free a DRM event and release its space 752 * @dev: DRM device 753 * @p: tracking structure for the pending event 754 * 755 * This function frees the event @p initialized with drm_event_reserve_init() 756 * and releases any allocated space. It is used to cancel an event when the 757 * nonblocking operation could not be submitted and needed to be aborted. 758 */ 759void drm_event_cancel_free(struct drm_device *dev, 760 struct drm_pending_event *p) 761{ 762 unsigned long flags; 763 764 spin_lock_irqsave(&dev->event_lock, flags); 765 if (p->file_priv) { 766 p->file_priv->event_space += p->event->length; 767 list_del(&p->pending_link); 768 } 769 spin_unlock_irqrestore(&dev->event_lock, flags); 770 771 if (p->fence) 772 dma_fence_put(p->fence); 773 774 kfree(p); 775} 776EXPORT_SYMBOL(drm_event_cancel_free); 777 778/** 779 * drm_send_event_locked - send DRM event to file descriptor 780 * @dev: DRM device 781 * @e: DRM event to deliver 782 * 783 * This function sends the event @e, initialized with drm_event_reserve_init(), 784 * to its associated userspace DRM file. Callers must already hold 785 * &drm_device.event_lock, see drm_send_event() for the unlocked version. 786 * 787 * Note that the core will take care of unlinking and disarming events when the 788 * corresponding DRM file is closed. Drivers need not worry about whether the 789 * DRM file for this event still exists and can call this function upon 790 * completion of the asynchronous work unconditionally. 791 */ 792void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e) 793{ 794 assert_spin_locked(&dev->event_lock); 795 796 if (e->completion) { 797 complete_all(e->completion); 798 e->completion_release(e->completion); 799 e->completion = NULL; 800 } 801 802 if (e->fence) { 803 dma_fence_signal(e->fence); 804 dma_fence_put(e->fence); 805 } 806 807 if (!e->file_priv) { 808 kfree(e); 809 return; 810 } 811 812 list_del(&e->pending_link); 813 list_add_tail(&e->link, 814 &e->file_priv->event_list); 815 wake_up_interruptible_poll(&e->file_priv->event_wait, 816 EPOLLIN | EPOLLRDNORM); 817} 818EXPORT_SYMBOL(drm_send_event_locked); 819 820/** 821 * drm_send_event - send DRM event to file descriptor 822 * @dev: DRM device 823 * @e: DRM event to deliver 824 * 825 * This function sends the event @e, initialized with drm_event_reserve_init(), 826 * to its associated userspace DRM file. This function acquires 827 * &drm_device.event_lock, see drm_send_event_locked() for callers which already 828 * hold this lock. 829 * 830 * Note that the core will take care of unlinking and disarming events when the 831 * corresponding DRM file is closed. Drivers need not worry about whether the 832 * DRM file for this event still exists and can call this function upon 833 * completion of the asynchronous work unconditionally. 834 */ 835void drm_send_event(struct drm_device *dev, struct drm_pending_event *e) 836{ 837 unsigned long irqflags; 838 839 spin_lock_irqsave(&dev->event_lock, irqflags); 840 drm_send_event_locked(dev, e); 841 spin_unlock_irqrestore(&dev->event_lock, irqflags); 842} 843EXPORT_SYMBOL(drm_send_event); 844 845/** 846 * mock_drm_getfile - Create a new struct file for the drm device 847 * @minor: drm minor to wrap (e.g. #drm_device.primary) 848 * @flags: file creation mode (O_RDWR etc) 849 * 850 * This create a new struct file that wraps a DRM file context around a 851 * DRM minor. This mimicks userspace opening e.g. /dev/dri/card0, but without 852 * invoking userspace. The struct file may be operated on using its f_op 853 * (the drm_device.driver.fops) to mimick userspace operations, or be supplied 854 * to userspace facing functions as an internal/anonymous client. 855 * 856 * RETURNS: 857 * Pointer to newly created struct file, ERR_PTR on failure. 858 */ 859struct file *mock_drm_getfile(struct drm_minor *minor, unsigned int flags) 860{ 861 struct drm_device *dev = minor->dev; 862 struct drm_file *priv; 863 struct file *file; 864 865 priv = drm_file_alloc(minor); 866 if (IS_ERR(priv)) 867 return ERR_CAST(priv); 868 869 file = anon_inode_getfile("drm", dev->driver->fops, priv, flags); 870 if (IS_ERR(file)) { 871 drm_file_free(priv); 872 return file; 873 } 874 875 /* Everyone shares a single global address space */ 876 file->f_mapping = dev->anon_inode->i_mapping; 877 878 drm_dev_get(dev); 879 priv->filp = file; 880 881 return file; 882} 883EXPORT_SYMBOL_FOR_TESTS_ONLY(mock_drm_getfile); 884 885#ifdef CONFIG_MMU 886#ifdef CONFIG_TRANSPARENT_HUGEPAGE 887/* 888 * drm_addr_inflate() attempts to construct an aligned area by inflating 889 * the area size and skipping the unaligned start of the area. 890 * adapted from shmem_get_unmapped_area() 891 */ 892static unsigned long drm_addr_inflate(unsigned long addr, 893 unsigned long len, 894 unsigned long pgoff, 895 unsigned long flags, 896 unsigned long huge_size) 897{ 898 unsigned long offset, inflated_len; 899 unsigned long inflated_addr; 900 unsigned long inflated_offset; 901 902 offset = (pgoff << PAGE_SHIFT) & (huge_size - 1); 903 if (offset && offset + len < 2 * huge_size) 904 return addr; 905 if ((addr & (huge_size - 1)) == offset) 906 return addr; 907 908 inflated_len = len + huge_size - PAGE_SIZE; 909 if (inflated_len > TASK_SIZE) 910 return addr; 911 if (inflated_len < len) 912 return addr; 913 914 inflated_addr = current->mm->get_unmapped_area(NULL, 0, inflated_len, 915 0, flags); 916 if (IS_ERR_VALUE(inflated_addr)) 917 return addr; 918 if (inflated_addr & ~PAGE_MASK) 919 return addr; 920 921 inflated_offset = inflated_addr & (huge_size - 1); 922 inflated_addr += offset - inflated_offset; 923 if (inflated_offset > offset) 924 inflated_addr += huge_size; 925 926 if (inflated_addr > TASK_SIZE - len) 927 return addr; 928 929 return inflated_addr; 930} 931 932/** 933 * drm_get_unmapped_area() - Get an unused user-space virtual memory area 934 * suitable for huge page table entries. 935 * @file: The struct file representing the address space being mmap()'d. 936 * @uaddr: Start address suggested by user-space. 937 * @len: Length of the area. 938 * @pgoff: The page offset into the address space. 939 * @flags: mmap flags 940 * @mgr: The address space manager used by the drm driver. This argument can 941 * probably be removed at some point when all drivers use the same 942 * address space manager. 943 * 944 * This function attempts to find an unused user-space virtual memory area 945 * that can accommodate the size we want to map, and that is properly 946 * aligned to facilitate huge page table entries matching actual 947 * huge pages or huge page aligned memory in buffer objects. Buffer objects 948 * are assumed to start at huge page boundary pfns (io memory) or be 949 * populated by huge pages aligned to the start of the buffer object 950 * (system- or coherent memory). Adapted from shmem_get_unmapped_area. 951 * 952 * Return: aligned user-space address. 953 */ 954unsigned long drm_get_unmapped_area(struct file *file, 955 unsigned long uaddr, unsigned long len, 956 unsigned long pgoff, unsigned long flags, 957 struct drm_vma_offset_manager *mgr) 958{ 959 unsigned long addr; 960 unsigned long inflated_addr; 961 struct drm_vma_offset_node *node; 962 963 if (len > TASK_SIZE) 964 return -ENOMEM; 965 966 /* 967 * @pgoff is the file page-offset the huge page boundaries of 968 * which typically aligns to physical address huge page boundaries. 969 * That's not true for DRM, however, where physical address huge 970 * page boundaries instead are aligned with the offset from 971 * buffer object start. So adjust @pgoff to be the offset from 972 * buffer object start. 973 */ 974 drm_vma_offset_lock_lookup(mgr); 975 node = drm_vma_offset_lookup_locked(mgr, pgoff, 1); 976 if (node) 977 pgoff -= node->vm_node.start; 978 drm_vma_offset_unlock_lookup(mgr); 979 980 addr = current->mm->get_unmapped_area(file, uaddr, len, pgoff, flags); 981 if (IS_ERR_VALUE(addr)) 982 return addr; 983 if (addr & ~PAGE_MASK) 984 return addr; 985 if (addr > TASK_SIZE - len) 986 return addr; 987 988 if (len < HPAGE_PMD_SIZE) 989 return addr; 990 if (flags & MAP_FIXED) 991 return addr; 992 /* 993 * Our priority is to support MAP_SHARED mapped hugely; 994 * and support MAP_PRIVATE mapped hugely too, until it is COWed. 995 * But if caller specified an address hint, respect that as before. 996 */ 997 if (uaddr) 998 return addr; 999 1000 inflated_addr = drm_addr_inflate(addr, len, pgoff, flags, 1001 HPAGE_PMD_SIZE); 1002 1003 if (IS_ENABLED(CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD) && 1004 len >= HPAGE_PUD_SIZE) 1005 inflated_addr = drm_addr_inflate(inflated_addr, len, pgoff, 1006 flags, HPAGE_PUD_SIZE); 1007 return inflated_addr; 1008} 1009#else /* CONFIG_TRANSPARENT_HUGEPAGE */ 1010unsigned long drm_get_unmapped_area(struct file *file, 1011 unsigned long uaddr, unsigned long len, 1012 unsigned long pgoff, unsigned long flags, 1013 struct drm_vma_offset_manager *mgr) 1014{ 1015 return current->mm->get_unmapped_area(file, uaddr, len, pgoff, flags); 1016} 1017#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ 1018EXPORT_SYMBOL_GPL(drm_get_unmapped_area); 1019#endif /* CONFIG_MMU */ 1020