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 203struct 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 211static 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 */ 222struct 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} 238EXPORT_SYMBOL(drm_syncobj_find); 239 240static 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 265static 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 */ 285void 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} 312EXPORT_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 */ 321void 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} 345EXPORT_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 */ 353static 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 */ 378int 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 *fence = drm_syncobj_fence_get(syncobj); 391 392 if (*fence) { 393 ret = dma_fence_chain_find_seqno(fence, point); 394 if (!ret) { 395 /* If the requested seqno is already signaled 396 * drm_syncobj_find_fence may return a NULL 397 * fence. To make sure the recipient gets 398 * signalled, use a new fence instead. 399 */ 400 if (!*fence) 401 *fence = dma_fence_get_stub(); 402 403 goto out; 404 } 405 dma_fence_put(*fence); 406 } else { 407 ret = -EINVAL; 408 } 409 410 if (!(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT)) 411 goto out; 412 413 memset(&wait, 0, sizeof(wait)); 414 wait.task = current; 415 wait.point = point; 416 drm_syncobj_fence_add_wait(syncobj, &wait); 417 418 do { 419 set_current_state(TASK_INTERRUPTIBLE); 420 if (wait.fence) { 421 ret = 0; 422 break; 423 } 424 if (timeout == 0) { 425 ret = -ETIME; 426 break; 427 } 428 429 if (signal_pending(current)) { 430 ret = -ERESTARTSYS; 431 break; 432 } 433 434 timeout = schedule_timeout(timeout); 435 } while (1); 436 437 __set_current_state(TASK_RUNNING); 438 *fence = wait.fence; 439 440 if (wait.node.next) 441 drm_syncobj_remove_wait(syncobj, &wait); 442 443out: 444 drm_syncobj_put(syncobj); 445 446 return ret; 447} 448EXPORT_SYMBOL(drm_syncobj_find_fence); 449 450/** 451 * drm_syncobj_free - free a sync object. 452 * @kref: kref to free. 453 * 454 * Only to be called from kref_put in drm_syncobj_put. 455 */ 456void drm_syncobj_free(struct kref *kref) 457{ 458 struct drm_syncobj *syncobj = container_of(kref, 459 struct drm_syncobj, 460 refcount); 461 drm_syncobj_replace_fence(syncobj, NULL); 462 kfree(syncobj); 463} 464EXPORT_SYMBOL(drm_syncobj_free); 465 466/** 467 * drm_syncobj_create - create a new syncobj 468 * @out_syncobj: returned syncobj 469 * @flags: DRM_SYNCOBJ_* flags 470 * @fence: if non-NULL, the syncobj will represent this fence 471 * 472 * This is the first function to create a sync object. After creating, drivers 473 * probably want to make it available to userspace, either through 474 * drm_syncobj_get_handle() or drm_syncobj_get_fd(). 475 * 476 * Returns 0 on success or a negative error value on failure. 477 */ 478int drm_syncobj_create(struct drm_syncobj **out_syncobj, uint32_t flags, 479 struct dma_fence *fence) 480{ 481 struct drm_syncobj *syncobj; 482 483 syncobj = kzalloc(sizeof(struct drm_syncobj), GFP_KERNEL); 484 if (!syncobj) 485 return -ENOMEM; 486 487 kref_init(&syncobj->refcount); 488 INIT_LIST_HEAD(&syncobj->cb_list); 489 spin_lock_init(&syncobj->lock); 490 491 if (flags & DRM_SYNCOBJ_CREATE_SIGNALED) 492 drm_syncobj_assign_null_handle(syncobj); 493 494 if (fence) 495 drm_syncobj_replace_fence(syncobj, fence); 496 497 *out_syncobj = syncobj; 498 return 0; 499} 500EXPORT_SYMBOL(drm_syncobj_create); 501 502/** 503 * drm_syncobj_get_handle - get a handle from a syncobj 504 * @file_private: drm file private pointer 505 * @syncobj: Sync object to export 506 * @handle: out parameter with the new handle 507 * 508 * Exports a sync object created with drm_syncobj_create() as a handle on 509 * @file_private to userspace. 510 * 511 * Returns 0 on success or a negative error value on failure. 512 */ 513int drm_syncobj_get_handle(struct drm_file *file_private, 514 struct drm_syncobj *syncobj, u32 *handle) 515{ 516 int ret; 517 518 /* take a reference to put in the idr */ 519 drm_syncobj_get(syncobj); 520 521 idr_preload(GFP_KERNEL); 522 spin_lock(&file_private->syncobj_table_lock); 523 ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT); 524 spin_unlock(&file_private->syncobj_table_lock); 525 526 idr_preload_end(); 527 528 if (ret < 0) { 529 drm_syncobj_put(syncobj); 530 return ret; 531 } 532 533 *handle = ret; 534 return 0; 535} 536EXPORT_SYMBOL(drm_syncobj_get_handle); 537 538static int drm_syncobj_create_as_handle(struct drm_file *file_private, 539 u32 *handle, uint32_t flags) 540{ 541 int ret; 542 struct drm_syncobj *syncobj; 543 544 ret = drm_syncobj_create(&syncobj, flags, NULL); 545 if (ret) 546 return ret; 547 548 ret = drm_syncobj_get_handle(file_private, syncobj, handle); 549 drm_syncobj_put(syncobj); 550 return ret; 551} 552 553static int drm_syncobj_destroy(struct drm_file *file_private, 554 u32 handle) 555{ 556 struct drm_syncobj *syncobj; 557 558 spin_lock(&file_private->syncobj_table_lock); 559 syncobj = idr_remove(&file_private->syncobj_idr, handle); 560 spin_unlock(&file_private->syncobj_table_lock); 561 562 if (!syncobj) 563 return -EINVAL; 564 565 drm_syncobj_put(syncobj); 566 return 0; 567} 568 569static int drm_syncobj_file_release(struct inode *inode, struct file *file) 570{ 571 struct drm_syncobj *syncobj = file->private_data; 572 573 drm_syncobj_put(syncobj); 574 return 0; 575} 576 577static const struct file_operations drm_syncobj_file_fops = { 578 .release = drm_syncobj_file_release, 579}; 580 581/** 582 * drm_syncobj_get_fd - get a file descriptor from a syncobj 583 * @syncobj: Sync object to export 584 * @p_fd: out parameter with the new file descriptor 585 * 586 * Exports a sync object created with drm_syncobj_create() as a file descriptor. 587 * 588 * Returns 0 on success or a negative error value on failure. 589 */ 590int drm_syncobj_get_fd(struct drm_syncobj *syncobj, int *p_fd) 591{ 592 struct file *file; 593 int fd; 594 595 fd = get_unused_fd_flags(O_CLOEXEC); 596 if (fd < 0) 597 return fd; 598 599 file = anon_inode_getfile("syncobj_file", 600 &drm_syncobj_file_fops, 601 syncobj, 0); 602 if (IS_ERR(file)) { 603 put_unused_fd(fd); 604 return PTR_ERR(file); 605 } 606 607 drm_syncobj_get(syncobj); 608 fd_install(fd, file); 609 610 *p_fd = fd; 611 return 0; 612} 613EXPORT_SYMBOL(drm_syncobj_get_fd); 614 615static int drm_syncobj_handle_to_fd(struct drm_file *file_private, 616 u32 handle, int *p_fd) 617{ 618 struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle); 619 int ret; 620 621 if (!syncobj) 622 return -EINVAL; 623 624 ret = drm_syncobj_get_fd(syncobj, p_fd); 625 drm_syncobj_put(syncobj); 626 return ret; 627} 628 629static int drm_syncobj_fd_to_handle(struct drm_file *file_private, 630 int fd, u32 *handle) 631{ 632 struct drm_syncobj *syncobj; 633 struct fd f = fdget(fd); 634 int ret; 635 636 if (!f.file) 637 return -EINVAL; 638 639 if (f.file->f_op != &drm_syncobj_file_fops) { 640 fdput(f); 641 return -EINVAL; 642 } 643 644 /* take a reference to put in the idr */ 645 syncobj = f.file->private_data; 646 drm_syncobj_get(syncobj); 647 648 idr_preload(GFP_KERNEL); 649 spin_lock(&file_private->syncobj_table_lock); 650 ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT); 651 spin_unlock(&file_private->syncobj_table_lock); 652 idr_preload_end(); 653 654 if (ret > 0) { 655 *handle = ret; 656 ret = 0; 657 } else 658 drm_syncobj_put(syncobj); 659 660 fdput(f); 661 return ret; 662} 663 664static int drm_syncobj_import_sync_file_fence(struct drm_file *file_private, 665 int fd, int handle) 666{ 667 struct dma_fence *fence = sync_file_get_fence(fd); 668 struct drm_syncobj *syncobj; 669 670 if (!fence) 671 return -EINVAL; 672 673 syncobj = drm_syncobj_find(file_private, handle); 674 if (!syncobj) { 675 dma_fence_put(fence); 676 return -ENOENT; 677 } 678 679 drm_syncobj_replace_fence(syncobj, fence); 680 dma_fence_put(fence); 681 drm_syncobj_put(syncobj); 682 return 0; 683} 684 685static int drm_syncobj_export_sync_file(struct drm_file *file_private, 686 int handle, int *p_fd) 687{ 688 int ret; 689 struct dma_fence *fence; 690 struct sync_file *sync_file; 691 int fd = get_unused_fd_flags(O_CLOEXEC); 692 693 if (fd < 0) 694 return fd; 695 696 ret = drm_syncobj_find_fence(file_private, handle, 0, 0, &fence); 697 if (ret) 698 goto err_put_fd; 699 700 sync_file = sync_file_create(fence); 701 702 dma_fence_put(fence); 703 704 if (!sync_file) { 705 ret = -EINVAL; 706 goto err_put_fd; 707 } 708 709 fd_install(fd, sync_file->file); 710 711 *p_fd = fd; 712 return 0; 713err_put_fd: 714 put_unused_fd(fd); 715 return ret; 716} 717/** 718 * drm_syncobj_open - initalizes syncobj file-private structures at devnode open time 719 * @file_private: drm file-private structure to set up 720 * 721 * Called at device open time, sets up the structure for handling refcounting 722 * of sync objects. 723 */ 724void 725drm_syncobj_open(struct drm_file *file_private) 726{ 727 idr_init_base(&file_private->syncobj_idr, 1); 728 spin_lock_init(&file_private->syncobj_table_lock); 729} 730 731static int 732drm_syncobj_release_handle(int id, void *ptr, void *data) 733{ 734 struct drm_syncobj *syncobj = ptr; 735 736 drm_syncobj_put(syncobj); 737 return 0; 738} 739 740/** 741 * drm_syncobj_release - release file-private sync object resources 742 * @file_private: drm file-private structure to clean up 743 * 744 * Called at close time when the filp is going away. 745 * 746 * Releases any remaining references on objects by this filp. 747 */ 748void 749drm_syncobj_release(struct drm_file *file_private) 750{ 751 idr_for_each(&file_private->syncobj_idr, 752 &drm_syncobj_release_handle, file_private); 753 idr_destroy(&file_private->syncobj_idr); 754} 755 756int 757drm_syncobj_create_ioctl(struct drm_device *dev, void *data, 758 struct drm_file *file_private) 759{ 760 struct drm_syncobj_create *args = data; 761 762 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 763 return -EOPNOTSUPP; 764 765 /* no valid flags yet */ 766 if (args->flags & ~DRM_SYNCOBJ_CREATE_SIGNALED) 767 return -EINVAL; 768 769 return drm_syncobj_create_as_handle(file_private, 770 &args->handle, args->flags); 771} 772 773int 774drm_syncobj_destroy_ioctl(struct drm_device *dev, void *data, 775 struct drm_file *file_private) 776{ 777 struct drm_syncobj_destroy *args = data; 778 779 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 780 return -EOPNOTSUPP; 781 782 /* make sure padding is empty */ 783 if (args->pad) 784 return -EINVAL; 785 return drm_syncobj_destroy(file_private, args->handle); 786} 787 788int 789drm_syncobj_handle_to_fd_ioctl(struct drm_device *dev, void *data, 790 struct drm_file *file_private) 791{ 792 struct drm_syncobj_handle *args = data; 793 794 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 795 return -EOPNOTSUPP; 796 797 if (args->pad) 798 return -EINVAL; 799 800 if (args->flags != 0 && 801 args->flags != DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE) 802 return -EINVAL; 803 804 if (args->flags & DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE) 805 return drm_syncobj_export_sync_file(file_private, args->handle, 806 &args->fd); 807 808 return drm_syncobj_handle_to_fd(file_private, args->handle, 809 &args->fd); 810} 811 812int 813drm_syncobj_fd_to_handle_ioctl(struct drm_device *dev, void *data, 814 struct drm_file *file_private) 815{ 816 struct drm_syncobj_handle *args = data; 817 818 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 819 return -EOPNOTSUPP; 820 821 if (args->pad) 822 return -EINVAL; 823 824 if (args->flags != 0 && 825 args->flags != DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE) 826 return -EINVAL; 827 828 if (args->flags & DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE) 829 return drm_syncobj_import_sync_file_fence(file_private, 830 args->fd, 831 args->handle); 832 833 return drm_syncobj_fd_to_handle(file_private, args->fd, 834 &args->handle); 835} 836 837static int drm_syncobj_transfer_to_timeline(struct drm_file *file_private, 838 struct drm_syncobj_transfer *args) 839{ 840 struct drm_syncobj *timeline_syncobj = NULL; 841 struct dma_fence *fence; 842 struct dma_fence_chain *chain; 843 int ret; 844 845 timeline_syncobj = drm_syncobj_find(file_private, args->dst_handle); 846 if (!timeline_syncobj) { 847 return -ENOENT; 848 } 849 ret = drm_syncobj_find_fence(file_private, args->src_handle, 850 args->src_point, args->flags, 851 &fence); 852 if (ret) 853 goto err; 854 chain = kzalloc(sizeof(struct dma_fence_chain), GFP_KERNEL); 855 if (!chain) { 856 ret = -ENOMEM; 857 goto err1; 858 } 859 drm_syncobj_add_point(timeline_syncobj, chain, fence, args->dst_point); 860err1: 861 dma_fence_put(fence); 862err: 863 drm_syncobj_put(timeline_syncobj); 864 865 return ret; 866} 867 868static int 869drm_syncobj_transfer_to_binary(struct drm_file *file_private, 870 struct drm_syncobj_transfer *args) 871{ 872 struct drm_syncobj *binary_syncobj = NULL; 873 struct dma_fence *fence; 874 int ret; 875 876 binary_syncobj = drm_syncobj_find(file_private, args->dst_handle); 877 if (!binary_syncobj) 878 return -ENOENT; 879 ret = drm_syncobj_find_fence(file_private, args->src_handle, 880 args->src_point, args->flags, &fence); 881 if (ret) 882 goto err; 883 drm_syncobj_replace_fence(binary_syncobj, fence); 884 dma_fence_put(fence); 885err: 886 drm_syncobj_put(binary_syncobj); 887 888 return ret; 889} 890int 891drm_syncobj_transfer_ioctl(struct drm_device *dev, void *data, 892 struct drm_file *file_private) 893{ 894 struct drm_syncobj_transfer *args = data; 895 int ret; 896 897 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE)) 898 return -EOPNOTSUPP; 899 900 if (args->pad) 901 return -EINVAL; 902 903 if (args->dst_point) 904 ret = drm_syncobj_transfer_to_timeline(file_private, args); 905 else 906 ret = drm_syncobj_transfer_to_binary(file_private, args); 907 908 return ret; 909} 910 911static void syncobj_wait_fence_func(struct dma_fence *fence, 912 struct dma_fence_cb *cb) 913{ 914 struct syncobj_wait_entry *wait = 915 container_of(cb, struct syncobj_wait_entry, fence_cb); 916 917 wake_up_process(wait->task); 918} 919 920static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj, 921 struct syncobj_wait_entry *wait) 922{ 923 struct dma_fence *fence; 924 925 /* This happens inside the syncobj lock */ 926 fence = rcu_dereference_protected(syncobj->fence, 927 lockdep_is_held(&syncobj->lock)); 928 dma_fence_get(fence); 929 if (!fence || dma_fence_chain_find_seqno(&fence, wait->point)) { 930 dma_fence_put(fence); 931 return; 932 } else if (!fence) { 933 wait->fence = dma_fence_get_stub(); 934 } else { 935 wait->fence = fence; 936 } 937 938 wake_up_process(wait->task); 939 list_del_init(&wait->node); 940} 941 942static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs, 943 void __user *user_points, 944 uint32_t count, 945 uint32_t flags, 946 signed long timeout, 947 uint32_t *idx) 948{ 949 struct syncobj_wait_entry *entries; 950 struct dma_fence *fence; 951 uint64_t *points; 952 uint32_t signaled_count, i; 953 954 points = kmalloc_array(count, sizeof(*points), GFP_KERNEL); 955 if (points == NULL) 956 return -ENOMEM; 957 958 if (!user_points) { 959 memset(points, 0, count * sizeof(uint64_t)); 960 961 } else if (copy_from_user(points, user_points, 962 sizeof(uint64_t) * count)) { 963 timeout = -EFAULT; 964 goto err_free_points; 965 } 966 967 entries = kcalloc(count, sizeof(*entries), GFP_KERNEL); 968 if (!entries) { 969 timeout = -ENOMEM; 970 goto err_free_points; 971 } 972 /* Walk the list of sync objects and initialize entries. We do 973 * this up-front so that we can properly return -EINVAL if there is 974 * a syncobj with a missing fence and then never have the chance of 975 * returning -EINVAL again. 976 */ 977 signaled_count = 0; 978 for (i = 0; i < count; ++i) { 979 struct dma_fence *fence; 980 981 entries[i].task = current; 982 entries[i].point = points[i]; 983 fence = drm_syncobj_fence_get(syncobjs[i]); 984 if (!fence || dma_fence_chain_find_seqno(&fence, points[i])) { 985 dma_fence_put(fence); 986 if (flags & (DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT | 987 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)) { 988 continue; 989 } else { 990 timeout = -EINVAL; 991 goto cleanup_entries; 992 } 993 } 994 995 if (fence) 996 entries[i].fence = fence; 997 else 998 entries[i].fence = dma_fence_get_stub(); 999 1000 if ((flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) || 1001 dma_fence_is_signaled(entries[i].fence)) { 1002 if (signaled_count == 0 && idx) 1003 *idx = i; 1004 signaled_count++; 1005 } 1006 } 1007 1008 if (signaled_count == count || 1009 (signaled_count > 0 && 1010 !(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL))) 1011 goto cleanup_entries; 1012 1013 /* There's a very annoying laxness in the dma_fence API here, in 1014 * that backends are not required to automatically report when a 1015 * fence is signaled prior to fence->ops->enable_signaling() being 1016 * called. So here if we fail to match signaled_count, we need to 1017 * fallthough and try a 0 timeout wait! 1018 */ 1019 1020 if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) { 1021 for (i = 0; i < count; ++i) 1022 drm_syncobj_fence_add_wait(syncobjs[i], &entries[i]); 1023 } 1024 1025 do { 1026 set_current_state(TASK_INTERRUPTIBLE); 1027 1028 signaled_count = 0; 1029 for (i = 0; i < count; ++i) { 1030 fence = entries[i].fence; 1031 if (!fence) 1032 continue; 1033 1034 if ((flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE) || 1035 dma_fence_is_signaled(fence) || 1036 (!entries[i].fence_cb.func && 1037 dma_fence_add_callback(fence, 1038 &entries[i].fence_cb, 1039 syncobj_wait_fence_func))) { 1040 /* The fence has been signaled */ 1041 if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL) { 1042 signaled_count++; 1043 } else { 1044 if (idx) 1045 *idx = i; 1046 goto done_waiting; 1047 } 1048 } 1049 } 1050 1051 if (signaled_count == count) 1052 goto done_waiting; 1053 1054 if (timeout == 0) { 1055 timeout = -ETIME; 1056 goto done_waiting; 1057 } 1058 1059 if (signal_pending(current)) { 1060 timeout = -ERESTARTSYS; 1061 goto done_waiting; 1062 } 1063 1064 timeout = schedule_timeout(timeout); 1065 } while (1); 1066 1067done_waiting: 1068 __set_current_state(TASK_RUNNING); 1069 1070cleanup_entries: 1071 for (i = 0; i < count; ++i) { 1072 drm_syncobj_remove_wait(syncobjs[i], &entries[i]); 1073 if (entries[i].fence_cb.func) 1074 dma_fence_remove_callback(entries[i].fence, 1075 &entries[i].fence_cb); 1076 dma_fence_put(entries[i].fence); 1077 } 1078 kfree(entries); 1079 1080err_free_points: 1081 kfree(points); 1082 1083 return timeout; 1084} 1085 1086/** 1087 * drm_timeout_abs_to_jiffies - calculate jiffies timeout from absolute value 1088 * 1089 * @timeout_nsec: timeout nsec component in ns, 0 for poll 1090 * 1091 * Calculate the timeout in jiffies from an absolute time in sec/nsec. 1092 */ 1093signed long drm_timeout_abs_to_jiffies(int64_t timeout_nsec) 1094{ 1095 ktime_t abs_timeout, now; 1096 u64 timeout_ns, timeout_jiffies64; 1097 1098 /* make 0 timeout means poll - absolute 0 doesn't seem valid */ 1099 if (timeout_nsec == 0) 1100 return 0; 1101 1102 abs_timeout = ns_to_ktime(timeout_nsec); 1103 now = ktime_get(); 1104 1105 if (!ktime_after(abs_timeout, now)) 1106 return 0; 1107 1108 timeout_ns = ktime_to_ns(ktime_sub(abs_timeout, now)); 1109 1110 timeout_jiffies64 = nsecs_to_jiffies64(timeout_ns); 1111 /* clamp timeout to avoid infinite timeout */ 1112 if (timeout_jiffies64 >= MAX_SCHEDULE_TIMEOUT - 1) 1113 return MAX_SCHEDULE_TIMEOUT - 1; 1114 1115 return timeout_jiffies64 + 1; 1116} 1117EXPORT_SYMBOL(drm_timeout_abs_to_jiffies); 1118 1119static int drm_syncobj_array_wait(struct drm_device *dev, 1120 struct drm_file *file_private, 1121 struct drm_syncobj_wait *wait, 1122 struct drm_syncobj_timeline_wait *timeline_wait, 1123 struct drm_syncobj **syncobjs, bool timeline) 1124{ 1125 signed long timeout = 0; 1126 uint32_t first = ~0; 1127 1128 if (!timeline) { 1129 timeout = drm_timeout_abs_to_jiffies(wait->timeout_nsec); 1130 timeout = drm_syncobj_array_wait_timeout(syncobjs, 1131 NULL, 1132 wait->count_handles, 1133 wait->flags, 1134 timeout, &first); 1135 if (timeout < 0) 1136 return timeout; 1137 wait->first_signaled = first; 1138 } else { 1139 timeout = drm_timeout_abs_to_jiffies(timeline_wait->timeout_nsec); 1140 timeout = drm_syncobj_array_wait_timeout(syncobjs, 1141 u64_to_user_ptr(timeline_wait->points), 1142 timeline_wait->count_handles, 1143 timeline_wait->flags, 1144 timeout, &first); 1145 if (timeout < 0) 1146 return timeout; 1147 timeline_wait->first_signaled = first; 1148 } 1149 return 0; 1150} 1151 1152static int drm_syncobj_array_find(struct drm_file *file_private, 1153 void __user *user_handles, 1154 uint32_t count_handles, 1155 struct drm_syncobj ***syncobjs_out) 1156{ 1157 uint32_t i, *handles; 1158 struct drm_syncobj **syncobjs; 1159 int ret; 1160 1161 handles = kmalloc_array(count_handles, sizeof(*handles), GFP_KERNEL); 1162 if (handles == NULL) 1163 return -ENOMEM; 1164 1165 if (copy_from_user(handles, user_handles, 1166 sizeof(uint32_t) * count_handles)) { 1167 ret = -EFAULT; 1168 goto err_free_handles; 1169 } 1170 1171 syncobjs = kmalloc_array(count_handles, sizeof(*syncobjs), GFP_KERNEL); 1172 if (syncobjs == NULL) { 1173 ret = -ENOMEM; 1174 goto err_free_handles; 1175 } 1176 1177 for (i = 0; i < count_handles; i++) { 1178 syncobjs[i] = drm_syncobj_find(file_private, handles[i]); 1179 if (!syncobjs[i]) { 1180 ret = -ENOENT; 1181 goto err_put_syncobjs; 1182 } 1183 } 1184 1185 kfree(handles); 1186 *syncobjs_out = syncobjs; 1187 return 0; 1188 1189err_put_syncobjs: 1190 while (i-- > 0) 1191 drm_syncobj_put(syncobjs[i]); 1192 kfree(syncobjs); 1193err_free_handles: 1194 kfree(handles); 1195 1196 return ret; 1197} 1198 1199static void drm_syncobj_array_free(struct drm_syncobj **syncobjs, 1200 uint32_t count) 1201{ 1202 uint32_t i; 1203 1204 for (i = 0; i < count; i++) 1205 drm_syncobj_put(syncobjs[i]); 1206 kfree(syncobjs); 1207} 1208 1209int 1210drm_syncobj_wait_ioctl(struct drm_device *dev, void *data, 1211 struct drm_file *file_private) 1212{ 1213 struct drm_syncobj_wait *args = data; 1214 struct drm_syncobj **syncobjs; 1215 int ret = 0; 1216 1217 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 1218 return -EOPNOTSUPP; 1219 1220 if (args->flags & ~(DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL | 1221 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT)) 1222 return -EINVAL; 1223 1224 if (args->count_handles == 0) 1225 return -EINVAL; 1226 1227 ret = drm_syncobj_array_find(file_private, 1228 u64_to_user_ptr(args->handles), 1229 args->count_handles, 1230 &syncobjs); 1231 if (ret < 0) 1232 return ret; 1233 1234 ret = drm_syncobj_array_wait(dev, file_private, 1235 args, NULL, syncobjs, false); 1236 1237 drm_syncobj_array_free(syncobjs, args->count_handles); 1238 1239 return ret; 1240} 1241 1242int 1243drm_syncobj_timeline_wait_ioctl(struct drm_device *dev, void *data, 1244 struct drm_file *file_private) 1245{ 1246 struct drm_syncobj_timeline_wait *args = data; 1247 struct drm_syncobj **syncobjs; 1248 int ret = 0; 1249 1250 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE)) 1251 return -EOPNOTSUPP; 1252 1253 if (args->flags & ~(DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL | 1254 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT | 1255 DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE)) 1256 return -EINVAL; 1257 1258 if (args->count_handles == 0) 1259 return -EINVAL; 1260 1261 ret = drm_syncobj_array_find(file_private, 1262 u64_to_user_ptr(args->handles), 1263 args->count_handles, 1264 &syncobjs); 1265 if (ret < 0) 1266 return ret; 1267 1268 ret = drm_syncobj_array_wait(dev, file_private, 1269 NULL, args, syncobjs, true); 1270 1271 drm_syncobj_array_free(syncobjs, args->count_handles); 1272 1273 return ret; 1274} 1275 1276 1277int 1278drm_syncobj_reset_ioctl(struct drm_device *dev, void *data, 1279 struct drm_file *file_private) 1280{ 1281 struct drm_syncobj_array *args = data; 1282 struct drm_syncobj **syncobjs; 1283 uint32_t i; 1284 int ret; 1285 1286 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 1287 return -EOPNOTSUPP; 1288 1289 if (args->pad != 0) 1290 return -EINVAL; 1291 1292 if (args->count_handles == 0) 1293 return -EINVAL; 1294 1295 ret = drm_syncobj_array_find(file_private, 1296 u64_to_user_ptr(args->handles), 1297 args->count_handles, 1298 &syncobjs); 1299 if (ret < 0) 1300 return ret; 1301 1302 for (i = 0; i < args->count_handles; i++) 1303 drm_syncobj_replace_fence(syncobjs[i], NULL); 1304 1305 drm_syncobj_array_free(syncobjs, args->count_handles); 1306 1307 return 0; 1308} 1309 1310int 1311drm_syncobj_signal_ioctl(struct drm_device *dev, void *data, 1312 struct drm_file *file_private) 1313{ 1314 struct drm_syncobj_array *args = data; 1315 struct drm_syncobj **syncobjs; 1316 uint32_t i; 1317 int ret; 1318 1319 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) 1320 return -EOPNOTSUPP; 1321 1322 if (args->pad != 0) 1323 return -EINVAL; 1324 1325 if (args->count_handles == 0) 1326 return -EINVAL; 1327 1328 ret = drm_syncobj_array_find(file_private, 1329 u64_to_user_ptr(args->handles), 1330 args->count_handles, 1331 &syncobjs); 1332 if (ret < 0) 1333 return ret; 1334 1335 for (i = 0; i < args->count_handles; i++) 1336 drm_syncobj_assign_null_handle(syncobjs[i]); 1337 1338 drm_syncobj_array_free(syncobjs, args->count_handles); 1339 1340 return ret; 1341} 1342 1343int 1344drm_syncobj_timeline_signal_ioctl(struct drm_device *dev, void *data, 1345 struct drm_file *file_private) 1346{ 1347 struct drm_syncobj_timeline_array *args = data; 1348 struct drm_syncobj **syncobjs; 1349 struct dma_fence_chain **chains; 1350 uint64_t *points; 1351 uint32_t i, j; 1352 int ret; 1353 1354 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE)) 1355 return -EOPNOTSUPP; 1356 1357 if (args->flags != 0) 1358 return -EINVAL; 1359 1360 if (args->count_handles == 0) 1361 return -EINVAL; 1362 1363 ret = drm_syncobj_array_find(file_private, 1364 u64_to_user_ptr(args->handles), 1365 args->count_handles, 1366 &syncobjs); 1367 if (ret < 0) 1368 return ret; 1369 1370 points = kmalloc_array(args->count_handles, sizeof(*points), 1371 GFP_KERNEL); 1372 if (!points) { 1373 ret = -ENOMEM; 1374 goto out; 1375 } 1376 if (!u64_to_user_ptr(args->points)) { 1377 memset(points, 0, args->count_handles * sizeof(uint64_t)); 1378 } else if (copy_from_user(points, u64_to_user_ptr(args->points), 1379 sizeof(uint64_t) * args->count_handles)) { 1380 ret = -EFAULT; 1381 goto err_points; 1382 } 1383 1384 chains = kmalloc_array(args->count_handles, sizeof(void *), GFP_KERNEL); 1385 if (!chains) { 1386 ret = -ENOMEM; 1387 goto err_points; 1388 } 1389 for (i = 0; i < args->count_handles; i++) { 1390 chains[i] = kzalloc(sizeof(struct dma_fence_chain), GFP_KERNEL); 1391 if (!chains[i]) { 1392 for (j = 0; j < i; j++) 1393 kfree(chains[j]); 1394 ret = -ENOMEM; 1395 goto err_chains; 1396 } 1397 } 1398 1399 for (i = 0; i < args->count_handles; i++) { 1400 struct dma_fence *fence = dma_fence_get_stub(); 1401 1402 drm_syncobj_add_point(syncobjs[i], chains[i], 1403 fence, points[i]); 1404 dma_fence_put(fence); 1405 } 1406err_chains: 1407 kfree(chains); 1408err_points: 1409 kfree(points); 1410out: 1411 drm_syncobj_array_free(syncobjs, args->count_handles); 1412 1413 return ret; 1414} 1415 1416int drm_syncobj_query_ioctl(struct drm_device *dev, void *data, 1417 struct drm_file *file_private) 1418{ 1419 struct drm_syncobj_timeline_array *args = data; 1420 struct drm_syncobj **syncobjs; 1421 uint64_t __user *points = u64_to_user_ptr(args->points); 1422 uint32_t i; 1423 int ret; 1424 1425 if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ_TIMELINE)) 1426 return -EOPNOTSUPP; 1427 1428 if (args->flags & ~DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED) 1429 return -EINVAL; 1430 1431 if (args->count_handles == 0) 1432 return -EINVAL; 1433 1434 ret = drm_syncobj_array_find(file_private, 1435 u64_to_user_ptr(args->handles), 1436 args->count_handles, 1437 &syncobjs); 1438 if (ret < 0) 1439 return ret; 1440 1441 for (i = 0; i < args->count_handles; i++) { 1442 struct dma_fence_chain *chain; 1443 struct dma_fence *fence; 1444 uint64_t point; 1445 1446 fence = drm_syncobj_fence_get(syncobjs[i]); 1447 chain = to_dma_fence_chain(fence); 1448 if (chain) { 1449 struct dma_fence *iter, *last_signaled = 1450 dma_fence_get(fence); 1451 1452 if (args->flags & 1453 DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED) { 1454 point = fence->seqno; 1455 } else { 1456 dma_fence_chain_for_each(iter, fence) { 1457 if (iter->context != fence->context) { 1458 dma_fence_put(iter); 1459 /* It is most likely that timeline has 1460 * unorder points. */ 1461 break; 1462 } 1463 dma_fence_put(last_signaled); 1464 last_signaled = dma_fence_get(iter); 1465 } 1466 point = dma_fence_is_signaled(last_signaled) ? 1467 last_signaled->seqno : 1468 to_dma_fence_chain(last_signaled)->prev_seqno; 1469 } 1470 dma_fence_put(last_signaled); 1471 } else { 1472 point = 0; 1473 } 1474 dma_fence_put(fence); 1475 ret = copy_to_user(&points[i], &point, sizeof(uint64_t)); 1476 ret = ret ? -EFAULT : 0; 1477 if (ret) 1478 break; 1479 } 1480 drm_syncobj_array_free(syncobjs, args->count_handles); 1481 1482 return ret; 1483} 1484