src/gallium/winsys/egl_drm/intel/ws_dri_fencemgr.c

   1 #include "ws_dri_fencemgr.h"
   2 #include "glthread.h"
   3 #include <xf86mm.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6
   7 /*
   8  * Note: Locking order is
   9  * _DriFenceObject::mutex
  10  * _DriFenceMgr::mutex
  11  */
  12
  13 struct _DriFenceMgr {
  14     /*
  15      * Constant members. Need no mutex protection.
  16      */
  17     struct _DriFenceMgrCreateInfo info;
  18     void *private;
  19
  20     /*
  21      * These members are protected by this->mutex
  22      */
  23     _glthread_Mutex mutex;
  24     int refCount;
  25     drmMMListHead *heads;
  26     int num_fences;
  27 };
  28
  29 struct _DriFenceObject {
  30
  31     /*
  32      * These members are constant and need no mutex protection.
  33      */
  34     struct _DriFenceMgr *mgr;
  35     uint32_t fence_class;
  36     uint32_t fence_type;
  37
  38     /*
  39      * These members are protected by mgr->mutex.
  40      */
  41     drmMMListHead head;
  42     int refCount;
  43
  44     /*
  45      * These members are protected by this->mutex.
  46      */
  47     _glthread_Mutex mutex;
  48     uint32_t signaled_type;
  49     void *private;
  50 };
  51
  52 uint32_t
  53 driFenceType(struct _DriFenceObject *fence)
  54 {
  55   return fence->fence_type;
  56 }
  57
  58 struct _DriFenceMgr *
  59 driFenceMgrCreate(const struct _DriFenceMgrCreateInfo *info)
  60 {
  61   struct _DriFenceMgr *tmp;
  62   uint32_t i;
  63
  64   tmp = calloc(1, sizeof(*tmp));
  65   if (!tmp)
  66       return NULL;
  67
  68   _glthread_INIT_MUTEX(tmp->mutex);
  69   _glthread_LOCK_MUTEX(tmp->mutex);
  70   tmp->refCount = 1;
  71   tmp->info = *info;
  72   tmp->num_fences = 0;
  73   tmp->heads = calloc(tmp->info.num_classes, sizeof(*tmp->heads));
  74   if (!tmp->heads)
  75       goto out_err;
  76
  77   for (i=0; i<tmp->info.num_classes; ++i) {
  78       DRMINITLISTHEAD(&tmp->heads[i]);
  79   }
  80   _glthread_UNLOCK_MUTEX(tmp->mutex);
  81   return tmp;
  82
  83   out_err:
  84   if (tmp)
  85       free(tmp);
  86   return NULL;
  87 }
  88
  89 static void
  90 driFenceMgrUnrefUnlock(struct _DriFenceMgr **pMgr)
  91 {
  92     struct _DriFenceMgr *mgr = *pMgr;
  93
  94     *pMgr = NULL;
  95     if (--mgr->refCount == 0)
  96         free(mgr);
  97     else
  98         _glthread_UNLOCK_MUTEX(mgr->mutex);
  99 }
 100
 101 void
 102 driFenceMgrUnReference(struct _DriFenceMgr **pMgr)
 103 {
 104     _glthread_LOCK_MUTEX((*pMgr)->mutex);
 105     driFenceMgrUnrefUnlock(pMgr);
 106 }
 107
 108 static void
 109 driFenceUnReferenceLocked(struct _DriFenceObject **pFence)
 110 {
 111     struct _DriFenceObject *fence = *pFence;
 112     struct _DriFenceMgr *mgr = fence->mgr;
 113
 114     *pFence = NULL;
 115     if (--fence->refCount == 0) {
 116         DRMLISTDELINIT(&fence->head);
 117         if (fence->private)
 118             mgr->info.unreference(mgr, &fence->private);
 119     --mgr->num_fences;
 120         fence->mgr = NULL;
 121         --mgr->refCount;
 122         free(fence);
 123
 124     }
 125 }
 126
 127
 128 static void
 129 driSignalPreviousFencesLocked(struct _DriFenceMgr *mgr,
 130                               drmMMListHead *list,
 131                               uint32_t fence_class,
 132                               uint32_t fence_type)
 133 {
 134     struct _DriFenceObject *entry;
 135     drmMMListHead *prev;
 136
 137     while(list != &mgr->heads[fence_class]) {
 138         entry = DRMLISTENTRY(struct _DriFenceObject, list, head);
 139
 140         /*
 141          * Up refcount so that entry doesn't disappear from under us
 142          * when we unlock-relock mgr to get the correct locking order.
 143          */
 144
 145         ++entry->refCount;
 146         _glthread_UNLOCK_MUTEX(mgr->mutex);
 147         _glthread_LOCK_MUTEX(entry->mutex);
 148         _glthread_LOCK_MUTEX(mgr->mutex);
 149
 150         prev = list->prev;
 151
 152
 153
 154         if (list->prev == list) {
 155
 156                 /*
 157                  * Somebody else removed the entry from the list.
 158                  */
 159
 160                 _glthread_UNLOCK_MUTEX(entry->mutex);
 161                 driFenceUnReferenceLocked(&entry);
 162                 return;
 163         }
 164
 165         entry->signaled_type |= (fence_type & entry->fence_type);
 166         if (entry->signaled_type == entry->fence_type) {
 167             DRMLISTDELINIT(list);
 168             mgr->info.unreference(mgr, &entry->private);
 169         }
 170         _glthread_UNLOCK_MUTEX(entry->mutex);
 171         driFenceUnReferenceLocked(&entry);
 172         list = prev;
 173     }
 174 }
 175
 176
 177 int
 178 driFenceFinish(struct _DriFenceObject *fence, uint32_t fence_type,
 179                int lazy_hint)
 180 {
 181     struct _DriFenceMgr *mgr = fence->mgr;
 182     int ret = 0;
 183
 184     _glthread_LOCK_MUTEX(fence->mutex);
 185
 186     if ((fence->signaled_type & fence_type) == fence_type)
 187         goto out0;
 188
 189     ret = mgr->info.finish(mgr, fence->private, fence_type, lazy_hint);
 190     if (ret)
 191         goto out0;
 192
 193     _glthread_LOCK_MUTEX(mgr->mutex);
 194     _glthread_UNLOCK_MUTEX(fence->mutex);
 195
 196     driSignalPreviousFencesLocked(mgr, &fence->head, fence->fence_class,
 197                                   fence_type);
 198     _glthread_UNLOCK_MUTEX(mgr->mutex);
 199     return 0;
 200
 201   out0:
 202     _glthread_UNLOCK_MUTEX(fence->mutex);
 203     return ret;
 204 }
 205
 206 uint32_t driFenceSignaledTypeCached(struct _DriFenceObject *fence)
 207 {
 208     uint32_t ret;
 209
 210     _glthread_LOCK_MUTEX(fence->mutex);
 211     ret = fence->signaled_type;
 212     _glthread_UNLOCK_MUTEX(fence->mutex);
 213
 214     return ret;
 215 }
 216
 217 int
 218 driFenceSignaledType(struct _DriFenceObject *fence, uint32_t flush_type,
 219                  uint32_t *signaled)
 220 {
 221     int ret = 0;
 222     struct _DriFenceMgr *mgr;
 223
 224     _glthread_LOCK_MUTEX(fence->mutex);
 225     mgr = fence->mgr;
 226     *signaled = fence->signaled_type;
 227     if ((fence->signaled_type & flush_type) == flush_type)
 228         goto out0;
 229
 230     ret = mgr->info.signaled(mgr, fence->private, flush_type, signaled);
 231     if (ret) {
 232         *signaled = fence->signaled_type;
 233         goto out0;
 234     }
 235
 236     if ((fence->signaled_type | *signaled) == fence->signaled_type)
 237         goto out0;
 238
 239     _glthread_LOCK_MUTEX(mgr->mutex);
 240     _glthread_UNLOCK_MUTEX(fence->mutex);
 241
 242     driSignalPreviousFencesLocked(mgr, &fence->head, fence->fence_class,
 243                                   *signaled);
 244
 245     _glthread_UNLOCK_MUTEX(mgr->mutex);
 246     return 0;
 247   out0:
 248     _glthread_UNLOCK_MUTEX(fence->mutex);
 249     return ret;
 250 }
 251
 252 struct _DriFenceObject *
 253 driFenceReference(struct _DriFenceObject *fence)
 254 {
 255     _glthread_LOCK_MUTEX(fence->mgr->mutex);
 256     ++fence->refCount;
 257     _glthread_UNLOCK_MUTEX(fence->mgr->mutex);
 258     return fence;
 259 }
 260
 261 void
 262 driFenceUnReference(struct _DriFenceObject **pFence)
 263 {
 264     struct _DriFenceMgr *mgr;
 265
 266     if (*pFence == NULL)
 267         return;
 268
 269     mgr = (*pFence)->mgr;
 270     _glthread_LOCK_MUTEX(mgr->mutex);
 271     ++mgr->refCount;
 272     driFenceUnReferenceLocked(pFence);
 273     driFenceMgrUnrefUnlock(&mgr);
 274 }
 275
 276 struct _DriFenceObject
 277 *driFenceCreate(struct _DriFenceMgr *mgr, uint32_t fence_class,
 278                 uint32_t fence_type, void *private, size_t private_size)
 279 {
 280     struct _DriFenceObject *fence;
 281     size_t fence_size = sizeof(*fence);
 282
 283     if (private_size)
 284         fence_size = ((fence_size + 15) & ~15);
 285
 286     fence = calloc(1, fence_size + private_size);
 287
 288     if (!fence) {
 289         int ret = mgr->info.finish(mgr, private, fence_type, 0);
 290
 291         if (ret)
 292             usleep(10000000);
 293
 294         return NULL;
 295     }
 296
 297     _glthread_INIT_MUTEX(fence->mutex);
 298     _glthread_LOCK_MUTEX(fence->mutex);
 299     _glthread_LOCK_MUTEX(mgr->mutex);
 300     fence->refCount = 1;
 301     DRMLISTADDTAIL(&fence->head, &mgr->heads[fence_class]);
 302     fence->mgr = mgr;
 303     ++mgr->refCount;
 304     ++mgr->num_fences;
 305     _glthread_UNLOCK_MUTEX(mgr->mutex);
 306     fence->fence_class = fence_class;
 307     fence->fence_type = fence_type;
 308     fence->signaled_type = 0;
 309     fence->private = private;
 310     if (private_size) {
 311         fence->private = (void *)(((uint8_t *) fence) + fence_size);
 312         memcpy(fence->private, private, private_size);
 313     }
 314
 315     _glthread_UNLOCK_MUTEX(fence->mutex);
 316     return fence;
 317 }
 318
 319
 320 static int
 321 tSignaled(struct _DriFenceMgr *mgr, void *private, uint32_t flush_type,
 322           uint32_t *signaled_type)
 323 {
 324   long fd = (long) mgr->private;
 325   int dummy;
 326   drmFence *fence = (drmFence *) private;
 327   int ret;
 328
 329   *signaled_type = 0;
 330   ret = drmFenceSignaled((int) fd, fence, flush_type, &dummy);
 331   if (ret)
 332     return ret;
 333
 334   *signaled_type = fence->signaled;
 335
 336   return 0;
 337 }
 338
 339 static int
 340 tFinish(struct _DriFenceMgr *mgr, void *private, uint32_t fence_type,
 341         int lazy_hint)
 342 {
 343   long fd = (long) mgr->private;
 344   unsigned flags = lazy_hint ? DRM_FENCE_FLAG_WAIT_LAZY : 0;
 345
 346   return drmFenceWait((int)fd, flags, (drmFence *) private, fence_type);
 347 }
 348
 349 static int
 350 tUnref(struct _DriFenceMgr *mgr, void **private)
 351 {
 352   long fd = (long) mgr->private;
 353   drmFence *fence = (drmFence *) *private;
 354   *private = NULL;
 355
 356   return drmFenceUnreference(fd, fence);
 357 }
 358
 359 struct _DriFenceMgr *driFenceMgrTTMInit(int fd)
 360 {
 361   struct _DriFenceMgrCreateInfo info;
 362   struct _DriFenceMgr *mgr;
 363
 364   info.flags = DRI_FENCE_CLASS_ORDERED;
 365   info.num_classes = 4;
 366   info.signaled = tSignaled;
 367   info.finish = tFinish;
 368   info.unreference = tUnref;
 369
 370   mgr = driFenceMgrCreate(&info);
 371   if (mgr == NULL)
 372     return NULL;
 373
 374   mgr->private = (void *) (long) fd;
 375   return mgr;
 376 }
 377