ClRcT clCntNextNodeGet(ClCntHandleT containerHandle, ClCntNodeHandleT currentNodeHandle, ClCntNodeHandleT *pNextNodeHandle) { CclContainer_t *pContainer = NULL; nullChkRet(pNextNodeHandle); *pNextNodeHandle = CL_HANDLE_INVALID_VALUE; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed handle is invalid"); } if (pContainer->fpFunctionContainerNextNodeGet == NULL) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); /* can't be right! DEBUG MESSAGE */ } return (pContainer->fpFunctionContainerNextNodeGet (containerHandle, currentNodeHandle, pNextNodeHandle)); }
ClRcT clCntPreviousNodeGet(ClCntHandleT containerHandle, ClCntNodeHandleT currentNodeHandle, ClCntNodeHandleT* pPreviousNodeHandle) { CclContainer_t *pContainer = NULL; nullChkRet(pPreviousNodeHandle); *pPreviousNodeHandle = CL_HANDLE_INVALID_VALUE; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if (pContainer->fpFunctionContainerPreviousNodeGet == NULL) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } return (pContainer->fpFunctionContainerPreviousNodeGet (containerHandle, currentNodeHandle, pPreviousNodeHandle)); }
ClRcT clCntNodeUserDataGet(ClCntHandleT containerHandle, ClCntNodeHandleT nodeHandle, ClCntDataHandleT *pUserDataHandle) { void *pNode = NULL; CclContainer_t *pContainer = NULL; ClRcT errorCode = CL_OK; ClCntDataHandleT tempDataHandle = CL_HANDLE_INVALID_VALUE; nullChkRet(pUserDataHandle); *pUserDataHandle = CL_HANDLE_INVALID_VALUE; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } pNode = (void*) nodeHandle; nullChkRet(pNode); errorCode = (pContainer->fpFunctionContainerUserDataGet(containerHandle, nodeHandle, &tempDataHandle)); if( CL_OK != errorCode ) { return errorCode; } *pUserDataHandle = tempDataHandle; return (CL_OK); }
ClRcT clCntNodeUserKeyGet(ClCntHandleT containerHandle, ClCntNodeHandleT nodeHandle, ClCntKeyHandleT* pUserKey) { void *pNode = NULL; CclContainer_t *pContainer = NULL; ClRcT errorCode = CL_OK; ClCntKeyHandleT tempKey = CL_HANDLE_INVALID_VALUE; /* User key validations */ nullChkRet(pUserKey); *pUserKey = CL_HANDLE_INVALID_VALUE; /*Container handle validations */ pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed handle is invalid"); } /* Node Handle validations */ pNode = (void*) nodeHandle; nullChkRet(pNode); errorCode = (pContainer->fpFunctionContainerUserKeyGet(containerHandle, nodeHandle, &tempKey)); if( CL_OK != errorCode ) { return errorCode; } *pUserKey = tempKey; return CL_OK; }
ClRcT cosSysvSemCreate (ClUint8T* pName, ClUint32T count, ClOsalSemIdT* pSemId) { ClInt32T retCode = CL_OK; CosSemCtl_t semArg = {0}; ClUint32T len = 0; ClUint32T key = 0; ClInt32T semId = -1; nullChkRet(pSemId); nullChkRet(pName); CL_FUNC_ENTER(); if ((count == 0) || count > CL_SEM_MAX_VALUE) { retCode = CL_OSAL_RC(CL_ERR_INVALID_PARAMETER); clDbgCodeError(retCode, ("Number of semaphores to create (count) [%d] must be between [1] and [%d]", count, CL_SEM_MAX_VALUE)); CL_FUNC_EXIT(); return(retCode); } len = (ClUint32T)strlen ((ClCharT*)pName); #if 0 /* Stone: why this limitation? */ if(len > 20) if(len > 256) { CL_DEBUG_PRINT (CL_DEBUG_INFO,("Sanity check, semaphore name length is suspiciously long")); retCode = CL_OSAL_RC(CL_OSAL_ERR_NAME_TOO_LONG); CL_FUNC_EXIT(); return(retCode); } #endif if(len > 256) { CL_DEBUG_PRINT (CL_DEBUG_INFO,("Sanity check, semaphore name [%s] is suspiciously long",pName)); } retCode = (ClInt32T)clCrc32bitCompute (pName, len, &key, NULL); CL_ASSERT(retCode == CL_OK); /* There is no possible error except for pName == NULL, which I've already checked, so don't check the retCode */ sysErrnoChkRet(semId = semget ((key_t)key, (int)count, IPC_CREAT|0666)); semArg.val = (int)count; /* Initialize all the semaphores to 0. This should never fail, because I just created the semaphores */ sysErrnoChkRet(semctl (semId, 0, SETVAL, semArg)); *pSemId = (ClOsalSemIdT)semId; CL_FUNC_EXIT(); return (CL_OK); }
ClRcT cosPosixSemCreate (ClUint8T* pName, ClUint32T count, ClOsalSemIdT* pSemId) { ClInt32T rc = CL_OK; sem_t *pSem = NULL; ClInt32T semValue = 0; ClInt32T i = 0; nullChkRet(pSemId); nullChkRet(pName); CL_FUNC_ENTER(); if ((count == 0) || count > CL_SEM_MAX_VALUE) { rc = CL_OSAL_RC(CL_ERR_INVALID_PARAMETER); clDbgCodeError(rc, ("Number of semaphores to create (count) [%d] must be between [1] and [%d]", count, CL_SEM_MAX_VALUE)); CL_FUNC_EXIT(); return(rc); } pSem = sem_open((ClCharT*)pName, O_CREAT, 0777, count); if(pSem == SEM_FAILED) { rc = CL_OSAL_RC(CL_ERR_LIBRARY); clDbgCodeError(rc, ("Failed at sem_open. system error code %d.\n", errno)); return rc; } sem_getvalue(pSem, &semValue); if (semValue < (ClInt32T)count) { for (i = semValue; i < (ClInt32T)count; ++i) { sem_post(pSem); } } else { for (i = count; i < semValue; ++i) { sem_wait(pSem); } } *pSemId = *(ClOsalSemIdT*)&pSem; CL_FUNC_EXIT(); return (rc); }
ClRcT __cosPosixMutexLock (ClOsalMutexIdT mutexId, ClBoolT verbose) { ClRcT rc = CL_OK; ClOsalMutexT *pMutex = (ClOsalMutexT*)mutexId; ClInt32T err=0; if(verbose) { nullChkRet(pMutex); } else if(!pMutex) { return CL_OSAL_RC(CL_ERR_NULL_POINTER); } CL_FUNC_ENTER(); retry: err = sem_wait(&pMutex->shared_lock.sem.posSem); if(err < 0 ) { if(errno == EINTR) goto retry; rc = CL_OSAL_RC(CL_ERR_LIBRARY); if(verbose) { clDbgCodeError(rc,("sem_wait returned [%s]\n",strerror(errno))); } } CL_FUNC_EXIT(); return (rc); }
ClRcT cosPosixProcessSharedSemInit(ClOsalMutexT *pMutex, ClUint8T *pKey, ClUint32T keyLen, ClInt32T value) { ClRcT rc = CL_OK; int err; nullChkRet(pKey); if(keyLen == 0) { clDbgCodeError(CL_ERR_INVALID_PARAMETER,("Invalid keylen [%d]\n",keyLen)); return CL_OSAL_RC(CL_ERR_INVALID_PARAMETER); } pthread_mutex_lock(&gClSemAccessLock); err = sem_init(&pMutex->shared_lock.sem.posSem,1, value); if(err < 0) { pthread_mutex_unlock(&gClSemAccessLock); rc = CL_OSAL_RC(CL_ERR_LIBRARY); goto out; } pthread_mutex_unlock(&gClSemAccessLock); pMutex->shared_lock.sem.numSems = 1; rc = CL_OK; out: return rc; }
ClRcT clCntDelete(ClCntHandleT containerHandle) { CclContainer_t *pContainer = NULL; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if (pContainer->fpFunctionContainerDestroy == NULL) { /* can't be right! DEBUG MESSAGE */ returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } #if HA_ENABLED /* HA-aware container Modifications Start: Hari*/ /* The container is getting destroyed. So de-register it with CPS*/ if (pContainer->haEnabled) { errorCode = clCPContainerDeReg(pContainer->cpsHdl, pContainer->domainId, pContainer->containerId); } #endif /* HA-aware container Modifications End: Hari*/ return (pContainer->fpFunctionContainerDestroy (containerHandle)); }
ClRcT clHandleWithAddressCreate ( ClHandleDatabaseHandleT databaseHandle, ClInt32T instance_size, ClIocPhysicalAddressT compAddr, ClHandleT *handle_out) { ClWordT idx = 0; void *instance = NULL; ClRcT rc = CL_OK; ClHdlDatabaseT *hdbp = (ClHdlDatabaseT*) databaseHandle; nullChkRet(handle_out); hdlDbValidityChk(hdbp); instance = clHeapCalloc (1, instance_size); if (instance == NULL) { rc = CL_HANDLE_RC(CL_ERR_NO_MEMORY); return rc; } rc = clHandleAdd (databaseHandle, instance, &compAddr, handle_out); idx = CL_HDL_IDX(*handle_out)-1; hdbp->handles[idx].flags = HANDLE_ALLOC_FLAG; if (rc != CL_OK) { clHeapFree(instance); } return rc; }
ClRcT cosPosixSemIdGet(ClUint8T* pName, ClOsalSemIdT* pSemId) { ClUint32T count = 0; sem_t *pSem; nullChkRet(pSemId); nullChkRet(pName); CL_FUNC_ENTER(); pSem = sem_open((ClCharT*)pName, O_CREAT, 0666, count); *pSemId = *(ClOsalSemIdT*)&pSem; CL_FUNC_EXIT(); return (CL_OK); }
ClRcT cosSysvSemIdGet(ClUint8T* pName, ClOsalSemIdT* pSemId) { ClUint32T key = 0; ClInt32T semId = -1; ClUint32T len = 0; ClUint32T count = 0; ClUint32T retCode = CL_OK; int err; nullChkRet(pSemId); nullChkRet(pName); CL_FUNC_ENTER(); len = (ClUint32T)strlen ((ClCharT*)pName); if(len > 256) { CL_DEBUG_PRINT (CL_DEBUG_INFO,("Sanity check, semaphore name [%s] is suspiciously long",pName)); } retCode = clCrc32bitCompute (pName, len, &key, NULL); CL_ASSERT(retCode == CL_OK); /* There is no possible error except for pName == NULL, which I've already checked, so don't check the retCode */ semId = semget ((key_t)key, (int)count, 0660); err = errno; if(semId == -1) { if (err == ENOENT) { CL_DEBUG_PRINT (CL_DEBUG_INFO,("Semaphore [%s], id [%u] accessed but not created. Creating it now",pName,key)); semId = semget ((key_t)key, (int)count, IPC_CREAT|0666); } } sysErrnoChkRet(semId); *pSemId = (ClOsalSemIdT)semId; CL_FUNC_EXIT(); return (CL_OK); }
ClRcT cosSysvProcessSharedSemInit(ClOsalMutexT *pMutex, ClUint8T *pKey, ClUint32T keyLen, ClInt32T value) { ClInt32T semId = 0; ClUint32T semKey = 0; ClRcT rc = CL_OK; ClUint32T flags = 0666; ClInt32T err = 0; nullChkRet(pKey); if(keyLen == 0) { clDbgCodeError(CL_ERR_INVALID_PARAMETER,("Invalid keylen [%d]\n",keyLen)); return CL_OSAL_RC(CL_ERR_INVALID_PARAMETER); } rc = clCrc32bitCompute(pKey, keyLen, &semKey, NULL); CL_ASSERT(rc == CL_OK && semKey ); pthread_mutex_lock(&gClSemAccessLock); retry: semId = semget(semKey, 1, flags); if(semId < 0 ) { if(errno == EINTR) goto retry; if(errno == ENOENT) { flags |= IPC_CREAT; goto retry; } pthread_mutex_unlock(&gClSemAccessLock); rc = CL_OSAL_RC(CL_ERR_LIBRARY); goto out; } pthread_mutex_unlock(&gClSemAccessLock); if( (flags & IPC_CREAT) ) { CosSemCtl_t arg = {0}; arg.val = value; retry1: err = semctl(semId,0,SETVAL,arg); if(err < 0 ) { if(errno == EINTR) goto retry1; rc = CL_OSAL_RC(CL_ERR_LIBRARY); goto out; } } pMutex->shared_lock.sem.semId = semId; pMutex->shared_lock.sem.numSems = 1; rc = CL_OK; out: return rc; }
ClRcT clCntNodeFind(ClCntHandleT containerHandle, ClCntKeyHandleT userKey, ClCntNodeHandleT *pNodeHandle) { CclContainer_t *pContainer = NULL; ClCntNodeHandleT tempNodeHandle = CL_HANDLE_INVALID_VALUE; ClRcT errorCode = CL_OK; BaseLinkedListNode_t *pBLlNode = NULL; nullChkRet(pNodeHandle); *pNodeHandle = CL_HANDLE_INVALID_VALUE; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if (pContainer->fpFunctionContainerNodeFind == NULL) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } errorCode = (pContainer->fpFunctionContainerNodeFind(containerHandle, userKey, &tempNodeHandle)); if(errorCode != CL_OK ) { return (errorCode); } else { pBLlNode = (BaseLinkedListNode_t *) tempNodeHandle; *pNodeHandle = tempNodeHandle; return (CL_OK); } }
ClRcT clCntDataForKeyGet(ClCntHandleT containerHandle, ClCntKeyHandleT userKey, ClCntDataHandleT *pUserData) { ClCntNodeHandleT containerNode = CL_HANDLE_INVALID_VALUE; CclContainer_t *pContainer = NULL; ClRcT errorCode = CL_OK; nullChkRet(pUserData); *pUserData = CL_HANDLE_INVALID_VALUE; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if(pContainer->isUniqueFlag == 0) { returnCntError(CL_ERR_NOT_IMPLEMENTED, "This feature is not applicaple for non unique container"); } errorCode = clCntNodeFind(containerHandle, userKey, &containerNode); if(errorCode != CL_OK) { returnCntError(CL_ERR_NOT_EXIST, "Key doesn't exist"); } errorCode = clCntNodeUserDataGet(containerHandle, containerNode, pUserData); if(errorCode != CL_OK) { return(errorCode); } return(CL_OK); }
ClRcT cosPosixSemValueGet(ClOsalSemIdT semId, ClUint32T* pSemValue) { sem_t *pSem = *(sem_t**)&semId; nullChkRet(pSemValue); CL_FUNC_ENTER(); sysErrnoChkRet(sem_getvalue(pSem, (ClInt32T*)pSemValue)); CL_FUNC_EXIT(); return (CL_OK); }
ClRcT clCntNodeDelete(ClCntHandleT containerHandle, ClCntNodeHandleT nodeHandle) { CclContainer_t *pContainer = NULL; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if (pContainer->fpFunctionContainerNodeDelete == NULL) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } #if HA_ENABLED /* HA-aware container Modifications Start: Hari*/ /* This element is going to be deleted. Let the redundancy peer know it*/ if(pContainer->haEnabled) { ClCntKeyHandleT userKey; if (CL_OK != clCntNodeUserKeyGet(containerHandle, nodeHandle, &userKey)) { errorCode =CL_CNT_RC(CL_ERR_INVALID_STATE); CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nInvalid state")); return (errorCode); } /* Update the standby component */ errorCode = clCPContainerElemSynch(pContainer->cpsHdl, pContainer->domainId, pContainer->containerId, userKey, 0x0000); /* ELEMENTDEL = 0x00000*/ } #endif /* HA-aware container Modifications End: Hari*/ return (pContainer->fpFunctionContainerNodeDelete (containerHandle, nodeHandle)); }
ClRcT clCntKeySizeGet(ClCntHandleT containerHandle, ClCntKeyHandleT userKey, ClUint32T *pSize) { CclContainer_t *pContainer = NULL; nullChkRet(pSize); *pSize = 0; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if (pContainer->fpFunctionContainerKeySizeGet == NULL) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } return (pContainer->fpFunctionContainerKeySizeGet (containerHandle, userKey, pSize)); }
ClRcT cosSysvSemValueGet(ClOsalSemIdT semId, ClUint32T* pSemValue) { ClInt32T count = -1; nullChkRet(pSemValue); CL_FUNC_ENTER(); sysErrnoChkRet(count = semctl ((int)semId, 0, GETVAL, 0)); *pSemValue = (ClUint32T)count; CL_FUNC_EXIT(); return (CL_OK); }
ClRcT clCntNodeAdd(ClCntHandleT containerHandle, ClCntKeyHandleT userKey, ClCntDataHandleT userData, ClRuleExprT *pExp) { CclContainer_t *pContainer = NULL; ClRcT errorCode = CL_OK; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if( CONTAINER_ID != pContainer->validContainer) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if( NULL == pContainer->fpFunctionContainerNodeAdd ) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } errorCode = pContainer->fpFunctionContainerNodeAdd (containerHandle, userKey, userData, pExp); /* HA-aware Container Modifications Start: Hari*/ #if HA_ENABLED /* Addition is succesfull and the container is ha enabled*/ if((pContainer->haEnabled)&& (errorCode == CL_OK)) { /* Update the standby component */ errorCode = clCPContainerElemSynch(pContainer->cpsHdl, pContainer->domainId, pContainer->containerId, userKey, 0xFFFF); /* ELEMENTADD = 0xFFFFF */ } #endif /*HA_ENABLED*/ /* HA-aware Container Modifications End: Hari*/ return (errorCode); }
ClRcT clCntAllNodesDelete(ClCntHandleT containerHandle) { CclContainer_t *pContainer = NULL; ClCntNodeHandleT containerNode = CL_HANDLE_INVALID_VALUE; ClCntNodeHandleT nextContainerNode = CL_HANDLE_INVALID_VALUE; ClRcT errorCode = CL_OK; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } errorCode = clCntFirstNodeGet(containerHandle, &containerNode); if(CL_OK != errorCode) { /* * Check if container is empty. */ if(CL_GET_ERROR_CODE(errorCode) == CL_ERR_NOT_EXIST) return CL_OK; return errorCode; } while(containerNode) { if(clCntNextNodeGet(containerHandle, containerNode, &nextContainerNode) != CL_OK) { nextContainerNode = 0; } errorCode = clCntNodeDelete(containerHandle, containerNode); if(errorCode != CL_OK) { return(errorCode); } containerNode = nextContainerNode; } return (CL_OK); }
ClRcT cosPosixMutexValueGet(ClOsalMutexIdT mutexId, ClInt32T *pValue) { ClOsalMutexT *pMutex = (ClOsalMutexT*) mutexId; ClRcT rc = CL_OK; ClInt32T val = 0; nullChkRet(pMutex); CL_FUNC_ENTER(); val = sem_getvalue(&pMutex->shared_lock.sem.posSem, pValue); if(val < 0 ) { clLogError(CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED,"Mutex value get- sem_getvalue() failed with [%s]\n", strerror(errno)); rc = CL_OSAL_RC(CL_ERR_LIBRARY); } CL_FUNC_EXIT(); return rc; }
/* * Creates a new handle database. User is responsible to cleanup and free * database. */ ClRcT clHandleDatabaseCreate( void (*destructor)(void*), ClHandleDatabaseHandleT *databaseHandle) { ClHdlDatabaseT *hdbp = NULL; nullChkRet(databaseHandle); hdbp = (ClHdlDatabaseT*) clHeapCalloc(1, sizeof(ClHdlDatabaseT)); if (NULL == hdbp) { clLogError(CL_HDL_AREA, CL_HDL_CTX_DBCREATE, "Memory allocation failed"); return CL_HANDLE_RC(CL_ERR_NO_MEMORY); } (void)pthread_mutex_init(&hdbp->mutex, NULL); /* This always returns 0 */ if (destructor != NULL) { hdbp->handle_instance_destructor = destructor; } hdbp->pValidDb = (void *) CL_HDL_VALID_DB; hdbp->id = handleDbId++; /* * Database handle is obtained from memory address here. This is OK, * since (1) handle type is larger or same size as address, (2) the * use of handle is limited to one process. */ *databaseHandle = hdbp; #if 0 clLogTrace(CL_HDL_AREA, CL_HDL_CTX_DBCREATE, "Database [%p] has been created", (ClPtrT) hdbp); #endif clDbgResourceNotify(clDbgHandleGroupResource, clDbgAllocate, 0, hdbp, ("Handle database %p allocated", (ClPtrT) hdbp)); return CL_OK; }
ClRcT clCntAllNodesForKeyDelete(ClCntHandleT containerHandle, ClCntKeyHandleT userKey) { CclContainer_t *pContainer = NULL; pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } if (pContainer->fpFunctionContainerKeyDelete == NULL) { returnCntError(CL_ERR_INVALID_STATE, "Container got corrupted"); } #if HA_ENABLED /* HA-aware container Modifications Start: Hari*/ /* This element is going to be deleted. Let the redundancy peer know it*/ if(pContainer->haEnabled) { /* Update the standby component */ errorCode = clCPContainerElemSynch(pContainer->cpsHdl, pContainer->domainId, pContainer->containerId, userKey, 0x0000); /* ELEMENTDEL = 0x00000*/ } /* HA-aware container Modifications End: Hari*/ #endif /*HA_ENABLED*/ return (pContainer->fpFunctionContainerKeyDelete (containerHandle, userKey)); }
ClRcT clCntNodeAddAndNodeGet(ClCntHandleT containerHandle, ClCntKeyHandleT userKey, ClCntDataHandleT userData, ClRuleExprT* pExp, ClCntNodeHandleT* pNodeHandle) { ClRcT rc = CL_OK; nullChkRet(pNodeHandle); rc = clCntNodeAdd(containerHandle, userKey, userData, pExp); if(CL_OK != rc) { return rc; } rc = clCntNodeFind (containerHandle, userKey, pNodeHandle); CL_ASSERT(rc == CL_OK); /* I just added it, so I should be able to find it! */ if(CL_OK != rc) { return rc; } return CL_OK; }
ClRcT clHandleAdd (ClHandleDatabaseHandleT databaseHandle, void* instance, ClIocPhysicalAddressT *compAddr, ClHandleT* handle_out) { ClHandleT handle = 0; ClHdlEntryT *new_handles = NULL; ClBoolT found = CL_FALSE; ClRcT rc = CL_OK; ClHdlDatabaseT *hdbp = (ClHdlDatabaseT*) databaseHandle; nullChkRet(handle_out); hdlDbValidityChk(hdbp); rc = pthread_mutex_lock (&hdbp->mutex); if (rc != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); } for (handle = 0; handle < hdbp->n_handles; handle++) { if (hdbp->handles[handle].state == HANDLE_STATE_EMPTY) { found = 1; break; } } if (found == 0) { new_handles = (ClHdlEntryT *) realloc ( hdbp->handles, sizeof (ClHdlEntryT) * (hdbp->n_handles + CL_HDL_NUM_HDLS_BUNCH)); if (new_handles == NULL) { rc = pthread_mutex_unlock (&hdbp->mutex); if (rc != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be very bad */ } return CL_HANDLE_RC(CL_ERR_NO_MEMORY); } memset(&new_handles[hdbp->n_handles], '\0', sizeof(ClHdlEntryT) * CL_HDL_NUM_HDLS_BUNCH); hdbp->n_handles += CL_HDL_NUM_HDLS_BUNCH; hdbp->handles = new_handles; } hdbp->handles[handle].state = HANDLE_STATE_USED; hdbp->handles[handle].instance = instance; hdbp->handles[handle].ref_count = 1; hdbp->handles[handle].flags = 0; hdbp->n_handles_used++; /* * Adding 1 to handle to ensure the non-zero handle interface. */ if (compAddr == NULL) *handle_out = CL_HDL_MAKE_ADDR(ASP_NODEADDR,gEOIocPort,hdbp->id, handle + 1); else *handle_out = CL_HDL_MAKE_ADDR(compAddr->nodeAddress,compAddr->portId, hdbp->id, handle + 1); hdbp->handles[handle].handle = *handle_out; // Log uses handle so handle cant' use log // clDbgResourceNotify(clDbgHandleResource, clDbgAllocate, hdbp, handle+1, ("Handle [%p:%#llX] allocated", (ClPtrT)hdbp, handle+1)); rc = pthread_mutex_unlock (&hdbp->mutex); if (rc != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be devastating */ } #if 0 clLogTrace(CL_HDL_AREA, CL_HDL_CTX_CREATE, "Handle [%p:%#llX] has been created", (ClPtrT) hdbp, (handle + 1)); #endif return rc; }
static ClRcT __clCntWalk(ClCntHandleT containerHandle, ClCntWalkCallbackT fpUserWalkCallback, ClCntArgHandleT userDataArg, ClInt32T dataLength, ClBoolT failSafe) { CclContainer_t *pContainer = NULL; ClCntNodeHandleT containerNode = CL_HANDLE_INVALID_VALUE; ClCntNodeHandleT nextContainerNode = CL_HANDLE_INVALID_VALUE; ClCntDataHandleT userData = CL_HANDLE_INVALID_VALUE; ClCntKeyHandleT userKey = CL_HANDLE_INVALID_VALUE; BaseLinkedListNode_t *pTemp = NULL; ClRcT errorCode = CL_OK; nullChkRet(fpUserWalkCallback); pContainer = (CclContainer_t *) containerHandle; nullChkRet(pContainer); if(pContainer->validContainer != CONTAINER_ID) { returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid"); } errorCode = clCntFirstNodeGet (containerHandle, &containerNode); if(errorCode != CL_OK) { if((CL_GET_ERROR_CODE(errorCode)) == CL_ERR_NOT_EXIST) { /* If the container is empty it means we dont have to walk anymore. * Hence return OK. */ return (CL_OK); } return(errorCode); } while (containerNode) { pTemp = (BaseLinkedListNode_t*) containerNode; if(clCntNextNodeGet(containerHandle, containerNode, &nextContainerNode) != CL_OK) { nextContainerNode = 0; } if ((pTemp->pRbeExpression == NULL) || (clRuleExprEvaluate(pTemp->pRbeExpression, (ClUint32T*) userDataArg, dataLength))) { errorCode = clCntNodeUserKeyGet (containerHandle, containerNode, &userKey); errorCode = clCntNodeUserDataGet (containerHandle, containerNode, &userData); errorCode = fpUserWalkCallback(userKey, userData, userDataArg,dataLength); if(!failSafe && (CL_OK != errorCode)) { return (errorCode); } } containerNode = nextContainerNode; } return(CL_OK); }
ClRcT clHandleCheckout( ClHandleDatabaseHandleT databaseHandle, ClHandleT handleArg, void **instance) { ClRcT rc = CL_OK; ClHdlDatabaseT *hdbp = (ClHdlDatabaseT*)databaseHandle; ClHdlStateT state = HANDLE_STATE_EMPTY; ClRcT ec = CL_OK; ClHandleT handle; hdlDbValidityChk(hdbp); /* sometimes people want to create the same handle across multiple nodes hdlValidityChk(handle,hdbp); */ handle = CL_HDL_IDX(handleArg); /* once we've verified it, we only care about the index */ nullChkRet(instance); /* * Decrementing handle to ensure the non-zero handle interface. */ if (CL_HANDLE_INVALID_VALUE == handle--) { clDbgCodeError(CL_HANDLE_RC(CL_ERR_INVALID_HANDLE), ("Passed Invalid Handle [0x0]")); return CL_HANDLE_RC(CL_ERR_INVALID_HANDLE); /* 0 no longer allowed */ } ec = pthread_mutex_lock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); } if (handle >= (ClHandleT)hdbp->n_handles) { rc = CL_HANDLE_RC(CL_ERR_INVALID_HANDLE); pthread_mutex_unlock(&hdbp->mutex); clDbgCodeError(rc, ("Passed Invalid Handle [%p:%#llx]", (ClPtrT) hdbp, handleArg)); return rc; } if ( ( state = hdbp->handles[handle].state ) != HANDLE_STATE_USED) { pthread_mutex_unlock(&hdbp->mutex); if (state == HANDLE_STATE_EMPTY) { /* In some of our ASP components the assumption made, * like checkout handle returns CL_ERR_INVALID_HANDLE * to verify the handle does exist or not. * so removing the debug pause */ #if 0 clDbgCodeError(rc, ("Handle [%p:%#llX] is not allocated", (ClPtrT) hdbp, (handle+1))); #endif } else if (state == HANDLE_STATE_PENDINGREMOVAL) { clDbgCodeError(rc, ("Handle [%p:%#llX] is being removed", (ClPtrT) hdbp, handleArg)); } else { clDbgCodeError(rc, ("Handle [%p:%#llX] invalid state %d", (ClPtrT) hdbp, handleArg, state)); } rc = CL_HANDLE_RC(CL_ERR_INVALID_HANDLE); clDbgCodeError(rc, ("Handle [%p:%#llX] is invalid", (ClPtrT) hdbp, handleArg)); return rc; } *instance = hdbp->handles[handle].instance; hdbp->handles[handle].ref_count += 1; ec = pthread_mutex_unlock (&hdbp->mutex); if (ec != 0) { clDbgCodeError(CL_HANDLE_RC(CL_ERR_MUTEX_ERROR), ("Mutex unlock failed errno %d", errno)); return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be devastating */ } #if 0 clLogTrace(CL_HDL_AREA, CL_HDL_CTX_CHECKOUT, "Checked out handle [%p:%#llX]", (ClPtrT) hdbp, handleArg); #endif return rc; }