/*! ****************************************************************************** @Function POOL_PoolSetFreeCallback ******************************************************************************/ IMG_RESULT POOL_PoolSetFreeCallback( IMG_HANDLE hPoolHandle, POOL_pfnFree pfnFree ) { POOL_sResPool * psResPool = hPoolHandle; POOL_sResource * psResource; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResPool != IMG_NULL); if (!gInitialised || psResPool == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); psResPool->pfnFree = pfnFree; /* If free callback set...*/ if (psResPool->pfnFree != IMG_NULL) { /* Move resources from free to active list...*/ psResource = (POOL_sResource *)LST_removeHead(&psResPool->sFreeResList); while (psResource != IMG_NULL) { /* Add to active list...*/ LST_add(&psResPool->sActResList, psResource); psResource->ui32RefCnt++; /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Call the free callback...*/ psResPool->pfnFree(psResource->ui32ResId, psResource->pvParam); /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* Get next free resource...*/ psResource = (POOL_sResource *)LST_removeHead(&psResPool->sFreeResList); } } /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function perflog_WriteFile @Description Writes to the file. @Input pFileHandler : file where data will be written @Input uiMsg : performance data @Return IMG_SUCCESS in case when data has been written successfully, error code otherwise ******************************************************************************/ static IMG_RESULT perflog_WriteFile(perflog_FileHandler *pFileHandler, IMG_UINT64 uiMsg) { perflog_Buffer *psBuffer; if(pFileHandler == IMG_NULL) { REPORT(REPORT_MODULE_PERFLOG, REPORT_ERR, "Performance logger cannot clean file: invalid parameters"); return IMG_ERROR_INVALID_PARAMETERS; } SYSOSKM_LockMutex(pFileHandler->hMutexHandle); //search for buffer that has place to store perf data psBuffer = LST_first(&pFileHandler->sBufferList); while(psBuffer) { if(psBuffer->stIter < psBuffer->stBufferSize) { break; } psBuffer = LST_next(psBuffer); } //new buffer is needed if(psBuffer == IMG_NULL) { IMG_RESULT result; //create new buffer if( (result = perflog_CreateBuffer(&psBuffer, ONE_BUFFER_SIZE)) != IMG_SUCCESS ) { SYSOSKM_UnlockMutex(pFileHandler->hMutexHandle); REPORT(REPORT_MODULE_PERFLOG, REPORT_ERR, "Performance logger cannot allocate buffers"); return result; } //add buffer to a list LST_add(&pFileHandler->sBufferList, psBuffer); } //write data psBuffer->pui64Buffer[(psBuffer->stIter)++] = uiMsg; SYSOSKM_UnlockMutex(pFileHandler->hMutexHandle); return IMG_SUCCESS; }
/*! ****************************************************************************** @Function SYSDEVU_RegisterDevices ******************************************************************************/ IMG_RESULT SYSDEVU_RegisterDevice( SYSDEVU_sInfo *psInfo ) { IMG_UINT32 ui32Result; IMG_ASSERT(gSysDevInitialised); /* Initialise parts of the device info structure...*/ psInfo->bDevLocated = IMG_FALSE; psInfo->pvLocParam = IMG_NULL; SYSOSKM_LockMutex(hNextDeviceIdMutex); psInfo->ui32DeviceId = gui32NextDeviceId; gui32NextDeviceId += 1; SYSOSKM_UnlockMutex(hNextDeviceIdMutex); /* Register the device with the device manager...*/ ui32Result = DMANKM_RegisterDevice(psInfo->sDevInfo.pszDeviceName, psInfo->sDevInfo.pfnDevRegister); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { return ui32Result; } /* Initialise the devices...*/ LST_add(&gsDevList, psInfo); gui32NoDevices++; /* Return success...*/ return IMG_SUCCESS; }
/*! ****************************************************************************** @Function perflog_CleanFile @Description Truncates performance file to zero length. @Input pFileHandler : file to be cleand @Return IMG_SUCCESS in case when file has been cleand successfully, error code otherwise ******************************************************************************/ static IMG_RESULT perflog_CleanFile(perflog_FileHandler *pFileHandler) { perflog_Buffer *psBuffer; if(pFileHandler == IMG_NULL) { REPORT(REPORT_MODULE_PERFLOG, REPORT_ERR, "Performance logger cannot clean file: invalid parameters"); return IMG_ERROR_INVALID_PARAMETERS; } SYSOSKM_LockMutex(pFileHandler->hMutexHandle); //removes all buffers psBuffer = LST_removeHead(&pFileHandler->sBufferList); while(psBuffer) { perflog_DestroyBuffer(psBuffer); psBuffer = LST_removeHead(&pFileHandler->sBufferList); } SYSOSKM_UnlockMutex(pFileHandler->hMutexHandle); return IMG_SUCCESS; }
/*! ****************************************************************************** @Function perflog_DeinitialiseFile @Description Deinitialises file. @Input pFileHandler : file to be deinitialised @Return IMG_SUCCESS in case when file has been deinitialised successfully, error code otherwise ******************************************************************************/ static IMG_VOID perflog_DeinitialiseFile( perflog_FileHandler *pFileHandler ) { if(pFileHandler == IMG_NULL) { REPORT(REPORT_MODULE_PERFLOG, REPORT_ERR, "Performance logger cannot deinitialise file: invalid parameters"); return; } SYSOSKM_LockMutex(pFileHandler->hMutexHandle); //removes file from debug filesystem... debugfs_remove(pFileHandler->psFile); //removes all internal structures perflog_CleanFile(pFileHandler); SYSOSKM_UnlockMutex(pFileHandler->hMutexHandle); //and file mutex SYSOSKM_DestroyMutex(pFileHandler->hMutexHandle); }
/*! ****************************************************************************** @Function POOL_ResDestroy1 ******************************************************************************/ IMG_RESULT POOL_ResDestroy1( IMG_HANDLE hPoolHandle, IMG_UINT32 ui32ResId, IMG_BOOL bForce ) { POOL_sResPool * psResPool = hPoolHandle; IMG_UINT32 ui32Result; IMG_HANDLE hPoolResHandle; IMG_ASSERT(gInitialised); IMG_ASSERT(psResPool != IMG_NULL); if (!gInitialised || psResPool == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); ui32Result = IDGEN_GetHandle(psResPool->hIdGenHandle, ui32ResId, &hPoolResHandle); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); return ui32Result; } /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Call on to destroy resource...*/ return POOL_ResDestroy(hPoolResHandle, bForce); error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function rman_GetResource ******************************************************************************/ static IMG_VOID * rman_GetResource( IMG_HANDLE hResBHandle, IMG_UINT32 ui32ResId, IMG_UINT32 ui32TypeId, IMG_HANDLE * phResHandle ) { RMAN_sBucket * psBucket = (RMAN_sBucket *) hResBHandle; RMAN_sResource * psResource; IMG_RESULT i32Result; IMG_ASSERT(ui32ResId <= RMAN_CRESID_MAX_RES_ID); /* Loop over the resources in this bucket till we find the required id...*/ //SYSOSKM_DisableInt(); SYSOSKM_LockMutex(globalMutext); i32Result = IDGEN_GetHandle(psBucket->hIdGenerator, ui32ResId, (void**)&psResource); SYSOSKM_UnlockMutex(globalMutext); //SYSOSKM_EnableInt(); if(i32Result != IMG_SUCCESS) { IMG_ASSERT(!"failed to get RMAN resource"); return IMG_NULL; } /* If the resource handle is required...*/ if (phResHandle != IMG_NULL) { /* Return it...*/ *phResHandle = psResource; } /* If the resource was not found...*/ IMG_ASSERT(psResource != IMG_NULL); IMG_ASSERT((IMG_VOID*)psResource != &psBucket->sResList); if ( (psResource == IMG_NULL) || ((IMG_VOID*)psResource == &psBucket->sResList) ) { return IMG_NULL; } /* Cross check the type...*/ IMG_ASSERT(ui32TypeId == psResource->ui32TypeId); /* Return the resource....*/ return psResource->pvParam; }
/*! ****************************************************************************** @Function POOL_ResAlloc ******************************************************************************/ IMG_RESULT POOL_ResAlloc( IMG_HANDLE hPoolHandle, IMG_HANDLE hPoolResHandle ) { POOL_sResPool * psResPool = hPoolHandle; POOL_sResource * psResource = hPoolResHandle; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResPool != IMG_NULL); IMG_ASSERT(hPoolResHandle != IMG_NULL); if (!gInitialised || psResPool == IMG_NULL || hPoolResHandle == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* Remove resource from free list...*/ LST_remove(&psResPool->sFreeResList, psResource); /* Add to active list...*/ LST_add(&psResPool->sActResList, psResource); psResource->ui32RefCnt++; /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function DMANKM_UnlockDeviceContext ******************************************************************************/ IMG_VOID DMANKM_UnlockDeviceContext( IMG_HANDLE hDevHandle) { /* Release mutex */ SYSOSKM_UnlockMutex(((DMANKM_sDevContext *) hDevHandle)->hMutexHandle); }
/*! ****************************************************************************** @Function POOL_ResClone ******************************************************************************/ IMG_RESULT POOL_ResClone( IMG_HANDLE hPoolResHandle, IMG_HANDLE * phClonePoolResHandle, IMG_VOID ** ppvParam ) { POOL_sResource * psResource = hPoolResHandle; POOL_sResPool * psResPool; POOL_sResource * psOrigResource = psResource; POOL_sResource * psCloneResource; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResource != IMG_NULL); if (!gInitialised || psResource == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } /* Allocate a resource structure...*/ psCloneResource = IMG_MALLOC(sizeof(*psCloneResource)); IMG_ASSERT(psCloneResource != IMG_NULL); if (psCloneResource == IMG_NULL) { return IMG_ERROR_OUT_OF_MEMORY; } IMG_MEMSET(psCloneResource, 0, sizeof(*psCloneResource)); psResPool = psResource->psResPool; IMG_ASSERT(psResPool != IMG_NULL); if(psResPool == IMG_NULL) { return IMG_ERROR_FATAL; } /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* Set resource id...*/ ui32Result = IDGEN_AllocId(psResPool->hIdGenHandle, (IMG_HANDLE)psCloneResource, &psCloneResource->ui32ResId); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { goto error_alloc_id; } /* If this is a clone, set the original...*/ if (psResource->bIsClone) { psOrigResource = psResource->psOrigResource; } IMG_ASSERT(psOrigResource->ui32RefCnt > 0); /* Setup the cloned resource...*/ psCloneResource->bIsClone = IMG_TRUE; psCloneResource->psResPool = psResPool; psCloneResource->psOrigResource = psOrigResource; /* Add to clone list...*/ LST_add(&psOrigResource->sCloneResList, psCloneResource); psOrigResource->ui32RefCnt++; /* If ppvParam is not IMG_NULL...*/ if (ppvParam !=IMG_NULL) { /* If the size of the original vParam is 0...*/ if (psOrigResource->ui32SizevParam == 0) { *ppvParam = IMG_NULL; } else { /* Allocate memory for a copy of the original vParam...*/ *ppvParam = IMG_MALLOC(psOrigResource->ui32SizevParam); IMG_ASSERT(*ppvParam != IMG_NULL); if (*ppvParam == IMG_NULL) { ui32Result = IMG_ERROR_OUT_OF_MEMORY; goto error_copy_param; } IMG_MEMCPY(*ppvParam, psOrigResource->pvParam, psOrigResource->ui32SizevParam); } } /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Return the cloned resource...*/ *phClonePoolResHandle = psCloneResource; /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; /* Error handling. */ error_copy_param: LST_remove(&psOrigResource->sCloneResList, psCloneResource); psOrigResource->ui32RefCnt--; error_alloc_id: IMG_FREE(psCloneResource); /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function POOL_ResFree ******************************************************************************/ IMG_RESULT POOL_ResFree( IMG_HANDLE hPoolResHandle ) { POOL_sResource * psResource = hPoolResHandle; POOL_sResPool * psResPool; POOL_sResource * psOrigResource; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResource != IMG_NULL); if (!gInitialised || psResource == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } psResPool = psResource->psResPool; /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* If this is a clone...*/ if (psResource->bIsClone) { /* Get access to the original...*/ psOrigResource = psResource->psOrigResource; IMG_ASSERT(psOrigResource != IMG_NULL); IMG_ASSERT(!psOrigResource->bIsClone); /* Remove from the clone list...*/ LST_remove(&psOrigResource->sCloneResList, psResource); /* Free resource id...*/ ui32Result = IDGEN_FreeId(psResPool->hIdGenHandle, psResource->ui32ResId); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); return ui32Result; } /* If we created a copy of the resources pvParam then free it...*/ if (psResource->pvParam != IMG_NULL) { IMG_FREE(psResource->pvParam ); } /* Free the clone resource structure...*/ IMG_FREE(psResource); /* Set resource to be "freed" to the original...*/ psResource = psOrigResource; } /* Update the reference count...*/ IMG_ASSERT(psResource->ui32RefCnt != 0); psResource->ui32RefCnt--; /* If there are still outstanding references...*/ if (psResource->ui32RefCnt != 0) { /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; } /* Remove the resource from the active list...*/ LST_remove(&psResPool->sActResList, psResource); /* If free callback set...*/ if (psResPool->pfnFree != IMG_NULL) { /* Add to active list...*/ LST_add(&psResPool->sActResList, psResource); psResource->ui32RefCnt++; } else { /* Add to free list...*/ LST_add(&psResPool->sFreeResList, psResource); } /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* If free callback set...*/ if (psResPool->pfnFree != IMG_NULL) { /* Call the free callback...*/ psResPool->pfnFree(psResource->ui32ResId, psResource->pvParam); } /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function POOL_ResDestroy ******************************************************************************/ IMG_RESULT POOL_ResDestroy( IMG_HANDLE hPoolResHandle, IMG_BOOL bForce ) { POOL_sResource * psResource = hPoolResHandle; POOL_sResPool * psResPool; POOL_sResource * psOrigResource; POOL_sResource * psCloneResource; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResource != IMG_NULL); if (!gInitialised || psResource == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } psResPool = psResource->psResPool; /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* If this is a clone...*/ if (psResource->bIsClone) { IMG_ASSERT(0); // We need to check this works. /* Get access to the original...*/ psOrigResource = psResource->psOrigResource; IMG_ASSERT(psOrigResource != IMG_NULL); if (psOrigResource == IMG_NULL) { ui32Result = IMG_ERROR_UNEXPECTED_STATE; goto error; } IMG_ASSERT(!psOrigResource->bIsClone); if (psOrigResource->bIsClone) { ui32Result = IMG_ERROR_UNEXPECTED_STATE; goto error; } /* Remove from the clone list...*/ LST_remove(&psOrigResource->sCloneResList, psResource); /* Free resource id...*/ ui32Result = IDGEN_FreeId(psResPool->hIdGenHandle, psResource->ui32ResId); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); return ui32Result; } /* If we created a copy of the resources pvParam then free it...*/ if (psResource->pvParam != IMG_NULL) { IMG_FREE(psResource->pvParam ); } /* Free the clone resource structure...*/ IMG_FREE(psResource); /* Set resource to be "freed" to the original...*/ psResource = psOrigResource; } /* If there are still outstanding references...*/ if ( (!bForce) && (psResource->ui32RefCnt != 0) ) { IMG_ASSERT(0); // We may need to mark the resource and destroy it when // there are no outstanding references /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; } /* Check clone list is empty...*/ psCloneResource = LST_first(&psResource->sCloneResList); IMG_ASSERT(psCloneResource == IMG_NULL); /* Has the resource outstanding references...*/ if (psResource->ui32RefCnt != 0) { /* Remove the resource from the active list...*/ LST_remove(&psResPool->sActResList, psResource); } else { /* Remove the resource from the free list...*/ LST_remove(&psResPool->sFreeResList, psResource); } /* Free resource id...*/ ui32Result = IDGEN_FreeId(psResPool->hIdGenHandle, psResource->ui32ResId); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); return ui32Result; } /* Call the resource destructor...*/ psResource->pfnDestructor(psResource->pvParam); IMG_FREE(psResource); /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; error: SYSOSKM_UnlockMutex(psResPool->hMutexHandle); error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function POOL_ResRegister ******************************************************************************/ IMG_RESULT POOL_ResRegister( IMG_HANDLE hPoolHandle, POOL_pfnDestructor pfnDestructor, IMG_VOID * pvParam, IMG_UINT32 ui32SizevParam, IMG_BOOL bAlloc, IMG_UINT32 * pui32ResId, IMG_HANDLE * phPoolResHandle ) { POOL_sResPool * psResPool = hPoolHandle; POOL_sResource * psResource; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResPool != IMG_NULL); if (!gInitialised || psResPool == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } /* Allocate a resource structure...*/ psResource = IMG_MALLOC(sizeof(*psResource)); IMG_ASSERT(psResource != IMG_NULL); if (psResource == IMG_NULL) { return IMG_ERROR_OUT_OF_MEMORY; } IMG_MEMSET(psResource, 0, sizeof(*psResource)); /* Setup the resource...*/ psResource->pfnDestructor = pfnDestructor; psResource->pvParam = pvParam; psResource->ui32SizevParam = ui32SizevParam; psResource->psResPool = psResPool; LST_init(&psResource->sCloneResList); /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* Set resource id...*/ ui32Result = IDGEN_AllocId(psResPool->hIdGenHandle, (IMG_HANDLE)psResource, &psResource->ui32ResId); IMG_ASSERT(ui32Result == IMG_SUCCESS); if (ui32Result != IMG_SUCCESS) { IMG_FREE(psResource); /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); return ui32Result; } /* If allocated or free callback not set...*/ if ( (bAlloc) || (psResPool->pfnFree != IMG_NULL) ) { /* Add to active list...*/ LST_add(&psResPool->sActResList, psResource); psResource->ui32RefCnt++; } else { /* Add to free list...*/ LST_add(&psResPool->sFreeResList, psResource); } /* Return the resource id...*/ if (pui32ResId != IMG_NULL) { *pui32ResId = psResource->ui32ResId; } /* Return the handle to the resource...*/ if (phPoolResHandle != IMG_NULL) { *phPoolResHandle = psResource; } /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* If free callback set...*/ if (psResPool->pfnFree != IMG_NULL) { /* Call the free callback...*/ psResPool->pfnFree(psResource->ui32ResId, psResource->pvParam); } /* Return IMG_SUCCESS...*/ return IMG_SUCCESS; error_nolock: return ui32Result; }
/*! ****************************************************************************** @Function POOL_PoolDestroy ******************************************************************************/ IMG_RESULT POOL_PoolDestroy( IMG_HANDLE hPoolHandle ) { POOL_sResPool * psResPool = hPoolHandle; POOL_sResource * psResource; POOL_sResource * psCloneResource; IMG_UINT32 ui32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(psResPool != IMG_NULL); if (!gInitialised || psResPool == IMG_NULL) { ui32Result = IMG_ERROR_INVALID_PARAMETERS; goto error_nolock; } /* Lock the pool...*/ SYSOSKM_LockMutex(psResPool->hMutexHandle); /* Disable interrupts. */ SYSOSKM_DisableInt(); /* Remove the pool from the active list...*/ LST_remove(&gsPoolList, psResPool); /* Enable interrupts. */ SYSOSKM_EnableInt(); /* Destroy any resources in the free list...*/ psResource = (POOL_sResource *)LST_removeHead(&psResPool->sFreeResList); while (psResource != IMG_NULL) { psResource->pfnDestructor(psResource->pvParam); IMG_FREE(psResource); psResource = (POOL_sResource *)LST_removeHead(&psResPool->sFreeResList); } /* Destroy any resources in the active list...*/ psResource = (POOL_sResource *)LST_removeHead(&psResPool->sActResList); while (psResource != IMG_NULL) { psCloneResource = (POOL_sResource *)LST_removeHead(&psResource->sCloneResList); while (psCloneResource != IMG_NULL) { /* If we created a copy of the resources pvParam then free it...*/ if (psCloneResource->pvParam != IMG_NULL) { IMG_FREE(psCloneResource->pvParam ); } IMG_FREE(psCloneResource); psCloneResource = (POOL_sResource *)LST_removeHead(&psResource->sCloneResList); } /* Call the resource destructor...*/ psResource->pfnDestructor(psResource->pvParam); IMG_FREE(psResource); psResource = (POOL_sResource *)LST_removeHead(&psResPool->sActResList); } /* Destroy the context for the Id generator...*/ if (psResPool->hIdGenHandle != IMG_NULL) { ui32Result = IDGEN_DestroyContext(psResPool->hIdGenHandle); IMG_ASSERT(ui32Result == IMG_SUCCESS); } /* Unlock the pool...*/ SYSOSKM_UnlockMutex(psResPool->hMutexHandle); /* Destroy mutex...*/ SYSOSKM_DestroyMutex(psResPool->hMutexHandle); /* Free the pool structure */ IMG_FREE(psResPool); return IMG_SUCCESS; error_nolock: return ui32Result; }
static void perflog_stop(struct seq_file *s, void *buffer) { //release file SYSOSKM_UnlockMutex(gsPerfFile.hMutexHandle); }
/*! ****************************************************************************** @Function RMAN_RegisterResource ******************************************************************************/ IMG_RESULT RMAN_RegisterResource( IMG_HANDLE hResBHandle, IMG_UINT32 ui32TypeId, RMAN_pfnFree pfnFree, IMG_VOID * pvParam, IMG_HANDLE * phResHandle, IMG_UINT32 * pui32ResId ) { RMAN_sBucket * psBucket = (RMAN_sBucket *) hResBHandle; RMAN_sResource * psResource; IMG_RESULT i32Result; IMG_ASSERT(gInitialised); IMG_ASSERT(ui32TypeId != RMAN_ALL_TYPES); IMG_ASSERT(hResBHandle != IMG_NULL); if (hResBHandle == IMG_NULL) { return IMG_ERROR_GENERIC_FAILURE; } /* Allocate a resource structure...*/ psResource = IMG_MALLOC(sizeof(*psResource)); IMG_ASSERT(psResource != IMG_NULL); if (psResource == IMG_NULL) { return IMG_ERROR_OUT_OF_MEMORY; } IMG_MEMSET(psResource, 0, sizeof(*psResource)); /* Fill in the resource structure...*/ psResource->psBucket = psBucket; psResource->ui32TypeId = ui32TypeId; psResource->pfnFree = pfnFree; psResource->pvParam = pvParam; /* Allocate resource Id...*/ SYSOSKM_LockMutex(globalMutext); i32Result = IDGEN_AllocId(psBucket->hIdGenerator, psResource, &psResource->ui32ResId); SYSOSKM_UnlockMutex(globalMutext); if(i32Result != IMG_SUCCESS) { IMG_ASSERT(!"failed to allocate RMAN id"); return i32Result; } IMG_ASSERT(psResource->ui32ResId <= RMAN_CRESID_MAX_RES_ID); // add this resource to the bucket SYSOSKM_DisableInt(); DQ_addTail(&psBucket->sResList, psResource); /* Update count of resources...*/ psBucket->ui32ResCnt++; SYSOSKM_EnableInt(); /* If resource handle required...*/ if (phResHandle != IMG_NULL) { *phResHandle = psResource; } /* If resource id required...*/ if (pui32ResId != IMG_NULL) { *pui32ResId = RMAN_GetResourceId(psResource); } /* Return success...*/ return IMG_SUCCESS; }