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 /* from BKL pushdown */ 52 DEFINE_MUTEX(drm_global_mutex); 53 54 bool drm_dev_needs_global_mutex(struct drm_device *dev) 55 { 56 /* 57 * Legacy drivers rely on all kinds of BKL locking semantics, don't 58 * bother. They also still need BKL locking for their ioctls, so better 59 * safe than sorry. 60 */ 61 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 62 return true; 63 64 /* 65 * The deprecated ->load callback must be called after the driver is 66 * already registered. This means such drivers rely on the BKL to make 67 * sure an open can't proceed until the driver is actually fully set up. 68 * Similar hilarity holds for the unload callback. 69 */ 70 if (dev->driver->load || dev->driver->unload) 71 return true; 72 73 /* 74 * Drivers with the lastclose callback assume that it's synchronized 75 * against concurrent opens, which again needs the BKL. The proper fix 76 * is to use the drm_client infrastructure with proper locking for each 77 * client. 78 */ 79 if (dev->driver->lastclose) 80 return true; 81 82 return false; 83 } 84 85 /** 86 * DOC: file operations 87 * 88 * Drivers must define the file operations structure that forms the DRM 89 * userspace API entry point, even though most of those operations are 90 * implemented in the DRM core. The resulting &struct file_operations must be 91 * stored in the &drm_driver.fops field. The mandatory functions are drm_open(), 92 * drm_read(), drm_ioctl() and drm_compat_ioctl() if CONFIG_COMPAT is enabled 93 * Note that drm_compat_ioctl will be NULL if CONFIG_COMPAT=n, so there's no 94 * need to sprinkle #ifdef into the code. Drivers which implement private ioctls 95 * that require 32/64 bit compatibility support must provide their own 96 * &file_operations.compat_ioctl handler that processes private ioctls and calls 97 * drm_compat_ioctl() for core ioctls. 98 * 99 * In addition drm_read() and drm_poll() provide support for DRM events. DRM 100 * events are a generic and extensible means to send asynchronous events to 101 * userspace through the file descriptor. They are used to send vblank event and 102 * page flip completions by the KMS API. But drivers can also use it for their 103 * own needs, e.g. to signal completion of rendering. 104 * 105 * For the driver-side event interface see drm_event_reserve_init() and 106 * drm_send_event() as the main starting points. 107 * 108 * The memory mapping implementation will vary depending on how the driver 109 * manages memory. Legacy drivers will use the deprecated drm_legacy_mmap() 110 * function, modern drivers should use one of the provided memory-manager 111 * specific implementations. For GEM-based drivers this is drm_gem_mmap(), and 112 * for drivers which use the CMA GEM helpers it's drm_gem_cma_mmap(). 113 * 114 * No other file operations are supported by the DRM userspace API. Overall the 115 * following is an example &file_operations structure:: 116 * 117 * static const example_drm_fops = { 118 * .owner = THIS_MODULE, 119 * .open = drm_open, 120 * .release = drm_release, 121 * .unlocked_ioctl = drm_ioctl, 122 * .compat_ioctl = drm_compat_ioctl, // NULL if CONFIG_COMPAT=n 123 * .poll = drm_poll, 124 * .read = drm_read, 125 * .llseek = no_llseek, 126 * .mmap = drm_gem_mmap, 127 * }; 128 * 129 * For plain GEM based drivers there is the DEFINE_DRM_GEM_FOPS() macro, and for 130 * CMA based drivers there is the DEFINE_DRM_GEM_CMA_FOPS() macro to make this 131 * simpler. 132 * 133 * The driver's &file_operations must be stored in &drm_driver.fops. 134 * 135 * For driver-private IOCTL handling see the more detailed discussion in 136 * :ref:`IOCTL support in the userland interfaces chapter<drm_driver_ioctl>`. 137 */ 138 139 /** 140 * drm_file_alloc - allocate file context 141 * @minor: minor to allocate on 142 * 143 * This allocates a new DRM file context. It is not linked into any context and 144 * can be used by the caller freely. Note that the context keeps a pointer to 145 * @minor, so it must be freed before @minor is. 146 * 147 * RETURNS: 148 * Pointer to newly allocated context, ERR_PTR on failure. 149 */ 150 struct drm_file *drm_file_alloc(struct drm_minor *minor) 151 { 152 struct drm_device *dev = minor->dev; 153 struct drm_file *file; 154 int ret; 155 156 file = kzalloc(sizeof(*file), GFP_KERNEL); 157 if (!file) 158 return ERR_PTR(-ENOMEM); 159 160 file->pid = get_pid(task_pid(current)); 161 file->minor = minor; 162 163 /* for compatibility root is always authenticated */ 164 file->authenticated = capable(CAP_SYS_ADMIN); 165 166 INIT_LIST_HEAD(&file->lhead); 167 INIT_LIST_HEAD(&file->fbs); 168 mutex_init(&file->fbs_lock); 169 INIT_LIST_HEAD(&file->blobs); 170 INIT_LIST_HEAD(&file->pending_event_list); 171 INIT_LIST_HEAD(&file->event_list); 172 init_waitqueue_head(&file->event_wait); 173 file->event_space = 4096; /* set aside 4k for event buffer */ 174 175 mutex_init(&file->event_read_lock); 176 177 if (drm_core_check_feature(dev, DRIVER_GEM)) 178 drm_gem_open(dev, file); 179 180 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 181 drm_syncobj_open(file); 182 183 drm_prime_init_file_private(&file->prime); 184 185 if (dev->driver->open) { 186 ret = dev->driver->open(dev, file); 187 if (ret < 0) 188 goto out_prime_destroy; 189 } 190 191 return file; 192 193 out_prime_destroy: 194 drm_prime_destroy_file_private(&file->prime); 195 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 196 drm_syncobj_release(file); 197 if (drm_core_check_feature(dev, DRIVER_GEM)) 198 drm_gem_release(dev, file); 199 put_pid(file->pid); 200 kfree(file); 201 202 return ERR_PTR(ret); 203 } 204 205 static void drm_events_release(struct drm_file *file_priv) 206 { 207 struct drm_device *dev = file_priv->minor->dev; 208 struct drm_pending_event *e, *et; 209 unsigned long flags; 210 211 spin_lock_irqsave(&dev->event_lock, flags); 212 213 /* Unlink pending events */ 214 list_for_each_entry_safe(e, et, &file_priv->pending_event_list, 215 pending_link) { 216 list_del(&e->pending_link); 217 e->file_priv = NULL; 218 } 219 220 /* Remove unconsumed events */ 221 list_for_each_entry_safe(e, et, &file_priv->event_list, link) { 222 list_del(&e->link); 223 kfree(e); 224 } 225 226 spin_unlock_irqrestore(&dev->event_lock, flags); 227 } 228 229 /** 230 * drm_file_free - free file context 231 * @file: context to free, or NULL 232 * 233 * This destroys and deallocates a DRM file context previously allocated via 234 * drm_file_alloc(). The caller must make sure to unlink it from any contexts 235 * before calling this. 236 * 237 * If NULL is passed, this is a no-op. 238 * 239 * RETURNS: 240 * 0 on success, or error code on failure. 241 */ 242 void drm_file_free(struct drm_file *file) 243 { 244 struct drm_device *dev; 245 246 if (!file) 247 return; 248 249 dev = file->minor->dev; 250 251 DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n", 252 task_pid_nr(current), 253 (long)old_encode_dev(file->minor->kdev->devt), 254 atomic_read(&dev->open_count)); 255 256 if (drm_core_check_feature(dev, DRIVER_LEGACY) && 257 dev->driver->preclose) 258 dev->driver->preclose(dev, file); 259 260 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 261 drm_legacy_lock_release(dev, file->filp); 262 263 if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)) 264 drm_legacy_reclaim_buffers(dev, file); 265 266 drm_events_release(file); 267 268 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 269 drm_fb_release(file); 270 drm_property_destroy_user_blobs(dev, file); 271 } 272 273 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 274 drm_syncobj_release(file); 275 276 if (drm_core_check_feature(dev, DRIVER_GEM)) 277 drm_gem_release(dev, file); 278 279 drm_legacy_ctxbitmap_flush(dev, file); 280 281 if (drm_is_primary_client(file)) 282 drm_master_release(file); 283 284 if (dev->driver->postclose) 285 dev->driver->postclose(dev, file); 286 287 drm_prime_destroy_file_private(&file->prime); 288 289 WARN_ON(!list_empty(&file->event_list)); 290 291 put_pid(file->pid); 292 kfree(file); 293 } 294 295 static void drm_close_helper(struct file *filp) 296 { 297 struct drm_file *file_priv = filp->private_data; 298 struct drm_device *dev = file_priv->minor->dev; 299 300 mutex_lock(&dev->filelist_mutex); 301 list_del(&file_priv->lhead); 302 mutex_unlock(&dev->filelist_mutex); 303 304 drm_file_free(file_priv); 305 } 306 307 /* 308 * Check whether DRI will run on this CPU. 309 * 310 * \return non-zero if the DRI will run on this CPU, or zero otherwise. 311 */ 312 static int drm_cpu_valid(void) 313 { 314 #if defined(__sparc__) && !defined(__sparc_v9__) 315 return 0; /* No cmpxchg before v9 sparc. */ 316 #endif 317 return 1; 318 } 319 320 /* 321 * Called whenever a process opens a drm node 322 * 323 * \param filp file pointer. 324 * \param minor acquired minor-object. 325 * \return zero on success or a negative number on failure. 326 * 327 * Creates and initializes a drm_file structure for the file private data in \p 328 * filp and add it into the double linked list in \p dev. 329 */ 330 static int drm_open_helper(struct file *filp, struct drm_minor *minor) 331 { 332 struct drm_device *dev = minor->dev; 333 struct drm_file *priv; 334 int ret; 335 336 if (filp->f_flags & O_EXCL) 337 return -EBUSY; /* No exclusive opens */ 338 if (!drm_cpu_valid()) 339 return -EINVAL; 340 if (dev->switch_power_state != DRM_SWITCH_POWER_ON && dev->switch_power_state != DRM_SWITCH_POWER_DYNAMIC_OFF) 341 return -EINVAL; 342 343 DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor->index); 344 345 priv = drm_file_alloc(minor); 346 if (IS_ERR(priv)) 347 return PTR_ERR(priv); 348 349 if (drm_is_primary_client(priv)) { 350 ret = drm_master_open(priv); 351 if (ret) { 352 drm_file_free(priv); 353 return ret; 354 } 355 } 356 357 filp->private_data = priv; 358 filp->f_mode |= FMODE_UNSIGNED_OFFSET; 359 priv->filp = filp; 360 361 mutex_lock(&dev->filelist_mutex); 362 list_add(&priv->lhead, &dev->filelist); 363 mutex_unlock(&dev->filelist_mutex); 364 365 #ifdef __alpha__ 366 /* 367 * Default the hose 368 */ 369 if (!dev->hose) { 370 struct pci_dev *pci_dev; 371 pci_dev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, NULL); 372 if (pci_dev) { 373 dev->hose = pci_dev->sysdata; 374 pci_dev_put(pci_dev); 375 } 376 if (!dev->hose) { 377 struct pci_bus *b = list_entry(pci_root_buses.next, 378 struct pci_bus, node); 379 if (b) 380 dev->hose = b->sysdata; 381 } 382 } 383 #endif 384 385 return 0; 386 } 387 388 /** 389 * drm_open - open method for DRM file 390 * @inode: device inode 391 * @filp: file pointer. 392 * 393 * This function must be used by drivers as their &file_operations.open method. 394 * It looks up the correct DRM device and instantiates all the per-file 395 * resources for it. It also calls the &drm_driver.open driver callback. 396 * 397 * RETURNS: 398 * 399 * 0 on success or negative errno value on falure. 400 */ 401 int drm_open(struct inode *inode, struct file *filp) 402 { 403 struct drm_device *dev; 404 struct drm_minor *minor; 405 int retcode; 406 int need_setup = 0; 407 408 minor = drm_minor_acquire(iminor(inode)); 409 if (IS_ERR(minor)) 410 return PTR_ERR(minor); 411 412 dev = minor->dev; 413 if (drm_dev_needs_global_mutex(dev)) 414 mutex_lock(&drm_global_mutex); 415 416 if (!atomic_fetch_inc(&dev->open_count)) 417 need_setup = 1; 418 419 /* share address_space across all char-devs of a single device */ 420 filp->f_mapping = dev->anon_inode->i_mapping; 421 422 retcode = drm_open_helper(filp, minor); 423 if (retcode) 424 goto err_undo; 425 if (need_setup) { 426 retcode = drm_legacy_setup(dev); 427 if (retcode) { 428 drm_close_helper(filp); 429 goto err_undo; 430 } 431 } 432 433 if (drm_dev_needs_global_mutex(dev)) 434 mutex_unlock(&drm_global_mutex); 435 436 return 0; 437 438 err_undo: 439 atomic_dec(&dev->open_count); 440 if (drm_dev_needs_global_mutex(dev)) 441 mutex_unlock(&drm_global_mutex); 442 drm_minor_release(minor); 443 return retcode; 444 } 445 EXPORT_SYMBOL(drm_open); 446 447 void drm_lastclose(struct drm_device * dev) 448 { 449 DRM_DEBUG("\n"); 450 451 if (dev->driver->lastclose) 452 dev->driver->lastclose(dev); 453 DRM_DEBUG("driver lastclose completed\n"); 454 455 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 456 drm_legacy_dev_reinit(dev); 457 458 drm_client_dev_restore(dev); 459 } 460 461 /** 462 * drm_release - release method for DRM file 463 * @inode: device inode 464 * @filp: file pointer. 465 * 466 * This function must be used by drivers as their &file_operations.release 467 * method. It frees any resources associated with the open file, and calls the 468 * &drm_driver.postclose driver callback. If this is the last open file for the 469 * DRM device also proceeds to call the &drm_driver.lastclose driver callback. 470 * 471 * RETURNS: 472 * 473 * Always succeeds and returns 0. 474 */ 475 int drm_release(struct inode *inode, struct file *filp) 476 { 477 struct drm_file *file_priv = filp->private_data; 478 struct drm_minor *minor = file_priv->minor; 479 struct drm_device *dev = minor->dev; 480 481 if (drm_dev_needs_global_mutex(dev)) 482 mutex_lock(&drm_global_mutex); 483 484 DRM_DEBUG("open_count = %d\n", atomic_read(&dev->open_count)); 485 486 drm_close_helper(filp); 487 488 if (atomic_dec_and_test(&dev->open_count)) 489 drm_lastclose(dev); 490 491 if (drm_dev_needs_global_mutex(dev)) 492 mutex_unlock(&drm_global_mutex); 493 494 drm_minor_release(minor); 495 496 return 0; 497 } 498 EXPORT_SYMBOL(drm_release); 499 500 /** 501 * drm_release_noglobal - release method for DRM file 502 * @inode: device inode 503 * @filp: file pointer. 504 * 505 * This function may be used by drivers as their &file_operations.release 506 * method. It frees any resources associated with the open file prior to taking 507 * the drm_global_mutex, which then calls the &drm_driver.postclose driver 508 * callback. If this is the last open file for the DRM device also proceeds to 509 * call the &drm_driver.lastclose driver callback. 510 * 511 * RETURNS: 512 * 513 * Always succeeds and returns 0. 514 */ 515 int drm_release_noglobal(struct inode *inode, struct file *filp) 516 { 517 struct drm_file *file_priv = filp->private_data; 518 struct drm_minor *minor = file_priv->minor; 519 struct drm_device *dev = minor->dev; 520 521 drm_close_helper(filp); 522 523 if (atomic_dec_and_mutex_lock(&dev->open_count, &drm_global_mutex)) { 524 drm_lastclose(dev); 525 mutex_unlock(&drm_global_mutex); 526 } 527 528 drm_minor_release(minor); 529 530 return 0; 531 } 532 EXPORT_SYMBOL(drm_release_noglobal); 533 534 /** 535 * drm_read - read method for DRM file 536 * @filp: file pointer 537 * @buffer: userspace destination pointer for the read 538 * @count: count in bytes to read 539 * @offset: offset to read 540 * 541 * This function must be used by drivers as their &file_operations.read 542 * method iff they use DRM events for asynchronous signalling to userspace. 543 * Since events are used by the KMS API for vblank and page flip completion this 544 * means all modern display drivers must use it. 545 * 546 * @offset is ignored, DRM events are read like a pipe. Therefore drivers also 547 * must set the &file_operation.llseek to no_llseek(). Polling support is 548 * provided by drm_poll(). 549 * 550 * This function will only ever read a full event. Therefore userspace must 551 * supply a big enough buffer to fit any event to ensure forward progress. Since 552 * the maximum event space is currently 4K it's recommended to just use that for 553 * safety. 554 * 555 * RETURNS: 556 * 557 * Number of bytes read (always aligned to full events, and can be 0) or a 558 * negative error code on failure. 559 */ 560 ssize_t drm_read(struct file *filp, char __user *buffer, 561 size_t count, loff_t *offset) 562 { 563 struct drm_file *file_priv = filp->private_data; 564 struct drm_device *dev = file_priv->minor->dev; 565 ssize_t ret; 566 567 if (!access_ok(buffer, count)) 568 return -EFAULT; 569 570 ret = mutex_lock_interruptible(&file_priv->event_read_lock); 571 if (ret) 572 return ret; 573 574 for (;;) { 575 struct drm_pending_event *e = NULL; 576 577 spin_lock_irq(&dev->event_lock); 578 if (!list_empty(&file_priv->event_list)) { 579 e = list_first_entry(&file_priv->event_list, 580 struct drm_pending_event, link); 581 file_priv->event_space += e->event->length; 582 list_del(&e->link); 583 } 584 spin_unlock_irq(&dev->event_lock); 585 586 if (e == NULL) { 587 if (ret) 588 break; 589 590 if (filp->f_flags & O_NONBLOCK) { 591 ret = -EAGAIN; 592 break; 593 } 594 595 mutex_unlock(&file_priv->event_read_lock); 596 ret = wait_event_interruptible(file_priv->event_wait, 597 !list_empty(&file_priv->event_list)); 598 if (ret >= 0) 599 ret = mutex_lock_interruptible(&file_priv->event_read_lock); 600 if (ret) 601 return ret; 602 } else { 603 unsigned length = e->event->length; 604 605 if (length > count - ret) { 606 put_back_event: 607 spin_lock_irq(&dev->event_lock); 608 file_priv->event_space -= length; 609 list_add(&e->link, &file_priv->event_list); 610 spin_unlock_irq(&dev->event_lock); 611 wake_up_interruptible(&file_priv->event_wait); 612 break; 613 } 614 615 if (copy_to_user(buffer + ret, e->event, length)) { 616 if (ret == 0) 617 ret = -EFAULT; 618 goto put_back_event; 619 } 620 621 ret += length; 622 kfree(e); 623 } 624 } 625 mutex_unlock(&file_priv->event_read_lock); 626 627 return ret; 628 } 629 EXPORT_SYMBOL(drm_read); 630 631 /** 632 * drm_poll - poll method for DRM file 633 * @filp: file pointer 634 * @wait: poll waiter table 635 * 636 * This function must be used by drivers as their &file_operations.read method 637 * iff they use DRM events for asynchronous signalling to userspace. Since 638 * events are used by the KMS API for vblank and page flip completion this means 639 * all modern display drivers must use it. 640 * 641 * See also drm_read(). 642 * 643 * RETURNS: 644 * 645 * Mask of POLL flags indicating the current status of the file. 646 */ 647 __poll_t drm_poll(struct file *filp, struct poll_table_struct *wait) 648 { 649 struct drm_file *file_priv = filp->private_data; 650 __poll_t mask = 0; 651 652 poll_wait(filp, &file_priv->event_wait, wait); 653 654 if (!list_empty(&file_priv->event_list)) 655 mask |= EPOLLIN | EPOLLRDNORM; 656 657 return mask; 658 } 659 EXPORT_SYMBOL(drm_poll); 660 661 /** 662 * drm_event_reserve_init_locked - init a DRM event and reserve space for it 663 * @dev: DRM device 664 * @file_priv: DRM file private data 665 * @p: tracking structure for the pending event 666 * @e: actual event data to deliver to userspace 667 * 668 * This function prepares the passed in event for eventual delivery. If the event 669 * doesn't get delivered (because the IOCTL fails later on, before queuing up 670 * anything) then the even must be cancelled and freed using 671 * drm_event_cancel_free(). Successfully initialized events should be sent out 672 * using drm_send_event() or drm_send_event_locked() to signal completion of the 673 * asynchronous event to userspace. 674 * 675 * If callers embedded @p into a larger structure it must be allocated with 676 * kmalloc and @p must be the first member element. 677 * 678 * This is the locked version of drm_event_reserve_init() for callers which 679 * already hold &drm_device.event_lock. 680 * 681 * RETURNS: 682 * 683 * 0 on success or a negative error code on failure. 684 */ 685 int drm_event_reserve_init_locked(struct drm_device *dev, 686 struct drm_file *file_priv, 687 struct drm_pending_event *p, 688 struct drm_event *e) 689 { 690 if (file_priv->event_space < e->length) 691 return -ENOMEM; 692 693 file_priv->event_space -= e->length; 694 695 p->event = e; 696 list_add(&p->pending_link, &file_priv->pending_event_list); 697 p->file_priv = file_priv; 698 699 return 0; 700 } 701 EXPORT_SYMBOL(drm_event_reserve_init_locked); 702 703 /** 704 * drm_event_reserve_init - init a DRM event and reserve space for it 705 * @dev: DRM device 706 * @file_priv: DRM file private data 707 * @p: tracking structure for the pending event 708 * @e: actual event data to deliver to userspace 709 * 710 * This function prepares the passed in event for eventual delivery. If the event 711 * doesn't get delivered (because the IOCTL fails later on, before queuing up 712 * anything) then the even must be cancelled and freed using 713 * drm_event_cancel_free(). Successfully initialized events should be sent out 714 * using drm_send_event() or drm_send_event_locked() to signal completion of the 715 * asynchronous event to userspace. 716 * 717 * If callers embedded @p into a larger structure it must be allocated with 718 * kmalloc and @p must be the first member element. 719 * 720 * Callers which already hold &drm_device.event_lock should use 721 * drm_event_reserve_init_locked() instead. 722 * 723 * RETURNS: 724 * 725 * 0 on success or a negative error code on failure. 726 */ 727 int drm_event_reserve_init(struct drm_device *dev, 728 struct drm_file *file_priv, 729 struct drm_pending_event *p, 730 struct drm_event *e) 731 { 732 unsigned long flags; 733 int ret; 734 735 spin_lock_irqsave(&dev->event_lock, flags); 736 ret = drm_event_reserve_init_locked(dev, file_priv, p, e); 737 spin_unlock_irqrestore(&dev->event_lock, flags); 738 739 return ret; 740 } 741 EXPORT_SYMBOL(drm_event_reserve_init); 742 743 /** 744 * drm_event_cancel_free - free a DRM event and release its space 745 * @dev: DRM device 746 * @p: tracking structure for the pending event 747 * 748 * This function frees the event @p initialized with drm_event_reserve_init() 749 * and releases any allocated space. It is used to cancel an event when the 750 * nonblocking operation could not be submitted and needed to be aborted. 751 */ 752 void drm_event_cancel_free(struct drm_device *dev, 753 struct drm_pending_event *p) 754 { 755 unsigned long flags; 756 spin_lock_irqsave(&dev->event_lock, flags); 757 if (p->file_priv) { 758 p->file_priv->event_space += p->event->length; 759 list_del(&p->pending_link); 760 } 761 spin_unlock_irqrestore(&dev->event_lock, flags); 762 763 if (p->fence) 764 dma_fence_put(p->fence); 765 766 kfree(p); 767 } 768 EXPORT_SYMBOL(drm_event_cancel_free); 769 770 /** 771 * drm_send_event_locked - send DRM event to file descriptor 772 * @dev: DRM device 773 * @e: DRM event to deliver 774 * 775 * This function sends the event @e, initialized with drm_event_reserve_init(), 776 * to its associated userspace DRM file. Callers must already hold 777 * &drm_device.event_lock, see drm_send_event() for the unlocked version. 778 * 779 * Note that the core will take care of unlinking and disarming events when the 780 * corresponding DRM file is closed. Drivers need not worry about whether the 781 * DRM file for this event still exists and can call this function upon 782 * completion of the asynchronous work unconditionally. 783 */ 784 void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e) 785 { 786 assert_spin_locked(&dev->event_lock); 787 788 if (e->completion) { 789 complete_all(e->completion); 790 e->completion_release(e->completion); 791 e->completion = NULL; 792 } 793 794 if (e->fence) { 795 dma_fence_signal(e->fence); 796 dma_fence_put(e->fence); 797 } 798 799 if (!e->file_priv) { 800 kfree(e); 801 return; 802 } 803 804 list_del(&e->pending_link); 805 list_add_tail(&e->link, 806 &e->file_priv->event_list); 807 wake_up_interruptible(&e->file_priv->event_wait); 808 } 809 EXPORT_SYMBOL(drm_send_event_locked); 810 811 /** 812 * drm_send_event - send DRM event to file descriptor 813 * @dev: DRM device 814 * @e: DRM event to deliver 815 * 816 * This function sends the event @e, initialized with drm_event_reserve_init(), 817 * to its associated userspace DRM file. This function acquires 818 * &drm_device.event_lock, see drm_send_event_locked() for callers which already 819 * hold this lock. 820 * 821 * Note that the core will take care of unlinking and disarming events when the 822 * corresponding DRM file is closed. Drivers need not worry about whether the 823 * DRM file for this event still exists and can call this function upon 824 * completion of the asynchronous work unconditionally. 825 */ 826 void drm_send_event(struct drm_device *dev, struct drm_pending_event *e) 827 { 828 unsigned long irqflags; 829 830 spin_lock_irqsave(&dev->event_lock, irqflags); 831 drm_send_event_locked(dev, e); 832 spin_unlock_irqrestore(&dev->event_lock, irqflags); 833 } 834 EXPORT_SYMBOL(drm_send_event); 835 836 /** 837 * mock_drm_getfile - Create a new struct file for the drm device 838 * @minor: drm minor to wrap (e.g. #drm_device.primary) 839 * @flags: file creation mode (O_RDWR etc) 840 * 841 * This create a new struct file that wraps a DRM file context around a 842 * DRM minor. This mimicks userspace opening e.g. /dev/dri/card0, but without 843 * invoking userspace. The struct file may be operated on using its f_op 844 * (the drm_device.driver.fops) to mimick userspace operations, or be supplied 845 * to userspace facing functions as an internal/anonymous client. 846 * 847 * RETURNS: 848 * Pointer to newly created struct file, ERR_PTR on failure. 849 */ 850 struct file *mock_drm_getfile(struct drm_minor *minor, unsigned int flags) 851 { 852 struct drm_device *dev = minor->dev; 853 struct drm_file *priv; 854 struct file *file; 855 856 priv = drm_file_alloc(minor); 857 if (IS_ERR(priv)) 858 return ERR_CAST(priv); 859 860 file = anon_inode_getfile("drm", dev->driver->fops, priv, flags); 861 if (IS_ERR(file)) { 862 drm_file_free(priv); 863 return file; 864 } 865 866 /* Everyone shares a single global address space */ 867 file->f_mapping = dev->anon_inode->i_mapping; 868 869 drm_dev_get(dev); 870 priv->filp = file; 871 872 return file; 873 } 874 EXPORT_SYMBOL_FOR_TESTS_ONLY(mock_drm_getfile); 875