src/gallium/winsys/svga/drm/vmw_fence.c

   1 /**********************************************************
   2  * Copyright 2009-2015 VMware, Inc.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  **********************************************************/
  25 #include "util/u_memory.h"
  26 #include "util/u_atomic.h"
  27 #include "util/list.h"
  28 #include "os/os_thread.h"
  29
  30 #include "pipebuffer/pb_buffer_fenced.h"
  31
  32 #include "vmw_screen.h"
  33 #include "vmw_fence.h"
  34
  35 struct vmw_fence_ops
  36 {
  37    /*
  38     * Immutable members.
  39     */
  40    struct pb_fence_ops base;
  41    struct vmw_winsys_screen *vws;
  42
  43    mtx_t mutex;
  44
  45    /*
  46     * Protected by mutex;
  47     */
  48    struct list_head not_signaled;
  49    uint32_t last_signaled;
  50    uint32_t last_emitted;
  51 };
  52
  53 struct vmw_fence
  54 {
  55    struct list_head ops_list;
  56    int32_t refcount;
  57    uint32_t handle;
  58    uint32_t mask;
  59    int32_t signalled;
  60    uint32_t seqno;
  61 };
  62
  63 /**
  64  * vmw_fence_seq_is_signaled - Check whether a fence seqno is
  65  * signaled.
  66  *
  67  * @ops: Pointer to a struct pb_fence_ops.
  68  *
  69  */
  70 static inline boolean
  71 vmw_fence_seq_is_signaled(uint32_t seq, uint32_t last, uint32_t cur)
  72 {
  73    return (cur - last <= cur - seq);
  74 }
  75
  76
  77 /**
  78  * vmw_fence_ops - Return the vmw_fence_ops structure backing a
  79  * struct pb_fence_ops pointer.
  80  *
  81  * @ops: Pointer to a struct pb_fence_ops.
  82  *
  83  */
  84 static inline struct vmw_fence_ops *
  85 vmw_fence_ops(struct pb_fence_ops *ops)
  86 {
  87    assert(ops);
  88    return (struct vmw_fence_ops *)ops;
  89 }
  90
  91
  92 /**
  93  * vmw_fences_release - Release all fences from the not_signaled
  94  * list.
  95  *
  96  * @ops: Pointer to a struct vmw_fence_ops.
  97  *
  98  */
  99 static void
 100 vmw_fences_release(struct vmw_fence_ops *ops)
 101 {
 102    struct vmw_fence *fence, *n;
 103
 104    pipe_mutex_lock(ops->mutex);
 105    LIST_FOR_EACH_ENTRY_SAFE(fence, n, &ops->not_signaled, ops_list)
 106       LIST_DELINIT(&fence->ops_list);
 107    pipe_mutex_unlock(ops->mutex);
 108 }
 109
 110 /**
 111  * vmw_fences_signal - Traverse the not_signaled list and try to
 112  * signal unsignaled fences.
 113  *
 114  * @ops: Pointer to a struct pb_fence_ops.
 115  * @signaled: Seqno that has signaled.
 116  * @emitted: Last seqno emitted by the kernel.
 117  * @has_emitted: Whether we provide the emitted value.
 118  *
 119  */
 120 void
 121 vmw_fences_signal(struct pb_fence_ops *fence_ops,
 122                   uint32_t signaled,
 123                   uint32_t emitted,
 124                   boolean has_emitted)
 125 {
 126    struct vmw_fence_ops *ops = NULL;
 127    struct vmw_fence *fence, *n;
 128
 129    if (fence_ops == NULL)
 130       return;
 131
 132    ops = vmw_fence_ops(fence_ops);
 133    pipe_mutex_lock(ops->mutex);
 134
 135    if (!has_emitted) {
 136       emitted = ops->last_emitted;
 137       if (emitted - signaled > (1 << 30))
 138         emitted = signaled;
 139    }
 140
 141    if (signaled == ops->last_signaled && emitted == ops->last_emitted)
 142       goto out_unlock;
 143
 144    LIST_FOR_EACH_ENTRY_SAFE(fence, n, &ops->not_signaled, ops_list) {
 145       if (!vmw_fence_seq_is_signaled(fence->seqno, signaled, emitted))
 146          break;
 147
 148       p_atomic_set(&fence->signalled, 1);
 149       LIST_DELINIT(&fence->ops_list);
 150    }
 151    ops->last_signaled = signaled;
 152    ops->last_emitted = emitted;
 153
 154 out_unlock:
 155    pipe_mutex_unlock(ops->mutex);
 156 }
 157
 158
 159 /**
 160  * vmw_fence - return the vmw_fence object identified by a
 161  * struct pipe_fence_handle *
 162  *
 163  * @fence: The opaque pipe fence handle.
 164  */
 165 static inline struct vmw_fence *
 166 vmw_fence(struct pipe_fence_handle *fence)
 167 {
 168    return (struct vmw_fence *) fence;
 169 }
 170
 171
 172 /**
 173  * vmw_fence_create - Create a user-space fence object.
 174  *
 175  * @fence_ops: The fence_ops manager to register with.
 176  * @handle: Handle identifying the kernel fence object.
 177  * @mask: Mask of flags that this fence object may signal.
 178  *
 179  * Returns NULL on failure.
 180  */
 181 struct pipe_fence_handle *
 182 vmw_fence_create(struct pb_fence_ops *fence_ops, uint32_t handle,
 183                  uint32_t seqno, uint32_t mask)
 184 {
 185    struct vmw_fence *fence = CALLOC_STRUCT(vmw_fence);
 186    struct vmw_fence_ops *ops = vmw_fence_ops(fence_ops);
 187
 188    if (!fence)
 189       return NULL;
 190
 191    p_atomic_set(&fence->refcount, 1);
 192    fence->handle = handle;
 193    fence->mask = mask;
 194    fence->seqno = seqno;
 195    p_atomic_set(&fence->signalled, 0);
 196    pipe_mutex_lock(ops->mutex);
 197
 198    if (vmw_fence_seq_is_signaled(seqno, ops->last_signaled, seqno)) {
 199       p_atomic_set(&fence->signalled, 1);
 200       LIST_INITHEAD(&fence->ops_list);
 201    } else {
 202       p_atomic_set(&fence->signalled, 0);
 203       LIST_ADDTAIL(&fence->ops_list, &ops->not_signaled);
 204    }
 205
 206    pipe_mutex_unlock(ops->mutex);
 207
 208    return (struct pipe_fence_handle *) fence;
 209 }
 210
 211
 212 /**
 213  * vmw_fence_reference - Reference / unreference a vmw fence object.
 214  *
 215  * @vws: Pointer to the winsys screen.
 216  * @ptr: Pointer to reference transfer destination.
 217  * @fence: Pointer to object to reference. May be NULL.
 218  */
 219 void
 220 vmw_fence_reference(struct vmw_winsys_screen *vws,
 221                     struct pipe_fence_handle **ptr,
 222                     struct pipe_fence_handle *fence)
 223 {
 224    if (*ptr) {
 225       struct vmw_fence *vfence = vmw_fence(*ptr);
 226
 227       if (p_atomic_dec_zero(&vfence->refcount)) {
 228          struct vmw_fence_ops *ops = vmw_fence_ops(vws->fence_ops);
 229
 230          vmw_ioctl_fence_unref(vws, vfence->handle);
 231
 232          pipe_mutex_lock(ops->mutex);
 233          LIST_DELINIT(&vfence->ops_list);
 234          pipe_mutex_unlock(ops->mutex);
 235
 236          FREE(vfence);
 237       }
 238    }
 239
 240    if (fence) {
 241       struct vmw_fence *vfence = vmw_fence(fence);
 242
 243       p_atomic_inc(&vfence->refcount);
 244    }
 245
 246    *ptr = fence;
 247 }
 248
 249
 250 /**
 251  * vmw_fence_signalled - Check whether a fence object is signalled.
 252  *
 253  * @vws: Pointer to the winsys screen.
 254  * @fence: Handle to the fence object.
 255  * @flag: Fence flags to check. If the fence object can't signal
 256  * a flag, it is assumed to be already signaled.
 257  *
 258  * Returns 0 if the fence object was signaled, nonzero otherwise.
 259  */
 260 int
 261 vmw_fence_signalled(struct vmw_winsys_screen *vws,
 262                    struct pipe_fence_handle *fence,
 263                    unsigned flag)
 264 {
 265    struct vmw_fence *vfence;
 266    int32_t vflags = SVGA_FENCE_FLAG_EXEC;
 267    int ret;
 268    uint32_t old;
 269
 270    if (!fence)
 271       return 0;
 272
 273    vfence = vmw_fence(fence);
 274    old = p_atomic_read(&vfence->signalled);
 275
 276    vflags &= ~vfence->mask;
 277
 278    if ((old & vflags) == vflags)
 279       return 0;
 280
 281    /*
 282     * Currently we update signaled fences on each execbuf call.
 283     * That should really be sufficient, and we can avoid
 284     * a lot of kernel calls this way.
 285     */
 286 #if 1
 287    ret = vmw_ioctl_fence_signalled(vws, vfence->handle, vflags);
 288
 289    if (ret == 0)
 290       p_atomic_set(&vfence->signalled, 1);
 291    return ret;
 292 #else
 293    (void) ret;
 294    return -1;
 295 #endif
 296 }
 297
 298 /**
 299  * vmw_fence_finish - Wait for a fence object to signal.
 300  *
 301  * @vws: Pointer to the winsys screen.
 302  * @fence: Handle to the fence object.
 303  * @flag: Fence flags to wait for. If the fence object can't signal
 304  * a flag, it is assumed to be already signaled.
 305  *
 306  * Returns 0 if the wait succeeded. Nonzero otherwise.
 307  */
 308 int
 309 vmw_fence_finish(struct vmw_winsys_screen *vws,
 310                  struct pipe_fence_handle *fence,
 311                  unsigned flag)
 312 {
 313    struct vmw_fence *vfence;
 314    int32_t vflags = SVGA_FENCE_FLAG_EXEC;
 315    int ret;
 316    uint32_t old;
 317
 318    if (!fence)
 319       return 0;
 320
 321    vfence = vmw_fence(fence);
 322    old = p_atomic_read(&vfence->signalled);
 323    vflags &= ~vfence->mask;
 324
 325    if ((old & vflags) == vflags)
 326       return 0;
 327
 328    ret = vmw_ioctl_fence_finish(vws, vfence->handle, vflags);
 329
 330    if (ret == 0) {
 331       int32_t prev = old;
 332
 333       do {
 334          old = prev;
 335          prev = p_atomic_cmpxchg(&vfence->signalled, old, old | vflags);
 336       } while (prev != old);
 337    }
 338
 339    return ret;
 340 }
 341
 342
 343 /**
 344  * vmw_fence_ops_fence_reference - wrapper for the pb_fence_ops api.
 345  *
 346  * wrapper around vmw_fence_reference.
 347  */
 348 static void
 349 vmw_fence_ops_fence_reference(struct pb_fence_ops *ops,
 350                               struct pipe_fence_handle **ptr,
 351                               struct pipe_fence_handle *fence)
 352 {
 353    struct vmw_winsys_screen *vws = vmw_fence_ops(ops)->vws;
 354
 355    vmw_fence_reference(vws, ptr, fence);
 356 }
 357
 358 /**
 359  * vmw_fence_ops_fence_signalled - wrapper for the pb_fence_ops api.
 360  *
 361  * wrapper around vmw_fence_signalled.
 362  */
 363 static int
 364 vmw_fence_ops_fence_signalled(struct pb_fence_ops *ops,
 365                               struct pipe_fence_handle *fence,
 366                               unsigned flag)
 367 {
 368    struct vmw_winsys_screen *vws = vmw_fence_ops(ops)->vws;
 369
 370    return vmw_fence_signalled(vws, fence, flag);
 371 }
 372
 373
 374 /**
 375  * vmw_fence_ops_fence_finish - wrapper for the pb_fence_ops api.
 376  *
 377  * wrapper around vmw_fence_finish.
 378  */
 379 static int
 380 vmw_fence_ops_fence_finish(struct pb_fence_ops *ops,
 381                            struct pipe_fence_handle *fence,
 382                            unsigned flag)
 383 {
 384    struct vmw_winsys_screen *vws = vmw_fence_ops(ops)->vws;
 385
 386    return vmw_fence_finish(vws, fence, flag);
 387 }
 388
 389
 390 /**
 391  * vmw_fence_ops_destroy - Destroy a pb_fence_ops function table.
 392  *
 393  * @ops: The function table to destroy.
 394  *
 395  * Part of the pb_fence_ops api.
 396  */
 397 static void
 398 vmw_fence_ops_destroy(struct pb_fence_ops *ops)
 399 {
 400    vmw_fences_release(vmw_fence_ops(ops));
 401    FREE(ops);
 402 }
 403
 404
 405 /**
 406  * vmw_fence_ops_create - Create a pb_fence_ops function table.
 407  *
 408  * @vws: Pointer to a struct vmw_winsys_screen.
 409  *
 410  * Returns a pointer to a pb_fence_ops function table to interface
 411  * with pipe_buffer. This function is typically called on driver setup.
 412  *
 413  * Returns NULL on failure.
 414  */
 415 struct pb_fence_ops *
 416 vmw_fence_ops_create(struct vmw_winsys_screen *vws)
 417 {
 418    struct vmw_fence_ops *ops;
 419
 420    ops = CALLOC_STRUCT(vmw_fence_ops);
 421    if(!ops)
 422       return NULL;
 423
 424    pipe_mutex_init(ops->mutex);
 425    LIST_INITHEAD(&ops->not_signaled);
 426    ops->base.destroy = &vmw_fence_ops_destroy;
 427    ops->base.fence_reference = &vmw_fence_ops_fence_reference;
 428    ops->base.fence_signalled = &vmw_fence_ops_fence_signalled;
 429    ops->base.fence_finish = &vmw_fence_ops_fence_finish;
 430
 431    ops->vws = vws;
 432
 433    return &ops->base;
 434 }