GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / gpu / drm / drm_syncobj.c
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  * Similarly, &DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT takes an array of syncobj
130  * handles as well as an array of u64 points and does a host-side wait on all
131  * of syncobj fences at the given points simultaneously.
132  *
133  * &DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT also adds the ability to wait for a given
134  * fence to materialize on the timeline without waiting for the fence to be
135  * signaled by using the &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE flag. This
136  * requirement is inherited from the wait-before-signal behavior required by
137  * the Vulkan timeline semaphore API.
138  *
139  *
140  * Import/export of syncobjs
141  * -------------------------
142  *
143  * &DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE and &DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD
144  * provide two mechanisms for import/export of syncobjs.
145  *
146  * The first lets the client import or export an entire syncobj to a file
147  * descriptor.
148  * These fd's are opaque and have no other use case, except passing the
149  * syncobj between processes.
150  * All exported file descriptors and any syncobj handles created as a
151  * result of importing those file descriptors own a reference to the
152  * same underlying struct &drm_syncobj and the syncobj can be used
153  * persistently across all the processes with which it is shared.
154  * The syncobj is freed only once the last reference is dropped.
155  * Unlike dma-buf, importing a syncobj creates a new handle (with its own
156  * reference) for every import instead of de-duplicating.
157  * The primary use-case of this persistent import/export is for shared
158  * Vulkan fences and semaphores.
159  *
160  * The second import/export mechanism, which is indicated by
161  * &DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE or
162  * &DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE lets the client
163  * import/export the syncobj's current fence from/to a &sync_file.
164  * When a syncobj is exported to a sync file, that sync file wraps the
165  * sycnobj's fence at the time of export and any later signal or reset
166  * operations on the syncobj will not affect the exported sync file.
167  * When a sync file is imported into a syncobj, the syncobj's fence is set
168  * to the fence wrapped by that sync file.
169  * Because sync files are immutable, resetting or signaling the syncobj
170  * will not affect any sync files whose fences have been imported into the
171  * syncobj.
172  *
173  *
174  * Import/export of timeline points in timeline syncobjs
175  * -----------------------------------------------------
176  *
177  * &DRM_IOCTL_SYNCOBJ_TRANSFER provides a mechanism to transfer a struct
178  * &dma_fence_chain of a syncobj at a given u64 point to another u64 point
179  * into another syncobj.
180  *
181  * Note that if you want to transfer a struct &dma_fence_chain from a given
182  * point on a timeline syncobj from/into a binary syncobj, you can use the
183  * point 0 to mean take/replace the fence in the syncobj.
184  */
185
186 #include <linux/anon_inodes.h>
187 #include <linux/file.h>
188 #include <linux/fs.h>
189 #include <linux/sched/signal.h>
190 #include <linux/sync_file.h>
191 #include <linux/uaccess.h>
192
193 #include <drm/drm.h>
194 #include <drm/drm_drv.h>
195 #include <drm/drm_file.h>
196 #include <drm/drm_gem.h>
197 #include <drm/drm_print.h>
198 #include <drm/drm_syncobj.h>
199 #include <drm/drm_utils.h>
200
201 #include "drm_internal.h"
202
203 struct syncobj_wait_entry {
204         struct list_head node;
205         struct task_struct *task;
206         struct dma_fence *fence;
207         struct dma_fence_cb fence_cb;
208         u64    point;
209 };
210
211 static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj,
212                                       struct syncobj_wait_entry *wait);
213
214 /**
215  * drm_syncobj_find - lookup and reference a sync object.
216  * @file_private: drm file private pointer
217  * @handle: sync object handle to lookup.
218  *
219  * Returns a reference to the syncobj pointed to by handle or NULL. The
220  * reference must be released by calling drm_syncobj_put().
221  */
222 struct drm_syncobj *drm_syncobj_find(struct drm_file *file_private,
223                                      u32 handle)
224 {
225         struct drm_syncobj *syncobj;
226
227         spin_lock(&file_private->syncobj_table_lock);
228
229         /* Check if we currently have a reference on the object */
230         syncobj = idr_find(&file_private->syncobj_idr, handle);
231         if (syncobj)
232                 drm_syncobj_get(syncobj);
233
234         spin_unlock(&file_private->syncobj_table_lock);
235
236         return syncobj;
237 }
238 EXPORT_SYMBOL(drm_syncobj_find);
239
240 static void drm_syncobj_fence_add_wait(struct drm_syncobj *syncobj,
241                                        struct syncobj_wait_entry *wait)
242 {
243         struct dma_fence *fence;
244
245         if (wait->fence)
246                 return;
247
248         spin_lock(&syncobj->lock);
249         /* We've already tried once to get a fence and failed.  Now that we
250          * have the lock, try one more time just to be sure we don't add a
251          * callback when a fence has already been set.
252          */
253         fence = dma_fence_get(rcu_dereference_protected(syncobj->fence, 1));
254         if (!fence || dma_fence_chain_find_seqno(&fence, wait->point)) {
255                 dma_fence_put(fence);
256                 list_add_tail(&wait->node, &syncobj->cb_list);
257         } else if (!fence) {
258                 wait->fence = dma_fence_get_stub();
259         } else {
260                 wait->fence = fence;
261         }
262         spin_unlock(&syncobj->lock);
263 }
264
265 static void drm_syncobj_remove_wait(struct drm_syncobj *syncobj,
266                                     struct syncobj_wait_entry *wait)
267 {
268         if (!wait->node.next)
269                 return;
270
271         spin_lock(&syncobj->lock);
272         list_del_init(&wait->node);
273         spin_unlock(&syncobj->lock);
274 }
275
276 /**
277  * drm_syncobj_add_point - add new timeline point to the syncobj
278  * @syncobj: sync object to add timeline point do
279  * @chain: chain node to use to add the point
280  * @fence: fence to encapsulate in the chain node
281  * @point: sequence number to use for the point
282  *
283  * Add the chain node as new timeline point to the syncobj.
284  */
285 void drm_syncobj_add_point(struct drm_syncobj *syncobj,
286                            struct dma_fence_chain *chain,
287                            struct dma_fence *fence,
288                            uint64_t point)
289 {
290         struct syncobj_wait_entry *cur, *tmp;
291         struct dma_fence *prev;
292
293         dma_fence_get(fence);
294
295         spin_lock(&syncobj->lock);
296
297         prev = drm_syncobj_fence_get(syncobj);
298         /* You are adding an unorder point to timeline, which could cause payload returned from query_ioctl is 0! */
299         if (prev && prev->seqno >= point)
300                 DRM_DEBUG("You are adding an unorder point to timeline!\n");
301         dma_fence_chain_init(chain, prev, fence, point);
302         rcu_assign_pointer(syncobj->fence, &chain->base);
303
304         list_for_each_entry_safe(cur, tmp, &syncobj->cb_list, node)
305                 syncobj_wait_syncobj_func(syncobj, cur);
306         spin_unlock(&syncobj->lock);
307
308         /* Walk the chain once to trigger garbage collection */
309         dma_fence_chain_for_each(fence, prev);
310         dma_fence_put(prev);
311 }
312 EXPORT_SYMBOL(drm_syncobj_add_point);
313
314 /**
315  * drm_syncobj_replace_fence - replace fence in a sync object.
316  * @syncobj: Sync object to replace fence in
317  * @fence: fence to install in sync file.
318  *
319  * This replaces the fence on a sync object.
320  */
321 void drm_syncobj_replace_fence(struct drm_syncobj *syncobj,
322                                struct dma_fence *fence)
323 {
324         struct dma_fence *old_fence;
325         struct syncobj_wait_entry *cur, *tmp;
326
327         if (fence)
328                 dma_fence_get(fence);
329
330         spin_lock(&syncobj->lock);
331
332         old_fence = rcu_dereference_protected(syncobj->fence,
333                                               lockdep_is_held(&syncobj->lock));
334         rcu_assign_pointer(syncobj->fence, fence);
335
336         if (fence != old_fence) {
337                 list_for_each_entry_safe(cur, tmp, &syncobj->cb_list, node)
338                         syncobj_wait_syncobj_func(syncobj, cur);
339         }
340
341         spin_unlock(&syncobj->lock);
342
343         dma_fence_put(old_fence);
344 }
345 EXPORT_SYMBOL(drm_syncobj_replace_fence);
346
347 /**
348  * drm_syncobj_assign_null_handle - assign a stub fence to the sync object
349  * @syncobj: sync object to assign the fence on
350  *
351  * Assign a already signaled stub fence to the sync object.
352  */
353 static void drm_syncobj_assign_null_handle(struct drm_syncobj *syncobj)
354 {
355         struct dma_fence *fence = dma_fence_get_stub();
356
357         drm_syncobj_replace_fence(syncobj, fence);
358         dma_fence_put(fence);
359 }
360
361 /* 5s default for wait submission */
362 #define DRM_SYNCOBJ_WAIT_FOR_SUBMIT_TIMEOUT 5000000000ULL
363 /**
364  * drm_syncobj_find_fence - lookup and reference the fence in a sync object
365  * @file_private: drm file private pointer
366  * @handle: sync object handle to lookup.
367  * @point: timeline point
368  * @flags: DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT or not
369  * @fence: out parameter for the fence
370  *
371  * This is just a convenience function that combines drm_syncobj_find() and
372  * drm_syncobj_fence_get().
373  *
374  * Returns 0 on success or a negative error value on failure. On success @fence
375  * contains a reference to the fence, which must be released by calling
376  * dma_fence_put().
377  */
378 int drm_syncobj_find_fence(struct drm_file *file_private,
379                            u32 handle, u64 point, u64 flags,
380                            struct dma_fence **fence)
381 {
382         struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
383         struct syncobj_wait_entry wait;
384         u64 timeout = nsecs_to_jiffies64(DRM_SYNCOBJ_WAIT_FOR_SUBMIT_TIMEOUT);
385         int ret;
386
387         if (!syncobj)
388                 return -ENOENT;
389
390         /* Waiting for userspace with locks help is illegal cause that can
391          * trivial deadlock with page faults for example. Make lockdep complain
392          * about it early on.
393          */
394         if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
395                 might_sleep();
396                 lockdep_assert_none_held_once();
397         }
398
399         *fence = drm_syncobj_fence_get(syncobj);
400
401         if (*fence) {
402                 ret = dma_fence_chain_find_seqno(fence, point);
403                 if (!ret) {
404                         /* If the requested seqno is already signaled
405                          * drm_syncobj_find_fence may return a NULL
406                          * fence. To make sure the recipient gets
407                          * signalled, use a new fence instead.
408                          */
409                         if (!*fence)
410                                 *fence = dma_fence_get_stub();
411
412                         goto out;
413                 }
414                 dma_fence_put(*fence);
415         } else {
416                 ret = -EINVAL;
417         }
418
419         if (!(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT))
420                 goto out;
421
422         memset(&wait, 0, sizeof(wait));
423         wait.task = current;
424         wait.point = point;
425         drm_syncobj_fence_add_wait(syncobj, &wait);
426
427         do {
428                 set_current_state(TASK_INTERRUPTIBLE);
429                 if (wait.fence) {
430                         ret = 0;
431                         break;
432                 }
433                 if (timeout == 0) {
434                         ret = -ETIME;
435                         break;
436                 }
437
438                 if (signal_pending(current)) {
439                         ret = -ERESTARTSYS;
440                         break;
441                 }
442
443                 timeout = schedule_timeout(timeout);
444         } while (1);
445
446         __set_current_state(TASK_RUNNING);
447         *fence = wait.fence;
448
449         if (wait.node.next)
450                 drm_syncobj_remove_wait(syncobj, &wait);
451
452 out:
453         drm_syncobj_put(syncobj);
454
455         return ret;
456 }
457 EXPORT_SYMBOL(drm_syncobj_find_fence);
458
459 /**
460  * drm_syncobj_free - free a sync object.
461  * @kref: kref to free.
462  *
463  * Only to be called from kref_put in drm_syncobj_put.
464  */
465 void drm_syncobj_free(struct kref *kref)
466 {
467         struct drm_syncobj *syncobj = container_of(kref,
468                                                    struct drm_syncobj,
469                                                    refcount);
470         drm_syncobj_replace_fence(syncobj, NULL);
471         kfree(syncobj);
472 }
473 EXPORT_SYMBOL(drm_syncobj_free);
474
475 /**
476  * drm_syncobj_create - create a new syncobj
477  * @out_syncobj: returned syncobj
478  * @flags: DRM_SYNCOBJ_* flags
479  * @fence: if non-NULL, the syncobj will represent this fence
480  *
481  * This is the first function to create a sync object. After creating, drivers
482  * probably want to make it available to userspace, either through
483  * drm_syncobj_get_handle() or drm_syncobj_get_fd().
484  *
485  * Returns 0 on success or a negative error value on failure.
486  */
487 int drm_syncobj_create(struct drm_syncobj **out_syncobj, uint32_t flags,
488                        struct dma_fence *fence)
489 {
490         struct drm_syncobj *syncobj;
491
492         syncobj = kzalloc(sizeof(struct drm_syncobj), GFP_KERNEL);
493         if (!syncobj)
494                 return -ENOMEM;
495
496         kref_init(&syncobj->refcount);
497         INIT_LIST_HEAD(&syncobj->cb_list);
498         spin_lock_init(&syncobj->lock);
499
500         if (flags & DRM_SYNCOBJ_CREATE_SIGNALED)
501                 drm_syncobj_assign_null_handle(syncobj);
502
503         if (fence)
504                 drm_syncobj_replace_fence(syncobj, fence);
505
506         *out_syncobj = syncobj;
507         return 0;
508 }
509 EXPORT_SYMBOL(drm_syncobj_create);
510
511 /**
512  * drm_syncobj_get_handle - get a handle from a syncobj
513  * @file_private: drm file private pointer
514  * @syncobj: Sync object to export
515  * @handle: out parameter with the new handle
516  *
517  * Exports a sync object created with drm_syncobj_create() as a handle on
518  * @file_private to userspace.
519  *
520  * Returns 0 on success or a negative error value on failure.
521  */
522 int drm_syncobj_get_handle(struct drm_file *file_private,
523                            struct drm_syncobj *syncobj, u32 *handle)
524 {
525         int ret;
526
527         /* take a reference to put in the idr */
528         drm_syncobj_get(syncobj);
529
530         idr_preload(GFP_KERNEL);
531         spin_lock(&file_private->syncobj_table_lock);
532         ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
533         spin_unlock(&file_private->syncobj_table_lock);
534
535         idr_preload_end();
536
537         if (ret < 0) {
538                 drm_syncobj_put(syncobj);
539                 return ret;
540         }
541
542         *handle = ret;
543         return 0;
544 }
545 EXPORT_SYMBOL(drm_syncobj_get_handle);
546
547 static int drm_syncobj_create_as_handle(struct drm_file *file_private,
548                                         u32 *handle, uint32_t flags)
549 {
550         int ret;
551         struct drm_syncobj *syncobj;
552
553         ret = drm_syncobj_create(&syncobj, flags, NULL);
554         if (ret)
555                 return ret;
556
557         ret = drm_syncobj_get_handle(file_private, syncobj, handle);
558         drm_syncobj_put(syncobj);
559         return ret;
560 }
561
562 static int drm_syncobj_destroy(struct drm_file *file_private,
563                                u32 handle)
564 {
565         struct drm_syncobj *syncobj;
566
567         spin_lock(&file_private->syncobj_table_lock);
568         syncobj = idr_remove(&file_private->syncobj_idr, handle);
569         spin_unlock(&file_private->syncobj_table_lock);
570
571         if (!syncobj)
572                 return -EINVAL;
573
574         drm_syncobj_put(syncobj);
575         return 0;
576 }
577
578 static int drm_syncobj_file_release(struct inode *inode, struct file *file)
579 {
580         struct drm_syncobj *syncobj = file->private_data;
581
582         drm_syncobj_put(syncobj);
583         return 0;
584 }
585
586 static const struct file_operations drm_syncobj_file_fops = {
587         .release = drm_syncobj_file_release,
588 };
589
590 /**
591  * drm_syncobj_get_fd - get a file descriptor from a syncobj
592  * @syncobj: Sync object to export
593  * @p_fd: out parameter with the new file descriptor
594  *
595  * Exports a sync object created with drm_syncobj_create() as a file descriptor.
596  *
597  * Returns 0 on success or a negative error value on failure.
598  */
599 int drm_syncobj_get_fd(struct drm_syncobj *syncobj, int *p_fd)
600 {
601         struct file *file;
602         int fd;
603
604         fd = get_unused_fd_flags(O_CLOEXEC);
605         if (fd < 0)
606                 return fd;
607
608         file = anon_inode_getfile("syncobj_file",
609                                   &drm_syncobj_file_fops,
610                                   syncobj, 0);
611         if (IS_ERR(file)) {
612                 put_unused_fd(fd);
613                 return PTR_ERR(file);
614         }
615
616         drm_syncobj_get(syncobj);
617         fd_install(fd, file);
618
619         *p_fd = fd;
620         return 0;
621 }
622 EXPORT_SYMBOL(drm_syncobj_get_fd);
623
624 static int drm_syncobj_handle_to_fd(struct drm_file *file_private,
625                                     u32 handle, int *p_fd)
626 {
627         struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
628         int ret;
629
630         if (!syncobj)
631                 return -EINVAL;
632
633         ret = drm_syncobj_get_fd(syncobj, p_fd);
634         drm_syncobj_put(syncobj);
635         return ret;
636 }
637
638 static int drm_syncobj_fd_to_handle(struct drm_file *file_private,
639                                     int fd, u32 *handle)
640 {
641         struct drm_syncobj *syncobj;
642         struct fd f = fdget(fd);
643         int ret;
644
645         if (!f.file)
646                 return -EINVAL;
647
648         if (f.file->f_op != &drm_syncobj_file_fops) {
649                 fdput(f);
650                 return -EINVAL;
651         }
652
653         /* take a reference to put in the idr */
654         syncobj = f.file->private_data;
655         drm_syncobj_get(syncobj);
656
657         idr_preload(GFP_KERNEL);
658         spin_lock(&file_private->syncobj_table_lock);
659         ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
660         spin_unlock(&file_private->syncobj_table_lock);
661         idr_preload_end();
662
663         if (ret > 0) {
664                 *handle = ret;
665                 ret = 0;
666         } else
667                 drm_syncobj_put(syncobj);
668
669         fdput(f);
670         return ret;
671 }
672
673 static int drm_syncobj_import_sync_file_fence(struct drm_file *file_private,
674                                               int fd, int handle)
675 {
676         struct dma_fence *fence = sync_file_get_fence(fd);
677         struct drm_syncobj *syncobj;
678
679         if (!fence)
680                 return -EINVAL;
681
682         syncobj = drm_syncobj_find(file_private, handle);
683         if (!syncobj) {
684                 dma_fence_put(fence);
685                 return -ENOENT;
686         }
687
688         drm_syncobj_replace_fence(syncobj, fence);
689         dma_fence_put(fence);
690         drm_syncobj_put(syncobj);
691         return 0;
692 }
693
694 static int drm_syncobj_export_sync_file(struct drm_file *file_private,
695                                         int handle, int *p_fd)
696 {
697         int ret;
698         struct dma_fence *fence;
699         struct sync_file *sync_file;
700         int fd = get_unused_fd_flags(O_CLOEXEC);
701
702         if (fd < 0)
703                 return fd;
704
705         ret = drm_syncobj_find_fence(file_private, handle, 0, 0, &fence);
706         if (ret)
707                 goto err_put_fd;
708
709         sync_file = sync_file_create(fence);
710
711         dma_fence_put(fence);
712
713         if (!sync_file) {
714                 ret = -EINVAL;
715                 goto err_put_fd;
716         }
717
718         fd_install(fd, sync_file->file);
719
720         *p_fd = fd;
721         return 0;
722 err_put_fd:
723         put_unused_fd(fd);
724         return ret;
725 }
726 /**
727  * drm_syncobj_open - initalizes syncobj file-private structures at devnode open time
728  * @file_private: drm file-private structure to set up
729  *
730  * Called at device open time, sets up the structure for handling refcounting
731  * of sync objects.
732  */
733 void
734 drm_syncobj_open(struct drm_file *file_private)
735 {
736         idr_init_base(&file_private->syncobj_idr, 1);
737         spin_lock_init(&file_private->syncobj_table_lock);
738 }
739
740 static int
741 drm_syncobj_release_handle(int id, void *ptr, void *data)
742 {
743         struct drm_syncobj *syncobj = ptr;
744
745         drm_syncobj_put(syncobj);
746         return 0;
747 }
748
749 /**
750  * drm_syncobj_release - release file-private sync object resources
751  * @file_private: drm file-private structure to clean up
752  *
753  * Called at close time when the filp is going away.
754  *
755  * Releases any remaining references on objects by this filp.
756  */
757 void
758 drm_syncobj_release(struct drm_file *file_private)
759 {
760         idr_for_each(&file_private->syncobj_idr,
761                      &drm_syncobj_release_handle, file_private);
762         idr_destroy(&file_private->syncobj_idr);
763 }
764
765 int
766 drm_syncobj_create_ioctl(struct drm_device *dev, void *data,
767                          struct drm_file *file_private)
768 {
769         struct drm_syncobj_create *args = data;
770
771         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
772                 return -EOPNOTSUPP;
773
774         /* no valid flags yet */
775         if (args->flags & ~DRM_SYNCOBJ_CREATE_SIGNALED)
776                 return -EINVAL;
777
778         return drm_syncobj_create_as_handle(file_private,
779                                             &args->handle, args->flags);
780 }
781
782 int
783 drm_syncobj_destroy_ioctl(struct drm_device *dev, void *data,
784                           struct drm_file *file_private)
785 {
786         struct drm_syncobj_destroy *args = data;
787
788         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
789                 return -EOPNOTSUPP;
790
791         /* make sure padding is empty */
792         if (args->pad)
793                 return -EINVAL;
794         return drm_syncobj_destroy(file_private, args->handle);
795 }
796
797 int
798 drm_syncobj_handle_to_fd_ioctl(struct drm_device *dev, void *data,
799                                    struct drm_file *file_private)
800 {
801         struct drm_syncobj_handle *args = data;
802
803         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
804                 return -EOPNOTSUPP;
805
806         if (args->pad)
807                 return -EINVAL;
808
809         if (args->flags != 0 &&
810             args->flags != DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
811                 return -EINVAL;
812
813         if (args->flags & DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
814                 return drm_syncobj_export_sync_file(file_private, args->handle,
815                                                     &args->fd);
816
817         return drm_syncobj_handle_to_fd(file_private, args->handle,
818                                         &args->fd);
819 }
820
821 int
822 drm_syncobj_fd_to_handle_ioctl(struct drm_device *dev, void *data,
823                                    struct drm_file *file_private)
824 {
825         struct drm_syncobj_handle *args = data;
826
827         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
828                 return -EOPNOTSUPP;
829
830         if (args->pad)
831                 return -EINVAL;
832
833         if (args->flags != 0 &&
834             args->flags != DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
835                 return -EINVAL;
836
837         if (args->flags & DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
838                 return drm_syncobj_import_sync_file_fence(file_private,
839                                                           args->fd,
840                                                           args->handle);
841
842         return drm_syncobj_fd_to_handle(file_private, args->fd,
843                                         &args->handle);
844 }
845
846 static int drm_syncobj_transfer_to_timeline(struct drm_file *file_private,
847                                             struct drm_syncobj_transfer *args)
848 {
849         struct drm_syncobj *timeline_syncobj = NULL;
850         struct dma_fence *fence;
851         struct dma_fence_chain *chain;
852         int ret;
853
854         timeline_syncobj = drm_syncobj_find(file_private, args->dst_handle);
855         if (!timeline_syncobj) {
856                 return -ENOENT;
857         }
858         ret = drm_syncobj_find_fence(file_private, args->src_handle,
859                                      args->src_point, args->flags,
860                                      &fence);
861         if (ret)
862                 goto err;
863         chain = kzalloc(sizeof(struct dma_fence_chain), GFP_KERNEL);
864         if (!chain) {
865                 ret = -ENOMEM;
866                 goto err1;
867         }
868         drm_syncobj_add_point(timeline_syncobj, chain, fence, args->dst_point);
869 err1:
870         dma_fence_put(fence);
871 err:
872         drm_syncobj_put(timeline_syncobj);
873
874         return ret;
875 }
876
877 static int
878 drm_syncobj_transfer_to_binary(struct drm_file *file_private,
879                                struct drm_syncobj_transfer *args)
880 {
881         struct drm_syncobj *binary_syncobj = NULL;
882         struct dma_fence *fence;
883         int ret;
884
885         binary_syncobj = drm_syncobj_find(file_private, args->dst_handle);
886         if (!binary_syncobj)
887                 return -ENOENT;
888         ret = drm_syncobj_find_fence(file_private, args->src_handle,
889                                      args->src_point, args->flags, &fence);
890         if (ret)
891                 goto err;
892         drm_syncobj_replace_fence(binary_syncobj, fence);
893         dma_fence_put(fence);
894 err:
895         drm_syncobj_put(binary_syncobj);
896
897         return ret;
898 }
899 int
900 drm_syncobj_transfer_ioctl(struct drm_device *dev, void *data,
901                            struct drm_file *file_private)
902 {
903         struct drm_syncobj_transfer *args = data;
904         int ret;
905
906         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
907                 return -EOPNOTSUPP;
908
909         if (args->pad)
910                 return -EINVAL;
911
912         if (args->dst_point)
913                 ret = drm_syncobj_transfer_to_timeline(file_private, args);
914         else
915                 ret = drm_syncobj_transfer_to_binary(file_private, args);
916
917         return ret;
918 }
919
920 static void syncobj_wait_fence_func(struct dma_fence *fence,
921                                     struct dma_fence_cb *cb)
922 {
923         struct syncobj_wait_entry *wait =
924                 container_of(cb, struct syncobj_wait_entry, fence_cb);
925
926         wake_up_process(wait->task);
927 }
928
929 static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj,
930                                       struct syncobj_wait_entry *wait)
931 {
932         struct dma_fence *fence;
933
934         /* This happens inside the syncobj lock */
935         fence = rcu_dereference_protected(syncobj->fence,
936                                           lockdep_is_held(&syncobj->lock));
937         dma_fence_get(fence);
938         if (!fence || dma_fence_chain_find_seqno(&fence, wait->point)) {
939                 dma_fence_put(fence);
940                 return;
941         } else if (!fence) {
942                 wait->fence = dma_fence_get_stub();
943         } else {
944                 wait->fence = fence;
945         }
946
947         wake_up_process(wait->task);
948         list_del_init(&wait->node);
949 }
950
951 static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs,
952                                                   void __user *user_points,
953                                                   uint32_t count,
954                                                   uint32_t flags,
955                                                   signed long timeout,
956                                                   uint32_t *idx)
957 {
958         struct syncobj_wait_entry *entries;
959         struct dma_fence *fence;
960         uint64_t *points;
961         uint32_t signaled_count, i;
962
963         if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
964                      DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE))
965                 lockdep_assert_none_held_once();
966
967         points = kmalloc_array(count, sizeof(*points), GFP_KERNEL);
968         if (points == NULL)
969                 return -ENOMEM;
970
971         if (!user_points) {
972                 memset(points, 0, count * sizeof(uint64_t));
973
974         } else if (copy_from_user(points, user_points,
975                                   sizeof(uint64_t) * count)) {
976                 timeout = -EFAULT;
977                 goto err_free_points;
978         }
979
980         entries = kcalloc(count, sizeof(*entries), GFP_KERNEL);
981         if (!entries) {
982                 timeout = -ENOMEM;
983                 goto err_free_points;
984         }
985         /* Walk the list of sync objects and initialize entries.  We do
986          * this up-front so that we can properly return -EINVAL if there is
987          * a syncobj with a missing fence and then never have the chance of
988          * returning -EINVAL again.
989          */
990         signaled_count = 0;
991         for (i = 0; i < count; ++i) {
992                 struct dma_fence *fence;
993
994                 entries[i].task = current;
995                 entries[i].point = points[i];
996                 fence = drm_syncobj_fence_get(syncobjs[i]);
997                 if (!fence || dma_fence_chain_find_seqno(&fence, points[i])) {
998                         dma_fence_put(fence);
999                         if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1000                                      DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)) {
1001                                 continue;
1002                         } else {
1003                                 timeout = -EINVAL;
1004                                 goto cleanup_entries;
1005                         }
1006                 }
1007
1008                 if (fence)
1009                         entries[i].fence = fence;
1010                 else
1011                         entries[i].fence = dma_fence_get_stub();
1012
1013                 if ((flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) ||
1014                     dma_fence_is_signaled(entries[i].fence)) {
1015                         if (signaled_count == 0 && idx)
1016                                 *idx = i;
1017                         signaled_count++;
1018                 }
1019         }
1020
1021         if (signaled_count == count ||
1022             (signaled_count > 0 &&
1023              !(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL)))
1024                 goto cleanup_entries;
1025
1026         /* There's a very annoying laxness in the dma_fence API here, in
1027          * that backends are not required to automatically report when a
1028          * fence is signaled prior to fence->ops->enable_signaling() being
1029          * called.  So here if we fail to match signaled_count, we need to
1030          * fallthough and try a 0 timeout wait!
1031          */
1032
1033         if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1034                      DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)) {
1035                 for (i = 0; i < count; ++i)
1036                         drm_syncobj_fence_add_wait(syncobjs[i], &entries[i]);
1037         }
1038
1039         do {
1040                 set_current_state(TASK_INTERRUPTIBLE);
1041
1042                 signaled_count = 0;
1043                 for (i = 0; i < count; ++i) {
1044                         fence = entries[i].fence;
1045                         if (!fence)
1046                                 continue;
1047
1048                         if ((flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) ||
1049                             dma_fence_is_signaled(fence) ||
1050                             (!entries[i].fence_cb.func &&
1051                              dma_fence_add_callback(fence,
1052                                                     &entries[i].fence_cb,
1053                                                     syncobj_wait_fence_func))) {
1054                                 /* The fence has been signaled */
1055                                 if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL) {
1056                                         signaled_count++;
1057                                 } else {
1058                                         if (idx)
1059                                                 *idx = i;
1060                                         goto done_waiting;
1061                                 }
1062                         }
1063                 }
1064
1065                 if (signaled_count == count)
1066                         goto done_waiting;
1067
1068                 if (timeout == 0) {
1069                         timeout = -ETIME;
1070                         goto done_waiting;
1071                 }
1072
1073                 if (signal_pending(current)) {
1074                         timeout = -ERESTARTSYS;
1075                         goto done_waiting;
1076                 }
1077
1078                 timeout = schedule_timeout(timeout);
1079         } while (1);
1080
1081 done_waiting:
1082         __set_current_state(TASK_RUNNING);
1083
1084 cleanup_entries:
1085         for (i = 0; i < count; ++i) {
1086                 drm_syncobj_remove_wait(syncobjs[i], &entries[i]);
1087                 if (entries[i].fence_cb.func)
1088                         dma_fence_remove_callback(entries[i].fence,
1089                                                   &entries[i].fence_cb);
1090                 dma_fence_put(entries[i].fence);
1091         }
1092         kfree(entries);
1093
1094 err_free_points:
1095         kfree(points);
1096
1097         return timeout;
1098 }
1099
1100 /**
1101  * drm_timeout_abs_to_jiffies - calculate jiffies timeout from absolute value
1102  *
1103  * @timeout_nsec: timeout nsec component in ns, 0 for poll
1104  *
1105  * Calculate the timeout in jiffies from an absolute time in sec/nsec.
1106  */
1107 signed long drm_timeout_abs_to_jiffies(int64_t timeout_nsec)
1108 {
1109         ktime_t abs_timeout, now;
1110         u64 timeout_ns, timeout_jiffies64;
1111
1112         /* make 0 timeout means poll - absolute 0 doesn't seem valid */
1113         if (timeout_nsec == 0)
1114                 return 0;
1115
1116         abs_timeout = ns_to_ktime(timeout_nsec);
1117         now = ktime_get();
1118
1119         if (!ktime_after(abs_timeout, now))
1120                 return 0;
1121
1122         timeout_ns = ktime_to_ns(ktime_sub(abs_timeout, now));
1123
1124         timeout_jiffies64 = nsecs_to_jiffies64(timeout_ns);
1125         /*  clamp timeout to avoid infinite timeout */
1126         if (timeout_jiffies64 >= MAX_SCHEDULE_TIMEOUT - 1)
1127                 return MAX_SCHEDULE_TIMEOUT - 1;
1128
1129         return timeout_jiffies64 + 1;
1130 }
1131 EXPORT_SYMBOL(drm_timeout_abs_to_jiffies);
1132
1133 static int drm_syncobj_array_wait(struct drm_device *dev,
1134                                   struct drm_file *file_private,
1135                                   struct drm_syncobj_wait *wait,
1136                                   struct drm_syncobj_timeline_wait *timeline_wait,
1137                                   struct drm_syncobj **syncobjs, bool timeline)
1138 {
1139         signed long timeout = 0;
1140         uint32_t first = ~0;
1141
1142         if (!timeline) {
1143                 timeout = drm_timeout_abs_to_jiffies(wait->timeout_nsec);
1144                 timeout = drm_syncobj_array_wait_timeout(syncobjs,
1145                                                          NULL,
1146                                                          wait->count_handles,
1147                                                          wait->flags,
1148                                                          timeout, &first);
1149                 if (timeout < 0)
1150                         return timeout;
1151                 wait->first_signaled = first;
1152         } else {
1153                 timeout = drm_timeout_abs_to_jiffies(timeline_wait->timeout_nsec);
1154                 timeout = drm_syncobj_array_wait_timeout(syncobjs,
1155                                                          u64_to_user_ptr(timeline_wait->points),
1156                                                          timeline_wait->count_handles,
1157                                                          timeline_wait->flags,
1158                                                          timeout, &first);
1159                 if (timeout < 0)
1160                         return timeout;
1161                 timeline_wait->first_signaled = first;
1162         }
1163         return 0;
1164 }
1165
1166 static int drm_syncobj_array_find(struct drm_file *file_private,
1167                                   void __user *user_handles,
1168                                   uint32_t count_handles,
1169                                   struct drm_syncobj ***syncobjs_out)
1170 {
1171         uint32_t i, *handles;
1172         struct drm_syncobj **syncobjs;
1173         int ret;
1174
1175         handles = kmalloc_array(count_handles, sizeof(*handles), GFP_KERNEL);
1176         if (handles == NULL)
1177                 return -ENOMEM;
1178
1179         if (copy_from_user(handles, user_handles,
1180                            sizeof(uint32_t) * count_handles)) {
1181                 ret = -EFAULT;
1182                 goto err_free_handles;
1183         }
1184
1185         syncobjs = kmalloc_array(count_handles, sizeof(*syncobjs), GFP_KERNEL);
1186         if (syncobjs == NULL) {
1187                 ret = -ENOMEM;
1188                 goto err_free_handles;
1189         }
1190
1191         for (i = 0; i < count_handles; i++) {
1192                 syncobjs[i] = drm_syncobj_find(file_private, handles[i]);
1193                 if (!syncobjs[i]) {
1194                         ret = -ENOENT;
1195                         goto err_put_syncobjs;
1196                 }
1197         }
1198
1199         kfree(handles);
1200         *syncobjs_out = syncobjs;
1201         return 0;
1202
1203 err_put_syncobjs:
1204         while (i-- > 0)
1205                 drm_syncobj_put(syncobjs[i]);
1206         kfree(syncobjs);
1207 err_free_handles:
1208         kfree(handles);
1209
1210         return ret;
1211 }
1212
1213 static void drm_syncobj_array_free(struct drm_syncobj **syncobjs,
1214                                    uint32_t count)
1215 {
1216         uint32_t i;
1217
1218         for (i = 0; i < count; i++)
1219                 drm_syncobj_put(syncobjs[i]);
1220         kfree(syncobjs);
1221 }
1222
1223 int
1224 drm_syncobj_wait_ioctl(struct drm_device *dev, void *data,
1225                        struct drm_file *file_private)
1226 {
1227         struct drm_syncobj_wait *args = data;
1228         struct drm_syncobj **syncobjs;
1229         int ret = 0;
1230
1231         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
1232                 return -EOPNOTSUPP;
1233
1234         if (args->flags & ~(DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL |
1235                             DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT))
1236                 return -EINVAL;
1237
1238         if (args->count_handles == 0)
1239                 return -EINVAL;
1240
1241         ret = drm_syncobj_array_find(file_private,
1242                                      u64_to_user_ptr(args->handles),
1243                                      args->count_handles,
1244                                      &syncobjs);
1245         if (ret < 0)
1246                 return ret;
1247
1248         ret = drm_syncobj_array_wait(dev, file_private,
1249                                      args, NULL, syncobjs, false);
1250
1251         drm_syncobj_array_free(syncobjs, args->count_handles);
1252
1253         return ret;
1254 }
1255
1256 int
1257 drm_syncobj_timeline_wait_ioctl(struct drm_device *dev, void *data,
1258                                 struct drm_file *file_private)
1259 {
1260         struct drm_syncobj_timeline_wait *args = data;
1261         struct drm_syncobj **syncobjs;
1262         int ret = 0;
1263
1264         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1265                 return -EOPNOTSUPP;
1266
1267         if (args->flags & ~(DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL |
1268                             DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT |
1269                             DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE))
1270                 return -EINVAL;
1271
1272         if (args->count_handles == 0)
1273                 return -EINVAL;
1274
1275         ret = drm_syncobj_array_find(file_private,
1276                                      u64_to_user_ptr(args->handles),
1277                                      args->count_handles,
1278                                      &syncobjs);
1279         if (ret < 0)
1280                 return ret;
1281
1282         ret = drm_syncobj_array_wait(dev, file_private,
1283                                      NULL, args, syncobjs, true);
1284
1285         drm_syncobj_array_free(syncobjs, args->count_handles);
1286
1287         return ret;
1288 }
1289
1290
1291 int
1292 drm_syncobj_reset_ioctl(struct drm_device *dev, void *data,
1293                         struct drm_file *file_private)
1294 {
1295         struct drm_syncobj_array *args = data;
1296         struct drm_syncobj **syncobjs;
1297         uint32_t i;
1298         int ret;
1299
1300         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
1301                 return -EOPNOTSUPP;
1302
1303         if (args->pad != 0)
1304                 return -EINVAL;
1305
1306         if (args->count_handles == 0)
1307                 return -EINVAL;
1308
1309         ret = drm_syncobj_array_find(file_private,
1310                                      u64_to_user_ptr(args->handles),
1311                                      args->count_handles,
1312                                      &syncobjs);
1313         if (ret < 0)
1314                 return ret;
1315
1316         for (i = 0; i < args->count_handles; i++)
1317                 drm_syncobj_replace_fence(syncobjs[i], NULL);
1318
1319         drm_syncobj_array_free(syncobjs, args->count_handles);
1320
1321         return 0;
1322 }
1323
1324 int
1325 drm_syncobj_signal_ioctl(struct drm_device *dev, void *data,
1326                          struct drm_file *file_private)
1327 {
1328         struct drm_syncobj_array *args = data;
1329         struct drm_syncobj **syncobjs;
1330         uint32_t i;
1331         int ret;
1332
1333         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
1334                 return -EOPNOTSUPP;
1335
1336         if (args->pad != 0)
1337                 return -EINVAL;
1338
1339         if (args->count_handles == 0)
1340                 return -EINVAL;
1341
1342         ret = drm_syncobj_array_find(file_private,
1343                                      u64_to_user_ptr(args->handles),
1344                                      args->count_handles,
1345                                      &syncobjs);
1346         if (ret < 0)
1347                 return ret;
1348
1349         for (i = 0; i < args->count_handles; i++)
1350                 drm_syncobj_assign_null_handle(syncobjs[i]);
1351
1352         drm_syncobj_array_free(syncobjs, args->count_handles);
1353
1354         return ret;
1355 }
1356
1357 int
1358 drm_syncobj_timeline_signal_ioctl(struct drm_device *dev, void *data,
1359                                   struct drm_file *file_private)
1360 {
1361         struct drm_syncobj_timeline_array *args = data;
1362         struct drm_syncobj **syncobjs;
1363         struct dma_fence_chain **chains;
1364         uint64_t *points;
1365         uint32_t i, j;
1366         int ret;
1367
1368         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1369                 return -EOPNOTSUPP;
1370
1371         if (args->flags != 0)
1372                 return -EINVAL;
1373
1374         if (args->count_handles == 0)
1375                 return -EINVAL;
1376
1377         ret = drm_syncobj_array_find(file_private,
1378                                      u64_to_user_ptr(args->handles),
1379                                      args->count_handles,
1380                                      &syncobjs);
1381         if (ret < 0)
1382                 return ret;
1383
1384         points = kmalloc_array(args->count_handles, sizeof(*points),
1385                                GFP_KERNEL);
1386         if (!points) {
1387                 ret = -ENOMEM;
1388                 goto out;
1389         }
1390         if (!u64_to_user_ptr(args->points)) {
1391                 memset(points, 0, args->count_handles * sizeof(uint64_t));
1392         } else if (copy_from_user(points, u64_to_user_ptr(args->points),
1393                                   sizeof(uint64_t) * args->count_handles)) {
1394                 ret = -EFAULT;
1395                 goto err_points;
1396         }
1397
1398         chains = kmalloc_array(args->count_handles, sizeof(void *), GFP_KERNEL);
1399         if (!chains) {
1400                 ret = -ENOMEM;
1401                 goto err_points;
1402         }
1403         for (i = 0; i < args->count_handles; i++) {
1404                 chains[i] = kzalloc(sizeof(struct dma_fence_chain), GFP_KERNEL);
1405                 if (!chains[i]) {
1406                         for (j = 0; j < i; j++)
1407                                 kfree(chains[j]);
1408                         ret = -ENOMEM;
1409                         goto err_chains;
1410                 }
1411         }
1412
1413         for (i = 0; i < args->count_handles; i++) {
1414                 struct dma_fence *fence = dma_fence_get_stub();
1415
1416                 drm_syncobj_add_point(syncobjs[i], chains[i],
1417                                       fence, points[i]);
1418                 dma_fence_put(fence);
1419         }
1420 err_chains:
1421         kfree(chains);
1422 err_points:
1423         kfree(points);
1424 out:
1425         drm_syncobj_array_free(syncobjs, args->count_handles);
1426
1427         return ret;
1428 }
1429
1430 int drm_syncobj_query_ioctl(struct drm_device *dev, void *data,
1431                             struct drm_file *file_private)
1432 {
1433         struct drm_syncobj_timeline_array *args = data;
1434         struct drm_syncobj **syncobjs;
1435         uint64_t __user *points = u64_to_user_ptr(args->points);
1436         uint32_t i;
1437         int ret;
1438
1439         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE))
1440                 return -EOPNOTSUPP;
1441
1442         if (args->flags & ~DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED)
1443                 return -EINVAL;
1444
1445         if (args->count_handles == 0)
1446                 return -EINVAL;
1447
1448         ret = drm_syncobj_array_find(file_private,
1449                                      u64_to_user_ptr(args->handles),
1450                                      args->count_handles,
1451                                      &syncobjs);
1452         if (ret < 0)
1453                 return ret;
1454
1455         for (i = 0; i < args->count_handles; i++) {
1456                 struct dma_fence_chain *chain;
1457                 struct dma_fence *fence;
1458                 uint64_t point;
1459
1460                 fence = drm_syncobj_fence_get(syncobjs[i]);
1461                 chain = to_dma_fence_chain(fence);
1462                 if (chain) {
1463                         struct dma_fence *iter, *last_signaled =
1464                                 dma_fence_get(fence);
1465
1466                         if (args->flags &
1467                             DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED) {
1468                                 point = fence->seqno;
1469                         } else {
1470                                 dma_fence_chain_for_each(iter, fence) {
1471                                         if (iter->context != fence->context) {
1472                                                 dma_fence_put(iter);
1473                                                 /* It is most likely that timeline has
1474                                                 * unorder points. */
1475                                                 break;
1476                                         }
1477                                         dma_fence_put(last_signaled);
1478                                         last_signaled = dma_fence_get(iter);
1479                                 }
1480                                 point = dma_fence_is_signaled(last_signaled) ?
1481                                         last_signaled->seqno :
1482                                         to_dma_fence_chain(last_signaled)->prev_seqno;
1483                         }
1484                         dma_fence_put(last_signaled);
1485                 } else {
1486                         point = 0;
1487                 }
1488                 dma_fence_put(fence);
1489                 ret = copy_to_user(&points[i], &point, sizeof(uint64_t));
1490                 ret = ret ? -EFAULT : 0;
1491                 if (ret)
1492                         break;
1493         }
1494         drm_syncobj_array_free(syncobjs, args->count_handles);
1495
1496         return ret;
1497 }