997 lines · c
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.com9 *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 a15 * copy of this software and associated documentation files (the "Software"),16 * to deal in the Software without restriction, including without limitation17 * the rights to use, copy, modify, merge, publish, distribute, sublicense,18 * and/or sell copies of the Software, and to permit persons to whom the19 * Software is furnished to do so, subject to the following conditions:20 *21 * The above copyright notice and this permission notice (including the next22 * paragraph) shall be included in all copies or substantial portions of the23 * Software.24 *25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR26 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,27 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL28 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR29 * 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 OR31 * 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#include <linux/vga_switcheroo.h>42 43#include <drm/drm_client.h>44#include <drm/drm_drv.h>45#include <drm/drm_file.h>46#include <drm/drm_gem.h>47#include <drm/drm_print.h>48 49#include "drm_crtc_internal.h"50#include "drm_internal.h"51 52/* from BKL pushdown */53DEFINE_MUTEX(drm_global_mutex);54 55bool drm_dev_needs_global_mutex(struct drm_device *dev)56{57 /*58 * The deprecated ->load callback must be called after the driver is59 * already registered. This means such drivers rely on the BKL to make60 * sure an open can't proceed until the driver is actually fully set up.61 * Similar hilarity holds for the unload callback.62 */63 if (dev->driver->load || dev->driver->unload)64 return true;65 66 return false;67}68 69/**70 * DOC: file operations71 *72 * Drivers must define the file operations structure that forms the DRM73 * userspace API entry point, even though most of those operations are74 * implemented in the DRM core. The resulting &struct file_operations must be75 * stored in the &drm_driver.fops field. The mandatory functions are drm_open(),76 * drm_read(), drm_ioctl() and drm_compat_ioctl() if CONFIG_COMPAT is enabled77 * Note that drm_compat_ioctl will be NULL if CONFIG_COMPAT=n, so there's no78 * need to sprinkle #ifdef into the code. Drivers which implement private ioctls79 * that require 32/64 bit compatibility support must provide their own80 * &file_operations.compat_ioctl handler that processes private ioctls and calls81 * drm_compat_ioctl() for core ioctls.82 *83 * In addition drm_read() and drm_poll() provide support for DRM events. DRM84 * events are a generic and extensible means to send asynchronous events to85 * userspace through the file descriptor. They are used to send vblank event and86 * page flip completions by the KMS API. But drivers can also use it for their87 * own needs, e.g. to signal completion of rendering.88 *89 * For the driver-side event interface see drm_event_reserve_init() and90 * drm_send_event() as the main starting points.91 *92 * The memory mapping implementation will vary depending on how the driver93 * manages memory. For GEM-based drivers this is drm_gem_mmap().94 *95 * No other file operations are supported by the DRM userspace API. Overall the96 * following is an example &file_operations structure::97 *98 * static const example_drm_fops = {99 * .owner = THIS_MODULE,100 * .open = drm_open,101 * .release = drm_release,102 * .unlocked_ioctl = drm_ioctl,103 * .compat_ioctl = drm_compat_ioctl, // NULL if CONFIG_COMPAT=n104 * .poll = drm_poll,105 * .read = drm_read,106 * .mmap = drm_gem_mmap,107 * };108 *109 * For plain GEM based drivers there is the DEFINE_DRM_GEM_FOPS() macro, and for110 * DMA based drivers there is the DEFINE_DRM_GEM_DMA_FOPS() macro to make this111 * simpler.112 *113 * The driver's &file_operations must be stored in &drm_driver.fops.114 *115 * For driver-private IOCTL handling see the more detailed discussion in116 * :ref:`IOCTL support in the userland interfaces chapter<drm_driver_ioctl>`.117 */118 119/**120 * drm_file_alloc - allocate file context121 * @minor: minor to allocate on122 *123 * This allocates a new DRM file context. It is not linked into any context and124 * can be used by the caller freely. Note that the context keeps a pointer to125 * @minor, so it must be freed before @minor is.126 *127 * RETURNS:128 * Pointer to newly allocated context, ERR_PTR on failure.129 */130struct drm_file *drm_file_alloc(struct drm_minor *minor)131{132 static atomic64_t ident = ATOMIC_INIT(0);133 struct drm_device *dev = minor->dev;134 struct drm_file *file;135 int ret;136 137 file = kzalloc(sizeof(*file), GFP_KERNEL);138 if (!file)139 return ERR_PTR(-ENOMEM);140 141 /* Get a unique identifier for fdinfo: */142 file->client_id = atomic64_inc_return(&ident);143 rcu_assign_pointer(file->pid, get_pid(task_tgid(current)));144 file->minor = minor;145 146 /* for compatibility root is always authenticated */147 file->authenticated = capable(CAP_SYS_ADMIN);148 149 INIT_LIST_HEAD(&file->lhead);150 INIT_LIST_HEAD(&file->fbs);151 mutex_init(&file->fbs_lock);152 INIT_LIST_HEAD(&file->blobs);153 INIT_LIST_HEAD(&file->pending_event_list);154 INIT_LIST_HEAD(&file->event_list);155 init_waitqueue_head(&file->event_wait);156 file->event_space = 4096; /* set aside 4k for event buffer */157 158 spin_lock_init(&file->master_lookup_lock);159 mutex_init(&file->event_read_lock);160 161 if (drm_core_check_feature(dev, DRIVER_GEM))162 drm_gem_open(dev, file);163 164 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ))165 drm_syncobj_open(file);166 167 drm_prime_init_file_private(&file->prime);168 169 if (dev->driver->open) {170 ret = dev->driver->open(dev, file);171 if (ret < 0)172 goto out_prime_destroy;173 }174 175 return file;176 177out_prime_destroy:178 drm_prime_destroy_file_private(&file->prime);179 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ))180 drm_syncobj_release(file);181 if (drm_core_check_feature(dev, DRIVER_GEM))182 drm_gem_release(dev, file);183 put_pid(rcu_access_pointer(file->pid));184 kfree(file);185 186 return ERR_PTR(ret);187}188 189static void drm_events_release(struct drm_file *file_priv)190{191 struct drm_device *dev = file_priv->minor->dev;192 struct drm_pending_event *e, *et;193 unsigned long flags;194 195 spin_lock_irqsave(&dev->event_lock, flags);196 197 /* Unlink pending events */198 list_for_each_entry_safe(e, et, &file_priv->pending_event_list,199 pending_link) {200 list_del(&e->pending_link);201 e->file_priv = NULL;202 }203 204 /* Remove unconsumed events */205 list_for_each_entry_safe(e, et, &file_priv->event_list, link) {206 list_del(&e->link);207 kfree(e);208 }209 210 spin_unlock_irqrestore(&dev->event_lock, flags);211}212 213/**214 * drm_file_free - free file context215 * @file: context to free, or NULL216 *217 * This destroys and deallocates a DRM file context previously allocated via218 * drm_file_alloc(). The caller must make sure to unlink it from any contexts219 * before calling this.220 *221 * If NULL is passed, this is a no-op.222 */223void drm_file_free(struct drm_file *file)224{225 struct drm_device *dev;226 227 if (!file)228 return;229 230 dev = file->minor->dev;231 232 drm_dbg_core(dev, "comm=\"%s\", pid=%d, dev=0x%lx, open_count=%d\n",233 current->comm, task_pid_nr(current),234 (long)old_encode_dev(file->minor->kdev->devt),235 atomic_read(&dev->open_count));236 237 drm_events_release(file);238 239 if (drm_core_check_feature(dev, DRIVER_MODESET)) {240 drm_fb_release(file);241 drm_property_destroy_user_blobs(dev, file);242 }243 244 if (drm_core_check_feature(dev, DRIVER_SYNCOBJ))245 drm_syncobj_release(file);246 247 if (drm_core_check_feature(dev, DRIVER_GEM))248 drm_gem_release(dev, file);249 250 if (drm_is_primary_client(file))251 drm_master_release(file);252 253 if (dev->driver->postclose)254 dev->driver->postclose(dev, file);255 256 drm_prime_destroy_file_private(&file->prime);257 258 WARN_ON(!list_empty(&file->event_list));259 260 put_pid(rcu_access_pointer(file->pid));261 kfree(file);262}263 264static void drm_close_helper(struct file *filp)265{266 struct drm_file *file_priv = filp->private_data;267 struct drm_device *dev = file_priv->minor->dev;268 269 mutex_lock(&dev->filelist_mutex);270 list_del(&file_priv->lhead);271 mutex_unlock(&dev->filelist_mutex);272 273 drm_file_free(file_priv);274}275 276/*277 * Check whether DRI will run on this CPU.278 *279 * \return non-zero if the DRI will run on this CPU, or zero otherwise.280 */281static int drm_cpu_valid(void)282{283#if defined(__sparc__) && !defined(__sparc_v9__)284 return 0; /* No cmpxchg before v9 sparc. */285#endif286 return 1;287}288 289/*290 * Called whenever a process opens a drm node291 *292 * \param filp file pointer.293 * \param minor acquired minor-object.294 * \return zero on success or a negative number on failure.295 *296 * Creates and initializes a drm_file structure for the file private data in \p297 * filp and add it into the double linked list in \p dev.298 */299int drm_open_helper(struct file *filp, struct drm_minor *minor)300{301 struct drm_device *dev = minor->dev;302 struct drm_file *priv;303 int ret;304 305 if (filp->f_flags & O_EXCL)306 return -EBUSY; /* No exclusive opens */307 if (!drm_cpu_valid())308 return -EINVAL;309 if (dev->switch_power_state != DRM_SWITCH_POWER_ON &&310 dev->switch_power_state != DRM_SWITCH_POWER_DYNAMIC_OFF)311 return -EINVAL;312 if (WARN_ON_ONCE(!(filp->f_op->fop_flags & FOP_UNSIGNED_OFFSET)))313 return -EINVAL;314 315 drm_dbg_core(dev, "comm=\"%s\", pid=%d, minor=%d\n",316 current->comm, task_pid_nr(current), minor->index);317 318 priv = drm_file_alloc(minor);319 if (IS_ERR(priv))320 return PTR_ERR(priv);321 322 if (drm_is_primary_client(priv)) {323 ret = drm_master_open(priv);324 if (ret) {325 drm_file_free(priv);326 return ret;327 }328 }329 330 filp->private_data = priv;331 priv->filp = filp;332 333 mutex_lock(&dev->filelist_mutex);334 list_add(&priv->lhead, &dev->filelist);335 mutex_unlock(&dev->filelist_mutex);336 337 return 0;338}339 340/**341 * drm_open - open method for DRM file342 * @inode: device inode343 * @filp: file pointer.344 *345 * This function must be used by drivers as their &file_operations.open method.346 * It looks up the correct DRM device and instantiates all the per-file347 * resources for it. It also calls the &drm_driver.open driver callback.348 *349 * RETURNS:350 * 0 on success or negative errno value on failure.351 */352int drm_open(struct inode *inode, struct file *filp)353{354 struct drm_device *dev;355 struct drm_minor *minor;356 int retcode;357 358 minor = drm_minor_acquire(&drm_minors_xa, iminor(inode));359 if (IS_ERR(minor))360 return PTR_ERR(minor);361 362 dev = minor->dev;363 if (drm_dev_needs_global_mutex(dev))364 mutex_lock(&drm_global_mutex);365 366 atomic_fetch_inc(&dev->open_count);367 368 /* share address_space across all char-devs of a single device */369 filp->f_mapping = dev->anon_inode->i_mapping;370 371 retcode = drm_open_helper(filp, minor);372 if (retcode)373 goto err_undo;374 375 if (drm_dev_needs_global_mutex(dev))376 mutex_unlock(&drm_global_mutex);377 378 return 0;379 380err_undo:381 atomic_dec(&dev->open_count);382 if (drm_dev_needs_global_mutex(dev))383 mutex_unlock(&drm_global_mutex);384 drm_minor_release(minor);385 return retcode;386}387EXPORT_SYMBOL(drm_open);388 389static void drm_lastclose(struct drm_device *dev)390{391 drm_client_dev_restore(dev);392 393 if (dev_is_pci(dev->dev))394 vga_switcheroo_process_delayed_switch();395}396 397/**398 * drm_release - release method for DRM file399 * @inode: device inode400 * @filp: file pointer.401 *402 * This function must be used by drivers as their &file_operations.release403 * method. It frees any resources associated with the open file. If this404 * is the last open file for the DRM device, it also restores the active405 * in-kernel DRM client.406 *407 * RETURNS:408 * Always succeeds and returns 0.409 */410int drm_release(struct inode *inode, struct file *filp)411{412 struct drm_file *file_priv = filp->private_data;413 struct drm_minor *minor = file_priv->minor;414 struct drm_device *dev = minor->dev;415 416 if (drm_dev_needs_global_mutex(dev))417 mutex_lock(&drm_global_mutex);418 419 drm_dbg_core(dev, "open_count = %d\n", atomic_read(&dev->open_count));420 421 drm_close_helper(filp);422 423 if (atomic_dec_and_test(&dev->open_count))424 drm_lastclose(dev);425 426 if (drm_dev_needs_global_mutex(dev))427 mutex_unlock(&drm_global_mutex);428 429 drm_minor_release(minor);430 431 return 0;432}433EXPORT_SYMBOL(drm_release);434 435void drm_file_update_pid(struct drm_file *filp)436{437 struct drm_device *dev;438 struct pid *pid, *old;439 440 /*441 * Master nodes need to keep the original ownership in order for442 * drm_master_check_perm to keep working correctly. (See comment in443 * drm_auth.c.)444 */445 if (filp->was_master)446 return;447 448 pid = task_tgid(current);449 450 /*451 * Quick unlocked check since the model is a single handover followed by452 * exclusive repeated use.453 */454 if (pid == rcu_access_pointer(filp->pid))455 return;456 457 dev = filp->minor->dev;458 mutex_lock(&dev->filelist_mutex);459 get_pid(pid);460 old = rcu_replace_pointer(filp->pid, pid, 1);461 mutex_unlock(&dev->filelist_mutex);462 463 synchronize_rcu();464 put_pid(old);465}466 467/**468 * drm_release_noglobal - release method for DRM file469 * @inode: device inode470 * @filp: file pointer.471 *472 * This function may be used by drivers as their &file_operations.release473 * method. It frees any resources associated with the open file prior to taking474 * the drm_global_mutex. If this is the last open file for the DRM device, it475 * then restores the active in-kernel DRM client.476 *477 * RETURNS:478 * Always succeeds and returns 0.479 */480int drm_release_noglobal(struct inode *inode, struct file *filp)481{482 struct drm_file *file_priv = filp->private_data;483 struct drm_minor *minor = file_priv->minor;484 struct drm_device *dev = minor->dev;485 486 drm_close_helper(filp);487 488 if (atomic_dec_and_mutex_lock(&dev->open_count, &drm_global_mutex)) {489 drm_lastclose(dev);490 mutex_unlock(&drm_global_mutex);491 }492 493 drm_minor_release(minor);494 495 return 0;496}497EXPORT_SYMBOL(drm_release_noglobal);498 499/**500 * drm_read - read method for DRM file501 * @filp: file pointer502 * @buffer: userspace destination pointer for the read503 * @count: count in bytes to read504 * @offset: offset to read505 *506 * This function must be used by drivers as their &file_operations.read507 * method if they use DRM events for asynchronous signalling to userspace.508 * Since events are used by the KMS API for vblank and page flip completion this509 * means all modern display drivers must use it.510 *511 * @offset is ignored, DRM events are read like a pipe. Polling support is512 * provided by drm_poll().513 *514 * This function will only ever read a full event. Therefore userspace must515 * supply a big enough buffer to fit any event to ensure forward progress. Since516 * the maximum event space is currently 4K it's recommended to just use that for517 * safety.518 *519 * RETURNS:520 * Number of bytes read (always aligned to full events, and can be 0) or a521 * negative error code on failure.522 */523ssize_t drm_read(struct file *filp, char __user *buffer,524 size_t count, loff_t *offset)525{526 struct drm_file *file_priv = filp->private_data;527 struct drm_device *dev = file_priv->minor->dev;528 ssize_t ret;529 530 ret = mutex_lock_interruptible(&file_priv->event_read_lock);531 if (ret)532 return ret;533 534 for (;;) {535 struct drm_pending_event *e = NULL;536 537 spin_lock_irq(&dev->event_lock);538 if (!list_empty(&file_priv->event_list)) {539 e = list_first_entry(&file_priv->event_list,540 struct drm_pending_event, link);541 file_priv->event_space += e->event->length;542 list_del(&e->link);543 }544 spin_unlock_irq(&dev->event_lock);545 546 if (e == NULL) {547 if (ret)548 break;549 550 if (filp->f_flags & O_NONBLOCK) {551 ret = -EAGAIN;552 break;553 }554 555 mutex_unlock(&file_priv->event_read_lock);556 ret = wait_event_interruptible(file_priv->event_wait,557 !list_empty(&file_priv->event_list));558 if (ret >= 0)559 ret = mutex_lock_interruptible(&file_priv->event_read_lock);560 if (ret)561 return ret;562 } else {563 unsigned length = e->event->length;564 565 if (length > count - ret) {566put_back_event:567 spin_lock_irq(&dev->event_lock);568 file_priv->event_space -= length;569 list_add(&e->link, &file_priv->event_list);570 spin_unlock_irq(&dev->event_lock);571 wake_up_interruptible_poll(&file_priv->event_wait,572 EPOLLIN | EPOLLRDNORM);573 break;574 }575 576 if (copy_to_user(buffer + ret, e->event, length)) {577 if (ret == 0)578 ret = -EFAULT;579 goto put_back_event;580 }581 582 ret += length;583 kfree(e);584 }585 }586 mutex_unlock(&file_priv->event_read_lock);587 588 return ret;589}590EXPORT_SYMBOL(drm_read);591 592/**593 * drm_poll - poll method for DRM file594 * @filp: file pointer595 * @wait: poll waiter table596 *597 * This function must be used by drivers as their &file_operations.read method598 * if they use DRM events for asynchronous signalling to userspace. Since599 * events are used by the KMS API for vblank and page flip completion this means600 * all modern display drivers must use it.601 *602 * See also drm_read().603 *604 * RETURNS:605 * Mask of POLL flags indicating the current status of the file.606 */607__poll_t drm_poll(struct file *filp, struct poll_table_struct *wait)608{609 struct drm_file *file_priv = filp->private_data;610 __poll_t mask = 0;611 612 poll_wait(filp, &file_priv->event_wait, wait);613 614 if (!list_empty(&file_priv->event_list))615 mask |= EPOLLIN | EPOLLRDNORM;616 617 return mask;618}619EXPORT_SYMBOL(drm_poll);620 621/**622 * drm_event_reserve_init_locked - init a DRM event and reserve space for it623 * @dev: DRM device624 * @file_priv: DRM file private data625 * @p: tracking structure for the pending event626 * @e: actual event data to deliver to userspace627 *628 * This function prepares the passed in event for eventual delivery. If the event629 * doesn't get delivered (because the IOCTL fails later on, before queuing up630 * anything) then the even must be cancelled and freed using631 * drm_event_cancel_free(). Successfully initialized events should be sent out632 * using drm_send_event() or drm_send_event_locked() to signal completion of the633 * asynchronous event to userspace.634 *635 * If callers embedded @p into a larger structure it must be allocated with636 * kmalloc and @p must be the first member element.637 *638 * This is the locked version of drm_event_reserve_init() for callers which639 * already hold &drm_device.event_lock.640 *641 * RETURNS:642 * 0 on success or a negative error code on failure.643 */644int drm_event_reserve_init_locked(struct drm_device *dev,645 struct drm_file *file_priv,646 struct drm_pending_event *p,647 struct drm_event *e)648{649 if (file_priv->event_space < e->length)650 return -ENOMEM;651 652 file_priv->event_space -= e->length;653 654 p->event = e;655 list_add(&p->pending_link, &file_priv->pending_event_list);656 p->file_priv = file_priv;657 658 return 0;659}660EXPORT_SYMBOL(drm_event_reserve_init_locked);661 662/**663 * drm_event_reserve_init - init a DRM event and reserve space for it664 * @dev: DRM device665 * @file_priv: DRM file private data666 * @p: tracking structure for the pending event667 * @e: actual event data to deliver to userspace668 *669 * This function prepares the passed in event for eventual delivery. If the event670 * doesn't get delivered (because the IOCTL fails later on, before queuing up671 * anything) then the even must be cancelled and freed using672 * drm_event_cancel_free(). Successfully initialized events should be sent out673 * using drm_send_event() or drm_send_event_locked() to signal completion of the674 * asynchronous event to userspace.675 *676 * If callers embedded @p into a larger structure it must be allocated with677 * kmalloc and @p must be the first member element.678 *679 * Callers which already hold &drm_device.event_lock should use680 * drm_event_reserve_init_locked() instead.681 *682 * RETURNS:683 * 0 on success or a negative error code on failure.684 */685int drm_event_reserve_init(struct drm_device *dev,686 struct drm_file *file_priv,687 struct drm_pending_event *p,688 struct drm_event *e)689{690 unsigned long flags;691 int ret;692 693 spin_lock_irqsave(&dev->event_lock, flags);694 ret = drm_event_reserve_init_locked(dev, file_priv, p, e);695 spin_unlock_irqrestore(&dev->event_lock, flags);696 697 return ret;698}699EXPORT_SYMBOL(drm_event_reserve_init);700 701/**702 * drm_event_cancel_free - free a DRM event and release its space703 * @dev: DRM device704 * @p: tracking structure for the pending event705 *706 * This function frees the event @p initialized with drm_event_reserve_init()707 * and releases any allocated space. It is used to cancel an event when the708 * nonblocking operation could not be submitted and needed to be aborted.709 */710void drm_event_cancel_free(struct drm_device *dev,711 struct drm_pending_event *p)712{713 unsigned long flags;714 715 spin_lock_irqsave(&dev->event_lock, flags);716 if (p->file_priv) {717 p->file_priv->event_space += p->event->length;718 list_del(&p->pending_link);719 }720 spin_unlock_irqrestore(&dev->event_lock, flags);721 722 if (p->fence)723 dma_fence_put(p->fence);724 725 kfree(p);726}727EXPORT_SYMBOL(drm_event_cancel_free);728 729static void drm_send_event_helper(struct drm_device *dev,730 struct drm_pending_event *e, ktime_t timestamp)731{732 assert_spin_locked(&dev->event_lock);733 734 if (e->completion) {735 complete_all(e->completion);736 e->completion_release(e->completion);737 e->completion = NULL;738 }739 740 if (e->fence) {741 if (timestamp)742 dma_fence_signal_timestamp(e->fence, timestamp);743 else744 dma_fence_signal(e->fence);745 dma_fence_put(e->fence);746 }747 748 if (!e->file_priv) {749 kfree(e);750 return;751 }752 753 list_del(&e->pending_link);754 list_add_tail(&e->link,755 &e->file_priv->event_list);756 wake_up_interruptible_poll(&e->file_priv->event_wait,757 EPOLLIN | EPOLLRDNORM);758}759 760/**761 * drm_send_event_timestamp_locked - send DRM event to file descriptor762 * @dev: DRM device763 * @e: DRM event to deliver764 * @timestamp: timestamp to set for the fence event in kernel's CLOCK_MONOTONIC765 * time domain766 *767 * This function sends the event @e, initialized with drm_event_reserve_init(),768 * to its associated userspace DRM file. Callers must already hold769 * &drm_device.event_lock.770 *771 * Note that the core will take care of unlinking and disarming events when the772 * corresponding DRM file is closed. Drivers need not worry about whether the773 * DRM file for this event still exists and can call this function upon774 * completion of the asynchronous work unconditionally.775 */776void drm_send_event_timestamp_locked(struct drm_device *dev,777 struct drm_pending_event *e, ktime_t timestamp)778{779 drm_send_event_helper(dev, e, timestamp);780}781EXPORT_SYMBOL(drm_send_event_timestamp_locked);782 783/**784 * drm_send_event_locked - send DRM event to file descriptor785 * @dev: DRM device786 * @e: DRM event to deliver787 *788 * This function sends the event @e, initialized with drm_event_reserve_init(),789 * to its associated userspace DRM file. Callers must already hold790 * &drm_device.event_lock, see drm_send_event() for the unlocked version.791 *792 * Note that the core will take care of unlinking and disarming events when the793 * corresponding DRM file is closed. Drivers need not worry about whether the794 * DRM file for this event still exists and can call this function upon795 * completion of the asynchronous work unconditionally.796 */797void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e)798{799 drm_send_event_helper(dev, e, 0);800}801EXPORT_SYMBOL(drm_send_event_locked);802 803/**804 * drm_send_event - send DRM event to file descriptor805 * @dev: DRM device806 * @e: DRM event to deliver807 *808 * This function sends the event @e, initialized with drm_event_reserve_init(),809 * to its associated userspace DRM file. This function acquires810 * &drm_device.event_lock, see drm_send_event_locked() for callers which already811 * hold this lock.812 *813 * Note that the core will take care of unlinking and disarming events when the814 * corresponding DRM file is closed. Drivers need not worry about whether the815 * DRM file for this event still exists and can call this function upon816 * completion of the asynchronous work unconditionally.817 */818void drm_send_event(struct drm_device *dev, struct drm_pending_event *e)819{820 unsigned long irqflags;821 822 spin_lock_irqsave(&dev->event_lock, irqflags);823 drm_send_event_helper(dev, e, 0);824 spin_unlock_irqrestore(&dev->event_lock, irqflags);825}826EXPORT_SYMBOL(drm_send_event);827 828static void print_size(struct drm_printer *p, const char *stat,829 const char *region, u64 sz)830{831 const char *units[] = {"", " KiB", " MiB"};832 unsigned u;833 834 for (u = 0; u < ARRAY_SIZE(units) - 1; u++) {835 if (sz == 0 || !IS_ALIGNED(sz, SZ_1K))836 break;837 sz = div_u64(sz, SZ_1K);838 }839 840 drm_printf(p, "drm-%s-%s:\t%llu%s\n", stat, region, sz, units[u]);841}842 843/**844 * drm_print_memory_stats - A helper to print memory stats845 * @p: The printer to print output to846 * @stats: The collected memory stats847 * @supported_status: Bitmask of optional stats which are available848 * @region: The memory region849 *850 */851void drm_print_memory_stats(struct drm_printer *p,852 const struct drm_memory_stats *stats,853 enum drm_gem_object_status supported_status,854 const char *region)855{856 print_size(p, "total", region, stats->private + stats->shared);857 print_size(p, "shared", region, stats->shared);858 print_size(p, "active", region, stats->active);859 860 if (supported_status & DRM_GEM_OBJECT_RESIDENT)861 print_size(p, "resident", region, stats->resident);862 863 if (supported_status & DRM_GEM_OBJECT_PURGEABLE)864 print_size(p, "purgeable", region, stats->purgeable);865}866EXPORT_SYMBOL(drm_print_memory_stats);867 868/**869 * drm_show_memory_stats - Helper to collect and show standard fdinfo memory stats870 * @p: the printer to print output to871 * @file: the DRM file872 *873 * Helper to iterate over GEM objects with a handle allocated in the specified874 * file.875 */876void drm_show_memory_stats(struct drm_printer *p, struct drm_file *file)877{878 struct drm_gem_object *obj;879 struct drm_memory_stats status = {};880 enum drm_gem_object_status supported_status = 0;881 int id;882 883 spin_lock(&file->table_lock);884 idr_for_each_entry (&file->object_idr, obj, id) {885 enum drm_gem_object_status s = 0;886 size_t add_size = (obj->funcs && obj->funcs->rss) ?887 obj->funcs->rss(obj) : obj->size;888 889 if (obj->funcs && obj->funcs->status) {890 s = obj->funcs->status(obj);891 supported_status = DRM_GEM_OBJECT_RESIDENT |892 DRM_GEM_OBJECT_PURGEABLE;893 }894 895 if (drm_gem_object_is_shared_for_memory_stats(obj)) {896 status.shared += obj->size;897 } else {898 status.private += obj->size;899 }900 901 if (s & DRM_GEM_OBJECT_RESIDENT) {902 status.resident += add_size;903 } else {904 /* If already purged or not yet backed by pages, don't905 * count it as purgeable:906 */907 s &= ~DRM_GEM_OBJECT_PURGEABLE;908 }909 910 if (!dma_resv_test_signaled(obj->resv, dma_resv_usage_rw(true))) {911 status.active += add_size;912 913 /* If still active, don't count as purgeable: */914 s &= ~DRM_GEM_OBJECT_PURGEABLE;915 }916 917 if (s & DRM_GEM_OBJECT_PURGEABLE)918 status.purgeable += add_size;919 }920 spin_unlock(&file->table_lock);921 922 drm_print_memory_stats(p, &status, supported_status, "memory");923}924EXPORT_SYMBOL(drm_show_memory_stats);925 926/**927 * drm_show_fdinfo - helper for drm file fops928 * @m: output stream929 * @f: the device file instance930 *931 * Helper to implement fdinfo, for userspace to query usage stats, etc, of a932 * process using the GPU. See also &drm_driver.show_fdinfo.933 *934 * For text output format description please see Documentation/gpu/drm-usage-stats.rst935 */936void drm_show_fdinfo(struct seq_file *m, struct file *f)937{938 struct drm_file *file = f->private_data;939 struct drm_device *dev = file->minor->dev;940 struct drm_printer p = drm_seq_file_printer(m);941 942 drm_printf(&p, "drm-driver:\t%s\n", dev->driver->name);943 drm_printf(&p, "drm-client-id:\t%llu\n", file->client_id);944 945 if (dev_is_pci(dev->dev)) {946 struct pci_dev *pdev = to_pci_dev(dev->dev);947 948 drm_printf(&p, "drm-pdev:\t%04x:%02x:%02x.%d\n",949 pci_domain_nr(pdev->bus), pdev->bus->number,950 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));951 }952 953 if (dev->driver->show_fdinfo)954 dev->driver->show_fdinfo(&p, file);955}956EXPORT_SYMBOL(drm_show_fdinfo);957 958/**959 * mock_drm_getfile - Create a new struct file for the drm device960 * @minor: drm minor to wrap (e.g. #drm_device.primary)961 * @flags: file creation mode (O_RDWR etc)962 *963 * This create a new struct file that wraps a DRM file context around a964 * DRM minor. This mimicks userspace opening e.g. /dev/dri/card0, but without965 * invoking userspace. The struct file may be operated on using its f_op966 * (the drm_device.driver.fops) to mimick userspace operations, or be supplied967 * to userspace facing functions as an internal/anonymous client.968 *969 * RETURNS:970 * Pointer to newly created struct file, ERR_PTR on failure.971 */972struct file *mock_drm_getfile(struct drm_minor *minor, unsigned int flags)973{974 struct drm_device *dev = minor->dev;975 struct drm_file *priv;976 struct file *file;977 978 priv = drm_file_alloc(minor);979 if (IS_ERR(priv))980 return ERR_CAST(priv);981 982 file = anon_inode_getfile("drm", dev->driver->fops, priv, flags);983 if (IS_ERR(file)) {984 drm_file_free(priv);985 return file;986 }987 988 /* Everyone shares a single global address space */989 file->f_mapping = dev->anon_inode->i_mapping;990 991 drm_dev_get(dev);992 priv->filp = file;993 994 return file;995}996EXPORT_SYMBOL_FOR_TESTS_ONLY(mock_drm_getfile);997