/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void radeonGetLock(radeonContextPtr rmesa, GLuint flags) { __DRIdrawablePrivate *const drawable = radeon_get_drawable(rmesa); __DRIdrawablePrivate *const readable = radeon_get_readable(rmesa); __DRIscreenPrivate *sPriv = rmesa->dri.screen; drmGetLock(rmesa->dri.fd, rmesa->dri.hwContext, flags); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ if (drawable) DRI_VALIDATE_DRAWABLE_INFO(sPriv, drawable); if (readable && drawable != readable) { DRI_VALIDATE_DRAWABLE_INFO(sPriv, readable); } if (drawable && (rmesa->lastStamp != drawable->lastStamp)) { radeon_window_moved(rmesa); rmesa->lastStamp = drawable->lastStamp; } rmesa->vtbl.get_lock(rmesa); }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void radeonGetLock(radeonContextPtr radeon, GLuint flags) { __DRIdrawablePrivate *dPriv = radeon->dri.drawable; __DRIscreenPrivate *sPriv = radeon->dri.screen; drm_radeon_sarea_t *sarea = radeon->sarea; drmGetLock(radeon->dri.fd, radeon->dri.hwContext, flags); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO(sPriv, dPriv); if (sarea->ctx_owner != radeon->dri.hwContext) sarea->ctx_owner = radeon->dri.hwContext; if (IS_FAMILY_R300(radeon)) r300RegainedLock(radeon); #if R200_MERGED else r200RegainedLock((r200ContextPtr)radeon); #endif radeon->lost_context = GL_TRUE; }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void sisGetLock( sisContextPtr smesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = smesa->driDrawable; __DRIscreenPrivate *sPriv = smesa->driScreen; SISSAREAPrivPtr sarea = smesa->sarea; drmGetLock( smesa->driFd, smesa->hHWContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv ); if ( smesa->lastStamp != dPriv->lastStamp ) { sisUpdateBufferSize( smesa ); sisUpdateClipping( smesa->glCtx ); sisDDDrawBuffer( smesa->glCtx, smesa->glCtx->Color.DrawBuffer ); smesa->lastStamp = dPriv->lastStamp; } if ( sarea->CtxOwner != smesa->hHWContext ) { sarea->CtxOwner = smesa->hHWContext; smesa->GlobalFlag = GFLAG_ALL; } }
static void client() { int drmfd, ret; unsigned int time; wait_event(0, SERVER_READY); /* XXX: Should make sure we open the same DRM as the master */ drmfd = drm_open_any(); client_auth(drmfd); /* Wait for the server to grab the lock, then grab it ourselves (to * contest it). Hopefully we hit it within the window of when the * server locks. */ wait_event(0, SERVER_LOCKED); ret = drmGetLock(drmfd, lock2, 0); time = get_millis(); if (ret != 0) err(1, "Failed to get lock on client\n"); drmUnlock(drmfd, lock2); /* Tell the server that our locking completed, and when it did */ send_event(0, CLIENT_LOCKED); ret = write(commfd[0], &time, sizeof(time)); close(drmfd); exit(0); }
void tdfxGetLock( tdfxContextPtr fxMesa ) { __DRIcontextPrivate *cPriv = fxMesa->driContext; __DRIdrawablePrivate *const drawable = cPriv->driDrawablePriv; __DRIdrawablePrivate *const readable = cPriv->driReadablePriv; __DRIscreenPrivate *sPriv = drawable->driScreenPriv; TDFXSAREAPriv *saPriv = (TDFXSAREAPriv *) (((char *) sPriv->pSAREA) + fxMesa->fxScreen->sarea_priv_offset); unsigned int stamp = drawable->lastStamp; drmGetLock( fxMesa->driFd, fxMesa->hHWContext, 0 ); /* This macro will update drawable's cliprects if needed */ DRI_VALIDATE_DRAWABLE_INFO(sPriv, drawable); if (drawable != readable) { DRI_VALIDATE_DRAWABLE_INFO(sPriv, readable); } if ( saPriv->fifoOwner != fxMesa->hHWContext ) { fxMesa->Glide.grDRIImportFifo( saPriv->fifoPtr, saPriv->fifoRead ); } if ( saPriv->ctxOwner != fxMesa->hHWContext ) { /* This sequence looks a little odd. Glide mirrors the state, and * when you get the state you are forcing the mirror to be up to * date, and then getting a copy from the mirror. You can then force * that state onto the hardware when you set the state. */ void *state; FxI32 stateSize; fxMesa->Glide.grGet(GR_GLIDE_STATE_SIZE, 4, &stateSize); state = malloc(stateSize); fxMesa->Glide.grGlideGetState( state ); fxMesa->Glide.grGlideSetState( state ); free( state ); } #if 0 if ( saPriv->texOwner != fxMesa->hHWContext ) { tdfxTMRestoreTextures_NoLock( fxMesa ); } #endif if ((*drawable->pStamp != stamp) || (saPriv->ctxOwner != fxMesa->hHWContext)) { driUpdateFramebufferSize(fxMesa->glCtx, drawable); if (drawable != readable) { driUpdateFramebufferSize(fxMesa->glCtx, readable); } tdfxUpdateClipping(fxMesa->glCtx); tdfxUploadClipping(fxMesa); } DEBUG_LOCK(); }
/** Tests that locking is successful in normal conditions */ static void test_lock_unlock(int drmfd) { int ret; ret = drmGetLock(drmfd, lock1, 0); if (ret != 0) err(1, "Locking failed"); ret = drmUnlock(drmfd, lock1); if (ret != 0) err(1, "Unlocking failed"); }
/** * Tests that an open/close by the same process doesn't result in the lock * being dropped. */ static void test_open_close_locked(drmfd) { int ret, tempfd; ret = drmGetLock(drmfd, lock1, 0); assert(ret == 0); /* XXX: Need to make sure that this is the same device as drmfd */ tempfd = drm_open_any(); close(tempfd); ret = drmUnlock(drmfd, lock1); if (ret != 0) errx(1, "lock lost during open/close by same pid"); }
/** Tests that unlocking a lock held by another context fails appropriately */ static void test_unlock_unowned(int drmfd) { int ret; ret = drmGetLock(drmfd, lock1, 0); assert(ret == 0); ret = drmUnlock(drmfd, lock2); if (ret == 0) errx(1, "Unlocking other context's lock succeeded"); ret = drmUnlock(drmfd, lock1); assert(ret == 0); }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void mach64GetLock( mach64ContextPtr mmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = mmesa->driDrawable; __DRIscreenPrivate *sPriv = mmesa->driScreen; drm_mach64_sarea_t *sarea = mmesa->sarea; int i; drmGetLock( mmesa->driFd, mmesa->hHWContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv ); if ( mmesa->lastStamp != dPriv->lastStamp ) { mmesa->lastStamp = dPriv->lastStamp; if (mmesa->glCtx->DrawBuffer->_ColorDrawBufferIndexes[0] == BUFFER_BACK_LEFT) mach64SetCliprects( mmesa->glCtx, GL_BACK_LEFT ); else mach64SetCliprects( mmesa->glCtx, GL_FRONT_LEFT ); driUpdateFramebufferSize( mmesa->glCtx, dPriv ); mach64CalcViewport( mmesa->glCtx ); } mmesa->dirty |= (MACH64_UPLOAD_CONTEXT | MACH64_UPLOAD_MISC | MACH64_UPLOAD_CLIPRECTS); /* EXA render acceleration uses the texture engine, so restore it */ mmesa->dirty |= (MACH64_UPLOAD_TEXTURE); if ( sarea->ctx_owner != mmesa->hHWContext ) { sarea->ctx_owner = mmesa->hHWContext; mmesa->dirty = MACH64_UPLOAD_ALL; } for ( i = mmesa->firstTexHeap ; i < mmesa->lastTexHeap ; i++ ) { DRI_AGE_TEXTURES( mmesa->texture_heaps[i] ); } }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void r200GetLock( r200ContextPtr rmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = rmesa->dri.drawable; __DRIscreenPrivate *sPriv = rmesa->dri.screen; drm_radeon_sarea_t *sarea = rmesa->sarea; int i; drmGetLock( rmesa->dri.fd, rmesa->dri.hwContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv ); if ( rmesa->lastStamp != dPriv->lastStamp ) { r200UpdatePageFlipping( rmesa ); if (rmesa->glCtx->DrawBuffer->_ColorDrawBufferMask[0] == BUFFER_BIT_BACK_LEFT) r200SetCliprects( rmesa, GL_BACK_LEFT ); else r200SetCliprects( rmesa, GL_FRONT_LEFT ); r200UpdateViewportOffset( rmesa->glCtx ); rmesa->lastStamp = dPriv->lastStamp; } R200_STATECHANGE( rmesa, ctx ); if (rmesa->sarea->tiling_enabled) { rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] |= R200_COLOR_TILE_ENABLE; } else rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] &= ~R200_COLOR_TILE_ENABLE; if ( sarea->ctx_owner != rmesa->dri.hwContext ) { sarea->ctx_owner = rmesa->dri.hwContext; } for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) { DRI_AGE_TEXTURES( rmesa->texture_heaps[ i ] ); } rmesa->lost_context = GL_TRUE; }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void radeonGetLock(radeonContextPtr rmesa, GLuint flags) { __DRIdrawablePrivate *const drawable = rmesa->dri.drawable; __DRIdrawablePrivate *const readable = rmesa->dri.readable; __DRIscreenPrivate *sPriv = rmesa->dri.screen; drm_radeon_sarea_t *sarea = rmesa->sarea; r300ContextPtr r300 = (r300ContextPtr) rmesa; assert(drawable != NULL); drmGetLock(rmesa->dri.fd, rmesa->dri.hwContext, flags); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO(sPriv, drawable); if (drawable != readable) { DRI_VALIDATE_DRAWABLE_INFO(sPriv, readable); } if (rmesa->lastStamp != drawable->lastStamp) { radeonUpdatePageFlipping(rmesa); radeonSetCliprects(rmesa); r300UpdateViewportOffset(rmesa->glCtx); driUpdateFramebufferSize(rmesa->glCtx, drawable); } if (sarea->ctx_owner != rmesa->dri.hwContext) { int i; sarea->ctx_owner = rmesa->dri.hwContext; for (i = 0; i < r300->nr_heaps; i++) { DRI_AGE_TEXTURES(r300->texture_heaps[i]); } } rmesa->lost_context = GL_TRUE; }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void s3vGetLock( s3vContextPtr vmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = vmesa->driDrawable; /* __DRIscreenPrivate *sPriv = vmesa->driScreen; */ printf("s3vGetLock <- ***\n"); drmGetLock( vmesa->driFd, vmesa->hHWContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ /* DRI_VALIDATE_DRAWABLE_INFO( vmesa->display, sPriv, dPriv ); */ if ( vmesa->lastStamp != dPriv->lastStamp ) { vmesa->lastStamp = dPriv->lastStamp; vmesa->new_state |= S3V_NEW_WINDOW | S3V_NEW_CLIP; } vmesa->numClipRects = dPriv->numClipRects; vmesa->pClipRects = dPriv->pClipRects; #if 0 vmesa->dirty = ~0; if ( sarea->ctxOwner != vmesa->hHWContext ) { sarea->ctxOwner = vmesa->hHWContext; vmesa->dirty = S3V_UPLOAD_ALL; } for ( i = 0 ; i < vmesa->lastTexHeap ; i++ ) { if ( sarea->texAge[i] != vmesa->lastTexAge[i] ) { s3vAgeTextures( vmesa, i ); } } #endif }
/* Lock the hardware and validate our state. */ void LOCK_HARDWARE(struct nouveau_context *nv) { struct nouveau_screen *nv_screen = nv->dri_screen->private; struct nouveau_device *dev = nv_screen->device; struct nouveau_device_priv *nvdev = nouveau_device(dev); char __ret=0; assert(!nv->locked); pipe_mutex_lock(lockMutex); DRM_CAS(nvdev->lock, nvdev->ctx, (DRM_LOCK_HELD | nvdev->ctx), __ret); if (__ret) { drmGetLock(nvdev->fd, nvdev->ctx, 0); nouveau_contended_lock(nv); } nv->locked = 1; }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void gammaGetLock( gammaContextPtr gmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = gmesa->driDrawable; __DRIscreenPrivate *sPriv = gmesa->driScreen; drmGetLock( gmesa->driFd, gmesa->hHWContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv ); if ( gmesa->lastStamp != dPriv->lastStamp ) { driUpdateFramebufferSize(gmesa->glCtx, dPriv); gmesa->lastStamp = dPriv->lastStamp; gmesa->new_state |= GAMMA_NEW_WINDOW | GAMMA_NEW_CLIP; } gmesa->numClipRects = dPriv->numClipRects; gmesa->pClipRects = dPriv->pClipRects; #if 0 gmesa->dirty = ~0; if ( sarea->ctxOwner != gmesa->hHWContext ) { sarea->ctxOwner = gmesa->hHWContext; gmesa->dirty = GAMMA_UPLOAD_ALL; } for ( i = 0 ; i < gmesa->lastTexHeap ; i++ ) { if ( sarea->texAge[i] != gmesa->lastTexAge[i] ) { gammaAgeTextures( gmesa, i ); } } #endif }
/* Update the hardware state. This is called if another main/context.has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void r128GetLock( r128ContextPtr rmesa, GLuint flags ) { __DRIdrawable *dPriv = rmesa->driDrawable; __DRIscreen *sPriv = rmesa->driScreen; drm_r128_sarea_t *sarea = rmesa->sarea; int i; drmGetLock( rmesa->driFd, rmesa->hHWContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv ); if ( rmesa->lastStamp != dPriv->lastStamp ) { r128UpdatePageFlipping( rmesa ); driUpdateFramebufferSize(rmesa->glCtx, dPriv); rmesa->lastStamp = dPriv->lastStamp; rmesa->new_state |= R128_NEW_CLIP; RENDERINPUTS_ONES( rmesa->tnl_state_bitset ); } rmesa->dirty |= R128_UPLOAD_CONTEXT | R128_UPLOAD_CLIPRECTS; rmesa->numClipRects = dPriv->numClipRects; rmesa->pClipRects = dPriv->pClipRects; if ( sarea->ctx_owner != rmesa->hHWContext ) { sarea->ctx_owner = rmesa->hHWContext; rmesa->dirty = R128_UPLOAD_ALL; } for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) { DRI_AGE_TEXTURES( rmesa->texture_heaps[i] ); } }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void nouveauGetLock( nouveauContextPtr nmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = nmesa->driDrawable; __DRIscreenPrivate *sPriv = nmesa->driScreen; drm_nouveau_sarea_t *sarea = nmesa->sarea; drmGetLock( nmesa->driFd, nmesa->hHWContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv ); /* If timestamps don't match, the window has been changed */ if (nmesa->lastStamp != dPriv->lastStamp) { struct gl_framebuffer *fb = (struct gl_framebuffer *)dPriv->driverPrivate; /* _mesa_resize_framebuffer will take care of calling the renderbuffer's * AllocStorage function if we need more memory to hold it */ if (fb->Width != dPriv->w || fb->Height != dPriv->h) { _mesa_resize_framebuffer(nmesa->glCtx, fb, dPriv->w, dPriv->h); /* resize buffers, will call nouveau_window_moved */ nouveau_build_framebuffer(nmesa->glCtx, fb); } else { nouveau_window_moved(nmesa->glCtx); } nmesa->lastStamp = dPriv->lastStamp; } nmesa->numClipRects = dPriv->numClipRects; nmesa->pClipRects = dPriv->pClipRects; }
static void server() { int drmfd, tempfd, ret; unsigned int client_time, unlock_time; drmfd = drm_open_any_master(); test_lock_unlock(drmfd); test_unlock_unlocked(drmfd); test_unlock_unowned(drmfd); test_open_close_locked(drmfd); /* Perform the authentication sequence with the client. */ server_auth(drmfd); /* Now, test that the client attempting to lock while the server * holds the lock works correctly. */ ret = drmGetLock(drmfd, lock1, 0); assert(ret == 0); send_event(1, SERVER_LOCKED); /* Wait a while for the client to do its thing */ sleep(1); ret = drmUnlock(drmfd, lock1); assert(ret == 0); unlock_time = get_millis(); wait_event(1, CLIENT_LOCKED); ret = read(commfd[1], &client_time, sizeof(client_time)); if (ret == -1) err(1, "Failure to read client magic"); if (client_time < unlock_time) errx(1, "Client took lock before server released it"); close(drmfd); }
/* Update the hardware state. This is called if another context has * grabbed the hardware lock, which includes the X server. This * function also updates the driver's window state after the X server * moves, resizes or restacks a window -- the change will be reflected * in the drawable position and clip rects. Since the X server grabs * the hardware lock when it changes the window state, this routine will * automatically be called after such a change. */ void radeonGetLock( radeonContextPtr rmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = rmesa->dri.drawable; __DRIscreenPrivate *sPriv = rmesa->dri.screen; RADEONSAREAPrivPtr sarea = rmesa->sarea; int i; drmGetLock( rmesa->dri.fd, rmesa->dri.hwContext, flags ); /* The window might have moved, so we might need to get new clip * rects. * * NOTE: This releases and regrabs the hw lock to allow the X server * to respond to the DRI protocol request for new drawable info. * Since the hardware state depends on having the latest drawable * clip rects, all state checking must be done _after_ this call. */ DRI_VALIDATE_DRAWABLE_INFO( rmesa->dri.display, sPriv, dPriv ); if ( rmesa->lastStamp != dPriv->lastStamp ) { radeonUpdatePageFlipping( rmesa ); radeonSetCliprects( rmesa, rmesa->glCtx->Color.DriverDrawBuffer ); radeonUpdateViewportOffset( rmesa->glCtx ); rmesa->lastStamp = dPriv->lastStamp; } if ( sarea->ctxOwner != rmesa->dri.hwContext ) { sarea->ctxOwner = rmesa->dri.hwContext; for ( i = 0 ; i < rmesa->texture.numHeaps ; i++ ) { if ( rmesa->texture.heap[i] && sarea->texAge[i] != rmesa->texture.age[i] ) { radeonAgeTextures( rmesa, i ); } } } }
struct bufmgr * bm_intel_Attach(struct intel_context *intel) { GLuint i; for (i = 0; i < nr_bms; i++) if (bufmgr_pool[i].driFd == intel->driFd) { bufmgr_pool[i].refcount++; _mesa_printf("retrieive old bufmgr for fd %d\n", bufmgr_pool[i].driFd); return &bufmgr_pool[i]; } if (nr_bms < BM_MAX) { struct bufmgr *bm = &bufmgr_pool[nr_bms++]; _mesa_printf("create new bufmgr for fd %d\n", intel->driFd); bm->driFd = intel->driFd; bm->hash = _mesa_NewHashTable(); bm->refcount = 1; _glthread_INIT_MUTEX(bm->mutex); drmGetLock(bm->driFd, intel->hHWContext, 0); BM_CKFATAL(drmMMAllocBufferPool(bm->driFd, mmPoolRing, 0, DRM_MM_TT | DRM_MM_NO_EVICT | DRM_MM_READ | DRM_MM_EXE | BM_BATCHBUFFER, 1024 * 1024, 4096, &bm->batchPool)); drmUnlock(bm->driFd, intel->hHWContext); return bm; } _mesa_printf("failed to create new bufmgr for fd %d\n", intel->driFd); return NULL; }