static ClRcT clBitmapRealloc(ClBitmapInfoT *pBitmapInfo, ClUint32T bitNum) { ClRcT rc = CL_OK; ClUint32T nBytes = 0; ClUint32T nInit = 0; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Enter: %u", bitNum)); nBytes = bitNum / CL_BM_BITS_IN_BYTE; ++nBytes; /* bitNum is 0-based */ pBitmapInfo->pBitmap = clHeapRealloc(pBitmapInfo->pBitmap, nBytes); if( NULL == pBitmapInfo->pBitmap ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHeapRealloc() failed")); return CL_BITMAP_RC(CL_ERR_NO_MEMORY); } CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Reallocated: %u from %u", nBytes, pBitmapInfo->nBytes)); nInit = nBytes - pBitmapInfo->nBytes; memset(&(pBitmapInfo->pBitmap[pBitmapInfo->nBytes]), 0, nInit); pBitmapInfo->nBytes = nBytes; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Exit")); return rc; }
ClRcT cosSysvShmSizeGet(ClOsalShmIdT shmId,ClUint32T* pSize) { struct shmid_ds shmSize ; ClInt32T retCode = CL_OK; CL_FUNC_ENTER(); if(NULL == pSize) { CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory SecurityModeGet: FAILED")); retCode = CL_OSAL_RC(CL_ERR_NULL_POINTER); CL_FUNC_EXIT(); return(retCode); } /* Get the current values set and modifiy it */ retCode = shmctl ((int)shmId, IPC_STAT, &shmSize); if(0 != retCode) { CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory SecurityModeGet: FAILED")); retCode = CL_OSAL_RC(CL_OSAL_ERR_SHM_SIZE); CL_FUNC_EXIT(); return(retCode); } *pSize = (ClUint32T)shmSize.shm_segsz; CL_FUNC_EXIT(); return (CL_OK); }
ClPtrT clMemPartRealloc(ClMemPartHandleT handle, ClPtrT memBase, ClUint32T size) { MEM_PART_STATS memPartStats; ClPtrT mem = NULL; ClMemPartT *pMemPart = NULL; ClRcT rc = CL_OK; if(!(pMemPart = (ClMemPartT*)handle) ) return NULL; if(!size) size = 16; clOsalMutexLock(&pMemPart->mutex); if(memPartInfoGet(pMemPart->partId, &memPartStats) == ERROR) { clOsalMutexUnlock(&pMemPart->mutex); CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("memPartInfoGet for size [%d] failed with [%s]\n", size, strerror(errno))); return mem; } if(size >= memPartStats.numBytesFree) { if( (rc = clMemPartExpand(pMemPart, CL_MEM_PART_EXPANSION_SIZE) ) != CL_OK) { /* do nothing now and fall back to realloc.*/ } } mem = memPartRealloc(pMemPart->partId, memBase, size); clOsalMutexUnlock(&pMemPart->mutex); if(!mem) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Mem part realloc failure for size [%d]\n", size)); CL_ASSERT(0); } return mem; }
/** *NOT AN EXTERNAL API. PLEASE DO NOT DOCUMENT. * * Validates the object handle that is provided as an input argument to * this routine. */ ClRcT omValidateHandle(ClHandleT handle) { ClOmClassControlBlockT * pTab; ClOmClassTypeT classId = CL_OM_HANDLE_TO_CLASSID(handle); ClUint32T instId = CL_OM_HANDLE_TO_INSTANCEID(handle); CL_FUNC_ENTER(); /* validate the input argument class Id field */ if (omClassTypeValidate(classId) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid classID field within handle argument")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_CLASS)); } pTab = clOmClassEntryGet(classId); CL_ASSERT(pTab); if (instId > pTab->maxObjInst) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid instance ID field within handle argument")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_INSTANCE)); } if (!mGET_REAL_ADDR(pTab->pInstTab[instId])) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("The Instance Table for this class is not initialized")); return (CL_OM_SET_RC(CL_OM_ERR_INSTANCE_TAB_NOINIT)); } CL_FUNC_EXIT(); return (CL_OK); }
ClRcT cosSysvShmSecurityModeGet(ClOsalShmIdT shmId,ClUint32T* pMode) { struct shmid_ds shmPerm ; ClInt32T retCode = CL_OK; CL_FUNC_ENTER(); if(NULL == pMode) { CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory SecurityModeGet: FAILED")); retCode = CL_OSAL_RC(CL_ERR_NULL_POINTER); CL_FUNC_EXIT(); return(retCode); } /* Get the current values set and modify it */ retCode = shmctl ((int)shmId, IPC_STAT, &shmPerm); if(0 != retCode) { CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory SecurityModeGet: FAILED")); retCode = CL_OSAL_RC(CL_OSAL_ERR_SHM_MODE_GET); CL_FUNC_EXIT(); return(retCode); } *pMode = shmPerm.shm_perm.mode; CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory SecurityModeGet: DONE")); CL_FUNC_EXIT(); return (CL_OK); }
/** * Get number of instances for given OM. * * This routine returns the total number of instances that are managed * by Object Manager for given class. * * @param handle - OM Handle * @param numInstances - [OUT]number of instances the class has * * @returns CL_OK if number of instances could be obtained successfully * @returns CL_OM_ERR_INVALID_CLASS if the class passed by means of handle is * is not valid */ ClRcT clOmNumberOfOmClassInstancesGet(ClHandleT handle, ClUint32T *numInstances) { ClOmClassTypeT classId = CL_OM_HANDLE_TO_CLASSID(handle); ClOmClassControlBlockT * pTab = NULL; CL_FUNC_ENTER(); CL_ASSERT(numInstances); /* sanity check for input parameters */ if(numInstances == NULL) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL input argument")); return (CL_OM_SET_RC(CL_OM_ERR_NULL_PTR)); } if (omClassTypeValidate(classId) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid classID field within handle argument")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_CLASS)); } pTab = clOmClassEntryGet(classId); CL_ASSERT(pTab); *numInstances = pTab->curObjCount; CL_FUNC_EXIT(); return (CL_OK); }
/** * Get OM object reference given handle * * This routine returns the reference to the OM object, from the input * OM object handle * * @param pThis - OM Object Handle * @param objRef - [OUT]Object reference * * @returns CL_OK if number of instances could be obtained successfully * @returns CL_OM_ERR_INVALID_OBJ_HANDLE if the object handle passed * is not valid */ ClRcT clOmObjectReferenceByOmHandleGet(ClHandleT pThis, void **objRef) { ClOmClassControlBlockT * pTab = NULL; ClOmClassTypeT classId; ClUint32T instId; CL_FUNC_ENTER(); CL_ASSERT(pThis); CL_ASSERT(objRef); if (!objRef) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL pointer passed")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_REF)); } if (omValidateHandle(pThis) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid input handle argument")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_HANDLE)); } classId = CL_OM_HANDLE_TO_CLASSID(pThis); instId = CL_OM_HANDLE_TO_INSTANCEID(pThis); pTab = clOmClassEntryGet(classId); CL_ASSERT(pTab); *objRef = (char *)mGET_REAL_ADDR(pTab->pInstTab[instId]); return (CL_OK); }
void timeStamp(ClCharT timeStr [], ClUint32T len) { time_t timer ; struct tm *t = NULL; ClCharT * pBuff =NULL; struct tm *localtimebuf = clHeapAllocate(sizeof(struct tm));; if(localtimebuf == NULL) { CL_DEBUG_PRINT(CL_DEBUG_ERROR,( "\nMemory Allocation failed\n")); return ; } ClCharT *asctimebuf = clHeapAllocate(BUFFER_LENGTH*sizeof(ClCharT)); if(asctimebuf == NULL) { CL_DEBUG_PRINT(CL_DEBUG_ERROR,( "\nMemory Allocation failed\n")); return ; } memset(&timer,0,sizeof(time_t)); time(&timer); t = localtime_r(&timer,localtimebuf); pBuff=asctime_r(t,asctimebuf); strncpy(timeStr,pBuff,len-1); timeStr[strlen(timeStr) - 1] ='\0'; clHeapFree(localtimebuf); clHeapFree(asctimebuf); }
/** * Delete OM object given reference. * * This routine deletes the object given an input reference to the object * * @param pThis - Object reference of the object to be deleted. * * @returns CL_OK if the delete operation is successful * */ ClRcT clOmObjectByReferenceDelete(void *pThis) { ClHandleT handle; int rc; CL_FUNC_ENTER(); CL_ASSERT(pThis); if (!pThis) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL pointer passed")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_REF)); } handle = ((struct CL_OM_BASE_CLASS *)pThis)->__objType; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("The Handle is %#llX, Obj reference = %p", handle, pThis)); if ((rc = omCommonDeleteObj(handle, 1, CL_OM_DELETE_FLAG, NULL, 0)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to delete OM object")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_REF)); } return (CL_OK); }
ClRcT dbalGetLibName(ClCharT *pLibName) { ClParserPtrT parent = NULL ; /*parent*/ ClParserPtrT engineType = NULL ; /*parser ptr to Component*/ ClParserPtrT libName = NULL ; /*parser ptr to ckptName*/ ClParserPtrT fileName = NULL ; /*parser ptr to ckptName*/ ClRcT rc = CL_OK; ClCharT *configPath = NULL; configPath = getenv("ASP_CONFIG"); if (configPath != NULL) { parent = clParserOpenFile(configPath, "clDbalConfig.xml"); if (parent == NULL) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Xml file for config is not proper rc [0x %x]\n",rc)); return CL_ERR_NULL_POINTER; } } else { rc = CL_ERR_NULL_POINTER; CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("ASP_CONFIG path is not set in the environment irc[0x %x] \n",rc)); } if(parent != NULL) { engineType = clParserChild(parent,"Dbal"); libName = clParserChild(engineType,"Engine"); fileName = clParserChild(libName,"FileName"); } if(fileName != NULL && pLibName != NULL) strcpy(pLibName, fileName->txt); if (parent != NULL) clParserFree(parent); return rc; }
/* The debug versions of the heap routines */ static ClPtrT heapAllocateDebug( ClUint32T size) { ClPtrT pAddress = NULL; ClPoolConfigT* pPoolConfig = NULL; ClPoolConfigT poolKey = { 0 }; ClPoolT poolHandle; ClPtrT pCookie = NULL; ClRcT rc; ClUint32T overhead = 0; /* Add the overhead over here for debug allocation. */ CL_HEAP_OVERHEAD_DEBUG (overhead); size += overhead; poolKey.chunkSize = size; /* * Do a binary search to get an index into the chunk config and hence * pool handle to allocate from. */ rc = clBinarySearch ((ClPtrT)&poolKey, gHeapList.heapConfig.pPoolConfig, gHeapList.heapConfig.numPools, sizeof (ClPoolConfigT), clPoolCmp, (ClPtrT*)&pPoolConfig); if (rc != CL_OK) { CL_HEAP_MEM_TRACKER_TRACE(NULL,size); CL_DEBUG_PRINT (CL_DEBUG_ERROR, ("Error in getting pool handle for size:%d\n", size)); goto out; } poolHandle = gHeapList.pPoolHandles [ pPoolConfig - gHeapList.heapConfig.pPoolConfig ]; rc = clPoolAllocate (poolHandle, (ClUint8T**) &pAddress, &pCookie); if (rc != CL_OK) { CL_HEAP_MEM_TRACKER_TRACE(NULL,size); CL_DEBUG_PRINT (CL_DEBUG_ERROR, ("Error allocating memory from pool size:%d for input " "size:%d\n", pPoolConfig->chunkSize, size)); goto out; } CL_HEAP_MEM_TRACKER_ADD (pAddress, pPoolConfig->chunkSize, pCookie); size -= overhead; CL_HEAP_SET_DEBUG_COOKIE (pAddress, pPoolConfig->chunkSize, size, pCookie); /*Zero off the contents till ASP gets cured*/ memset (pAddress, 0, size); out: return (ClPtrT)pAddress; }
/* * clBitmapCreate() */ ClRcT clBitmapCreate(ClBitmapHandleT *phBitmap, ClUint32T bitNum) { ClRcT rc = CL_OK; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Enter")); if ( NULL == phBitmap) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Null Pointer")); return CL_BITMAP_RC(CL_ERR_NULL_POINTER); } *phBitmap = clHeapRealloc(NULL, sizeof(ClBitmapInfoT)); if( NULL == *phBitmap) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHeapRealloc() failed")); return CL_BITMAP_RC(CL_ERR_NO_MEMORY); } rc = clBitmapInfoInitialize(*phBitmap, bitNum); if (rc != CL_OK) { clHeapFree(phBitmap); return rc; } CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Exit")); return rc; }
static ClRcT clBitmapInfoInitialize(ClBitmapInfoT *pBitmapInfo, ClUint32T bitNum) { ClRcT rc = CL_OK; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Enter")); rc = clOsalMutexCreate(&(pBitmapInfo->bitmapLock)); if( CL_OK != rc ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clOsalMutexCreate() rc: %x", rc)); return rc; } pBitmapInfo->pBitmap = NULL; pBitmapInfo->nBytes = 0; pBitmapInfo->nBits = 0; pBitmapInfo->nBitsSet = 0; rc = clBitmapRealloc(pBitmapInfo, bitNum); if( CL_OK != rc ) { clOsalMutexDelete(pBitmapInfo->bitmapLock); return rc; } pBitmapInfo->nBits = bitNum + 1; /* bitNum is 0-based FIXME i felt this is wrong*/ CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Exit")); return rc; }
ClRcT clBitmap2BufferGet(ClBitmapHandleT hBitmap, ClUint32T *pListLen, ClUint8T **ppPositionList) { ClBitmapInfoT *pBitmapInfo = hBitmap; ClRcT rc = CL_OK; if( CL_BM_INVALID_BITMAP_HANDLE == hBitmap ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid Handle")); return CL_BITMAP_RC(CL_ERR_INVALID_HANDLE); } rc = clOsalMutexLock(pBitmapInfo->bitmapLock); if( CL_OK != rc ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clOsalMutexLock() rc: %x", rc)); return rc; } *ppPositionList = clHeapCalloc(pBitmapInfo->nBytes, sizeof(ClUint8T)); if( NULL == *ppPositionList ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHeapCalloc()")); clOsalMutexUnlock(pBitmapInfo->bitmapLock); return rc; } memcpy(*ppPositionList, pBitmapInfo->pBitmap, pBitmapInfo->nBytes); *pListLen = pBitmapInfo->nBytes; clOsalMutexUnlock(pBitmapInfo->bitmapLock); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Exit")); return rc; }
/** * Get class name * * Gives class name given the OM Handle. * * @param handle - OM Handle * @param nameBuf - [OUT]Buffer where class name is copied * * @returns CL_OK if the handle is valid and class name is obtained * successfully *@returns CL_OM_ERR_INVALID_OBJ_HANDLE if the passed object handle * is invalid */ ClRcT clOmClassNameGet(ClHandleT handle, char *nameBuf) { ClOmClassControlBlockT * pTab = NULL; CL_FUNC_ENTER(); CL_ASSERT(nameBuf); if (omValidateHandle(handle) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid input handle argument")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_HANDLE)); } if (!nameBuf) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL name buffer passed")); return (CL_ERR_NULL_POINTER); } pTab = clOmClassEntryGet(CL_OM_HANDLE_TO_CLASSID(handle)); CL_ASSERT(pTab); strcpy(nameBuf, (const char*) pTab->className); CL_FUNC_EXIT(); return (CL_OK); }
ClRcT cosSysvMutexValueSet(ClOsalMutexIdT mutexId, ClInt32T value) { ClOsalMutexT *pMutex = (ClOsalMutexT *) mutexId; ClRcT rc = CL_OK; ClInt32T semId = pMutex->shared_lock.sem.semId; ClInt32T err = 0; CosSemCtl_t arg = {0}; CL_FUNC_ENTER(); if(value >= SEMVMX) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Error in setting sem value to [%d]\n", value)); rc = CL_OSAL_RC(CL_ERR_INVALID_PARAMETER); goto out; } arg.val = value; err = semctl(semId, 0, SETVAL, arg); if(err < 0 ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Mutex value set- semctl error: [%s]\n", strerror(errno))); rc = CL_OSAL_RC(CL_ERR_LIBRARY); goto out; } CL_FUNC_EXIT(); out: return rc; }
/** * This routine returns the class of the super class of the parent class */ ClRcT clOmParentClassGet(ClHandleT handle, ClOmClassTypeT *peParentClass) { ClOmClassTypeT classId = CL_OM_HANDLE_TO_CLASSID(handle); ClOmClassControlBlockT * pTab = NULL; CL_FUNC_ENTER(); /* sanity check for input parameters */ if(NULL == peParentClass) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL input argument")); return CL_OM_SET_RC(CL_OM_ERR_NULL_PTR); } if (omClassTypeValidate(classId) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid classID field within handle argument")); return CL_OM_SET_RC(CL_OM_ERR_INVALID_CLASS); } pTab = clOmClassEntryGet(classId); if(NULL == pTab) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Class Entry not found for classId %d\n",classId)); return CL_OM_SET_RC(CL_OM_ERR_INVALID_CLASS); } *peParentClass = pTab->eParentObj; CL_FUNC_EXIT(); return CL_OK; }
ClRcT cosSysvShmAttach(ClOsalShmIdT shmId,void* pInMem, void** ppOutMem) { ClRcT retCode = 0; void* pShared = NULL; CL_FUNC_ENTER(); if(NULL == ppOutMem) { CL_DEBUG_PRINT (CL_DEBUG_INFO,("\nShared Memory Attach: FAILED")); retCode = CL_OSAL_RC(CL_ERR_NULL_POINTER); CL_FUNC_EXIT(); return(retCode); } pShared = shmat ((int)shmId, pInMem, 0); if((void*)-1 == pShared) { CL_DEBUG_PRINT (CL_DEBUG_INFO,("\nShared Memory Attach: FAILED")); retCode = CL_OSAL_RC(CL_OSAL_ERR_SHM_ATTACH); CL_FUNC_EXIT(); return(retCode); } else { *ppOutMem = pShared; } CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory Attach: DONE")); CL_FUNC_EXIT(); return (CL_OK); }
/** * Get class version * * This routine returns the current version that is associated with the * class of objects. * * @param handle - OM handle * @param version - [OUT] Version of th class * * @returns CL_OK if number of instances could be obtained successfully * @returns CL_OM_ERR_INVALID_CLASS if the class passed by means of handle is * is not valid */ ClRcT clOmClassVersionGet(ClHandleT handle, ClUint32T *version) { ClOmClassTypeT classId = CL_OM_HANDLE_TO_CLASSID(handle); ClOmClassControlBlockT * pTab = NULL; CL_ASSERT(version); CL_FUNC_ENTER(); if (omClassTypeValidate(classId) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid classID field within handle argument")); return (CL_OM_SET_RC(CL_OM_ERR_INVALID_CLASS)); } if (!version) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL version argument passed")); return (CL_ERR_INVALID_PARAMETER); } pTab = clOmClassEntryGet(classId); CL_ASSERT(pTab); *version = pTab->vVersion; CL_FUNC_EXIT(); return (CL_OK); }
ClRcT cosSysvShmDetach(void* pMem) { ClInt32T retCode = CL_OK; CL_FUNC_ENTER(); if(NULL == pMem) { CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory Detach: FAILED")); retCode = CL_OSAL_RC(CL_ERR_NULL_POINTER); CL_FUNC_EXIT(); return(retCode); } retCode = shmdt (pMem); if(0 != retCode) { CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory Detach: FAILED")); retCode = CL_OSAL_RC(CL_OSAL_ERR_SHM_DETACH); CL_FUNC_EXIT(); return(retCode); } CL_DEBUG_PRINT (CL_DEBUG_TRACE,("\nShared Memory Detach: DONE")); CL_FUNC_EXIT(); return (CL_OK); }
/** * Get OM Handle given object reference. * * This routine returns the OM object handle, given the reference to the * om Object. * * @param pThis - Object reference. * @param pHandle - [OUT] Object handle for given object. * * @returns CL_OK if number of instances could be obtained successfully * @returns CL_OM_ERR_INVALID_OBJ_HANDLE if the object handle passed * is not valid */ ClRcT clOmOmHandleByObjectReferenceGet(void *pThis, ClHandleT *pHandle) { ClRcT rc = CL_OK; #ifdef CL_DEBUG ClUint8T aFuncName[] = "clOmOmHandleByObjectReferenceGet()"; #endif CL_FUNC_ENTER(); if (!pThis) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: NULL pointer passed\r\n", aFuncName)); rc = CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_REF); goto ERROR_CASE; } if (!pHandle) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: NULL pointer passed\r\n", aFuncName)); rc = CL_OM_SET_RC(CL_OM_ERR_INVALID_OBJ_HANDLE); goto ERROR_CASE; } *pHandle = ((struct CL_OM_BASE_CLASS *)pThis)->__objType; return (CL_OK); ERROR_CASE: if(pHandle) *pHandle = 0; return (rc); }
static ClRcT clMemPartExpand(ClMemPartT *pMemPart, ClUint32T size) { STATUS rc = 0; if(pMemPart->index >= CL_MEM_PART_EXPANSION_SLOTS) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Mem part out of expansion slots trying to expand for size [%d]\n", size)); return CL_ERR_NO_SPACE; } if(pMemPart->partitions[pMemPart->index]) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Mem part already expanded\n")); return CL_ERR_UNSPECIFIED; } pMemPart->partitions[pMemPart->index] = malloc(size); if(!pMemPart->partitions[pMemPart->index]) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Mem part expand calloc failure for size [%d]\n", size)); return CL_ERR_NO_MEMORY; } if( (rc = memPartAddToPool(pMemPart->partId, pMemPart->partitions[pMemPart->index], size) ) == ERROR ) { free(pMemPart->partitions[pMemPart->index]); pMemPart->partitions[pMemPart->index] = NULL; CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Mem part add to pool for size [%d] failed with [%s]\n", size, strerror(errno))); return CL_ERR_NO_MEMORY; } ++pMemPart->index; return CL_OK; }
ClRcT clCorDataSave() { ClRcT rc = CL_OK; corPersisInfo_t corData; memset(&corData, 0, sizeof(corData)); CL_FUNC_ENTER(); CL_DEBUG_PRINT(CL_DEBUG_TRACE,("\n Inside clCorDataSave \n")); /* corData.version = CL_COR_VERSION_NO; */ CL_COR_VERSION_SET(corData.version); corData.operation = COR_DATA_SAVE; COR_CALL_RMD(COR_EO_PERSISTENCY_OP, VDECL_VER(clXdrMarshallcorPersisInfo_t, 4, 0, 0), &corData, sizeof(corData), VDECL_VER(clXdrUnmarshallcorPersisInfo_t, 4, 0, 0), NULL, NULL, rc); if(rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ( "clCorDataSave returns error,rc=%x",rc)); } CL_FUNC_EXIT(); return rc; }
/*Currently we are having another API clCorClassDelete for same purpose. However, it takes class handle as input. If we plan to remove it. This will be useful.*/ ClRcT dmClassDelete(ClCorClassTypeT id) { ClRcT ret = CL_OK; CORClass_h tmp = 0; CL_FUNC_ENTER(); if((!dmGlobal)) { CL_FUNC_EXIT(); return(CL_COR_SET_RC(CL_COR_ERR_NULL_PTR)); } CL_DEBUG_PRINT(CL_DEBUG_TRACE, ( "ClassDelete (Class:%04x)", id)); /* check if class already present */ HASH_GET(dmGlobal->classTable, id, tmp); if(tmp) { ret = dmClassByHandleDelete(tmp); } else { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ( "ClassDelete (Class:%04x) [Unknown class]", id)); ret = CL_COR_SET_RC(CL_COR_ERR_CLASS_NOT_PRESENT); } CL_FUNC_EXIT(); return (ret); }
ClRcT clBitmapDestroy(ClBitmapHandleT hBitmap) { ClRcT rc = CL_OK; ClBitmapInfoT *pBitmapInfo = hBitmap; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Enter")); if( CL_BM_INVALID_BITMAP_HANDLE == hBitmap ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Invalid Handle")); return CL_BITMAP_RC(CL_ERR_INVALID_HANDLE); } do { rc = clOsalMutexDelete(pBitmapInfo->bitmapLock); }while( CL_OSAL_ERR_MUTEX_EBUSY == rc ); clHeapFree(pBitmapInfo->pBitmap); clHeapFree(pBitmapInfo); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Exit")); return rc; }
/** * API to restore recovery logs of previously active transactions * from check-point */ ClRcT clTxnServiceCkptRecoveryLogRestore() { ClRcT rc = CL_OK; if(!clTxnServiceCfg->dsblCkpt) { SaNameT txnCkptName; CL_FUNC_ENTER(); txnCkptName.length = strlen(CL_TXN_CKPT_NAME) + 1; memset(&(txnCkptName.value[0]), '\0', txnCkptName.length); strncpy(&(txnCkptName.value[0]), CL_TXN_CKPT_NAME, txnCkptName.length); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Restoring transaction-recovery logs")); /* AD-1: To use the checkpoint exists api to check whether its recovery or * normal startup */ clLogDebug("SER", NULL, "Checkpoint exists, reading data for recovery"); rc = clCkptLibraryCkptDataSetRead(clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_RECOVERY_DATA_SET, 0x0); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to restore transaction-service state. rc:0x%x", rc)); rc = CL_GET_ERROR_CODE(rc); } } CL_FUNC_EXIT(); return (rc); }
/* * This api would be called as and when the object is no more and the corresponding entry * within the container needs to be deleted. */ ClRcT clAlarmPayloadCntDelete(ClCorMOIdPtrT pMoId, ClAlarmProbableCauseT probCause, ClAlarmSpecificProblemT specificProblem) { ClRcT rc = CL_OK; ClCntNodeHandleT nodeH; ClAlarmPayloadCntKeyT *pCntKey = clHeapAllocate(sizeof(ClAlarmPayloadCntKeyT)); if(NULL == pCntKey) { CL_DEBUG_PRINT (CL_DEBUG_CRITICAL,("Memory allocation failed with rc 0x%x ", rc)); return (rc); } pCntKey->probCause = probCause; pCntKey->specificProblem = specificProblem; pCntKey->moId = *pMoId; clOsalMutexLock(gClAlarmPayloadCntMutex); rc = clCntNodeFind(gPayloadCntHandle,(ClCntKeyHandleT)pCntKey,&nodeH); if(CL_OK == rc) { rc = clCntAllNodesForKeyDelete(gPayloadCntHandle,(ClCntKeyHandleT)pCntKey); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clCntAllNodesForKeyDelete failed w rc:0x%x\n", rc)); } } else { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Node does not exist with rc:0x%x\n", rc)); } clHeapFree(pCntKey); clOsalMutexUnlock(gClAlarmPayloadCntMutex); return rc; }
ClRcT clComponentTimerInit(ClEoExecutionObjT* peoObj) { ClRcT rc = CL_OK; ClTimerTimeOutT ComponentTimeOut = {0,0}; ComponentTimeOut.tsSec = 0; ComponentTimeOut.tsMilliSec = COMPONENT_CALLBACK_TIME; rc= clTimerCreate(ComponentTimeOut, CL_TIMER_ONE_SHOT, CL_TIMER_SEPARATE_CONTEXT, clComponentCallBack, (void*)peoObj, &gComponentTimerHandle); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, (" clTimerCreate failed with rc: 0x%x \n", rc)); return rc; } rc = clTimerStart(gComponentTimerHandle); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, (" clTimerStart failed with rc: 0x%x \n", rc)); return rc; } return rc; }
ClRcT clNameContextCkptNameUnpack(ClBufferHandleT inMsg) { ClRcT rc = CL_OK; ClUint32T key = 0; ClUint32T size = 0; ClUint32T count = 0; ClIocNodeAddressT localAddr = 0; ClIocNodeAddressT masterAddr = 0; CL_NAME_DEBUG_TRACE(("Enter")); rc = clXdrUnmarshallClUint32T(inMsg, &size); if( CL_OK != rc ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clXdrUnmarshallClUint32T(): rc[0x %x]", rc)); return rc; } clLogDebug("SVR", "CKP", "Num of contexts: %d", size); for( count = 0; count < size; count++) { rc = clXdrUnmarshallClUint32T(inMsg, &key); if( CL_OK != rc ) { return rc; } if( (key > CL_NS_DEFAULT_GLOBAL_CONTEXT) && (key < CL_NS_BASE_NODELOCAL_CONTEXT) ) { localAddr = clIocLocalAddressGet(); rc = clCpmMasterAddressGet(&masterAddr); if (rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR,("clCpmMasterAddressGet failed with rc 0x%x",rc)); return rc; } if( masterAddr == localAddr ) { rc = clNameSvcCtxRecreate(key); if( CL_OK != rc ) { return rc; } } } else { rc = clNameSvcCtxRecreate(key); if( CL_OK != rc ) { return rc; } } } CL_NAME_DEBUG_TRACE(("Exit")); return rc; }
/* * Insert the class tab entry into the class id table. */ static ClRcT omClassEntryReload (ClCharT *pClassName, ClOmClassTypeT classId) { ClRcT rc = CL_OK; ClOmClassControlBlockT *pClassTab = NULL; ClCntNodeHandleT nodeHandle = 0; CL_FUNC_ENTER(); if(!pClassName) { rc = CL_OM_SET_RC(CL_OM_ERR_NULL_PTR); CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL PTR PASSED")); CL_FUNC_EXIT(); return rc; } CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("OM entry reload for class = %s, class type %d", pClassName, classId)); /* * First check if the class id entry is already present in the om class id table. */ if(clCntNodeFind(ghOmClassHashTbl, (ClCntKeyHandleT)(ClWordT)classId, &nodeHandle) == CL_OK) return CL_OK; /* Add this class entry into the OM class lookup table */ rc = clCntNodeFind(ghOmClassNameHashTbl, (ClCntKeyHandleT)pClassName, &nodeHandle); if (rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Unable to find OM Class name [%s] entry in om class table", pClassName)); return (rc); } rc = clCntNodeUserDataGet(ghOmClassNameHashTbl, nodeHandle, (ClCntDataHandleT*)&pClassTab); if(rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Unable to get data for OM Class [%s] from om class name table", pClassName)); return rc; } /* * Insert this entry into the class id table. */ pClassTab->eMyClassType = classId; rc = clCntNodeAdd(ghOmClassHashTbl, (ClCntKeyHandleT)(ClWordT)pClassTab->eMyClassType, (ClCntDataHandleT)pClassTab, NULL); if(rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Unable to add entry [%#x] for class [%s] to OM class id table", classId, pClassName)); return rc; } CL_FUNC_EXIT(); return (rc); }