void clDifferenceVectorCopy(ClDifferenceVectorT *dest, ClDifferenceVectorT *src)
{
if(!dest || !src) return;
memcpy(dest, src, sizeof(*dest));
if(src->dataVectors)
{
if(src->numDataVectors)
{
dest->dataVectors = (ClDataVectorT*) clHeapCalloc(src->numDataVectors, sizeof(*dest->dataVectors));
CL_ASSERT(dest->dataVectors != NULL);
memcpy(dest->dataVectors, src->dataVectors,
sizeof(*dest->dataVectors) * src->numDataVectors);
}
else dest->dataVectors = NULL;
}
else dest->numDataVectors = 0;
if(src->md5List)
{
if(src->md5Blocks)
{
dest->md5List = (ClMD5T*) clHeapCalloc(src->md5Blocks, sizeof(*dest->md5List));
CL_ASSERT(dest->md5List != NULL);
memcpy(dest->md5List, src->md5List, sizeof(*dest->md5List) * src->md5Blocks);
}
else dest->md5List = NULL;
}
else dest->md5Blocks = 0;
}
ClRcT
clTestSectionCreate(ClCkptHdlT ckptHdl,
ClUint32T sectionIdx)
{
ClRcT rc = CL_OK;
ClCkptSectionCreationAttributesT secCreateAttr = {0};
secCreateAttr.sectionId = clHeapCalloc(1, sizeof(ClCkptSectionIdT));
if( NULL == secCreateAttr.sectionId )
{
return CL_OK;
}
secCreateAttr.expirationTime = CL_TIME_END;
secCreateAttr.sectionId->id = clHeapCalloc(1, 15);
if( NULL == secCreateAttr.sectionId->id )
{
clHeapFree(secCreateAttr.sectionId);
return CL_OK;
}
snprintf((ClCharT *) secCreateAttr.sectionId->id,15, "section%d", sectionIdx);
secCreateAttr.sectionId->idLen = strlen((ClCharT *) secCreateAttr.sectionId->id) + 1;
rc = clCkptSectionCreate(ckptHdl, &secCreateAttr, NULL, 0);
if( CL_OK != rc )
{
return rc;
}
clHeapFree(secCreateAttr.sectionId->id);
clHeapFree(secCreateAttr.sectionId);
return CL_OK;
}
ClRcT
clLogCompEntryUnpackNAdd(ClBufferHandleT msg,
ClLogStreamOwnerDataT *pStreamOwnerData)
{
ClRcT rc = CL_OK;
ClLogCompKeyT compKey = {0};
ClLogCompKeyT *pCompKey = NULL;
ClLogSOCompDataT compData = {0};
ClLogSOCompDataT *pData = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = VDECL_VER(clXdrUnmarshallClLogCompKeyT, 4, 0, 0)(msg, &compKey);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("VDECL_VER(clXdrUnmarshallClLogCompKeyT, 4, 0, 0)(): rc[0x %x]", rc));
return rc;
}
rc = VDECL_VER(clXdrUnmarshallClLogSOCompDataT, 4, 0, 0)(msg, &compData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("VDECL_VER(clXdrUnmarshallClLogSOCompDataT, 4, 0, 0)(): rc[0x %x]", rc));
return rc;
}
pCompKey = (ClLogCompKeyT*)clHeapCalloc(1, sizeof(ClLogCompKeyT));
if( NULL == pCompKey )
{
CL_LOG_DEBUG_ERROR(( "clHeapCalloc()"));
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
*pCompKey = compKey;
CL_LOG_DEBUG_VERBOSE(("compKey.nodeAddress: %u", compKey.nodeAddr));
CL_LOG_DEBUG_VERBOSE(("compKey.compId : %u", compKey.compId));
pData = (ClLogSOCompDataT*)clHeapCalloc(1, sizeof(ClLogSOCompDataT));
if( NULL == pData )
{
CL_LOG_DEBUG_ERROR(( "clHeapCalloc()"));
clHeapFree(pCompKey);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
*pData = compData;
CL_LOG_DEBUG_VERBOSE(("compData.refCount : %u", pData->refCount));
CL_LOG_DEBUG_VERBOSE(("compData.ackerCnt : %u", pData->ackerCnt));
CL_LOG_DEBUG_VERBOSE(("compData.nonAckerCnt : %u", pData->nonAckerCnt));
rc = clCntNodeAdd(pStreamOwnerData->hCompTable,
(ClCntKeyHandleT) pCompKey,
(ClCntDataHandleT) pData, NULL);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(( "clCntNodeAdd(): rc[0x %x]", rc));
clHeapFree(pData);
clHeapFree(pCompKey);
}
CL_LOG_DEBUG_TRACE(("Exit"));
return CL_OK;
}
ClRcT clCpmNodeNameGet(ClUint32T argc, ClCharT *argv[], ClCharT **retStr)
{
ClRcT rc = CL_OK;
ClNameT nodeName={0};
*retStr = NULL;
if(argc > 1 )
{
ClCharT tempStr[0x100];
rc = CL_CPM_RC(CL_ERR_INVALID_PARAMETER);
snprintf(tempStr, sizeof(tempStr),
"Usage: nodename\n");
*retStr = (ClCharT *) clHeapAllocate(strlen(tempStr) + 1);
if (*retStr)
strcpy(*retStr, tempStr);
goto out;
}
rc = clCpmLocalNodeNameGet(&nodeName);
if(rc != CL_OK)
{
rc = CL_CPM_RC(CL_ERR_UNSPECIFIED);
goto out;
}
*retStr = clHeapCalloc(1,nodeName.length+1);
if(!*retStr)
{
rc = CL_CPM_RC(CL_ERR_NO_MEMORY);
goto out;
}
strncpy(*retStr,nodeName.value,nodeName.length);
rc = CL_OK;
out:
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;
}
ClRcT
clNameSvcEntryDeserializer(ClUint32T dsId,
ClAddrT pBuffer,
ClUint32T size,
ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClNsEntryPackT *pNsEntryInfo = (ClNsEntryPackT *)cookie;
CL_NAME_DEBUG_TRACE(("Enter"));
memcpy(&pNsEntryInfo->type, pBuffer, sizeof(pNsEntryInfo->type));
pBuffer += sizeof(pNsEntryInfo->type);
memcpy(&pNsEntryInfo->nsInfo, pBuffer, sizeof(ClNameSvcInfoIDLT));
pBuffer += sizeof(ClNameSvcInfoIDLT);
if( pNsEntryInfo->nsInfo.attrCount > 0 )
{
pNsEntryInfo->nsInfo.attr = clHeapCalloc(pNsEntryInfo->nsInfo.attrLen,
sizeof(ClCharT));
if( NULL == pNsEntryInfo->nsInfo.attr )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHeapCalloc(): "));
return CL_NS_RC(CL_ERR_NO_MEMORY);
}
memcpy(pNsEntryInfo->nsInfo.attr, pBuffer,
pNsEntryInfo->nsInfo.attrLen);
}
CL_NAME_DEBUG_TRACE(("Exit"));
return rc;
}
static ClUint32T differenceVectorGet(ClDifferenceVectorKeyT *key, ClUint8T *data, ClOffsetT offset, ClSizeT size,
ClDifferenceVectorT *vector, ClBoolT copyData,
ClDifferenceBlockT **pBlock)
{
ClDifferenceBlockT *block;
block = differenceVectorAdd(key, NULL);
CL_ASSERT(block != NULL);
if(pBlock) *pBlock = block;
/*
* Store the data too if enabled. Heavy though coz of duplication.
*/
if(copyData)
{
if(block->size < offset+size)
{
if(block->data) clHeapFree(block->data);
block->data = (ClUint8T*) clHeapCalloc(1, offset+size);
CL_ASSERT(block->data != NULL);
block->size = offset+size;
}
if(block->data)
memcpy(block->data + offset, data + offset, size);
}
return __differenceVectorGet(block, data, offset, size, vector);
}
ClRcT
clLogStreamOwnerEntrySerialiser(ClUint32T dsId,
ClAddrT *pBuffer,
ClUint32T *pSize,
ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClBufferHandleT msg = (ClBufferHandleT) cookie;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clBufferLengthGet(msg, pSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));
return rc;
}
*pBuffer = (ClAddrT)clHeapCalloc(*pSize, sizeof(ClUint8T));
if( NULL == *pBuffer )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
return rc;
}
rc = clBufferNBytesRead(msg, (ClUint8T *) *pBuffer, pSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));
clHeapFree(*pBuffer);
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static ClRcT clCorDeltaDbContAdd(ClCorDeltaSaveKeyT *deltaDbKey, ClDBRecordT deltaDbData, ClUint32T dataSize)
{
ClRcT rc = CL_OK;
ClCorDeltaSaveKeyT *tempKey = deltaDbKey;
ClCorDeltaContDataT *tempCont = clHeapCalloc(1, sizeof(ClCorDeltaContDataT));
CL_ASSERT(tempCont != NULL);
tempCont->data = deltaDbData;
tempCont->dataSize = dataSize;
if( tempKey == NULL || tempCont->data == NULL)
{
clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_DEBUG, NULL,
CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED);
CL_DEBUG_PRINT(CL_DEBUG_ERROR,(CL_COR_ERR_STR(CL_COR_ERR_NO_MEM)));
return CL_COR_SET_RC(CL_COR_ERR_NO_MEM);
}
rc = clCntNodeAdd(gCorDeltaSaveKeyTable, (ClCntKeyHandleT) tempKey, (ClCntDataHandleT) tempCont , NULL);
if(CL_OK != rc)
{
if (CL_GET_ERROR_CODE(rc) == CL_ERR_DUPLICATE)
rc = CL_OK;
else
CL_COR_RETURN_ERROR(CL_DEBUG_ERROR, "Could not add node in the Delta Save Key Table", rc);
clHeapFree(tempCont);
}
return rc;
}
static ClDifferenceBlockT *differenceVectorAdd(ClDifferenceVectorKeyT *key,
ClBoolT *lastStatus)
{
ClDifferenceBlockT *block;
ClUint32T hashKey = 0;
ClBoolT status = CL_TRUE;
block = differenceVectorFind(key, &hashKey);
if(!block)
{
block = (ClDifferenceBlockT *) clHeapCalloc(1, sizeof(*block));
CL_ASSERT(block != NULL);
block->key.groupKey = clStringDup(key->groupKey);
CL_ASSERT(block->key.groupKey != NULL);
block->key.sectionKey = clStringDup(key->sectionKey);
CL_ASSERT(block->key.sectionKey != NULL);
hashAdd(differenceVectorTable, hashKey, &block->hash);
status = CL_FALSE;
}
if(lastStatus)
*lastStatus = status;
return block;
}
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;
}
/*
* The operations for the FILE type backing storage.
*/
ClRcT clBackingStorageInitFile(const ClBackingStorageAttributesT *pAttr, ClPtrT *pPrivateData)
{
ClBackingStorageAttributesFileT *pFileAttr = NULL;
ClRcT rc = CL_BACKING_STORAGE_RC(CL_ERR_LIBRARY);
ClFdT fd = -1;
fd = open(pAttr->location, pAttr->mode, 0666);
if(fd < 0)
{
clLogError(CL_LOG_AREA_BACKING_STORAGE, CL_LOG_CONTEXT_INIT_FILE, "open failed with error [%s]", strerror(errno));
goto out;
}
rc = CL_BACKING_STORAGE_RC(CL_ERR_NO_MEMORY);
pFileAttr = (ClBackingStorageAttributesFileT *) clHeapCalloc(1, sizeof(*pFileAttr));
if(!pFileAttr)
{
clLogError(CL_LOG_AREA_BACKING_STORAGE, CL_LOG_CONTEXT_INIT_FILE, "No memory");
goto out;
}
memcpy(&pFileAttr->baseAttr, pAttr, sizeof(pFileAttr->baseAttr));
pFileAttr->fd = fd;
*pPrivateData = (ClPtrT)pFileAttr;
rc = CL_OK;
out:
return rc;
}
static ClRcT fileEntryRecoverBaseVersion(ClLogMasterEoDataT *pMasterEoEntry,
ClBufferHandleT hFileEntryBuf)
{
ClRcT rc = CL_OK;
ClLogFileKeyT fileKey = {{0}};
ClLogFileKeyT *pFileKey = NULL;
ClLogFileDataT *pFileData = NULL;
rc = clLogMasterFileKeyUnpack(&fileKey, hFileEntryBuf);
if( CL_OK != rc )
{
return rc;
}
clLogInfo(CL_LOG_AREA_MASTER, CL_LOG_CTX_CKPT_READ,
"Recreating files fileName: %.*s fileLocation: %.*s",
fileKey.fileName.length, fileKey.fileName.pValue,
fileKey.fileLocation.length, fileKey.fileLocation.pValue);
rc = clLogFileKeyCreate(&fileKey.fileName, &fileKey.fileLocation,
pMasterEoEntry->maxFiles, &pFileKey);
if( CL_OK != rc )
{
clHeapFree(fileKey.fileName.pValue);
clHeapFree(fileKey.fileLocation.pValue);
return rc;
}
clHeapFree(fileKey.fileName.pValue);
clHeapFree(fileKey.fileLocation.pValue);
/* find out the filelocation is available */
pFileData = (ClLogFileDataT*) clHeapCalloc(1, sizeof(ClLogFileDataT));
if( NULL == pFileData )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clLogFileKeyDestroy(pFileKey);
return rc;
}
pFileData->nActiveStreams = 0;
rc = clLogMasterFileDataRecreate(pFileData, hFileEntryBuf);
if( CL_OK != rc )
{
clLogFileKeyDestroy(pFileKey);
return rc;
}
rc = clCntNodeAdd(pMasterEoEntry->hMasterFileTable,
(ClCntKeyHandleT) pFileKey,
(ClCntDataHandleT) pFileData, NULL);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeAdd()"));
CL_LOG_CLEANUP(clCntDelete(pFileData->hStreamTable), CL_OK); //FIXME
clHeapFree(pFileData);
clLogFileKeyDestroy(pFileKey);
return rc;
}
return rc;
}
static ClRcT
clLogMasterFileEntrySecIdGet(ClLogFileKeyT *pFileKey,
ClCkptSectionIdT *pSecId)
{
ClRcT rc = CL_OK;
CL_LOG_DEBUG_TRACE(("Enter: namelen: %u locationlen: %u",
pFileKey->fileName.length,
pFileKey->fileLocation.length));
CL_LOG_PARAM_CHK((NULL == pFileKey->fileName.pValue),
CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pFileKey->fileLocation.pValue),
CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pSecId), CL_LOG_RC(CL_ERR_NULL_POINTER));
/*
* ClString: Assuming length includes NULL terminator also.
* So we idLen will include 2 more than the characters.
* One we will use for / so we need to decrement it by 1
*/
pSecId->idLen = pFileKey->fileName.length + pFileKey->fileLocation.length + 1;
pSecId->id = (ClUint8T*) clHeapCalloc(pSecId->idLen, sizeof(ClCharT));
if( NULL == pSecId->id )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
snprintf((ClCharT *) pSecId->id, pSecId->idLen, "%s/%s", pFileKey->fileLocation.pValue,
pFileKey->fileName.pValue);
CL_LOG_DEBUG_TRACE(("Exit [%*s]", pSecId->idLen, pSecId->id));
return rc;
}
static ClRcT clAmsEntityTrigger(ClAmsEntityTriggerT *pEntityTrigger,
ClMetricIdT id,
ClBoolT reset)
{
ClAmsEntityTriggerT *pEntityTriggerRecovery = NULL;
ClRcT rc = CL_OK;
pEntityTriggerRecovery = (ClAmsEntityTriggerT*) clHeapCalloc(1, sizeof(*pEntityTriggerRecovery));
CL_ASSERT(pEntityTriggerRecovery != NULL);
/*
*Safe w.r.t deletes behind our back while the trigger is running from the recovery queue.
*/
memcpy(pEntityTriggerRecovery, pEntityTrigger, sizeof(*pEntityTrigger));
pEntityTriggerRecovery->recoveryThresholdId = id;
if(reset == CL_TRUE)
{
ClMetricIdT start = id;
ClMetricIdT end = (ClMetricIdT) (start+1);
register ClInt32T i;
if(start == CL_METRIC_ALL)
{
start = (ClMetricIdT) (start+1);
end = CL_METRIC_MAX;
}
for(i = start; i < end; ++i)
{
pEntityTriggerRecovery->thresholds[i].recoveryReset = CL_TRUE;
}
}
rc = clAmsEntityTriggerRecoveryListAdd(pEntityTriggerRecovery);
return rc;
}
ClStringT *clStringDup(const ClStringT *str)
{
ClStringT *dest;
if(!str) return NULL;
dest = (ClStringT *) clHeapCalloc(1, sizeof(*dest));
if(!dest) return NULL;
dest->pValue = (ClCharT*) clHeapCalloc(str->length, sizeof(*dest->pValue));
if(!dest->pValue)
{
clHeapFree(dest);
return NULL;
}
if(str->pValue)
memcpy(dest->pValue, str->pValue, str->length);
dest->length = str->length;
return dest;
}
ClRcT
clTestCheckpointReadWithOffSet(ClCkptHdlT ckptHdl,
ClUint32T numSections)
{
ClRcT rc = CL_OK;
ClUint32T i = 0;
ClCkptIOVectorElementT iov[numSections];
ClUint32T readIdx = 0;
memset(iov, 0, numSections * sizeof(ClCkptIOVectorElementT));
for( i = 0; i < numSections; i++ )
{
if( numSections != 1 )
{
iov[i].sectionId.id = clHeapCalloc(1, 15);
if( NULL == iov[i].sectionId.id )
{
return CL_OK;
}
snprintf( (ClCharT *) iov[i].sectionId.id, 15,"section%d", i);
iov[i].sectionId.idLen = strlen((ClCharT *) iov[i].sectionId.id) + 1;
}
iov[i].dataSize = 30;
if( NULL != (iov[i].dataBuffer = clHeapCalloc(1, iov[i].dataSize)) )
{
iov[i].dataBuffer = NULL;
}
iov[i].readSize = 0;
iov[i].dataOffset = 20;
}
rc = clCkptCheckpointRead(ckptHdl, iov, numSections, &readIdx);
if( CL_OK != rc )
{
return rc;
}
for( i = 0; i < numSections; i++ )
{
if( NULL != iov[i].sectionId.id )
{
clHeapFree(iov[i].sectionId.id);
}
clHeapFree(iov[i].dataBuffer);
}
return CL_OK;
}
ClRcT
clLogClntFileKeyCreate(ClCharT *fileName,
ClCharT *fileLocation,
ClLogClntFileKeyT **pFileKey)
{
ClRcT rc = CL_OK;
CL_LOG_DEBUG_TRACE(("Enter"));
*pFileKey = clHeapCalloc(1, sizeof(ClLogClntFileKeyT));
if( NULL == *pFileKey )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
(*pFileKey)->fileName.length = strlen(fileName) + 1;
(*pFileKey)->fileName.pValue = clHeapCalloc((*pFileKey)->fileName.length,
sizeof(ClCharT));
if( NULL == (*pFileKey)->fileName.pValue )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clHeapFree(*pFileKey);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
(*pFileKey)->fileLocation.length = strlen(fileLocation) + 1;
(*pFileKey)->fileLocation.pValue = clHeapCalloc((*pFileKey)->fileLocation.length,
sizeof(ClCharT));
if( NULL == (*pFileKey)->fileLocation.pValue )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clHeapFree((*pFileKey)->fileName.pValue);
clHeapFree(*pFileKey);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
strncpy((*pFileKey)->fileName.pValue, fileName,
(*pFileKey)->fileName.length);
strncpy((*pFileKey)->fileLocation.pValue, fileLocation,
(*pFileKey)->fileLocation.length);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClCharT *clStrdup(const ClCharT *str)
{
ClCharT *dest = NULL;
if(!str) return NULL;
dest = (ClCharT *) clHeapCalloc(1, strlen(str)+1);
if(!dest) return NULL;
strcpy(dest, str);
return dest;
}
/* A helper function so that we can someday queue unused ClJobTs instead of constantly alloc/dealloc */
static ClJobT* getJob(ClJobQueueT* hdl, ClCallbackT job,ClPtrT data)
{
ClJobT* ret = (ClJobT*) clHeapCalloc(1, sizeof(ClJobT));
if (ret)
{
ret->job = job;
ret->data = data;
}
return ret;
}
ClUint32T clGetTable ( ClSnmpReqInfoT* reqInfo,
void* data,
ClInt32T* pErrCode)
{
ClMedOpT opInfo;
ClMedVarBindT *tempVarInfo = NULL;
ClInt32T errorCode = CL_OK;
ClInt32T retVal = 0;
ClCharT oid[CL_SNMP_DISPLAY_STRING_SIZE];
opInfo.varCount = 1;
tempVarInfo =
(ClMedVarBindT *) clHeapCalloc(1,opInfo.varCount * sizeof (ClMedVarBindT));
if (tempVarInfo == NULL)
{
clLogError("SNM","OPE", "Failed while allocating the varbind.");
return (CL_RC(CL_CID_SNMP, CL_ERR_NO_MEMORY));
}
retVal = 0;
strcpy(oid, reqInfo->oid);
/*oid received till this point is that of the table. Add .1.1 to
get oid of the first entry in the table
*/
strcat(oid,".1.1");
opInfo.varInfo = tempVarInfo;
opInfo.varInfo[0].pVal = data;
opInfo.varInfo[0].errId = 0;
opInfo.varInfo[0].pInst = reqInfo;
opInfo.opCode = reqInfo->opCode;
opInfo.varInfo[0].attrId.id = (ClUint8T*)oid;
opInfo.varInfo[0].attrId.len = (ClUint32T)strlen(oid) + 1;
opInfo.varInfo[0].len = reqInfo->dataLen;
errorCode = clMedOperationExecute (gSubAgentInfo.medHdl, &opInfo);
if ((opInfo.varInfo[0].errId == 0) && (errorCode == 0))
{
clHeapFree (tempVarInfo);
return (CL_OK);
}
else
{
if (errorCode != CL_OK)
*pErrCode = errorCode;
else
*pErrCode = opInfo.varInfo[0].errId;
clLogError(CL_LOG_AREA_UNSPECIFIED,CL_LOG_CONTEXT_UNSPECIFIED,
"clMedOperationExecute returned error. error code = %x, error id = %d",
errorCode, opInfo.varInfo[0].errId);
}
clHeapFree (tempVarInfo);
return (errorCode);
}
ClRcT clTransportNotifyRegister(ClTransportNotifyCallbackT callback, ClPtrT arg)
{
ClTransportNotifyRegistrantT *registrant = NULL;
if(!callback) return CL_ERR_INVALID_PARAMETER;
registrant = clHeapCalloc(1, sizeof(*registrant));
CL_ASSERT(registrant != NULL);
registrant->callback = callback;
registrant->arg = arg;
clListAddTail(®istrant->list, &gClXportNotifyRegistrants);
return CL_OK;
}
ClRcT
clLogMasterCompData2BufferGet(ClLogCompDataT *pCompData,
ClUint8T **ppBuffer,
ClUint32T *pDataSize)
{
ClRcT rc = CL_OK;
ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clBufferCreate(&msg);
if(CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
return rc;
}
rc = VDECL_VER(clXdrMarshallClLogCompDataT, 4, 0, 0)(pCompData, msg, 0);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogMarshallClLogCompDataT(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
rc = clBufferLengthGet(msg, pDataSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
*ppBuffer = (ClUint8T*) clHeapCalloc(*pDataSize, sizeof(ClUint8T));
if( NULL == *ppBuffer )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
rc = clBufferNBytesRead(msg, *ppBuffer, pDataSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));
clHeapFree(*ppBuffer);
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return CL_OK;
}
static void clAmsMgmtOIExtendedCacheAdd(ClAmsMgmtOIExtendedClassTypeT type,
ClCorInstanceIdT instance,
ClAmsMgmtOIExtendedEntityConfigT *pConfig,
ClUint32T configSize)
{
struct hashStruct **table = NULL;
ClAmsMgmtOIExtendedCacheT *cacheEntry = NULL;
if(type >= CL_AMS_MGMT_OI_EXTENDED_CLASS_MAX || !pConfig || !configSize)
return;
clOsalMutexLock(&gClAmsMgmtOICacheMutex);
table = gClAmsMgmtOIExtendedCacheTable[type];
if( (cacheEntry = clAmsMgmtOIExtendedCacheFind(table, instance) ) )
{
CL_ASSERT(cacheEntry->pConfig != NULL);
if(cacheEntry->configSize != configSize)
{
clHeapFree(cacheEntry->pConfig);
cacheEntry->pConfig = clHeapCalloc(1, configSize);
CL_ASSERT(cacheEntry->pConfig != NULL);
cacheEntry->configSize = configSize;
}
memcpy(cacheEntry->pConfig, pConfig, configSize);
}
else
{
ClAmsMgmtOIExtendedEntityConfigT *pExtendedConfig = NULL;
cacheEntry = clHeapCalloc(1, sizeof(*cacheEntry));
CL_ASSERT(cacheEntry != NULL);
pExtendedConfig = clHeapCalloc(1, configSize);
CL_ASSERT(pExtendedConfig != NULL);
cacheEntry->pConfig = pExtendedConfig;
cacheEntry->instance = instance;
memcpy(cacheEntry->pConfig, pConfig, configSize);
hashAdd(table, entityCacheHashKey(instance), &cacheEntry->hash);
clLogNotice("AMF", "MGMT", "Added entity [%s], instance [%d] to the extended class [%s]",
pConfig->entity.name.value, instance, gClAmsMgmtOIExtendedCacheStrTable[type]);
}
clOsalMutexUnlock(&gClAmsMgmtOICacheMutex);
}
ClRcT
clLogFileHdlrStreamAttributesCopy(ClLogStreamAttrIDLT *pSource,
ClLogStreamAttributesT *pDest)
{
ClRcT rc = CL_OK;
CL_LOG_DEBUG_TRACE(("Enter"));
pDest->fileUnitSize = pSource->fileUnitSize;
pDest->recordSize = pSource->recordSize;
pDest->haProperty = pSource->haProperty;
pDest->fileFullAction = pSource->fileFullAction;
pDest->maxFilesRotated = pSource->maxFilesRotated;
pDest->flushFreq = pSource->flushFreq;
pDest->flushInterval = pSource->flushInterval;
pDest->waterMark = pSource->waterMark;
pDest->fileName
= clHeapCalloc(pSource->fileName.length, sizeof(ClCharT));
if( NULL == pDest->fileName )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
pDest->fileLocation
= clHeapCalloc(pSource->fileLocation.length, sizeof(ClCharT));
if( NULL == pDest->fileLocation )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clHeapFree(pDest->fileName);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
memcpy(pDest->fileName, pSource->fileName.pValue, pSource->fileName.length);
memcpy(pDest->fileLocation, pSource->fileLocation.pValue,
pSource->fileLocation.length);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clTestCkptRead_withTime(ClCkptHdlT ckptHdl,
ClUint32T numSections)
{
ClRcT rc = CL_OK;
ClUint32T i = 0, j = 0;
ClCkptIOVectorElementT iov[numSections];
ClUint32T readIdx = 0;
ClUint32T timeDelay[] = {1000000, 100000, 10000, 1000, 100, 10 , 0};
memset(iov, 0, numSections * sizeof(ClCkptIOVectorElementT));
for( i = 0; i < numSections; i++ )
{
if( numSections != 1 )
{
iov[i].sectionId.id = clHeapCalloc(1, 15);
if( NULL == iov[i].sectionId.id )
{
return CL_OK;
}
snprintf( (ClCharT *) iov[i].sectionId.id,15, "section%d", i);
iov[i].sectionId.idLen = strlen((ClCharT *) iov[i].sectionId.id) + 1;
}
iov[i].dataSize = 0;
iov[i].dataBuffer = NULL;
iov[i].readSize = 0;
iov[i].dataOffset = 0;
}
for( i = 0; i < (sizeof(timeDelay) / sizeof(sizeof(timeDelay[0]))); i++ )
{
for( j = 0; j < 1000; j++ )
{
rc = clCkptCheckpointRead(ckptHdl, iov, numSections, &readIdx);
for( i = 0; i < numSections; i++ )
{
clHeapFree(iov[i].dataBuffer);
iov[i].dataBuffer = NULL;
}
usleep(timeDelay[i]);
}
}
for( i = 0; i < numSections; i++ )
{
if( NULL != iov[i].sectionId.id )
{
clHeapFree(iov[i].sectionId.id);
}
}
return CL_OK;
}
static ClTransportNotifyMapT *addNotifyMap(ClInt32T watchFd, ClInt32T port)
{
ClTransportNotifyMapT *notify;
if(port < 0) return NULL;
if( !(notify = findNotifyMap(watchFd, port)))
{
ClUint32T hash = TRANSPORT_NOTIFY_HASH(port);
notify = clHeapCalloc(1, sizeof(*notify));
CL_ASSERT(notify != NULL);
hashAdd(gNotifyMap, hash, ¬ify->hash);
}
notify->watchFd = watchFd;
notify->port = port;
return notify;
}
ClRcT clDebugPrint(ClDebugPrintHandleT handle, const char* fmtStr, ...)
{
char buf[CL_DEBUG_MAX_PRINT];
char *space = buf;
va_list args;
ClRcT rc = CL_OK;
ClBufferHandleT msg = (ClBufferHandleT)handle;
ClInt32T c = 0, bytes = 0;
/*
* Estimate the space required for the buffer
*/
va_start(args, fmtStr);
bytes = vsnprintf((ClCharT*)&c, 1, fmtStr, args);
va_end(args);
if(!bytes) goto failure;
if(bytes >= sizeof(buf))
{
space = clHeapCalloc(1, bytes + 1);
CL_ASSERT(space != NULL);
}
va_start(args, fmtStr);
vsnprintf(space, bytes+1, fmtStr, args);
va_end(args);
if (0 != msg)
{
rc = clBufferNBytesWrite(msg, (ClUint8T*)space, bytes);
if (CL_OK != rc)
{
goto failure;
}
}
else
{
rc = CL_DEBUG_RC(CL_ERR_INVALID_PARAMETER);
goto failure;
}
failure:
if(space != buf)
clHeapFree(space);
return rc;
}
ClRcT
clTestSectionOverwrite_withTime(ClCkptHdlT ckptHdl,
ClUint32T numSections,
ClUint32T sectionSize)
{
ClRcT rc = CL_OK;
ClUint32T i = 0, j = 0, secNum = 0;
ClUint8T data[sectionSize];
ClCkptSectionIdT secId[numSections];
ClUint32T timeDelay[] = {1000000, 100000, 10000, 1000, 100, 10 , 0};
memset(data, 'a', sectionSize);
for( i = 0; i < numSections; i++ )
{
secId[i].id = clHeapCalloc(1, 15);
if( NULL == secId[i].id )
{
return CL_OK;
}
snprintf((ClCharT *) secId[i].id, 15, "section%d", i);
secId[i].idLen = strlen((ClCharT *) secId[i].id) + 1;
}
for( i = 0; i < sizeof(timeDelay) / sizeof(timeDelay[0]); i++ )
{
for( j = 0; j < 1000; j++ )
{
for( secNum = 0; secNum < numSections; secNum++ )
{
rc = clCkptSectionOverwrite(ckptHdl, &secId[secNum], data, sectionSize);
if( CL_OK != rc )
{
printf("Section overwrite failed rc[0x %x]", rc);
}
usleep(timeDelay[i]);
}
}
}
if( numSections != 1 )
{
for( i = 0; i < numSections; i++ )
{
clHeapFree(secId[i].id);
}
}
return CL_OK;
}
ClRcT clJobQueueCreate(ClJobQueueT** hdl, ClUint32T maxJobs, ClUint32T maxTasks)
{
ClRcT rc;
*hdl = (ClJobQueueT*) clHeapCalloc(1, sizeof(ClJobQueueT));
if (*hdl == NULL) return CL_JOBQUEUE_RC(CL_ERR_NO_MEMORY);
rc = clJobQueueInit(*hdl, maxJobs, maxTasks);
if (rc != CL_OK)
{
clHeapFree(*hdl);
*hdl = NULL;
}
else (*hdl)->flags |= CreatedJobQueue;
return rc;
}