src/wsbm_fencemgr.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Tx., USA
   4  * All Rights Reserved.
   5  * Copyright 2009 VMware, Inc., Palo Alto, CA., USA
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  23  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  24  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  25  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  26  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29 /*
  30  * Authors: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include "wsbm_fencemgr.h"
  38 #include "wsbm_pool.h"
  39 #include "wsbm_manager.h"
  40 #include <xf86drm.h>
  41 #include <ttm/ttm_fence_user.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44
  45 struct _WsbmFenceClass
  46 {
  47     struct _WsbmListHead head;
  48     struct _WsbmMutex mutex;
  49     struct _WsbmMutex cmd_mutex;
  50 };
  51
  52 /*
  53  * Note: The struct _WsbmFenceMgr::Mutex should never be held
  54  * during sleeps, since that may block fast concurrent access to
  55  * fence data.
  56  */
  57
  58 struct _WsbmFenceMgr
  59 {
  60     /*
  61      * Constant members. Need no mutex protection.
  62      */
  63     struct _WsbmFenceMgrCreateInfo info;
  64     void *private;
  65
  66     /*
  67      * Atomic members. No mutex protection.
  68      */
  69
  70     struct _WsbmAtomic count;
  71
  72     /*
  73      * These members are protected by this->mutex
  74      */
  75
  76     struct _WsbmFenceClass *classes;
  77     uint32_t num_classes;
  78 };
  79
  80 struct _WsbmFenceObject
  81 {
  82
  83     /*
  84      * These members are constant and need no mutex protection.
  85      * Note that @private may point to a structure with its own
  86      * mutex protection, that we don't care about.
  87      */
  88
  89     struct _WsbmFenceMgr *mgr;
  90     uint32_t fence_class;
  91     uint32_t fence_type;
  92     void *private;
  93
  94     /*
  95      * Atomic members. No mutex protection. note that
  96      * @signaled types is updated using a compare-and-swap
  97      * scheme to guarantee atomicity.
  98      */
  99
 100     struct _WsbmAtomic refCount;
 101     struct _WsbmAtomic signaled_types;
 102
 103     /*
 104      * These members are protected by mgr->mutex.
 105      */
 106     struct _WsbmListHead head;
 107 };
 108
 109 uint32_t
 110 wsbmFenceType(struct _WsbmFenceObject *fence)
 111 {
 112     return fence->fence_type;
 113 }
 114
 115 struct _WsbmFenceMgr *
 116 wsbmFenceMgrCreate(const struct _WsbmFenceMgrCreateInfo *info)
 117 {
 118     struct _WsbmFenceMgr *tmp;
 119     uint32_t i, j;
 120     int ret;
 121
 122     tmp = calloc(1, sizeof(*tmp));
 123     if (!tmp)
 124         return NULL;
 125
 126     tmp->info = *info;
 127     tmp->classes = calloc(tmp->info.num_classes, sizeof(*tmp->classes));
 128     if (!tmp->classes)
 129         goto out_err;
 130
 131     for (i = 0; i < tmp->info.num_classes; ++i) {
 132         struct _WsbmFenceClass *fc = &tmp->classes[i];
 133
 134         WSBMINITLISTHEAD(&fc->head);
 135         ret = WSBM_MUTEX_INIT(&fc->mutex);
 136         if (ret)
 137             goto out_err1;
 138         ret = WSBM_MUTEX_INIT(&fc->cmd_mutex);
 139         if (ret) {
 140             WSBM_MUTEX_FREE(&fc->mutex);
 141             goto out_err1;
 142         }
 143     }
 144     wsbmAtomicSet(&tmp->count, 0);
 145
 146     return tmp;
 147
 148   out_err1:
 149     for (j = 0; j < i; ++j) {
 150         WSBM_MUTEX_FREE(&tmp->classes[j].mutex);
 151         WSBM_MUTEX_FREE(&tmp->classes[j].cmd_mutex);
 152     }
 153     free(tmp->classes);
 154   out_err:
 155     if (tmp)
 156         free(tmp);
 157     return NULL;
 158 }
 159
 160 void
 161 wsbmFenceUnreference(struct _WsbmFenceObject **pFence)
 162 {
 163     struct _WsbmFenceObject *fence = *pFence;
 164     struct _WsbmFenceMgr *mgr;
 165
 166     *pFence = NULL;
 167     if (fence == NULL)
 168         return;
 169
 170     mgr = fence->mgr;
 171     if (wsbmAtomicDecZero(&fence->refCount)) {
 172         struct _WsbmFenceClass *fc = &mgr->classes[fence->fence_class];
 173
 174         WSBM_MUTEX_LOCK(&fc->mutex);
 175         WSBMLISTDELINIT(&fence->head);
 176         WSBM_MUTEX_UNLOCK(&fc->mutex);
 177         if (fence->private)
 178             mgr->info.unreference(mgr, &fence->private);
 179         fence->mgr = NULL;
 180         wsbmAtomicDecZero(&mgr->count);
 181         free(fence);
 182     }
 183 }
 184
 185 static void
 186 wsbmSignalPreviousFences(struct _WsbmFenceMgr *mgr,
 187                          struct _WsbmListHead *list,
 188                          uint32_t fence_class, uint32_t signaled_types)
 189 {
 190     struct _WsbmFenceClass *fc = &mgr->classes[fence_class];
 191     struct _WsbmFenceObject *entry;
 192     struct _WsbmListHead *prev;
 193     uint32_t old_signaled_types;
 194     uint32_t ret_st;
 195
 196     WSBM_MUTEX_LOCK(&fc->mutex);
 197     while (list != &fc->head && list->next != list) {
 198         entry = WSBMLISTENTRY(list, struct _WsbmFenceObject, head);
 199
 200         prev = list->prev;
 201
 202         do {
 203             old_signaled_types = wsbmAtomicRead(&entry->signaled_types);
 204             signaled_types =
 205                 old_signaled_types | (signaled_types & entry->fence_type);
 206             if (signaled_types == old_signaled_types)
 207                 break;
 208
 209             ret_st =
 210                 wsbmAtomicCmpXchg(&entry->signaled_types, old_signaled_types,
 211                                   signaled_types);
 212         } while (ret_st != old_signaled_types);
 213
 214         if (signaled_types == entry->fence_type)
 215             WSBMLISTDELINIT(list);
 216
 217         list = prev;
 218     }
 219     WSBM_MUTEX_UNLOCK(&fc->mutex);
 220 }
 221
 222 int
 223 wsbmFenceFinish(struct _WsbmFenceObject *fence, uint32_t fence_type,
 224                 int lazy_hint)
 225 {
 226     struct _WsbmFenceMgr *mgr = fence->mgr;
 227     int ret = 0;
 228
 229     if ((wsbmAtomicRead(&fence->signaled_types) & fence_type) == fence_type)
 230         goto out;
 231
 232     ret = mgr->info.finish(mgr, fence->private, fence_type, lazy_hint);
 233     if (ret)
 234         goto out;
 235
 236     wsbmSignalPreviousFences(mgr, &fence->head, fence->fence_class,
 237                              fence_type);
 238   out:
 239     return ret;
 240 }
 241
 242 uint32_t
 243 wsbmFenceSignaledTypeCached(struct _WsbmFenceObject * fence)
 244 {
 245     return wsbmAtomicRead(&fence->signaled_types);
 246 }
 247
 248 int
 249 wsbmFenceSignaledType(struct _WsbmFenceObject *fence, uint32_t flush_type,
 250                       uint32_t * signaled)
 251 {
 252     int ret = 0;
 253     struct _WsbmFenceMgr *mgr;
 254     uint32_t signaled_types;
 255     uint32_t old_signaled_types;
 256     uint32_t ret_st;
 257
 258     mgr = fence->mgr;
 259     *signaled = wsbmAtomicRead(&fence->signaled_types);
 260     if ((*signaled & flush_type) == flush_type)
 261         goto out0;
 262
 263     ret = mgr->info.signaled(mgr, fence->private, flush_type, signaled);
 264     if (ret) {
 265         *signaled = wsbmAtomicRead(&fence->signaled_types);
 266         goto out0;
 267     }
 268
 269     do {
 270         old_signaled_types = wsbmAtomicRead(&fence->signaled_types);
 271         signaled_types = old_signaled_types | *signaled;
 272         if (signaled_types == old_signaled_types)
 273             break;
 274
 275         ret_st = wsbmAtomicCmpXchg(&fence->signaled_types, old_signaled_types,
 276                                    signaled_types);
 277         if (old_signaled_types == ret_st)
 278             wsbmSignalPreviousFences(mgr, &fence->head, fence->fence_class,
 279                                      *signaled);
 280     } while (old_signaled_types != ret_st);
 281
 282     return 0;
 283   out0:
 284     return ret;
 285 }
 286
 287 struct _WsbmFenceObject *
 288 wsbmFenceReference(struct _WsbmFenceObject *fence)
 289 {
 290     if (fence == NULL)
 291         return NULL;
 292     wsbmAtomicInc(&fence->refCount);
 293     return fence;
 294 }
 295
 296 struct _WsbmFenceObject *
 297 wsbmFenceCreateSig(struct _WsbmFenceMgr *mgr, uint32_t fence_class,
 298                    uint32_t fence_type, uint32_t signaled_types,
 299                    void *private, size_t private_size)
 300 {
 301     struct _WsbmFenceClass *fc = &mgr->classes[fence_class];
 302     struct _WsbmFenceObject *fence;
 303     size_t fence_size = sizeof(*fence);
 304
 305     if (private_size)
 306         fence_size = ((fence_size + 15) & ~15);
 307
 308     fence = calloc(1, fence_size + private_size);
 309
 310     if (!fence)
 311         goto out_err;
 312
 313     wsbmAtomicSet(&fence->refCount, 1);
 314     fence->mgr = mgr;
 315     fence->fence_class = fence_class;
 316     fence->fence_type = fence_type;
 317     wsbmAtomicSet(&fence->signaled_types, signaled_types);
 318     fence->private = private;
 319     if (private_size) {
 320         fence->private = (void *)(((uint8_t *) fence) + fence_size);
 321         memcpy(fence->private, private, private_size);
 322     }
 323
 324     WSBM_MUTEX_LOCK(&fc->mutex);
 325     WSBMLISTADDTAIL(&fence->head, &fc->head);
 326     WSBM_MUTEX_UNLOCK(&fc->mutex);
 327     wsbmAtomicInc(&mgr->count);
 328     return fence;
 329
 330   out_err:
 331     {
 332         int ret = mgr->info.finish(mgr, private, fence_type, 0);
 333
 334         if (ret)
 335             usleep(10000000);
 336     }
 337     if (fence)
 338         free(fence);
 339
 340     mgr->info.unreference(mgr, &private);
 341     return NULL;
 342 }
 343
 344 struct _WsbmFenceObject *
 345 wsbmFenceCreate(struct _WsbmFenceMgr *mgr, uint32_t fence_class,
 346                 uint32_t fence_type, void *private, size_t private_size)
 347 {
 348   return wsbmFenceCreateSig(mgr, fence_class, fence_type, 0, private,
 349                             private_size);
 350 }
 351
 352 struct _WsbmTTMFenceMgrPriv
 353 {
 354     int fd;
 355     unsigned int devOffset;
 356 };
 357
 358 static int
 359 tSignaled(struct _WsbmFenceMgr *mgr, void *private, uint32_t flush_type,
 360           uint32_t * signaled_type)
 361 {
 362     struct _WsbmTTMFenceMgrPriv *priv =
 363         (struct _WsbmTTMFenceMgrPriv *)mgr->private;
 364     union ttm_fence_signaled_arg arg;
 365     int ret;
 366
 367     arg.req.handle = (unsigned long)private;
 368     arg.req.fence_type = flush_type;
 369     arg.req.flush = 1;
 370     *signaled_type = 0;
 371
 372     ret = drmCommandWriteRead(priv->fd, priv->devOffset + TTM_FENCE_SIGNALED,
 373                               &arg, sizeof(arg));
 374     if (ret)
 375         return ret;
 376
 377     *signaled_type = arg.rep.signaled_types;
 378     return 0;
 379 }
 380
 381 static int
 382 tFinish(struct _WsbmFenceMgr *mgr, void *private, uint32_t fence_type,
 383         int lazy_hint)
 384 {
 385     struct _WsbmTTMFenceMgrPriv *priv =
 386         (struct _WsbmTTMFenceMgrPriv *)mgr->private;
 387     union ttm_fence_finish_arg arg =
 388         {.req = {.handle = (unsigned long)private,
 389                  .fence_type = fence_type,
 390                  .mode = (lazy_hint) ? TTM_FENCE_FINISH_MODE_LAZY : 0}
 391     };
 392     int ret;
 393
 394     do {
 395         ret = drmCommandWriteRead(priv->fd, priv->devOffset + TTM_FENCE_FINISH,
 396                                   &arg, sizeof(arg));
 397     } while (ret == -EAGAIN || ret == -ERESTART);
 398
 399     return ret;
 400 }
 401
 402 static int
 403 tUnref(struct _WsbmFenceMgr *mgr, void **private)
 404 {
 405     struct _WsbmTTMFenceMgrPriv *priv =
 406         (struct _WsbmTTMFenceMgrPriv *)mgr->private;
 407     struct ttm_fence_unref_arg arg = {.handle = (unsigned long)*private };
 408
 409     *private = NULL;
 410
 411     return drmCommandWrite(priv->fd, priv->devOffset + TTM_FENCE_UNREF,
 412                            &arg, sizeof(arg));
 413 }
 414
 415 struct _WsbmFenceMgr *
 416 wsbmFenceMgrTTMInit(int fd, unsigned int numClass, unsigned int devOffset)
 417 {
 418     struct _WsbmFenceMgrCreateInfo info;
 419     struct _WsbmFenceMgr *mgr;
 420     struct _WsbmTTMFenceMgrPriv *priv = malloc(sizeof(*priv));
 421
 422     if (!priv)
 423         return NULL;
 424
 425     priv->fd = fd;
 426     priv->devOffset = devOffset;
 427
 428     info.flags = WSBM_FENCE_CLASS_ORDERED;
 429     info.num_classes = numClass;
 430     info.signaled = tSignaled;
 431     info.finish = tFinish;
 432     info.unreference = tUnref;
 433
 434     mgr = wsbmFenceMgrCreate(&info);
 435     if (mgr == NULL) {
 436         free(priv);
 437         return NULL;
 438     }
 439
 440     mgr->private = (void *)priv;
 441     return mgr;
 442 }
 443
 444 void
 445 wsbmFenceCmdLock(struct _WsbmFenceMgr *mgr, uint32_t fence_class)
 446 {
 447     WSBM_MUTEX_LOCK(&mgr->classes[fence_class].cmd_mutex);
 448 }
 449
 450 void
 451 wsbmFenceCmdUnlock(struct _WsbmFenceMgr *mgr, uint32_t fence_class)
 452 {
 453     WSBM_MUTEX_UNLOCK(&mgr->classes[fence_class].cmd_mutex);
 454 }
 455
 456 void
 457 wsbmFenceMgrTTMTakedown(struct _WsbmFenceMgr *mgr)
 458 {
 459     int i;
 460
 461     if (!mgr)
 462         return;
 463
 464     if (mgr->private)
 465         free(mgr->private);
 466
 467     for (i = 0; i < mgr->info.num_classes; ++i) {
 468         WSBM_MUTEX_FREE(&mgr->classes[i].mutex);
 469         WSBM_MUTEX_FREE(&mgr->classes[i].cmd_mutex);
 470     }
 471     free(mgr);
 472
 473     return;
 474 }