1/*
   2 * Copyright 2017 Red Hat
   3 * Parts ported from amdgpu (fence wait code).
   4 * Copyright 2016 Advanced Micro Devices, Inc.
   5 *
   6 * Permission is hereby granted, free of charge, to any person obtaining a
   7 * copy of this software and associated documentation files (the "Software"),
   8 * to deal in the Software without restriction, including without limitation
   9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10 * and/or sell copies of the Software, and to permit persons to whom the
  11 * Software is furnished to do so, subject to the following conditions:
  12 *
  13 * The above copyright notice and this permission notice (including the next
  14 * paragraph) shall be included in all copies or substantial portions of the
  15 * Software.
  16 *
  17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  23 * IN THE SOFTWARE.
  24 *
  25 * Authors:
  26 *
  27 */
  28
  29/**
  30 * DOC: Overview
  31 *
  32 * DRM synchronisation objects (syncobj, see struct &drm_syncobj) provide a
  33 * container for a synchronization primitive which can be used by userspace
  34 * to explicitly synchronize GPU commands, can be shared between userspace
  35 * processes, and can be shared between different DRM drivers.
  36 * Their primary use-case is to implement Vulkan fences and semaphores.
  37 * The syncobj userspace API provides ioctls for several operations:
  38 *
  39 *  - Creation and destruction of syncobjs
  40 *  - Import and export of syncobjs to/from a syncobj file descriptor
  41 *  - Import and export a syncobj's underlying fence to/from a sync file
  42 *  - Reset a syncobj (set its fence to NULL)
  43 *  - Signal a syncobj (set a trivially signaled fence)
  44 *  - Wait for a syncobj's fence to appear and be signaled
  45 *
  46 * The syncobj userspace API also provides operations to manipulate a syncobj
  47 * in terms of a timeline of struct &dma_fence_chain rather than a single
  48 * struct &dma_fence, through the following operations:
  49 *
  50 *   - Signal a given point on the timeline
  51 *   - Wait for a given point to appear and/or be signaled
  52 *   - Import and export from/to a given point of a timeline
  53 *
  54 * At it's core, a syncobj is simply a wrapper around a pointer to a struct
  55 * &dma_fence which may be NULL.
  56 * When a syncobj is first created, its pointer is either NULL or a pointer
  57 * to an already signaled fence depending on whether the
  58 * &DRM_SYNCOBJ_CREATE_SIGNALED flag is passed to
  59 * &DRM_IOCTL_SYNCOBJ_CREATE.
  60 *
  61 * If the syncobj is considered as a binary (its state is either signaled or
  62 * unsignaled) primitive, when GPU work is enqueued in a DRM driver to signal
  63 * the syncobj, the syncobj's fence is replaced with a fence which will be
  64 * signaled by the completion of that work.
  65 * If the syncobj is considered as a timeline primitive, when GPU work is
  66 * enqueued in a DRM driver to signal the a given point of the syncobj, a new
  67 * struct &dma_fence_chain pointing to the DRM driver's fence and also
  68 * pointing to the previous fence that was in the syncobj. The new struct
  69 * &dma_fence_chain fence replace the syncobj's fence and will be signaled by
  70 * completion of the DRM driver's work and also any work associated with the
  71 * fence previously in the syncobj.
  72 *
  73 * When GPU work which waits on a syncobj is enqueued in a DRM driver, at the
  74 * time the work is enqueued, it waits on the syncobj's fence before
  75 * submitting the work to hardware. That fence is either :
  76 *
  77 *    - The syncobj's current fence if the syncobj is considered as a binary
  78 *      primitive.
  79 *    - The struct &dma_fence associated with a given point if the syncobj is
  80 *      considered as a timeline primitive.
  81 *
  82 * If the syncobj's fence is NULL or not present in the syncobj's timeline,
  83 * the enqueue operation is expected to fail.
  84 *
  85 * With binary syncobj, all manipulation of the syncobjs's fence happens in
  86 * terms of the current fence at the time the ioctl is called by userspace
  87 * regardless of whether that operation is an immediate host-side operation
  88 * (signal or reset) or or an operation which is enqueued in some driver
  89 * queue. &DRM_IOCTL_SYNCOBJ_RESET and &DRM_IOCTL_SYNCOBJ_SIGNAL can be used
  90 * to manipulate a syncobj from the host by resetting its pointer to NULL or
  91 * setting its pointer to a fence which is already signaled.
  92 *
  93 * With a timeline syncobj, all manipulation of the synobj's fence happens in
  94 * terms of a u64 value referring to point in the timeline. See
  95 * dma_fence_chain_find_seqno() to see how a given point is found in the
  96 * timeline.
  97 *
  98 * Note that applications should be careful to always use timeline set of
  99 * ioctl() when dealing with syncobj considered as timeline. Using a binary
 100 * set of ioctl() with a syncobj considered as timeline could result incorrect
 101 * synchronization. The use of binary syncobj is supported through the
 102 * timeline set of ioctl() by using a point value of 0, this will reproduce
 103 * the behavior of the binary set of ioctl() (for example replace the
 104 * syncobj's fence when signaling).
 105 *
 106 *
 107 * Host-side wait on syncobjs
 108 * --------------------------
 109 *
 110 * &DRM_IOCTL_SYNCOBJ_WAIT takes an array of syncobj handles and does a
 111 * host-side wait on all of the syncobj fences simultaneously.
 112 * If &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL is set, the wait ioctl will wait on
 113 * all of the syncobj fences to be signaled before it returns.
 114 * Otherwise, it returns once at least one syncobj fence has been signaled
 115 * and the index of a signaled fence is written back to the client.
 116 *
 117 * Unlike the enqueued GPU work dependencies which fail if they see a NULL
 118 * fence in a syncobj, if &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT is set,
 119 * the host-side wait will first wait for the syncobj to receive a non-NULL
 120 * fence and then wait on that fence.
 121 * If &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT is not set and any one of the
 122 * syncobjs in the array has a NULL fence, -EINVAL will be returned.
 123 * Assuming the syncobj starts off with a NULL fence, this allows a client
 124 * to do a host wait in one thread (or process) which waits on GPU work
 125 * submitted in another thread (or process) without having to manually
 126 * synchronize between the two.
 127 * This requirement is inherited from the Vulkan fence API.
 128 *
 129 * If &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE is set, the ioctl will also set
 130 * a fence deadline hint on the backing fences before waiting, to provide the
 131 * fence signaler with an appropriate sense of urgency.  The deadline is
 132 * specified as an absolute &CLOCK_MONOTONIC value in units of ns.
 133 *
 134 * Similarly, &DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT takes an array of syncobj
 135 * handles as well as an array of u64 points and does a host-side wait on all
 136 * of syncobj fences at the given points simultaneously.
 137 *
 138 * &DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT also adds the ability to wait for a given
 139 * fence to materialize on the timeline without waiting for the fence to be
 140 * signaled by using the &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE flag. This
 141 * requirement is inherited from the wait-before-signal behavior required by
 142 * the Vulkan timeline semaphore API.
 143 *
 144 * Alternatively, &DRM_IOCTL_SYNCOBJ_EVENTFD can be used to wait without
 145 * blocking: an eventfd will be signaled when the syncobj is. This is useful to
 146 * integrate the wait in an event loop.
 147 *
 148 *
 149 * Import/export of syncobjs
 150 * -------------------------
 151 *
 152 * &DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE and &DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD
 153 * provide two mechanisms for import/export of syncobjs.
 154 *
 155 * The first lets the client import or export an entire syncobj to a file
 156 * descriptor.
 157 * These fd's are opaque and have no other use case, except passing the
 158 * syncobj between processes.
 159 * All exported file descriptors and any syncobj handles created as a
 160 * result of importing those file descriptors own a reference to the
 161 * same underlying struct &drm_syncobj and the syncobj can be used
 162 * persistently across all the processes with which it is shared.
 163 * The syncobj is freed only once the last reference is dropped.
 164 * Unlike dma-buf, importing a syncobj creates a new handle (with its own
 165 * reference) for every import instead of de-duplicating.
 166 * The primary use-case of this persistent import/export is for shared
 167 * Vulkan fences and semaphores.
 168 *
 169 * The second import/export mechanism, which is indicated by
 170 * &DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE or
 171 * &DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE lets the client
 172 * import/export the syncobj's current fence from/to a &sync_file.
 173 * When a syncobj is exported to a sync file, that sync file wraps the
 174 * sycnobj's fence at the time of export and any later signal or reset
 175 * operations on the syncobj will not affect the exported sync file.
 176 * When a sync file is imported into a syncobj, the syncobj's fence is set
 177 * to the fence wrapped by that sync file.
 178 * Because sync files are immutable, resetting or signaling the syncobj
 179 * will not affect any sync files whose fences have been imported into the
 180 * syncobj.
 181 *
 182 *
 183 * Import/export of timeline points in timeline syncobjs
 184 * -----------------------------------------------------
 185 *
 186 * &DRM_IOCTL_SYNCOBJ_TRANSFER provides a mechanism to transfer a struct
 187 * &dma_fence_chain of a syncobj at a given u64 point to another u64 point
 188 * into another syncobj.
 189 *
 190 * Note that if you want to transfer a struct &dma_fence_chain from a given
 191 * point on a timeline syncobj from/into a binary syncobj, you can use the
 192 * point 0 to mean take/replace the fence in the syncobj.
 193 */
 194
 195#include <linux/anon_inodes.h>
 196#include <linux/dma-fence-unwrap.h>
 197#include <linux/eventfd.h>
 198#include <linux/file.h>
 199#include <linux/fs.h>
 200#include <linux/sched/signal.h>
 201#include <linux/sync_file.h>
 202#include <linux/uaccess.h>
 203
 204#include <drm/drm.h>
 205#include <drm/drm_drv.h>
 206#include <drm/drm_file.h>
 207#include <drm/drm_gem.h>
 208#include <drm/drm_print.h>
 209#include <drm/drm_syncobj.h>
 210#include <drm/drm_utils.h>
 211
 212#include "drm_internal.h"
 213
 214struct syncobj_wait_entry {
 215	struct list_head node;
 216	struct task_struct *task;
 217	struct dma_fence *fence;
 218	struct dma_fence_cb fence_cb;
 219	u64    point;
 220};
 221
 222static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj,
 223				      struct syncobj_wait_entry *wait);
 224
 225struct syncobj_eventfd_entry {
 226	struct list_head node;
 227	struct dma_fence *fence;
 228	struct dma_fence_cb fence_cb;
 229	struct drm_syncobj *syncobj;
 230	struct eventfd_ctx *ev_fd_ctx;
 231	u64 point;
 232	u32 flags;
 233};
 234
 235static void
 236syncobj_eventfd_entry_func(struct drm_syncobj *syncobj,
 237			   struct syncobj_eventfd_entry *entry);
 238
 239/**
 240 * drm_syncobj_find - lookup and reference a sync object.
 241 * @file_private: drm file private pointer
 242 * @handle: sync object handle to lookup.
 243 *
 244 * Returns a reference to the syncobj pointed to by handle or NULL. The
 245 * reference must be released by calling drm_syncobj_put().
 246 */
 247struct drm_syncobj *drm_syncobj_find(struct drm_file *file_private,
 248				     u32 handle)
 249{
 250	struct drm_syncobj *syncobj;
 251
 252	spin_lock(&file_private->syncobj_table_lock);
 253
 254	/* Check if we currently have a reference on the object */
 255	syncobj = idr_find(&file_private->syncobj_idr, handle);
 256	if (syncobj)
 257		drm_syncobj_get(syncobj);
 258
 259	spin_unlock(&file_private->syncobj_table_lock);
 260
 261	return syncobj;
 262}
 263EXPORT_SYMBOL(drm_syncobj_find);
 264
 265static void drm_syncobj_fence_add_wait(struct drm_syncobj *syncobj,
 266				       struct syncobj_wait_entry *wait)
 267{
 268	struct dma_fence *fence;
 269
 270	if (wait->fence)
 271		return;
 272
 273	spin_lock(&syncobj->lock);
 274	/* We've already tried once to get a fence and failed.  Now that we
 275	 * have the lock, try one more time just to be sure we don't add a
 276	 * callback when a fence has already been set.
 277	 */
 278	fence = dma_fence_get(rcu_dereference_protected(syncobj->fence, 1));
 279	if (!fence || dma_fence_chain_find_seqno(&fence, wait->point)) {
 280		dma_fence_put(fence);
 281		list_add_tail(&wait->node, &syncobj->cb_list);
 282	} else if (!fence) {
 283		wait->fence = dma_fence_get_stub();
 284	} else {
 285		wait->fence = fence;
 286	}
 287	spin_unlock(&syncobj->lock);
 288}
 289
 290static void drm_syncobj_remove_wait(struct drm_syncobj *syncobj,
 291				    struct syncobj_wait_entry *wait)
 292{
 293	if (!wait->node.next)
 294		return;
 295
 296	spin_lock(&syncobj->lock);
 297	list_del_init(&wait->node);
 298	spin_unlock(&syncobj->lock);
 299}
 300
 301static void
 302syncobj_eventfd_entry_free(struct syncobj_eventfd_entry *entry)
 303{
 304	eventfd_ctx_put(entry->ev_fd_ctx);
 305	dma_fence_put(entry->fence);
 306	/* This happens either inside the syncobj lock, or after the node has
 307	 * already been removed from the list.
 308	 */
 309	list_del(&entry->node);
 310	kfree(entry);
 311}
 312
 313static void
 314drm_syncobj_add_eventfd(struct drm_syncobj *syncobj,
 315			struct syncobj_eventfd_entry *entry)
 316{
 317	spin_lock(&syncobj->lock);
 318	list_add_tail(&entry->node, &syncobj->ev_fd_list);
 319	syncobj_eventfd_entry_func(syncobj, entry);
 320	spin_unlock(&syncobj->lock);
 321}
 322
 323/**
 324 * drm_syncobj_add_point - add new timeline point to the syncobj
 325 * @syncobj: sync object to add timeline point do
 326 * @chain: chain node to use to add the point
 327 * @fence: fence to encapsulate in the chain node
 328 * @point: sequence number to use for the point
 329 *
 330 * Add the chain node as new timeline point to the syncobj.
 331 */
 332void drm_syncobj_add_point(struct drm_syncobj *syncobj,
 333			   struct dma_fence_chain *chain,
 334			   struct dma_fence *fence,
 335			   uint64_t point)
 336{
 337	struct syncobj_wait_entry *wait_cur, *wait_tmp;
 338	struct syncobj_eventfd_entry *ev_fd_cur, *ev_fd_tmp;
 339	struct dma_fence *prev;
 340
 341	dma_fence_get(fence);
 342
 343	spin_lock(&syncobj->lock);
 344
 345	prev = drm_syncobj_fence_get(syncobj);
 346	/* You are adding an unorder point to timeline, which could cause payload returned from query_ioctl is 0! */
 347	if (prev && prev->seqno >= point)
 348		DRM_DEBUG("You are adding an unorder point to timeline!\n");
 349	dma_fence_chain_init(chain, prev, fence, point);
 350	rcu_assign_pointer(syncobj->fence, &chain->base);
 351
 352	list_for_each_entry_safe(wait_cur, wait_tmp, &syncobj->cb_list, node)
 353		syncobj_wait_syncobj_func(syncobj, wait_cur);
 354	list_for_each_entry_safe(ev_fd_cur, ev_fd_tmp, &syncobj->ev_fd_list, node)
 355		syncobj_eventfd_entry_func(syncobj, ev_fd_cur);
 356	spin_unlock(&syncobj->lock);
 357
 358	/* Walk the chain once to trigger garbage collection */
 359	dma_fence_chain_for_each(fence, prev);
 360	dma_fence_put(prev);
 361}
 362EXPORT_SYMBOL(drm_syncobj_add_point);
 363
 364/**
 365 * drm_syncobj_replace_fence - replace fence in a sync object.
 366 * @syncobj: Sync object to replace fence in
 367 * @fence: fence to install in sync file.
 368 *
 369 * This replaces the fence on a sync object.
 370 */
 371void drm_syncobj_replace_fence(struct drm_syncobj *syncobj,
 372			       struct dma_fence *fence)
 373{
 374	struct dma_fence *old_fence;
 375	struct syncobj_wait_entry *wait_cur, *wait_tmp;
 376	struct syncobj_eventfd_entry *ev_fd_cur, *ev_fd_tmp;
 377
 378	if (fence)
 379		dma_fence_get(fence);
 380
 381	spin_lock(&syncobj->lock);
 382
 383	old_fence = rcu_dereference_protected(syncobj->fence,
 384					      lockdep_is_held(&syncobj->lock));
 385	rcu_assign_pointer(syncobj->fence, fence);
 386
 387	if (fence != old_fence) {
 388		list_for_each_entry_safe(wait_cur, wait_tmp, &syncobj->cb_list, node)
 389			syncobj_wait_syncobj_func(syncobj, wait_cur);
 390		list_for_each_entry_safe(ev_fd_cur, ev_fd_tmp, &syncobj->ev_fd_list, node)
 391			syncobj_eventfd_entry_func(syncobj, ev_fd_cur);
 392	}
 393
 394	spin_unlock(&syncobj->lock);
 395
 396	dma_fence_put(old_fence);
 397}
 398EXPORT_SYMBOL(drm_syncobj_replace_fence);
 399
 400/**
 401 * drm_syncobj_assign_null_handle - assign a stub fence to the sync object
 402 * @syncobj: sync object to assign the fence on
 403 *
 404 * Assign a already signaled stub fence to the sync object.
 405 */
 406static int drm_syncobj_assign_null_handle(struct drm_syncobj *syncobj)
 407{
 408	struct dma_fence *fence = dma_fence_allocate_private_stub(ktime_get());
 409
 410	if (!fence)
 411		return -ENOMEM;
 412
 413	drm_syncobj_replace_fence(syncobj, fence);
 414	dma_fence_put(fence);
 415	return 0;
 416}
 417
 418/* 5s default for wait submission */
 419#define DRM_SYNCOBJ_WAIT_FOR_SUBMIT_TIMEOUT 5000000000ULL
 420/**
 421 * drm_syncobj_find_fence - lookup and reference the fence in a sync object
 422 * @file_private: drm file private pointer
 423 * @handle: sync object handle to lookup.
 424 * @point: timeline point
 425 * @flags: DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT or not
 426 * @fence: out parameter for the fence
 427 *
 428 * This is just a convenience function that combines drm_syncobj_find() and
 429 * drm_syncobj_fence_get().
 430 *
 431 * Returns 0 on success or a negative error value on failure. On success @fence
 432 * contains a reference to the fence, which must be released by calling
 433 * dma_fence_put().
 434 */
 435int drm_syncobj_find_fence(struct drm_file *file_private,
 436			   u32 handle, u64 point, u64 flags,
 437			   struct dma_fence **fence)
 438{
 439	struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
 440	struct syncobj_wait_entry wait;
 441	u64 timeout = nsecs_to_jiffies64(DRM_SYNCOBJ_WAIT_FOR_SUBMIT_TIMEOUT);
 442	int ret;
 443
 444	if (!syncobj)
 445		return -ENOENT;
 446
 447	/* Waiting for userspace with locks help is illegal cause that can
 448	 * trivial deadlock with page faults for example. Make lockdep complain
 449	 * about it early on.
 450	 */
 451	if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
 452		might_sleep();
 453		lockdep_assert_none_held_once();
 454	}
 455
 456	*fence = drm_syncobj_fence_get(syncobj);
 457
 458	if (*fence) {
 459		ret = dma_fence_chain_find_seqno(fence, point);
 460		if (!ret) {
 461			/* If the requested seqno is already signaled
 462			 * drm_syncobj_find_fence may return a NULL
 463			 * fence. To make sure the recipient gets
 464			 * signalled, use a new fence instead.
 465			 */
 466			if (!*fence)
 467				*fence = dma_fence_get_stub();
 468
 469			goto out;
 470		}
 471		dma_fence_put(*fence);
 472	} else {
 473		ret = -EINVAL;
 474	}
 475
 476	if (!(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT))
 477		goto out;
 478
 479	memset(&wait, 0, sizeof(wait));
 480	wait.task = current;
 481	wait.point = point;
 482	drm_syncobj_fence_add_wait(syncobj, &wait);
 483
 484	do {
 485		set_current_state(TASK_INTERRUPTIBLE);
 486		if (wait.fence) {
 487			ret = 0;
 488			break;
 489		}
 490                if (timeout == 0) {
 491                        ret = -ETIME;
 492                        break;
 493                }
 494
 495		if (signal_pending(current)) {
 496			ret = -ERESTARTSYS;
 497			break;
 498		}
 499
 500                timeout = schedule_timeout(timeout);
 501	} while (1);
 502
 503	__set_current_state(TASK_RUNNING);
 504	*fence = wait.fence;
 505
 506	if (wait.node.next)
 507		drm_syncobj_remove_wait(syncobj, &wait);
 508
 509out:
 510	drm_syncobj_put(syncobj);
 511
 512	return ret;
 513}
 514EXPORT_SYMBOL(drm_syncobj_find_fence);
 515
 516/**
 517 * drm_syncobj_free - free a sync object.
 518 * @kref: kref to free.
 519 *
 520 * Only to be called from kref_put in drm_syncobj_put.
 521 */
 522void drm_syncobj_free(struct kref *kref)
 523{
 524	struct drm_syncobj *syncobj = container_of(kref,
 525						   struct drm_syncobj,
 526						   refcount);
 527	struct syncobj_eventfd_entry *ev_fd_cur, *ev_fd_tmp;
 528
 529	drm_syncobj_replace_fence(syncobj, NULL);
 530
 531	list_for_each_entry_safe(ev_fd_cur, ev_fd_tmp, &syncobj->ev_fd_list, node)
 532		syncobj_eventfd_entry_free(ev_fd_cur);
 533
 534	kfree(syncobj);
 535}
 536EXPORT_SYMBOL(drm_syncobj_free);
 537
 538/**
 539 * drm_syncobj_create - create a new syncobj
 540 * @out_syncobj: returned syncobj
 541 * @flags: DRM_SYNCOBJ_* flags
 542 * @fence: if non-NULL, the syncobj will represent this fence
 543 *
 544 * This is the first function to create a sync object. After creating, drivers
 545 * probably want to make it available to userspace, either through
 546 * drm_syncobj_get_handle() or drm_syncobj_get_fd().
 547 *
 548 * Returns 0 on success or a negative error value on failure.
 549 */
 550int drm_syncobj_create(struct drm_syncobj **out_syncobj, uint32_t flags,
 551		       struct dma_fence *fence)
 552{
 553	int ret;
 554	struct drm_syncobj *syncobj;
 555
 556	syncobj = kzalloc(sizeof(struct drm_syncobj), GFP_KERNEL);
 557	if (!syncobj)
 558		return -ENOMEM;
 559
 560	kref_init(&syncobj->refcount);
 561	INIT_LIST_HEAD(&syncobj->cb_list);
 562	INIT_LIST_HEAD(&syncobj->ev_fd_list);
 563	spin_lock_init(&syncobj->lock);
 564
 565	if (flags & DRM_SYNCOBJ_CREATE_SIGNALED) {
 566		ret = drm_syncobj_assign_null_handle(syncobj);
 567		if (ret < 0) {
 568			drm_syncobj_put(syncobj);
 569			return ret;
 570		}
 571	}
 572
 573	if (fence)
 574		drm_syncobj_replace_fence(syncobj, fence);
 575
 576	*out_syncobj = syncobj;
 577	return 0;
 578}
 579EXPORT_SYMBOL(drm_syncobj_create);
 580
 581/**
 582 * drm_syncobj_get_handle - get a handle from a syncobj
 583 * @file_private: drm file private pointer
 584 * @syncobj: Sync object to export
 585 * @handle: out parameter with the new handle
 586 *
 587 * Exports a sync object created with drm_syncobj_create() as a handle on
 588 * @file_private to userspace.
 589 *
 590 * Returns 0 on success or a negative error value on failure.
 591 */
 592int drm_syncobj_get_handle(struct drm_file *file_private,
 593			   struct drm_syncobj *syncobj, u32 *handle)
 594{
 595	int ret;
 596
 597	/* take a reference to put in the idr */
 598	drm_syncobj_get(syncobj);
 599
 600	idr_preload(GFP_KERNEL);
 601	spin_lock(&file_private->syncobj_table_lock);
 602	ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
 603	spin_unlock(&file_private->syncobj_table_lock);
 604
 605	idr_preload_end();
 606
 607	if (ret < 0) {
 608		drm_syncobj_put(syncobj);
 609		return ret;
 610	}
 611
 612	*handle = ret;
 613	return 0;
 614}
 615EXPORT_SYMBOL(drm_syncobj_get_handle);
 616
 617static int drm_syncobj_create_as_handle(struct drm_file *file_private,
 618					u32 *handle, uint32_t flags)
 619{
 620	int ret;
 621	struct drm_syncobj *syncobj;
 622
 623	ret = drm_syncobj_create(&syncobj, flags, NULL);
 624	if (ret)
 625		return ret;
 626
 627	ret = drm_syncobj_get_handle(file_private, syncobj, handle);
 628	drm_syncobj_put(syncobj);
 629	return ret;
 630}
 631
 632static int drm_syncobj_destroy(struct drm_file *file_private,
 633			       u32 handle)
 634{
 635	struct drm_syncobj *syncobj;
 636
 637	spin_lock(&file_private->syncobj_table_lock);
 638	syncobj = idr_remove(&file_private->syncobj_idr, handle);
 639	spin_unlock(&file_private->syncobj_table_lock);
 640
 641	if (!syncobj)
 642		return -EINVAL;
 643
 644	drm_syncobj_put(syncobj);
 645	return 0;
 646}
 647
 648static int drm_syncobj_file_release(struct inode *inode, struct file *file)
 649{
 650	struct drm_syncobj *syncobj = file->private_data;
 651
 652	drm_syncobj_put(syncobj);
 653	return 0;
 654}
 655
 656static const struct file_operations drm_syncobj_file_fops = {
 657	.release = drm_syncobj_file_release,
 658};
 659
 660/**
 661 * drm_syncobj_get_fd - get a file descriptor from a syncobj
 662 * @syncobj: Sync object to export
 663 * @p_fd: out parameter with the new file descriptor
 664 *
 665 * Exports a sync object created with drm_syncobj_create() as a file descriptor.
 666 *
 667 * Returns 0 on success or a negative error value on failure.
 668 */
 669int drm_syncobj_get_fd(struct drm_syncobj *syncobj, int *p_fd)
 670{
 671	struct file *file;
 672	int fd;
 673
 674	fd = get_unused_fd_flags(O_CLOEXEC);
 675	if (fd < 0)
 676		return fd;
 677
 678	file = anon_inode_getfile("syncobj_file",
 679				  &drm_syncobj_file_fops,
 680				  syncobj, 0);
 681	if (IS_ERR(file)) {
 682		put_unused_fd(fd);
 683		return PTR_ERR(file);
 684	}
 685
 686	drm_syncobj_get(syncobj);
 687	fd_install(fd, file);
 688
 689	*p_fd = fd;
 690	return 0;
 691}
 692EXPORT_SYMBOL(drm_syncobj_get_fd);
 693
 694static int drm_syncobj_handle_to_fd(struct drm_file *file_private,
 695				    u32 handle, int *p_fd)
 696{
 697	struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
 698	int ret;
 699
 700	if (!syncobj)
 701		return -EINVAL;
 702
 703	ret = drm_syncobj_get_fd(syncobj, p_fd);
 704	drm_syncobj_put(syncobj);
 705	return ret;
 706}
 707
 708static int drm_syncobj_fd_to_handle(struct drm_file *file_private,
 709				    int fd, u32 *handle)
 710{
 711	struct drm_syncobj *syncobj;
 712	struct fd f = fdget(fd);
 713	int ret;
 714
 715	if (!f.file)
 716		return -EINVAL;
 717
 718	if (f.file->f_op != &drm_syncobj_file_fops) {
 719		fdput(f);
 720		return -EINVAL;
 721	}
 722
 723	/* take a reference to put in the idr */
 724	syncobj = f.file->private_data;
 725	drm_syncobj_get(syncobj);
 726
 727	idr_preload(GFP_KERNEL);
 728	spin_lock(&file_private->syncobj_table_lock);
 729	ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
 730	spin_unlock(&file_private->syncobj_table_lock);
 731	idr_preload_end();
 732
 733	if (ret > 0) {
 734		*handle = ret;
 735		ret = 0;
 736	} else
 737		drm_syncobj_put(syncobj);
 738
 739	fdput(f);
 740	return ret;
 741}
 742
 743static int drm_syncobj_import_sync_file_fence(struct drm_file *file_private,
 744					      int fd, int handle)
 745{
 746	struct dma_fence *fence = sync_file_get_fence(fd);
 747	struct drm_syncobj *syncobj;
 748
 749	if (!fence)
 750		return -EINVAL;
 751
 752	syncobj = drm_syncobj_find(file_private, handle);
 753	if (!syncobj) {
 754		dma_fence_put(fence);
 755		return -ENOENT;
 756	}
 757
 758	drm_syncobj_replace_fence(syncobj, fence);
 759	dma_fence_put(fence);
 760	drm_syncobj_put(syncobj);
 761	return 0;
 762}
 763
 764static int drm_syncobj_export_sync_file(struct drm_file *file_private,
 765					int handle, int *p_fd)
 766{
 767	int ret;
 768	struct dma_fence *fence;
 769	struct sync_file *sync_file;
 770	int fd = get_unused_fd_flags(O_CLOEXEC);
 771
 772	if (fd < 0)
 773		return fd;
 774
 775	ret = drm_syncobj_find_fence(file_private, handle, 0, 0, &fence);
 776	if (ret)
 777		goto err_put_fd;
 778
 779	sync_file = sync_file_create(fence);
 780
 781	dma_fence_put(fence);
 782
 783	if (!sync_file) {
 784		ret = -EINVAL;
 785		goto err_put_fd;
 786	}
 787
 788	fd_install(fd, sync_file->file);
 789
 790	*p_fd = fd;
 791	return 0;
 792err_put_fd:
 793	put_unused_fd(fd);
 794	return ret;
 795}
 796/**
 797 * drm_syncobj_open - initializes syncobj file-private structures at devnode open time
 798 * @file_private: drm file-private structure to set up
 799 *
 800 * Called at device open time, sets up the structure for handling refcounting
 801 * of sync objects.
 802 */
 803void
 804drm_syncobj_open(struct drm_file *file_private)
 805{
 806	idr_init_base(&file_private->syncobj_idr, 1);
 807	spin_lock_init(&file_private->syncobj_table_lock);
 808}
 809
 810static int
 811drm_syncobj_release_handle(int id, void *ptr, void *data)
 812{
 813	struct drm_syncobj *syncobj = ptr;
 814
 815	drm_syncobj_put(syncobj);
 816	return 0;
 817}
 818
 819/**
 820 * drm_syncobj_release - release file-private sync object resources
 821 * @file_private: drm file-private structure to clean up
 822 *
 823 * Called at close time when the filp is going away.
 824 *
 825 * Releases any remaining references on objects by this filp.
 826 */
 827void
 828drm_syncobj_release(struct drm_file *file_private)
 829{
 830	idr_for_each(&file_private->syncobj_idr,
 831		     &drm_syncobj_release_handle, file_private);
 832	idr_destroy(&file_private->syncobj_idr);
 833}
 834
 835int
 836drm_syncobj_create_ioctl(struct drm_device *dev, void *data,
 837			 struct drm_file *file_private)
 838{
 839	struct drm_syncobj_create *args = data;
 840
 841	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 842		return -EOPNOTSUPP;
 843
 844	/* no valid flags yet */
 845	if (args->flags & ~DRM_SYNCOBJ_CREATE_SIGNALED)
 846		return -EINVAL;
 847
 848	return drm_syncobj_create_as_handle(file_private,
 849					    &args->handle, args->flags);
 850}
 851
 852int
 853drm_syncobj_destroy_ioctl(struct drm_device *dev, void *data,
 854			  struct drm_file *file_private)
 855{
 856	struct drm_syncobj_destroy *args = data;
 857
 858	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 859		return -EOPNOTSUPP;
 860
 861	/* make sure padding is empty */
 862	if (args->pad)
 863		return -EINVAL;
 864	return drm_syncobj_destroy(file_private, args->handle);
 865}
 866
 867int
 868drm_syncobj_handle_to_fd_ioctl(struct drm_device *dev, void *data,
 869				   struct drm_file *file_private)
 870{
 871	struct drm_syncobj_handle *args = data;
 872
 873	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 874		return -EOPNOTSUPP;
 875
 876	if (args->pad)
 877		return -EINVAL;
 878
 879	if (args->flags != 0 &&
 880	    args->flags != DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
 881		return -EINVAL;
 882
 883	if (args->flags & DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
 884		return drm_syncobj_export_sync_file(file_private, args->handle,
 885						    &args->fd);
 886
 887	return drm_syncobj_handle_to_fd(file_private, args->handle,
 888					&args->fd);
 889}
 890
 891int
 892drm_syncobj_fd_to_handle_ioctl(struct drm_device *dev, void *data,
 893				   struct drm_file *file_private)
 894{
 895	struct drm_syncobj_handle *args = data;
 896
 897	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 898		return -EOPNOTSUPP;
 899
 900	if (args->pad)
 901		return -EINVAL;
 902
 903	if (args->flags != 0 &&
 904	    args->flags != DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
 905		return -EINVAL;
 906
 907	if (args->flags & DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
 908		return drm_syncobj_import_sync_file_fence(file_private,
 909							  args->fd,
 910							  args->handle);
 911
 912	return drm_syncobj_fd_to_handle(file_private, args->fd,
 913					&args->handle);
 914}
 915
 916static int drm_syncobj_transfer_to_timeline(struct drm_file *file_private,
 917					    struct drm_syncobj_transfer *args)
 918{
 919	struct drm_syncobj *timeline_syncobj = NULL;
 920	struct dma_fence *fence, *tmp;
 921	struct dma_fence_chain *chain;
 922	int ret;
 923
 924	timeline_syncobj = drm_syncobj_find(file_private, args->dst_handle);
 925	if (!timeline_syncobj) {
 926		return -ENOENT;
 927	}
 928	ret = drm_syncobj_find_fence(file_private, args->src_handle,
 929				     args->src_point, args->flags,
 930				     &tmp);
 931	if (ret)
 932		goto err_put_timeline;
 933
 934	fence = dma_fence_unwrap_merge(tmp);
 935	dma_fence_put(tmp);
 936	if (!fence) {
 937		ret = -ENOMEM;
 938		goto err_put_timeline;
 939	}
 940
 941	chain = dma_fence_chain_alloc();
 942	if (!chain) {
 943		ret = -ENOMEM;
 944		goto err_free_fence;
 945	}
 946
 947	drm_syncobj_add_point(timeline_syncobj, chain, fence, args->dst_point);
 948err_free_fence:
 949	dma_fence_put(fence);
 950err_put_timeline:
 951	drm_syncobj_put(timeline_syncobj);
 952
 953	return ret;
 954}
 955
 956static int
 957drm_syncobj_transfer_to_binary(struct drm_file *file_private,
 958			       struct drm_syncobj_transfer *args)
 959{
 960	struct drm_syncobj *binary_syncobj = NULL;
 961	struct dma_fence *fence;
 962	int ret;
 963
 964	binary_syncobj = drm_syncobj_find(file_private, args->dst_handle);
 965	if (!binary_syncobj)
 966		return -ENOENT;
 967	ret = drm_syncobj_find_fence(file_private, args->src_handle,
 968				     args->src_point, args->flags, &fence);
 969	if (ret)
 970		goto err;
 971	drm_syncobj_replace_fence(binary_syncobj, fence);
 972	dma_fence_put(fence);
 973err:
 974	drm_syncobj_put(binary_syncobj);
 975
 976	return ret;
 977}
 978int
 979drm_syncobj_transfer_ioctl(struct drm_device *dev, void *data,
 980			   struct drm_file *file_private)
 981{
 982	struct drm_syncobj_transfer *args = data;
 983	int ret;
 984
 985	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
 986		return -EOPNOTSUPP;
 987
 988	if (args->pad)
 989		return -EINVAL;
 990
 991	if (args->dst_point)
 992		ret = drm_syncobj_transfer_to_timeline(file_private, args);
 993	else
 994		ret = drm_syncobj_transfer_to_binary(file_private, args);
 995
 996	return ret;
 997}
 998
 999static void syncobj_wait_fence_func(struct dma_fence *fence,
1000				    struct dma_fence_cb *cb)
1001{
1002	struct syncobj_wait_entry *wait =
1003		container_of(cb, struct syncobj_wait_entry, fence_cb);
1004
1005	wake_up_process(wait->task);
1006}
1007
1008static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj,
1009				      struct syncobj_wait_entry *wait)
1010{
1011	struct dma_fence *fence;
1012
1013	/* This happens inside the syncobj lock */
1014	fence = rcu_dereference_protected(syncobj->fence,
1015					  lockdep_is_held(&syncobj->lock));
1016	dma_fence_get(fence);
1017	if (!fence || dma_fence_chain_find_seqno(&fence, wait->point)) {
1018		dma_fence_put(fence);
1019		return;
1020	} else if (!fence) {
1021		wait->fence = dma_fence_get_stub();
1022	} else {
1023		wait->fence = fence;
1024	}
1025
1026	wake_up_process(wait->task);
1027	list_del_init(&wait->node);
1028}
1029
1030static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs,
1031						  void __user *user_points,
1032						  uint32_t count,
1033						  uint32_t flags,
1034						  signed long timeout,
1035						  uint32_t *idx,
1036						  ktime_t *deadline)
1037{
1038	struct syncobj_wait_entry *entries;
1039	struct dma_fence *fence;
1040	uint64_t *points;
1041	uint32_t signaled_count, i;
1042
1043	if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1044		     DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE))
1045		lockdep_assert_none_held_once();
1046
1047	points = kmalloc_array(count, sizeof(*points), GFP_KERNEL);
1048	if (points == NULL)
1049		return -ENOMEM;
1050
1051	if (!user_points) {
1052		memset(points, 0, count * sizeof(uint64_t));
1053
1054	} else if (copy_from_user(points, user_points,
1055				  sizeof(uint64_t) * count)) {
1056		timeout = -EFAULT;
1057		goto err_free_points;
1058	}
1059
1060	entries = kcalloc(count, sizeof(*entries), GFP_KERNEL);
1061	if (!entries) {
1062		timeout = -ENOMEM;
1063		goto err_free_points;
1064	}
1065	/* Walk the list of sync objects and initialize entries.  We do
1066	 * this up-front so that we can properly return -EINVAL if there is
1067	 * a syncobj with a missing fence and then never have the chance of
1068	 * returning -EINVAL again.
1069	 */
1070	signaled_count = 0;
1071	for (i = 0; i < count; ++i) {
1072		struct dma_fence *fence;
1073
1074		entries[i].task = current;
1075		entries[i].point = points[i];
1076		fence = drm_syncobj_fence_get(syncobjs[i]);
1077		if (!fence || dma_fence_chain_find_seqno(&fence, points[i])) {
1078			dma_fence_put(fence);
1079			if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1080				     DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)) {
1081				continue;
1082			} else {
1083				timeout = -EINVAL;
1084				goto cleanup_entries;
1085			}
1086		}
1087
1088		if (fence)
1089			entries[i].fence = fence;
1090		else
1091			entries[i].fence = dma_fence_get_stub();
1092
1093		if ((flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) ||
1094		    dma_fence_is_signaled(entries[i].fence)) {
1095			if (signaled_count == 0 && idx)
1096				*idx = i;
1097			signaled_count++;
1098		}
1099	}
1100
1101	if (signaled_count == count ||
1102	    (signaled_count > 0 &&
1103	     !(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL)))
1104		goto cleanup_entries;
1105
1106	/* There's a very annoying laxness in the dma_fence API here, in
1107	 * that backends are not required to automatically report when a
1108	 * fence is signaled prior to fence->ops->enable_signaling() being
1109	 * called.  So here if we fail to match signaled_count, we need to
1110	 * fallthough and try a 0 timeout wait!
1111	 */
1112
1113	if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1114		     DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)) {
1115		for (i = 0; i < count; ++i)
1116			drm_syncobj_fence_add_wait(syncobjs[i], &entries[i]);
1117	}
1118
1119	if (deadline) {
1120		for (i = 0; i < count; ++i) {
1121			fence = entries[i].fence;
1122			if (!fence)
1123				continue;
1124			dma_fence_set_deadline(fence, *deadline);
1125		}
1126	}
1127
1128	do {
1129		set_current_state(TASK_INTERRUPTIBLE);
1130
1131		signaled_count = 0;
1132		for (i = 0; i < count; ++i) {
1133			fence = entries[i].fence;
1134			if (!fence)
1135				continue;
1136
1137			if ((flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) ||
1138			    dma_fence_is_signaled(fence) ||
1139			    (!entries[i].fence_cb.func &&
1140			     dma_fence_add_callback(fence,
1141						    &entries[i].fence_cb,
1142						    syncobj_wait_fence_func))) {
1143				/* The fence has been signaled */
1144				if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL) {
1145					signaled_count++;
1146				} else {
1147					if (idx)
1148						*idx = i;
1149					goto done_waiting;
1150				}
1151			}
1152		}
1153
1154		if (signaled_count == count)
1155			goto done_waiting;
1156
1157		if (timeout == 0) {
1158			timeout = -ETIME;
1159			goto done_waiting;
1160		}
1161
1162		if (signal_pending(current)) {
1163			timeout = -ERESTARTSYS;
1164			goto done_waiting;
1165		}
1166
1167		timeout = schedule_timeout(timeout);
1168	} while (1);
1169
1170done_waiting:
1171	__set_current_state(TASK_RUNNING);
1172
1173cleanup_entries:
1174	for (i = 0; i < count; ++i) {
1175		drm_syncobj_remove_wait(syncobjs[i], &entries[i]);
1176		if (entries[i].fence_cb.func)
1177			dma_fence_remove_callback(entries[i].fence,
1178						  &entries[i].fence_cb);
1179		dma_fence_put(entries[i].fence);
1180	}
1181	kfree(entries);
1182
1183err_free_points:
1184	kfree(points);
1185
1186	return timeout;
1187}
1188
1189/**
1190 * drm_timeout_abs_to_jiffies - calculate jiffies timeout from absolute value
1191 *
1192 * @timeout_nsec: timeout nsec component in ns, 0 for poll
1193 *
1194 * Calculate the timeout in jiffies from an absolute time in sec/nsec.
1195 */
1196signed long drm_timeout_abs_to_jiffies(int64_t timeout_nsec)
1197{
1198	ktime_t abs_timeout, now;
1199	u64 timeout_ns, timeout_jiffies64;
1200
1201	/* make 0 timeout means poll - absolute 0 doesn't seem valid */
1202	if (timeout_nsec == 0)
1203		return 0;
1204
1205	abs_timeout = ns_to_ktime(timeout_nsec);
1206	now = ktime_get();
1207
1208	if (!ktime_after(abs_timeout, now))
1209		return 0;
1210
1211	timeout_ns = ktime_to_ns(ktime_sub(abs_timeout, now));
1212
1213	timeout_jiffies64 = nsecs_to_jiffies64(timeout_ns);
1214	/*  clamp timeout to avoid infinite timeout */
1215	if (timeout_jiffies64 >= MAX_SCHEDULE_TIMEOUT - 1)
1216		return MAX_SCHEDULE_TIMEOUT - 1;
1217
1218	return timeout_jiffies64 + 1;
1219}
1220EXPORT_SYMBOL(drm_timeout_abs_to_jiffies);
1221
1222static int drm_syncobj_array_wait(struct drm_device *dev,
1223				  struct drm_file *file_private,
1224				  struct drm_syncobj_wait *wait,
1225				  struct drm_syncobj_timeline_wait *timeline_wait,
1226				  struct drm_syncobj **syncobjs, bool timeline,
1227				  ktime_t *deadline)
1228{
1229	signed long timeout = 0;
1230	uint32_t first = ~0;
1231
1232	if (!timeline) {
1233		timeout = drm_timeout_abs_to_jiffies(wait->timeout_nsec);
1234		timeout = drm_syncobj_array_wait_timeout(syncobjs,
1235							 NULL,
1236							 wait->count_handles,
1237							 wait->flags,
1238							 timeout, &first,
1239							 deadline);
1240		if (timeout < 0)
1241			return timeout;
1242		wait->first_signaled = first;
1243	} else {
1244		timeout = drm_timeout_abs_to_jiffies(timeline_wait->timeout_nsec);
1245		timeout = drm_syncobj_array_wait_timeout(syncobjs,
1246							 u64_to_user_ptr(timeline_wait->points),
1247							 timeline_wait->count_handles,
1248							 timeline_wait->flags,
1249							 timeout, &first,
1250							 deadline);
1251		if (timeout < 0)
1252			return timeout;
1253		timeline_wait->first_signaled = first;
1254	}
1255	return 0;
1256}
1257
1258static int drm_syncobj_array_find(struct drm_file *file_private,
1259				  void __user *user_handles,
1260				  uint32_t count_handles,
1261				  struct drm_syncobj ***syncobjs_out)
1262{
1263	uint32_t i, *handles;
1264	struct drm_syncobj **syncobjs;
1265	int ret;
1266
1267	handles = kmalloc_array(count_handles, sizeof(*handles), GFP_KERNEL);
1268	if (handles == NULL)
1269		return -ENOMEM;
1270
1271	if (copy_from_user(handles, user_handles,
1272			   sizeof(uint32_t) * count_handles)) {
1273		ret = -EFAULT;
1274		goto err_free_handles;
1275	}
1276
1277	syncobjs = kmalloc_array(count_handles, sizeof(*syncobjs), GFP_KERNEL);
1278	if (syncobjs == NULL) {
1279		ret = -ENOMEM;
1280		goto err_free_handles;
1281	}
1282
1283	for (i = 0; i < count_handles; i++) {
1284		syncobjs[i] = drm_syncobj_find(file_private, handles[i]);
1285		if (!syncobjs[i]) {
1286			ret = -ENOENT;
1287			goto err_put_syncobjs;
1288		}
1289	}
1290
1291	kfree(handles);
1292	*syncobjs_out = syncobjs;
1293	return 0;
1294
1295err_put_syncobjs:
1296	while (i-- > 0)
1297		drm_syncobj_put(syncobjs[i]);
1298	kfree(syncobjs);
1299err_free_handles:
1300	kfree(handles);
1301
1302	return ret;
1303}
1304
1305static void drm_syncobj_array_free(struct drm_syncobj **syncobjs,
1306				   uint32_t count)
1307{
1308	uint32_t i;
1309
1310	for (i = 0; i < count; i++)
1311		drm_syncobj_put(syncobjs[i]);
1312	kfree(syncobjs);
1313}
1314
1315int
1316drm_syncobj_wait_ioctl(struct drm_device *dev, void *data,
1317		       struct drm_file *file_private)
1318{
1319	struct drm_syncobj_wait *args = data;
1320	struct drm_syncobj **syncobjs;
1321	unsigned int possible_flags;
1322	ktime_t t, *tp = NULL;
1323	int ret = 0;
1324
1325	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
1326		return -EOPNOTSUPP;
1327
1328	possible_flags = DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL |
1329			 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1330			 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE;
1331
1332	if (args->flags & ~possible_flags)
1333		return -EINVAL;
1334
1335	if (args->count_handles == 0)
1336		return 0;
1337
1338	ret = drm_syncobj_array_find(file_private,
1339				     u64_to_user_ptr(args->handles),
1340				     args->count_handles,
1341				     &syncobjs);
1342	if (ret < 0)
1343		return ret;
1344
1345	if (args->flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE) {
1346		t = ns_to_ktime(args->deadline_nsec);
1347		tp = &t;
1348	}
1349
1350	ret = drm_syncobj_array_wait(dev, file_private,
1351				     args, NULL, syncobjs, false, tp);
1352
1353	drm_syncobj_array_free(syncobjs, args->count_handles);
1354
1355	return ret;
1356}
1357
1358int
1359drm_syncobj_timeline_wait_ioctl(struct drm_device *dev, void *data,
1360				struct drm_file *file_private)
1361{
1362	struct drm_syncobj_timeline_wait *args = data;
1363	struct drm_syncobj **syncobjs;
1364	unsigned int possible_flags;
1365	ktime_t t, *tp = NULL;
1366	int ret = 0;
1367
1368	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1369		return -EOPNOTSUPP;
1370
1371	possible_flags = DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL |
1372			 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1373			 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE |
1374			 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE;
1375
1376	if (args->flags & ~possible_flags)
1377		return -EINVAL;
1378
1379	if (args->count_handles == 0)
1380		return 0;
1381
1382	ret = drm_syncobj_array_find(file_private,
1383				     u64_to_user_ptr(args->handles),
1384				     args->count_handles,
1385				     &syncobjs);
1386	if (ret < 0)
1387		return ret;
1388
1389	if (args->flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE) {
1390		t = ns_to_ktime(args->deadline_nsec);
1391		tp = &t;
1392	}
1393
1394	ret = drm_syncobj_array_wait(dev, file_private,
1395				     NULL, args, syncobjs, true, tp);
1396
1397	drm_syncobj_array_free(syncobjs, args->count_handles);
1398
1399	return ret;
1400}
1401
1402static void syncobj_eventfd_entry_fence_func(struct dma_fence *fence,
1403					     struct dma_fence_cb *cb)
1404{
1405	struct syncobj_eventfd_entry *entry =
1406		container_of(cb, struct syncobj_eventfd_entry, fence_cb);
1407
1408	eventfd_signal(entry->ev_fd_ctx);
1409	syncobj_eventfd_entry_free(entry);
1410}
1411
1412static void
1413syncobj_eventfd_entry_func(struct drm_syncobj *syncobj,
1414			   struct syncobj_eventfd_entry *entry)
1415{
1416	int ret;
1417	struct dma_fence *fence;
1418
1419	/* This happens inside the syncobj lock */
1420	fence = dma_fence_get(rcu_dereference_protected(syncobj->fence, 1));
1421	if (!fence)
1422		return;
1423
1424	ret = dma_fence_chain_find_seqno(&fence, entry->point);
1425	if (ret != 0) {
1426		/* The given seqno has not been submitted yet. */
1427		dma_fence_put(fence);
1428		return;
1429	} else if (!fence) {
1430		/* If dma_fence_chain_find_seqno returns 0 but sets the fence
1431		 * to NULL, it implies that the given seqno is signaled and a
1432		 * later seqno has already been submitted. Assign a stub fence
1433		 * so that the eventfd still gets signaled below.
1434		 */
1435		fence = dma_fence_get_stub();
1436	}
1437
1438	list_del_init(&entry->node);
1439	entry->fence = fence;
1440
1441	if (entry->flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) {
1442		eventfd_signal(entry->ev_fd_ctx);
1443		syncobj_eventfd_entry_free(entry);
1444	} else {
1445		ret = dma_fence_add_callback(fence, &entry->fence_cb,
1446					     syncobj_eventfd_entry_fence_func);
1447		if (ret == -ENOENT) {
1448			eventfd_signal(entry->ev_fd_ctx);
1449			syncobj_eventfd_entry_free(entry);
1450		}
1451	}
1452}
1453
1454int
1455drm_syncobj_eventfd_ioctl(struct drm_device *dev, void *data,
1456			  struct drm_file *file_private)
1457{
1458	struct drm_syncobj_eventfd *args = data;
1459	struct drm_syncobj *syncobj;
1460	struct eventfd_ctx *ev_fd_ctx;
1461	struct syncobj_eventfd_entry *entry;
1462
1463	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1464		return -EOPNOTSUPP;
1465
1466	if (args->flags & ~DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)
1467		return -EINVAL;
1468
1469	if (args->pad)
1470		return -EINVAL;
1471
1472	syncobj = drm_syncobj_find(file_private, args->handle);
1473	if (!syncobj)
1474		return -ENOENT;
1475
1476	ev_fd_ctx = eventfd_ctx_fdget(args->fd);
1477	if (IS_ERR(ev_fd_ctx))
1478		return PTR_ERR(ev_fd_ctx);
1479
1480	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
1481	if (!entry) {
1482		eventfd_ctx_put(ev_fd_ctx);
1483		return -ENOMEM;
1484	}
1485	entry->syncobj = syncobj;
1486	entry->ev_fd_ctx = ev_fd_ctx;
1487	entry->point = args->point;
1488	entry->flags = args->flags;
1489
1490	drm_syncobj_add_eventfd(syncobj, entry);
1491	drm_syncobj_put(syncobj);
1492
1493	return 0;
1494}
1495
1496int
1497drm_syncobj_reset_ioctl(struct drm_device *dev, void *data,
1498			struct drm_file *file_private)
1499{
1500	struct drm_syncobj_array *args = data;
1501	struct drm_syncobj **syncobjs;
1502	uint32_t i;
1503	int ret;
1504
1505	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
1506		return -EOPNOTSUPP;
1507
1508	if (args->pad != 0)
1509		return -EINVAL;
1510
1511	if (args->count_handles == 0)
1512		return -EINVAL;
1513
1514	ret = drm_syncobj_array_find(file_private,
1515				     u64_to_user_ptr(args->handles),
1516				     args->count_handles,
1517				     &syncobjs);
1518	if (ret < 0)
1519		return ret;
1520
1521	for (i = 0; i < args->count_handles; i++)
1522		drm_syncobj_replace_fence(syncobjs[i], NULL);
1523
1524	drm_syncobj_array_free(syncobjs, args->count_handles);
1525
1526	return 0;
1527}
1528
1529int
1530drm_syncobj_signal_ioctl(struct drm_device *dev, void *data,
1531			 struct drm_file *file_private)
1532{
1533	struct drm_syncobj_array *args = data;
1534	struct drm_syncobj **syncobjs;
1535	uint32_t i;
1536	int ret;
1537
1538	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
1539		return -EOPNOTSUPP;
1540
1541	if (args->pad != 0)
1542		return -EINVAL;
1543
1544	if (args->count_handles == 0)
1545		return -EINVAL;
1546
1547	ret = drm_syncobj_array_find(file_private,
1548				     u64_to_user_ptr(args->handles),
1549				     args->count_handles,
1550				     &syncobjs);
1551	if (ret < 0)
1552		return ret;
1553
1554	for (i = 0; i < args->count_handles; i++) {
1555		ret = drm_syncobj_assign_null_handle(syncobjs[i]);
1556		if (ret < 0)
1557			break;
1558	}
1559
1560	drm_syncobj_array_free(syncobjs, args->count_handles);
1561
1562	return ret;
1563}
1564
1565int
1566drm_syncobj_timeline_signal_ioctl(struct drm_device *dev, void *data,
1567				  struct drm_file *file_private)
1568{
1569	struct drm_syncobj_timeline_array *args = data;
1570	struct drm_syncobj **syncobjs;
1571	struct dma_fence_chain **chains;
1572	uint64_t *points;
1573	uint32_t i, j;
1574	int ret;
1575
1576	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1577		return -EOPNOTSUPP;
1578
1579	if (args->flags != 0)
1580		return -EINVAL;
1581
1582	if (args->count_handles == 0)
1583		return -EINVAL;
1584
1585	ret = drm_syncobj_array_find(file_private,
1586				     u64_to_user_ptr(args->handles),
1587				     args->count_handles,
1588				     &syncobjs);
1589	if (ret < 0)
1590		return ret;
1591
1592	points = kmalloc_array(args->count_handles, sizeof(*points),
1593			       GFP_KERNEL);
1594	if (!points) {
1595		ret = -ENOMEM;
1596		goto out;
1597	}
1598	if (!u64_to_user_ptr(args->points)) {
1599		memset(points, 0, args->count_handles * sizeof(uint64_t));
1600	} else if (copy_from_user(points, u64_to_user_ptr(args->points),
1601				  sizeof(uint64_t) * args->count_handles)) {
1602		ret = -EFAULT;
1603		goto err_points;
1604	}
1605
1606	chains = kmalloc_array(args->count_handles, sizeof(void *), GFP_KERNEL);
1607	if (!chains) {
1608		ret = -ENOMEM;
1609		goto err_points;
1610	}
1611	for (i = 0; i < args->count_handles; i++) {
1612		chains[i] = dma_fence_chain_alloc();
1613		if (!chains[i]) {
1614			for (j = 0; j < i; j++)
1615				dma_fence_chain_free(chains[j]);
1616			ret = -ENOMEM;
1617			goto err_chains;
1618		}
1619	}
1620
1621	for (i = 0; i < args->count_handles; i++) {
1622		struct dma_fence *fence = dma_fence_get_stub();
1623
1624		drm_syncobj_add_point(syncobjs[i], chains[i],
1625				      fence, points[i]);
1626		dma_fence_put(fence);
1627	}
1628err_chains:
1629	kfree(chains);
1630err_points:
1631	kfree(points);
1632out:
1633	drm_syncobj_array_free(syncobjs, args->count_handles);
1634
1635	return ret;
1636}
1637
1638int drm_syncobj_query_ioctl(struct drm_device *dev, void *data,
1639			    struct drm_file *file_private)
1640{
1641	struct drm_syncobj_timeline_array *args = data;
1642	struct drm_syncobj **syncobjs;
1643	uint64_t __user *points = u64_to_user_ptr(args->points);
1644	uint32_t i;
1645	int ret;
1646
1647	if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1648		return -EOPNOTSUPP;
1649
1650	if (args->flags & ~DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED)
1651		return -EINVAL;
1652
1653	if (args->count_handles == 0)
1654		return -EINVAL;
1655
1656	ret = drm_syncobj_array_find(file_private,
1657				     u64_to_user_ptr(args->handles),
1658				     args->count_handles,
1659				     &syncobjs);
1660	if (ret < 0)
1661		return ret;
1662
1663	for (i = 0; i < args->count_handles; i++) {
1664		struct dma_fence_chain *chain;
1665		struct dma_fence *fence;
1666		uint64_t point;
1667
1668		fence = drm_syncobj_fence_get(syncobjs[i]);
1669		chain = to_dma_fence_chain(fence);
1670		if (chain) {
1671			struct dma_fence *iter, *last_signaled =
1672				dma_fence_get(fence);
1673
1674			if (args->flags &
1675			    DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED) {
1676				point = fence->seqno;
1677			} else {
1678				dma_fence_chain_for_each(iter, fence) {
1679					if (iter->context != fence->context) {
1680						dma_fence_put(iter);
1681						/* It is most likely that timeline has
1682						* unorder points. */
1683						break;
1684					}
1685					dma_fence_put(last_signaled);
1686					last_signaled = dma_fence_get(iter);
1687				}
1688				point = dma_fence_is_signaled(last_signaled) ?
1689					last_signaled->seqno :
1690					to_dma_fence_chain(last_signaled)->prev_seqno;
1691			}
1692			dma_fence_put(last_signaled);
1693		} else {
1694			point = 0;
1695		}
1696		dma_fence_put(fence);
1697		ret = copy_to_user(&points[i], &point, sizeof(uint64_t));
1698		ret = ret ? -EFAULT : 0;
1699		if (ret)
1700			break;
1701	}
1702	drm_syncobj_array_free(syncobjs, args->count_handles);
1703
1704	return ret;
1705}