ws_dri_fencemgr.c File Reference

Include dependency graph for ws_dri_fencemgr.c:

Go to the source code of this file.

Data Structures
struct	_DriFenceMgr
struct	_DriFenceObject
Functions
uint32_t	driFenceType (struct _DriFenceObject *fence)
struct _DriFenceMgr *	driFenceMgrCreate (const struct _DriFenceMgrCreateInfo *info)
static void	driFenceMgrUnrefUnlock (struct _DriFenceMgr **pMgr)
void	driFenceMgrUnReference (struct _DriFenceMgr **pMgr)
static void	driFenceUnReferenceLocked (struct _DriFenceObject **pFence)
static void	driSignalPreviousFencesLocked (struct _DriFenceMgr *mgr, drmMMListHead *list, uint32_t fence_class, uint32_t fence_type)
int	driFenceFinish (struct _DriFenceObject *fence, uint32_t fence_type, int lazy_hint)
uint32_t	driFenceSignaledTypeCached (struct _DriFenceObject *fence)
int	driFenceSignaledType (struct _DriFenceObject *fence, uint32_t flush_type, uint32_t *signaled)
struct _DriFenceObject *	driFenceReference (struct _DriFenceObject *fence)
void	driFenceUnReference (struct _DriFenceObject **pFence)
struct _DriFenceObject *	driFenceCreate (struct _DriFenceMgr *mgr, uint32_t fence_class, uint32_t fence_type, void *private, size_t private_size)
static int	tSignaled (struct _DriFenceMgr *mgr, void *private, uint32_t flush_type, uint32_t *signaled_type)
static int	tFinish (struct _DriFenceMgr *mgr, void *private, uint32_t fence_type, int lazy_hint)
static int	tUnref (struct _DriFenceMgr *mgr, void **private)
struct _DriFenceMgr *	driFenceMgrTTMInit (int fd)

---

Function Documentation

struct _DriFenceObject* driFenceCreate	(	struct _DriFenceMgr *	mgr,
		uint32_t	fence_class,
		uint32_t	fence_type,
		void *	private,
		size_t	private_size
	)			[read]

Definition at line 277 of file ws_dri_fencemgr.c.

References _DriFenceObject::fence_class, _DriFenceObject::fence_type, _DriFenceMgrCreateInfo::finish, _DriFenceObject::head, _DriFenceMgr::heads, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::mutex, _DriFenceObject::mutex, _DriFenceMgr::num_fences, pipe_mutex_init, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, _DriFenceMgr::refCount, _DriFenceObject::refCount, and _DriFenceObject::signaled_type.

{
    struct _DriFenceObject *fence;
    size_t fence_size = sizeof(*fence);

    if (private_size)
        fence_size = ((fence_size + 15) & ~15);

    fence = calloc(1, fence_size + private_size);

    if (!fence) {
        int ret = mgr->info.finish(mgr, private, fence_type, 0);

        if (ret)
            usleep(10000000);

        return NULL;
    }

    pipe_mutex_init(fence->mutex);
    pipe_mutex_lock(fence->mutex);
    pipe_mutex_lock(mgr->mutex);
    fence->refCount = 1;
    DRMLISTADDTAIL(&fence->head, &mgr->heads[fence_class]);
    fence->mgr = mgr;
    ++mgr->refCount;
    ++mgr->num_fences;
    pipe_mutex_unlock(mgr->mutex);
    fence->fence_class = fence_class;
    fence->fence_type = fence_type;
    fence->signaled_type = 0;
    fence->private = private;
    if (private_size) {
        fence->private = (void *)(((uint8_t *) fence) + fence_size);
        memcpy(fence->private, private, private_size);
    }

    pipe_mutex_unlock(fence->mutex);
    return fence;
}

int driFenceFinish	(	struct _DriFenceObject *	fence,
		uint32_t	fence_type,
		int	lazy_hint
	)

Definition at line 178 of file ws_dri_fencemgr.c.

References driSignalPreviousFencesLocked(), _DriFenceObject::fence_class, _DriFenceMgrCreateInfo::finish, _DriFenceObject::head, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::mutex, _DriFenceObject::mutex, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, and _DriFenceObject::signaled_type.

{
    struct _DriFenceMgr *mgr = fence->mgr;
    int ret = 0;

    pipe_mutex_lock(fence->mutex);

    if ((fence->signaled_type & fence_type) == fence_type)
        goto out0;

    ret = mgr->info.finish(mgr, fence->private, fence_type, lazy_hint);
    if (ret)
        goto out0;

    pipe_mutex_lock(mgr->mutex);
    pipe_mutex_unlock(fence->mutex);

    driSignalPreviousFencesLocked(mgr, &fence->head, fence->fence_class,
                                  fence_type);
    pipe_mutex_unlock(mgr->mutex);
    return 0;

  out0:
    pipe_mutex_unlock(fence->mutex);
    return ret;
}

struct _DriFenceMgr* driFenceMgrCreate

(

const struct _DriFenceMgrCreateInfo *

info

)

[read]

Definition at line 59 of file ws_dri_fencemgr.c.

References _DriFenceMgr::heads, _DriFenceMgr::info, _DriFenceMgr::mutex, _DriFenceMgrCreateInfo::num_classes, _DriFenceMgr::num_fences, pipe_mutex_init, pipe_mutex_lock, pipe_mutex_unlock, and _DriFenceMgr::refCount.

{
  struct _DriFenceMgr *tmp;
  uint32_t i;

  tmp = calloc(1, sizeof(*tmp));
  if (!tmp)
      return NULL;

  pipe_mutex_init(tmp->mutex);
  pipe_mutex_lock(tmp->mutex);
  tmp->refCount = 1;
  tmp->info = *info;
  tmp->num_fences = 0;
  tmp->heads = calloc(tmp->info.num_classes, sizeof(*tmp->heads));
  if (!tmp->heads)
      goto out_err;

  for (i=0; i<tmp->info.num_classes; ++i) {
      DRMINITLISTHEAD(&tmp->heads[i]);
  }
  pipe_mutex_unlock(tmp->mutex);
  return tmp;

  out_err:
  if (tmp)
      free(tmp);
  return NULL;
}

struct _DriFenceMgr* driFenceMgrTTMInit

(

int

fd

)

[read]

Definition at line 359 of file ws_dri_fencemgr.c.

References DRI_FENCE_CLASS_ORDERED, driFenceMgrCreate(), _DriFenceMgrCreateInfo::finish, _DriFenceMgrCreateInfo::flags, _DriFenceMgrCreateInfo::num_classes, _DriFenceMgr::private, _DriFenceMgrCreateInfo::signaled, tFinish(), tSignaled(), tUnref(), and _DriFenceMgrCreateInfo::unreference.

{
  struct _DriFenceMgrCreateInfo info;
  struct _DriFenceMgr *mgr;

  info.flags = DRI_FENCE_CLASS_ORDERED;
  info.num_classes = 4;
  info.signaled = tSignaled;
  info.finish = tFinish;
  info.unreference = tUnref;

  mgr = driFenceMgrCreate(&info);
  if (mgr == NULL)
    return NULL;

  mgr->private = (void *) (long) fd;
  return mgr;
}

void driFenceMgrUnReference

(

struct _DriFenceMgr **

pMgr

)

Definition at line 102 of file ws_dri_fencemgr.c.

References driFenceMgrUnrefUnlock(), and pipe_mutex_lock.

{
    pipe_mutex_lock((*pMgr)->mutex);
    driFenceMgrUnrefUnlock(pMgr);
}

static void driFenceMgrUnrefUnlock

(

struct _DriFenceMgr **

pMgr

)

[static]

Definition at line 90 of file ws_dri_fencemgr.c.

References _DriFenceMgr::mutex, pipe_mutex_unlock, and _DriFenceMgr::refCount.

{
    struct _DriFenceMgr *mgr = *pMgr;

    *pMgr = NULL;
    if (--mgr->refCount == 0)
        free(mgr);
    else
        pipe_mutex_unlock(mgr->mutex);
}

struct _DriFenceObject* driFenceReference

(

struct _DriFenceObject *

fence

)

[read]

Definition at line 253 of file ws_dri_fencemgr.c.

References _DriFenceObject::mgr, _DriFenceMgr::mutex, pipe_mutex_lock, pipe_mutex_unlock, and _DriFenceObject::refCount.

{
    pipe_mutex_lock(fence->mgr->mutex);
    ++fence->refCount;
    pipe_mutex_unlock(fence->mgr->mutex);
    return fence;
}

int driFenceSignaledType	(	struct _DriFenceObject *	fence,
		uint32_t	flush_type,
		uint32_t *	signaled
	)

Definition at line 218 of file ws_dri_fencemgr.c.

References driSignalPreviousFencesLocked(), _DriFenceObject::fence_class, _DriFenceObject::head, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::mutex, _DriFenceObject::mutex, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, _DriFenceMgrCreateInfo::signaled, and _DriFenceObject::signaled_type.

{
    int ret = 0;
    struct _DriFenceMgr *mgr;

    pipe_mutex_lock(fence->mutex);
    mgr = fence->mgr;
    *signaled = fence->signaled_type;
    if ((fence->signaled_type & flush_type) == flush_type)
        goto out0;

    ret = mgr->info.signaled(mgr, fence->private, flush_type, signaled);
    if (ret) {
        *signaled = fence->signaled_type;
        goto out0;
    }

    if ((fence->signaled_type | *signaled) == fence->signaled_type)
        goto out0;

    pipe_mutex_lock(mgr->mutex);
    pipe_mutex_unlock(fence->mutex);

    driSignalPreviousFencesLocked(mgr, &fence->head, fence->fence_class,
                                  *signaled);

    pipe_mutex_unlock(mgr->mutex);
    return 0;
  out0:
    pipe_mutex_unlock(fence->mutex);
    return ret;
}

uint32_t driFenceSignaledTypeCached

(

struct _DriFenceObject *

fence

)

Definition at line 206 of file ws_dri_fencemgr.c.

References _DriFenceObject::mutex, pipe_mutex_lock, pipe_mutex_unlock, and _DriFenceObject::signaled_type.

{
    uint32_t ret;

    pipe_mutex_lock(fence->mutex);
    ret = fence->signaled_type;
    pipe_mutex_unlock(fence->mutex);

    return ret;
}

uint32_t driFenceType

(

struct _DriFenceObject *

fence

)

Definition at line 53 of file ws_dri_fencemgr.c.

References _DriFenceObject::fence_type.

{
  return fence->fence_type;
}

void driFenceUnReference

(

struct _DriFenceObject **

pFence

)

Definition at line 262 of file ws_dri_fencemgr.c.

References driFenceMgrUnrefUnlock(), driFenceUnReferenceLocked(), _DriFenceMgr::mutex, pipe_mutex_lock, and _DriFenceMgr::refCount.

{
    struct _DriFenceMgr *mgr;

    if (*pFence == NULL)
        return;

    mgr = (*pFence)->mgr;
    pipe_mutex_lock(mgr->mutex);
    ++mgr->refCount;
    driFenceUnReferenceLocked(pFence);
    driFenceMgrUnrefUnlock(&mgr);
}

static void driFenceUnReferenceLocked

(

struct _DriFenceObject **

pFence

)

[static]

Definition at line 109 of file ws_dri_fencemgr.c.

References _DriFenceObject::head, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::num_fences, _DriFenceObject::private, _DriFenceMgr::refCount, _DriFenceObject::refCount, and _DriFenceMgrCreateInfo::unreference.

{
    struct _DriFenceObject *fence = *pFence;
    struct _DriFenceMgr *mgr = fence->mgr;

    *pFence = NULL;
    if (--fence->refCount == 0) {
        DRMLISTDELINIT(&fence->head);
        if (fence->private)
            mgr->info.unreference(mgr, &fence->private);
    --mgr->num_fences;
        fence->mgr = NULL;
        --mgr->refCount;
        free(fence);

    }
}

static void driSignalPreviousFencesLocked	(	struct _DriFenceMgr *	mgr,
		drmMMListHead *	list,
		uint32_t	fence_class,
		uint32_t	fence_type
	)			[static]

Definition at line 129 of file ws_dri_fencemgr.c.

References driFenceUnReferenceLocked(), _DriFenceObject::fence_type, _DriFenceObject::head, _DriFenceMgr::heads, _DriFenceMgr::info, _DriFenceObject::mutex, _DriFenceMgr::mutex, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, _DriFenceObject::refCount, _DriFenceObject::signaled_type, and _DriFenceMgrCreateInfo::unreference.

{
    struct _DriFenceObject *entry;
    drmMMListHead *prev;

    while(list != &mgr->heads[fence_class]) {
        entry = DRMLISTENTRY(struct _DriFenceObject, list, head);

        /*
         * Up refcount so that entry doesn't disappear from under us
         * when we unlock-relock mgr to get the correct locking order.
         */

        ++entry->refCount;
        pipe_mutex_unlock(mgr->mutex);
        pipe_mutex_lock(entry->mutex);
        pipe_mutex_lock(mgr->mutex);

        prev = list->prev;



        if (list->prev == list) {

                /*
                 * Somebody else removed the entry from the list.
                 */

                pipe_mutex_unlock(entry->mutex);
                driFenceUnReferenceLocked(&entry);
                return;
        }

        entry->signaled_type |= (fence_type & entry->fence_type);
        if (entry->signaled_type == entry->fence_type) {
            DRMLISTDELINIT(list);
            mgr->info.unreference(mgr, &entry->private);
        }
        pipe_mutex_unlock(entry->mutex);
        driFenceUnReferenceLocked(&entry);
        list = prev;
    }
}

static int tFinish	(	struct _DriFenceMgr *	mgr,
		void *	private,
		uint32_t	fence_type,
		int	lazy_hint
	)			[static]

Definition at line 340 of file ws_dri_fencemgr.c.

References _DriFenceMgr::private.

{
  long fd = (long) mgr->private;
  unsigned flags = lazy_hint ? DRM_FENCE_FLAG_WAIT_LAZY : 0;

  return drmFenceWait((int)fd, flags, (drmFence *) private, fence_type);
}

static int tSignaled	(	struct _DriFenceMgr *	mgr,
		void *	private,
		uint32_t	flush_type,
		uint32_t *	signaled_type
	)			[static]

Definition at line 321 of file ws_dri_fencemgr.c.

References _DriFenceMgr::private.

{
  long fd = (long) mgr->private;
  int dummy;
  drmFence *fence = (drmFence *) private;
  int ret;

  *signaled_type = 0;
  ret = drmFenceSignaled((int) fd, fence, flush_type, &dummy);
  if (ret)
    return ret;

  *signaled_type = fence->signaled;

  return 0;
}

static int tUnref	(	struct _DriFenceMgr *	mgr,
		void **	private
	)			[static]

Definition at line 350 of file ws_dri_fencemgr.c.

References _DriFenceMgr::private.

{
  long fd = (long) mgr->private;
  drmFence *fence = (drmFence *) *private;
  *private = NULL;

  return drmFenceUnreference(fd, fence);
}

---