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) are a persistent objects,
  33  * that contain an optional fence. The fence can be updated with a new
  34  * fence, or be NULL.
  35  *
  36  * syncobj's can be waited upon, where it will wait for the underlying
  37  * fence.
  38  *
  39  * syncobj's can be export to fd's and back, these fd's are opaque and
  40  * have no other use case, except passing the syncobj between processes.
  41  *
  42  * Their primary use-case is to implement Vulkan fences and semaphores.
  43  *
  44  * syncobj have a kref reference count, but also have an optional file.
  45  * The file is only created once the syncobj is exported.
  46  * The file takes a reference on the kref.
  47  */
  48
  49 #include <drm/drmP.h>
  50 #include <linux/file.h>
  51 #include <linux/fs.h>
  52 #include <linux/anon_inodes.h>
  53 #include <linux/sync_file.h>
  54 #include <linux/sched/signal.h>
  55
  56 #include "drm_internal.h"
  57 #include <drm/drm_syncobj.h>
  58
  59 /**
  60  * drm_syncobj_find - lookup and reference a sync object.
  61  * @file_private: drm file private pointer
  62  * @handle: sync object handle to lookup.
  63  *
  64  * Returns a reference to the syncobj pointed to by handle or NULL.
  65  */
  66 struct drm_syncobj *drm_syncobj_find(struct drm_file *file_private,
  67                                      u32 handle)
  68 {
  69         struct drm_syncobj *syncobj;
  70
  71         spin_lock(&file_private->syncobj_table_lock);
  72
  73         /* Check if we currently have a reference on the object */
  74         syncobj = idr_find(&file_private->syncobj_idr, handle);
  75         if (syncobj)
  76                 drm_syncobj_get(syncobj);
  77
  78         spin_unlock(&file_private->syncobj_table_lock);
  79
  80         return syncobj;
  81 }
  82 EXPORT_SYMBOL(drm_syncobj_find);
  83
  84 static void drm_syncobj_add_callback_locked(struct drm_syncobj *syncobj,
  85                                             struct drm_syncobj_cb *cb,
  86                                             drm_syncobj_func_t func)
  87 {
  88         cb->func = func;
  89         list_add_tail(&cb->node, &syncobj->cb_list);
  90 }
  91
  92 static int drm_syncobj_fence_get_or_add_callback(struct drm_syncobj *syncobj,
  93                                                  struct dma_fence **fence,
  94                                                  struct drm_syncobj_cb *cb,
  95                                                  drm_syncobj_func_t func)
  96 {
  97         int ret;
  98
  99         WARN_ON(*fence);
 100
 101         *fence = drm_syncobj_fence_get(syncobj);
 102         if (*fence)
 103                 return 1;
 104
 105         spin_lock(&syncobj->lock);
 106         /* We've already tried once to get a fence and failed.  Now that we
 107          * have the lock, try one more time just to be sure we don't add a
 108          * callback when a fence has already been set.
 109          */
 110         if (syncobj->fence) {
 111                 *fence = dma_fence_get(syncobj->fence);
 112                 ret = 1;
 113         } else {
 114                 *fence = NULL;
 115                 drm_syncobj_add_callback_locked(syncobj, cb, func);
 116                 ret = 0;
 117         }
 118         spin_unlock(&syncobj->lock);
 119
 120         return ret;
 121 }
 122
 123 /**
 124  * drm_syncobj_add_callback - adds a callback to syncobj::cb_list
 125  * @syncobj: Sync object to which to add the callback
 126  * @cb: Callback to add
 127  * @func: Func to use when initializing the drm_syncobj_cb struct
 128  *
 129  * This adds a callback to be called next time the fence is replaced
 130  */
 131 void drm_syncobj_add_callback(struct drm_syncobj *syncobj,
 132                               struct drm_syncobj_cb *cb,
 133                               drm_syncobj_func_t func)
 134 {
 135         spin_lock(&syncobj->lock);
 136         drm_syncobj_add_callback_locked(syncobj, cb, func);
 137         spin_unlock(&syncobj->lock);
 138 }
 139 EXPORT_SYMBOL(drm_syncobj_add_callback);
 140
 141 /**
 142  * drm_syncobj_add_callback - removes a callback to syncobj::cb_list
 143  * @syncobj: Sync object from which to remove the callback
 144  * @cb: Callback to remove
 145  */
 146 void drm_syncobj_remove_callback(struct drm_syncobj *syncobj,
 147                                  struct drm_syncobj_cb *cb)
 148 {
 149         spin_lock(&syncobj->lock);
 150         list_del_init(&cb->node);
 151         spin_unlock(&syncobj->lock);
 152 }
 153 EXPORT_SYMBOL(drm_syncobj_remove_callback);
 154
 155 /**
 156  * drm_syncobj_replace_fence - replace fence in a sync object.
 157  * @syncobj: Sync object to replace fence in
 158  * @fence: fence to install in sync file.
 159  *
 160  * This replaces the fence on a sync object.
 161  */
 162 void drm_syncobj_replace_fence(struct drm_syncobj *syncobj,
 163                                struct dma_fence *fence)
 164 {
 165         struct dma_fence *old_fence;
 166         struct drm_syncobj_cb *cur, *tmp;
 167
 168         if (fence)
 169                 dma_fence_get(fence);
 170
 171         spin_lock(&syncobj->lock);
 172
 173         old_fence = syncobj->fence;
 174         syncobj->fence = fence;
 175
 176         if (fence != old_fence) {
 177                 list_for_each_entry_safe(cur, tmp, &syncobj->cb_list, node) {
 178                         list_del_init(&cur->node);
 179                         cur->func(syncobj, cur);
 180                 }
 181         }
 182
 183         spin_unlock(&syncobj->lock);
 184
 185         dma_fence_put(old_fence);
 186 }
 187 EXPORT_SYMBOL(drm_syncobj_replace_fence);
 188
 189 struct drm_syncobj_null_fence {
 190         struct dma_fence base;
 191         spinlock_t lock;
 192 };
 193
 194 static const char *drm_syncobj_null_fence_get_name(struct dma_fence *fence)
 195 {
 196         return "syncobjnull";
 197 }
 198
 199 static bool drm_syncobj_null_fence_enable_signaling(struct dma_fence *fence)
 200 {
 201     dma_fence_enable_sw_signaling(fence);
 202     return !dma_fence_is_signaled(fence);
 203 }
 204
 205 static const struct dma_fence_ops drm_syncobj_null_fence_ops = {
 206         .get_driver_name = drm_syncobj_null_fence_get_name,
 207         .get_timeline_name = drm_syncobj_null_fence_get_name,
 208         .enable_signaling = drm_syncobj_null_fence_enable_signaling,
 209         .wait = dma_fence_default_wait,
 210         .release = NULL,
 211 };
 212
 213 static int drm_syncobj_assign_null_handle(struct drm_syncobj *syncobj)
 214 {
 215         struct drm_syncobj_null_fence *fence;
 216         fence = kzalloc(sizeof(*fence), GFP_KERNEL);
 217         if (fence == NULL)
 218                 return -ENOMEM;
 219
 220         spin_lock_init(&fence->lock);
 221         dma_fence_init(&fence->base, &drm_syncobj_null_fence_ops,
 222                        &fence->lock, 0, 0);
 223         dma_fence_signal(&fence->base);
 224
 225         drm_syncobj_replace_fence(syncobj, &fence->base);
 226
 227         dma_fence_put(&fence->base);
 228
 229         return 0;
 230 }
 231
 232 int drm_syncobj_find_fence(struct drm_file *file_private,
 233                            u32 handle,
 234                            struct dma_fence **fence)
 235 {
 236         struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
 237         int ret = 0;
 238
 239         if (!syncobj)
 240                 return -ENOENT;
 241
 242         *fence = drm_syncobj_fence_get(syncobj);
 243         if (!*fence) {
 244                 ret = -EINVAL;
 245         }
 246         drm_syncobj_put(syncobj);
 247         return ret;
 248 }
 249 EXPORT_SYMBOL(drm_syncobj_find_fence);
 250
 251 /**
 252  * drm_syncobj_free - free a sync object.
 253  * @kref: kref to free.
 254  *
 255  * Only to be called from kref_put in drm_syncobj_put.
 256  */
 257 void drm_syncobj_free(struct kref *kref)
 258 {
 259         struct drm_syncobj *syncobj = container_of(kref,
 260                                                    struct drm_syncobj,
 261                                                    refcount);
 262         drm_syncobj_replace_fence(syncobj, NULL);
 263         kfree(syncobj);
 264 }
 265 EXPORT_SYMBOL(drm_syncobj_free);
 266
 267 static int drm_syncobj_create(struct drm_file *file_private,
 268                               u32 *handle, uint32_t flags)
 269 {
 270         int ret;
 271         struct drm_syncobj *syncobj;
 272
 273         syncobj = kzalloc(sizeof(struct drm_syncobj), GFP_KERNEL);
 274         if (!syncobj)
 275                 return -ENOMEM;
 276
 277         kref_init(&syncobj->refcount);
 278         INIT_LIST_HEAD(&syncobj->cb_list);
 279         spin_lock_init(&syncobj->lock);
 280
 281         if (flags & DRM_SYNCOBJ_CREATE_SIGNALED) {
 282                 ret = drm_syncobj_assign_null_handle(syncobj);
 283                 if (ret < 0) {
 284                         drm_syncobj_put(syncobj);
 285                         return ret;
 286                 }
 287         }
 288
 289         idr_preload(GFP_KERNEL);
 290         spin_lock(&file_private->syncobj_table_lock);
 291         ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
 292         spin_unlock(&file_private->syncobj_table_lock);
 293
 294         idr_preload_end();
 295
 296         if (ret < 0) {
 297                 drm_syncobj_put(syncobj);
 298                 return ret;
 299         }
 300
 301         *handle = ret;
 302         return 0;
 303 }
 304
 305 static int drm_syncobj_destroy(struct drm_file *file_private,
 306                                u32 handle)
 307 {
 308         struct drm_syncobj *syncobj;
 309
 310         spin_lock(&file_private->syncobj_table_lock);
 311         syncobj = idr_remove(&file_private->syncobj_idr, handle);
 312         spin_unlock(&file_private->syncobj_table_lock);
 313
 314         if (!syncobj)
 315                 return -EINVAL;
 316
 317         drm_syncobj_put(syncobj);
 318         return 0;
 319 }
 320
 321 static int drm_syncobj_file_release(struct inode *inode, struct file *file)
 322 {
 323         struct drm_syncobj *syncobj = file->private_data;
 324
 325         drm_syncobj_put(syncobj);
 326         return 0;
 327 }
 328
 329 static const struct file_operations drm_syncobj_file_fops = {
 330         .release = drm_syncobj_file_release,
 331 };
 332
 333 static int drm_syncobj_handle_to_fd(struct drm_file *file_private,
 334                                     u32 handle, int *p_fd)
 335 {
 336         struct drm_syncobj *syncobj = drm_syncobj_find(file_private, handle);
 337         struct file *file;
 338         int fd;
 339
 340         if (!syncobj)
 341                 return -EINVAL;
 342
 343         fd = get_unused_fd_flags(O_CLOEXEC);
 344         if (fd < 0) {
 345                 drm_syncobj_put(syncobj);
 346                 return fd;
 347         }
 348
 349         file = anon_inode_getfile("syncobj_file",
 350                                   &drm_syncobj_file_fops,
 351                                   syncobj, 0);
 352         if (IS_ERR(file)) {
 353                 put_unused_fd(fd);
 354                 drm_syncobj_put(syncobj);
 355                 return PTR_ERR(file);
 356         }
 357
 358         fd_install(fd, file);
 359
 360         *p_fd = fd;
 361         return 0;
 362 }
 363
 364 static int drm_syncobj_fd_to_handle(struct drm_file *file_private,
 365                                     int fd, u32 *handle)
 366 {
 367         struct drm_syncobj *syncobj;
 368         struct file *file;
 369         int ret;
 370
 371         file = fget(fd);
 372         if (!file)
 373                 return -EINVAL;
 374
 375         if (file->f_op != &drm_syncobj_file_fops) {
 376                 fput(file);
 377                 return -EINVAL;
 378         }
 379
 380         /* take a reference to put in the idr */
 381         syncobj = file->private_data;
 382         drm_syncobj_get(syncobj);
 383
 384         idr_preload(GFP_KERNEL);
 385         spin_lock(&file_private->syncobj_table_lock);
 386         ret = idr_alloc(&file_private->syncobj_idr, syncobj, 1, 0, GFP_NOWAIT);
 387         spin_unlock(&file_private->syncobj_table_lock);
 388         idr_preload_end();
 389
 390         if (ret > 0) {
 391                 *handle = ret;
 392                 ret = 0;
 393         } else
 394                 drm_syncobj_put(syncobj);
 395
 396         fput(file);
 397         return ret;
 398 }
 399
 400 int drm_syncobj_import_sync_file_fence(struct drm_file *file_private,
 401                                        int fd, int handle)
 402 {
 403         struct dma_fence *fence = sync_file_get_fence(fd);
 404         struct drm_syncobj *syncobj;
 405
 406         if (!fence)
 407                 return -EINVAL;
 408
 409         syncobj = drm_syncobj_find(file_private, handle);
 410         if (!syncobj) {
 411                 dma_fence_put(fence);
 412                 return -ENOENT;
 413         }
 414
 415         drm_syncobj_replace_fence(syncobj, fence);
 416         dma_fence_put(fence);
 417         drm_syncobj_put(syncobj);
 418         return 0;
 419 }
 420
 421 int drm_syncobj_export_sync_file(struct drm_file *file_private,
 422                                  int handle, int *p_fd)
 423 {
 424         int ret;
 425         struct dma_fence *fence;
 426         struct sync_file *sync_file;
 427         int fd = get_unused_fd_flags(O_CLOEXEC);
 428
 429         if (fd < 0)
 430                 return fd;
 431
 432         ret = drm_syncobj_find_fence(file_private, handle, &fence);
 433         if (ret)
 434                 goto err_put_fd;
 435
 436         sync_file = sync_file_create(fence);
 437
 438         dma_fence_put(fence);
 439
 440         if (!sync_file) {
 441                 ret = -EINVAL;
 442                 goto err_put_fd;
 443         }
 444
 445         fd_install(fd, sync_file->file);
 446
 447         *p_fd = fd;
 448         return 0;
 449 err_put_fd:
 450         put_unused_fd(fd);
 451         return ret;
 452 }
 453 /**
 454  * drm_syncobj_open - initalizes syncobj file-private structures at devnode open time
 455  * @file_private: drm file-private structure to set up
 456  *
 457  * Called at device open time, sets up the structure for handling refcounting
 458  * of sync objects.
 459  */
 460 void
 461 drm_syncobj_open(struct drm_file *file_private)
 462 {
 463         idr_init(&file_private->syncobj_idr);
 464         spin_lock_init(&file_private->syncobj_table_lock);
 465 }
 466
 467 static int
 468 drm_syncobj_release_handle(int id, void *ptr, void *data)
 469 {
 470         struct drm_syncobj *syncobj = ptr;
 471
 472         drm_syncobj_put(syncobj);
 473         return 0;
 474 }
 475
 476 /**
 477  * drm_syncobj_release - release file-private sync object resources
 478  * @file_private: drm file-private structure to clean up
 479  *
 480  * Called at close time when the filp is going away.
 481  *
 482  * Releases any remaining references on objects by this filp.
 483  */
 484 void
 485 drm_syncobj_release(struct drm_file *file_private)
 486 {
 487         idr_for_each(&file_private->syncobj_idr,
 488                      &drm_syncobj_release_handle, file_private);
 489         idr_destroy(&file_private->syncobj_idr);
 490 }
 491
 492 int
 493 drm_syncobj_create_ioctl(struct drm_device *dev, void *data,
 494                          struct drm_file *file_private)
 495 {
 496         struct drm_syncobj_create *args = data;
 497
 498         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 499                 return -ENODEV;
 500
 501         /* no valid flags yet */
 502         if (args->flags & ~DRM_SYNCOBJ_CREATE_SIGNALED)
 503                 return -EINVAL;
 504
 505         return drm_syncobj_create(file_private,
 506                                   &args->handle, args->flags);
 507 }
 508
 509 int
 510 drm_syncobj_destroy_ioctl(struct drm_device *dev, void *data,
 511                           struct drm_file *file_private)
 512 {
 513         struct drm_syncobj_destroy *args = data;
 514
 515         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 516                 return -ENODEV;
 517
 518         /* make sure padding is empty */
 519         if (args->pad)
 520                 return -EINVAL;
 521         return drm_syncobj_destroy(file_private, args->handle);
 522 }
 523
 524 int
 525 drm_syncobj_handle_to_fd_ioctl(struct drm_device *dev, void *data,
 526                                    struct drm_file *file_private)
 527 {
 528         struct drm_syncobj_handle *args = data;
 529
 530         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 531                 return -ENODEV;
 532
 533         if (args->pad)
 534                 return -EINVAL;
 535
 536         if (args->flags != 0 &&
 537             args->flags != DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
 538                 return -EINVAL;
 539
 540         if (args->flags & DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE)
 541                 return drm_syncobj_export_sync_file(file_private, args->handle,
 542                                                     &args->fd);
 543
 544         return drm_syncobj_handle_to_fd(file_private, args->handle,
 545                                         &args->fd);
 546 }
 547
 548 int
 549 drm_syncobj_fd_to_handle_ioctl(struct drm_device *dev, void *data,
 550                                    struct drm_file *file_private)
 551 {
 552         struct drm_syncobj_handle *args = data;
 553
 554         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 555                 return -ENODEV;
 556
 557         if (args->pad)
 558                 return -EINVAL;
 559
 560         if (args->flags != 0 &&
 561             args->flags != DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
 562                 return -EINVAL;
 563
 564         if (args->flags & DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE)
 565                 return drm_syncobj_import_sync_file_fence(file_private,
 566                                                           args->fd,
 567                                                           args->handle);
 568
 569         return drm_syncobj_fd_to_handle(file_private, args->fd,
 570                                         &args->handle);
 571 }
 572
 573 struct syncobj_wait_entry {
 574         struct task_struct *task;
 575         struct dma_fence *fence;
 576         struct dma_fence_cb fence_cb;
 577         struct drm_syncobj_cb syncobj_cb;
 578 };
 579
 580 static void syncobj_wait_fence_func(struct dma_fence *fence,
 581                                     struct dma_fence_cb *cb)
 582 {
 583         struct syncobj_wait_entry *wait =
 584                 container_of(cb, struct syncobj_wait_entry, fence_cb);
 585
 586         wake_up_process(wait->task);
 587 }
 588
 589 static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj,
 590                                       struct drm_syncobj_cb *cb)
 591 {
 592         struct syncobj_wait_entry *wait =
 593                 container_of(cb, struct syncobj_wait_entry, syncobj_cb);
 594
 595         /* This happens inside the syncobj lock */
 596         wait->fence = dma_fence_get(syncobj->fence);
 597         wake_up_process(wait->task);
 598 }
 599
 600 static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs,
 601                                                   uint32_t count,
 602                                                   uint32_t flags,
 603                                                   signed long timeout,
 604                                                   uint32_t *idx)
 605 {
 606         struct syncobj_wait_entry *entries;
 607         struct dma_fence *fence;
 608         signed long ret;
 609         uint32_t signaled_count, i;
 610
 611         entries = kcalloc(count, sizeof(*entries), GFP_KERNEL);
 612         if (!entries)
 613                 return -ENOMEM;
 614
 615         /* Walk the list of sync objects and initialize entries.  We do
 616          * this up-front so that we can properly return -EINVAL if there is
 617          * a syncobj with a missing fence and then never have the chance of
 618          * returning -EINVAL again.
 619          */
 620         signaled_count = 0;
 621         for (i = 0; i < count; ++i) {
 622                 entries[i].task = current;
 623                 entries[i].fence = drm_syncobj_fence_get(syncobjs[i]);
 624                 if (!entries[i].fence) {
 625                         if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
 626                                 continue;
 627                         } else {
 628                                 ret = -EINVAL;
 629                                 goto cleanup_entries;
 630                         }
 631                 }
 632
 633                 if (dma_fence_is_signaled(entries[i].fence)) {
 634                         if (signaled_count == 0 && idx)
 635                                 *idx = i;
 636                         signaled_count++;
 637                 }
 638         }
 639
 640         /* Initialize ret to the max of timeout and 1.  That way, the
 641          * default return value indicates a successful wait and not a
 642          * timeout.
 643          */
 644         ret = max_t(signed long, timeout, 1);
 645
 646         if (signaled_count == count ||
 647             (signaled_count > 0 &&
 648              !(flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL)))
 649                 goto cleanup_entries;
 650
 651         /* There's a very annoying laxness in the dma_fence API here, in
 652          * that backends are not required to automatically report when a
 653          * fence is signaled prior to fence->ops->enable_signaling() being
 654          * called.  So here if we fail to match signaled_count, we need to
 655          * fallthough and try a 0 timeout wait!
 656          */
 657
 658         if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
 659                 for (i = 0; i < count; ++i) {
 660                         if (entries[i].fence)
 661                                 continue;
 662
 663                         drm_syncobj_fence_get_or_add_callback(syncobjs[i],
 664                                                               &entries[i].fence,
 665                                                               &entries[i].syncobj_cb,
 666                                                               syncobj_wait_syncobj_func);
 667                 }
 668         }
 669
 670         do {
 671                 set_current_state(TASK_INTERRUPTIBLE);
 672
 673                 signaled_count = 0;
 674                 for (i = 0; i < count; ++i) {
 675                         fence = entries[i].fence;
 676                         if (!fence)
 677                                 continue;
 678
 679                         if (dma_fence_is_signaled(fence) ||
 680                             (!entries[i].fence_cb.func &&
 681                              dma_fence_add_callback(fence,
 682                                                     &entries[i].fence_cb,
 683                                                     syncobj_wait_fence_func))) {
 684                                 /* The fence has been signaled */
 685                                 if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL) {
 686                                         signaled_count++;
 687                                 } else {
 688                                         if (idx)
 689                                                 *idx = i;
 690                                         goto done_waiting;
 691                                 }
 692                         }
 693                 }
 694
 695                 if (signaled_count == count)
 696                         goto done_waiting;
 697
 698                 if (timeout == 0) {
 699                         /* If we are doing a 0 timeout wait and we got
 700                          * here, then we just timed out.
 701                          */
 702                         ret = 0;
 703                         goto done_waiting;
 704                 }
 705
 706                 ret = schedule_timeout(ret);
 707
 708                 if (ret > 0 && signal_pending(current))
 709                         ret = -ERESTARTSYS;
 710         } while (ret > 0);
 711
 712 done_waiting:
 713         __set_current_state(TASK_RUNNING);
 714
 715 cleanup_entries:
 716         for (i = 0; i < count; ++i) {
 717                 if (entries[i].syncobj_cb.func)
 718                         drm_syncobj_remove_callback(syncobjs[i],
 719                                                     &entries[i].syncobj_cb);
 720                 if (entries[i].fence_cb.func)
 721                         dma_fence_remove_callback(entries[i].fence,
 722                                                   &entries[i].fence_cb);
 723                 dma_fence_put(entries[i].fence);
 724         }
 725         kfree(entries);
 726
 727         return ret;
 728 }
 729
 730 /**
 731  * drm_timeout_abs_to_jiffies - calculate jiffies timeout from absolute value
 732  *
 733  * @timeout_nsec: timeout nsec component in ns, 0 for poll
 734  *
 735  * Calculate the timeout in jiffies from an absolute time in sec/nsec.
 736  */
 737 static signed long drm_timeout_abs_to_jiffies(int64_t timeout_nsec)
 738 {
 739         ktime_t abs_timeout, now;
 740         u64 timeout_ns, timeout_jiffies64;
 741
 742         /* make 0 timeout means poll - absolute 0 doesn't seem valid */
 743         if (timeout_nsec == 0)
 744                 return 0;
 745
 746         abs_timeout = ns_to_ktime(timeout_nsec);
 747         now = ktime_get();
 748
 749         if (!ktime_after(abs_timeout, now))
 750                 return 0;
 751
 752         timeout_ns = ktime_to_ns(ktime_sub(abs_timeout, now));
 753
 754         timeout_jiffies64 = nsecs_to_jiffies64(timeout_ns);
 755         /*  clamp timeout to avoid infinite timeout */
 756         if (timeout_jiffies64 >= MAX_SCHEDULE_TIMEOUT - 1)
 757                 return MAX_SCHEDULE_TIMEOUT - 1;
 758
 759         return timeout_jiffies64 + 1;
 760 }
 761
 762 static int drm_syncobj_array_wait(struct drm_device *dev,
 763                                   struct drm_file *file_private,
 764                                   struct drm_syncobj_wait *wait,
 765                                   struct drm_syncobj **syncobjs)
 766 {
 767         signed long timeout = drm_timeout_abs_to_jiffies(wait->timeout_nsec);
 768         signed long ret = 0;
 769         uint32_t first = ~0;
 770
 771         ret = drm_syncobj_array_wait_timeout(syncobjs,
 772                                              wait->count_handles,
 773                                              wait->flags,
 774                                              timeout, &first);
 775         if (ret < 0)
 776                 return ret;
 777
 778         wait->first_signaled = first;
 779         if (ret == 0)
 780                 return -ETIME;
 781         return 0;
 782 }
 783
 784 static int drm_syncobj_array_find(struct drm_file *file_private,
 785                                   void *user_handles, uint32_t count_handles,
 786                                   struct drm_syncobj ***syncobjs_out)
 787 {
 788         uint32_t i, *handles;
 789         struct drm_syncobj **syncobjs;
 790         int ret;
 791
 792         handles = kmalloc_array(count_handles, sizeof(*handles), GFP_KERNEL);
 793         if (handles == NULL)
 794                 return -ENOMEM;
 795
 796         if (copy_from_user(handles, user_handles,
 797                            sizeof(uint32_t) * count_handles)) {
 798                 ret = -EFAULT;
 799                 goto err_free_handles;
 800         }
 801
 802         syncobjs = kmalloc_array(count_handles, sizeof(*syncobjs), GFP_KERNEL);
 803         if (syncobjs == NULL) {
 804                 ret = -ENOMEM;
 805                 goto err_free_handles;
 806         }
 807
 808         for (i = 0; i < count_handles; i++) {
 809                 syncobjs[i] = drm_syncobj_find(file_private, handles[i]);
 810                 if (!syncobjs[i]) {
 811                         ret = -ENOENT;
 812                         goto err_put_syncobjs;
 813                 }
 814         }
 815
 816         kfree(handles);
 817         *syncobjs_out = syncobjs;
 818         return 0;
 819
 820 err_put_syncobjs:
 821         while (i-- > 0)
 822                 drm_syncobj_put(syncobjs[i]);
 823         kfree(syncobjs);
 824 err_free_handles:
 825         kfree(handles);
 826
 827         return ret;
 828 }
 829
 830 static void drm_syncobj_array_free(struct drm_syncobj **syncobjs,
 831                                    uint32_t count)
 832 {
 833         uint32_t i;
 834         for (i = 0; i < count; i++)
 835                 drm_syncobj_put(syncobjs[i]);
 836         kfree(syncobjs);
 837 }
 838
 839 int
 840 drm_syncobj_wait_ioctl(struct drm_device *dev, void *data,
 841                        struct drm_file *file_private)
 842 {
 843         struct drm_syncobj_wait *args = data;
 844         struct drm_syncobj **syncobjs;
 845         int ret = 0;
 846
 847         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 848                 return -ENODEV;
 849
 850         if (args->flags & ~(DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL |
 851                             DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT))
 852                 return -EINVAL;
 853
 854         if (args->count_handles == 0)
 855                 return -EINVAL;
 856
 857         ret = drm_syncobj_array_find(file_private,
 858                                      u64_to_user_ptr(args->handles),
 859                                      args->count_handles,
 860                                      &syncobjs);
 861         if (ret < 0)
 862                 return ret;
 863
 864         ret = drm_syncobj_array_wait(dev, file_private,
 865                                      args, syncobjs);
 866
 867         drm_syncobj_array_free(syncobjs, args->count_handles);
 868
 869         return ret;
 870 }
 871
 872 int
 873 drm_syncobj_reset_ioctl(struct drm_device *dev, void *data,
 874                         struct drm_file *file_private)
 875 {
 876         struct drm_syncobj_array *args = data;
 877         struct drm_syncobj **syncobjs;
 878         uint32_t i;
 879         int ret;
 880
 881         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 882                 return -ENODEV;
 883
 884         if (args->pad != 0)
 885                 return -EINVAL;
 886
 887         if (args->count_handles == 0)
 888                 return -EINVAL;
 889
 890         ret = drm_syncobj_array_find(file_private,
 891                                      u64_to_user_ptr(args->handles),
 892                                      args->count_handles,
 893                                      &syncobjs);
 894         if (ret < 0)
 895                 return ret;
 896
 897         for (i = 0; i < args->count_handles; i++)
 898                 drm_syncobj_replace_fence(syncobjs[i], NULL);
 899
 900         drm_syncobj_array_free(syncobjs, args->count_handles);
 901
 902         return 0;
 903 }
 904
 905 int
 906 drm_syncobj_signal_ioctl(struct drm_device *dev, void *data,
 907                          struct drm_file *file_private)
 908 {
 909         struct drm_syncobj_array *args = data;
 910         struct drm_syncobj **syncobjs;
 911         uint32_t i;
 912         int ret;
 913
 914         if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
 915                 return -ENODEV;
 916
 917         if (args->pad != 0)
 918                 return -EINVAL;
 919
 920         if (args->count_handles == 0)
 921                 return -EINVAL;
 922
 923         ret = drm_syncobj_array_find(file_private,
 924                                      u64_to_user_ptr(args->handles),
 925                                      args->count_handles,
 926                                      &syncobjs);
 927         if (ret < 0)
 928                 return ret;
 929
 930         for (i = 0; i < args->count_handles; i++) {
 931                 ret = drm_syncobj_assign_null_handle(syncobjs[i]);
 932                 if (ret < 0)
 933                         break;
 934         }
 935
 936         drm_syncobj_array_free(syncobjs, args->count_handles);
 937
 938         return ret;
 939 }