void clMsgQueueEmpty(ClMsgQueueInfoT *pQInfo)
{
ClRcT rc;
ClCntNodeHandleT nodeHandle = NULL, nextNodeHandle = NULL;
ClUint32T i;
ClRcT retCode;
for(i = 0; i < CL_MSG_QUEUE_PRIORITIES; i++)
{
rc = clCntFirstNodeGet(pQInfo->pPriorityContainer[i], &nodeHandle);
if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
continue;
do {
rc = clCntNextNodeGet(pQInfo->pPriorityContainer[i], nodeHandle, &nextNodeHandle);
if(CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST && rc != CL_OK)
{
clLogError("QUE", "EMT", "Failed to get the next node from container. error code [0x%x].", rc);
break;
}
retCode = clCntNodeDelete(pQInfo->pPriorityContainer[i], nodeHandle);
if(retCode != CL_OK)
clLogError("QUE", "EMT", "Failed to delete a node from container. error code [0x%x].", retCode);
nodeHandle = nextNodeHandle;
}while(CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST);
}
}
/* Cleanup Functions */
void clCorMoIdToNodeNameTablesCleanUp(void)
{
ClCntNodeHandleT nodeH = 0;
ClCntNodeHandleT nextNodeH = 0;
clCntFirstNodeGet(nodeNameToMoIdTableHandle, &nodeH);
while(nodeH)
{
clCntNextNodeGet(nodeNameToMoIdTableHandle, nodeH, &nextNodeH);
clCntNodeDelete(nodeNameToMoIdTableHandle, nodeH);
nodeH = nextNodeH;
}
nodeH = 0;
clCntFirstNodeGet(moIdToNodeNameTableHandle, &nodeH);
while(nodeH)
{
clCntNextNodeGet(moIdToNodeNameTableHandle, nodeH, &nextNodeH);
clCntNodeDelete(moIdToNodeNameTableHandle, nodeH);
nodeH = nextNodeH;
}
}
ClRcT cpmNodeDelByNodeId(ClUint32T nodeId)
{
ClRcT rc = CL_OK;
ClCntNodeHandleT cpmNode = 0;
ClUint32T cpmLCount = 0;
ClCpmLT *tempCpmL = NULL;
ClUint32T found = 0;
cpmLCount = gpClCpm->noOfCpm;
if (gpClCpm->pCpmConfig->cpmType == CL_CPM_GLOBAL && cpmLCount != 0)
{
rc = clCntFirstNodeGet(gpClCpm->cpmTable, &cpmNode);
CL_CPM_CHECK_2(CL_LOG_SEV_ERROR, CL_CPM_LOG_2_CNT_FIRST_NODE_GET_ERR, "CPM-L", rc, rc, CL_LOG_HANDLE_APP);
while (cpmLCount)
{
rc = clCntNodeUserDataGet(gpClCpm->cpmTable, cpmNode, (ClCntDataHandleT *) &tempCpmL);
CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_CNT_NODE_USR_DATA_GET_ERR, rc, rc, CL_LOG_HANDLE_APP);
if (tempCpmL->pCpmLocalInfo)
{
if ((ClUint32T) tempCpmL->pCpmLocalInfo->nodeId == nodeId)
{
clCntNodeDelete(gpClCpm->cpmTable,cpmNode);
gpClCpm->noOfCpm--;
found = 1;
break;
}
}
cpmLCount--;
if (cpmLCount)
{
rc = clCntNextNodeGet(gpClCpm->cpmTable, cpmNode, &cpmNode);
CL_CPM_CHECK_2(CL_LOG_SEV_ERROR, CL_CPM_LOG_2_CNT_NEXT_NODE_GET_ERR, "CPM-L", rc, rc, CL_LOG_HANDLE_APP);
}
}
}
if(found == 1)
return CL_OK;
else
return CL_CPM_RC(CL_ERR_DOESNT_EXIST);
failure:
return rc;
}
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 cpmInvocationDeleteInvocation(ClInvocationT invocationId)
{
ClRcT rc = CL_OK;
ClCntNodeHandleT cntNodeHandle = 0;
ClCpmInvocationT *invocationData = NULL;
clOsalMutexLock(gpClCpm->invocationMutex);
rc = clCntNodeFind(gpClCpm->invocationTable,
(ClCntKeyHandleT)&invocationId, &cntNodeHandle);
if (rc != CL_OK)
goto withLock;
rc = clCntNodeUserDataGet(gpClCpm->invocationTable, cntNodeHandle,
(ClCntDataHandleT *) &invocationData);
if (rc != CL_OK)
goto withLock;
rc = clCntNodeDelete(gpClCpm->invocationTable, cntNodeHandle);
if (rc != CL_OK)
goto withLock;
if( (invocationData->flags & CL_CPM_INVOCATION_DATA_COPIED))
{
clHeapFree(invocationData->data);
}
clHeapFree(invocationData);
clOsalMutexUnlock(gpClCpm->invocationMutex);
clLogDebug("INVOCATION", "DEL", "Deleted invocation [%#llx]", invocationId);
return rc;
withLock:
clOsalMutexUnlock(gpClCpm->invocationMutex);
return rc;
}
ClRcT clCntNonUniqueKeyDelete(ClCntHandleT container, ClCntKeyHandleT key, ClCntDataHandleT givenData,
ClInt32T (*cmp)(ClCntDataHandleT data1, ClCntDataHandleT data2))
{
ClUint32T sz = 0;
ClRcT rc = CL_OK;
ClCntNodeHandleT node = 0;
ClCntNodeHandleT nextNode = 0;
ClCntDataHandleT data = 0;
if(!container || !key || !givenData || !cmp)
return CL_CNT_RC(CL_ERR_INVALID_PARAMETER);
rc = clCntNodeFind(container, key, &node);
if(rc != CL_OK)
return rc;
rc = clCntKeySizeGet(container, key, &sz);
if(rc != CL_OK)
return rc;
while(sz-- > 0)
{
rc = clCntNodeUserDataGet(container, node, &data);
if(rc != CL_OK)
return rc;
if(!cmp(givenData, data))
return clCntNodeDelete(container, node);
if(sz > 0)
{
nextNode = 0;
rc = clCntNextNodeGet(container, node, &nextNode);
if(rc != CL_OK)
break;
node = nextNode;
}
}
return CL_CNT_RC(CL_ERR_NOT_EXIST);
}
static ClRcT cpmNodeRmv(ClCharT *nodeName)
{
ClRcT rc = CL_OK;
ClUint16T nodeKey = 0;
ClCntNodeHandleT hNode = 0;
ClUint32T numNode = 0;
ClCpmLT *cpm = NULL;
ClBoolT done = CL_NO;
if (!nodeName)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"NULL pointer passed.");
goto failure;
}
rc = clCksm16bitCompute((ClUint8T *)nodeName,
strlen(nodeName),
&nodeKey);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Failed to compute checksum for node, "
"error [%#x]",
rc);
goto failure;
}
clOsalMutexLock(gpClCpm->cpmTableMutex);
rc = clCntNodeFind(gpClCpm->cpmTable,
(ClCntKeyHandleT)(ClWordT)nodeKey,
&hNode);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Failed to find node [%s], error [%#x]",
nodeName,
rc);
goto unlock;
}
rc = clCntKeySizeGet(gpClCpm->cpmTable,
(ClCntKeyHandleT)(ClWordT)nodeKey,
&numNode);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Unable to get key size, error [%#x]",
rc);
goto unlock;
}
while (numNode > 0)
{
rc = clCntNodeUserDataGet(gpClCpm->cpmTable,
hNode,
(ClCntNodeHandleT *) &cpm);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Unable to get user data, error [%#x]",
rc);
goto unlock;
}
if (!strncmp(nodeName, cpm->nodeName, CL_MAX_NAME_LENGTH-1))
{
clCntNodeDelete(gpClCpm->cpmTable, hNode);
done = CL_YES;
break;
}
if (--numNode)
{
rc = clCntNextNodeGet(gpClCpm->cpmTable, hNode, &hNode);
if (CL_OK != rc)
{
break;
}
}
}
if (!done)
{
rc = CL_CPM_RC(CL_ERR_DOESNT_EXIST);
goto unlock;
}
--gpClCpm->noOfCpm;
clOsalMutexUnlock(gpClCpm->cpmTableMutex);
/*
* Delete from slot table
*/
clOsalMutexLock(&gpClCpm->cpmMutex);
if(cpmSlotClassDelete(nodeName) != CL_OK)
{
clLogWarning("CPM", "MGMT", "Slot class delete failed for node [%s]", nodeName);
}
clOsalMutexUnlock(&gpClCpm->cpmMutex);
return CL_OK;
unlock:
clOsalMutexUnlock(gpClCpm->cpmTableMutex);
failure:
return rc;
}
static ClRcT cpmComponentRmv(ClCharT *compName)
{
ClRcT rc = CL_OK;
ClUint16T compKey = 0;
ClCntNodeHandleT hNode = 0;
ClUint32T numNode = 0;
ClCpmComponentT *comp = NULL;
ClBoolT done = CL_NO;
SaNameT entity = {0};
if (!compName)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"NULL pointer passed.");
goto failure;
}
rc = clCksm16bitCompute((ClUint8T *)compName,
strlen(compName),
&compKey);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Failed to compute checksum for component, "
"error [%#x]",
rc);
goto failure;
}
saNameSet(&entity, compName);
/*
* Clear pending invocations for the component being removed.
*/
(void)cpmInvocationClearCompInvocation(&entity);
clOsalMutexLock(gpClCpm->compTableMutex);
clOsalMutexLock(&gpClCpm->compTerminateMutex);
rc = clCntNodeFind(gpClCpm->compTable,
(ClCntKeyHandleT)(ClWordT)compKey,
&hNode);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Failed to find component [%s], error [%#x]",
compName,
rc);
goto unlock;
}
rc = clCntKeySizeGet(gpClCpm->compTable,
(ClCntKeyHandleT)(ClWordT)compKey,
&numNode);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Unable to get key size, error [%#x]",
rc);
goto unlock;
}
while (numNode > 0)
{
rc = clCntNodeUserDataGet(gpClCpm->compTable,
hNode,
(ClCntNodeHandleT *) &comp);
if (CL_OK != rc)
{
clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
"Unable to get user data, error [%#x]",
rc);
goto unlock;
}
if (!strncmp(compName,
comp->compConfig->compName,
CL_MAX_NAME_LENGTH-1))
{
clCntNodeDelete(gpClCpm->compTable, hNode);
done = CL_YES;
break;
}
if (--numNode)
{
rc = clCntNextNodeGet(gpClCpm->compTable, hNode, &hNode);
if (CL_OK != rc)
{
break;
}
}
}
if (!done)
{
rc = CL_CPM_RC(CL_ERR_DOESNT_EXIST);
goto unlock;
}
--gpClCpm->noOfComponent;
clOsalMutexUnlock(&gpClCpm->compTerminateMutex);
clOsalMutexUnlock(gpClCpm->compTableMutex);
return CL_OK;
unlock:
clOsalMutexUnlock(&gpClCpm->compTerminateMutex);
clOsalMutexUnlock(gpClCpm->compTableMutex);
failure:
return rc;
}
ClRcT
clLogClntStreamOpen(ClLogHandleT hLog,
SaNameT *pStreamName,
SaNameT *pNodeName,
ClStringT *pShmName,
ClUint32T shmSize,
ClLogStreamHandleT *phStream,
ClUint32T recSize)
{
ClRcT rc = CL_OK;
ClLogClntEoDataT *pClntEoEntry = NULL;
ClBoolT addedTable = CL_FALSE;
ClBoolT addedEntry = CL_FALSE;
ClCntNodeHandleT hClntStreamNode = CL_HANDLE_INVALID_VALUE;
ClLogClntStreamDataT *pUserData = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == pStreamName), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pNodeName), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pShmName), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((sizeof(ClLogStreamHeaderT) > shmSize),
CL_LOG_RC(CL_ERR_INVALID_PARAMETER));
CL_LOG_PARAM_CHK((NULL == phStream), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clLogClntEoEntryGet(&pClntEoEntry);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogClntEoEntryGet(): rc[0x %x]", rc));
return rc;
}
rc = clOsalMutexLock_L(&(pClntEoEntry->clntStreamTblLock));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalMutexLock(): rc[0x %x]", rc));
return rc;
}
if( CL_HANDLE_INVALID_VALUE == pClntEoEntry->hClntStreamTable )
{
rc = clCntHashtblCreate(pClntEoEntry->maxStreams,
clLogStreamKeyCompare,
clLogStreamHashFn,
clLogClntStreamDeleteCb,
clLogClntStreamDeleteCb,
CL_CNT_UNIQUE_KEY,
&(pClntEoEntry->hClntStreamTable));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntHashtblCreate(): rc[0x %x]", rc));
CL_LOG_CLEANUP(
clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),CL_OK);
return rc;
}
addedTable = CL_TRUE;
CL_LOG_DEBUG_VERBOSE(("Created the HashTable"));
}
rc = clLogClntStreamEntryGet(pClntEoEntry, pStreamName, pNodeName,
pShmName, shmSize, &hClntStreamNode,
&addedEntry);
if( CL_OK != rc)
{
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Got the stream entry"));
rc = clLogHandleStreamHandleCreate(hLog, hClntStreamNode, phStream);
if( CL_OK != rc)
{
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Created the streamhandle"));
rc = clCntNodeUserDataGet(pClntEoEntry->hClntStreamTable, hClntStreamNode,
(ClCntDataHandleT *) &pUserData);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB,
*phStream), CL_OK);
*phStream = CL_HANDLE_INVALID_VALUE;
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
#ifdef NO_SAF
pUserData->recSize=recSize;
#endif
CL_LOG_DEBUG_VERBOSE(("Got stream entry"));
rc = clBitmapBitSet(pUserData->hStreamBitmap, CL_HDL_IDX(*phStream));
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phStream),
CL_OK);
*phStream = CL_HANDLE_INVALID_VALUE;
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Updated stream bitmap"));
rc = clLogHandleInitHandleStreamAdd(hLog, *phStream);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clBitmapBitClear(pUserData->hStreamBitmap, CL_HDL_IDX(*phStream)),
CL_OK);
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phStream),
CL_OK);
*phStream = CL_HANDLE_INVALID_VALUE;
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Updated init handle"));
rc = clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalMutexUnlock(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT cpmInvocationClearCompInvocation(SaNameT *compName)
{
ClRcT rc = CL_OK;
ClCntNodeHandleT nodeHandle, nextNodeHandle;
ClCpmInvocationT *invocationData = NULL;
void *data = NULL;
/*
* Check the input parameter
*/
if (!compName)
{
CL_CPM_CHECK(CL_LOG_SEV_ERROR, ("Invalid parameter passed \n"),
CL_CPM_RC(CL_ERR_NULL_POINTER));
}
clOsalMutexLock(gpClCpm->invocationMutex);
rc = clCntFirstNodeGet(gpClCpm->invocationTable, &nodeHandle);
if (rc != CL_OK)
goto withLock;
while (nodeHandle)
{
rc = clCntNodeUserDataGet(gpClCpm->invocationTable, nodeHandle,
(ClCntDataHandleT *) &invocationData);
if (rc != CL_OK)
goto withLock;
rc = clCntNextNodeGet(gpClCpm->invocationTable, nodeHandle,
&nextNodeHandle);
if((data = invocationData->data))
{
ClUint32T matched = 0;
if ((invocationData->flags & CL_CPM_INVOCATION_AMS))
{
matched = !strncmp((const ClCharT *) (((ClAmsInvocationT*) data)->compName.value), (const ClCharT *) compName->value,
((ClAmsInvocationT*) data)->compName.length);
}
else if ((invocationData->flags & CL_CPM_INVOCATION_CPM))
{
matched = !strncmp((const ClCharT *) (((ClCpmComponentT*) data)->compConfig->compName), (const ClCharT *) compName->value,
compName->length);
}
if(matched)
{
clLogDebug("INVOCATION", "CLEAR", "Clearing invocation for component [%.*s] "
"invocation [%#llx]", compName->length, compName->value, invocationData->invocation);
if (clCntNodeDelete(gpClCpm->invocationTable, nodeHandle) != CL_OK)
goto withLock;
if( (invocationData->flags & CL_CPM_INVOCATION_DATA_COPIED) )
clHeapFree(data);
clHeapFree(invocationData);
}
}
if (CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
break;
if (rc != CL_OK)
goto withLock;
nodeHandle = nextNodeHandle;
}
clOsalMutexUnlock(gpClCpm->invocationMutex);
return CL_OK;
withLock:
failure:
clOsalMutexUnlock(gpClCpm->invocationMutex);
return rc;
}
static ClRcT rmdSendTimerFunc(void *pData)
{
ClCntNodeHandleT nodeHandle;
ClRmdRecordSendT *rec = NULL;
ClRcT rc;
ClRcT retCode = 0;
ClRmdObjT *pRmdObject;
ClRmdAsyncCallbackT fpTempPtr;
void *cookie;
ClBufferHandleT outMsgHdl;
ClEoExecutionObjT *pThis = NULL;
ClUint64T msgId = (ClUint32T)(ClWordT) pData;
CL_FUNC_ENTER();
if (pData == NULL)
{
return (CL_RMD_RC(CL_ERR_INVALID_BUFFER));
}
rc = clEoMyEoObjectGet(&pThis);
if ( CL_OK != rc )
{
return rc;
}
pRmdObject = (ClRmdObjT *) (pThis->rmdObj);
if (pRmdObject == NULL)
{
return (CL_RMD_RC(CL_ERR_INVALID_BUFFER));
}
rc = clOsalMutexLock(pRmdObject->semaForSendHashTable);
CL_ASSERT(rc == CL_OK);
clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 0");
rc = clCntNodeFind(pRmdObject->sndRecContainerHandle, (ClPtrT)(ClWordT)msgId,
&nodeHandle);
if (rc == CL_OK)
{
clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 1");
rc = clCntNodeUserDataGet(pRmdObject->sndRecContainerHandle, nodeHandle,
(ClCntDataHandleT *) &rec);
if (rc == CL_OK)
{
clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 2");
if (rec)
{
/*
* Disabling retries for ASYNC since we dont want
* to land up in duplicate send mess as anyway we have
* accounted for the retries while creating the async timer.
*/
if (0 && rec->recType.asyncRec.noOfRetry > 0)
{
/*
* key is part of record so no need to free just reuse
*/
retCode = resendMsg(rec, pRmdObject, pThis);
}
else
{
/*
* key is part of record so no need to free, it will be
* freed by hash delete callback
*/
RMD_STAT_INC(pRmdObject->rmdStats.nCallTimeouts);
retCode = clTimerDeleteAsync(&rec->recType.asyncRec.timerID);
if (rec->recType.asyncRec.func)
{
/*
* unlocking it as callback func can make the rmd call
*/
ClBufferHandleT message;
fpTempPtr = rec->recType.asyncRec.func;
cookie = rec->recType.asyncRec.cookie;
outMsgHdl = rec->recType.asyncRec.outMsgHdl;
message = rec->recType.asyncRec.sndMsgHdl;
clBufferHeaderTrim(message, rec->hdrLen);
rc = clCntNodeDelete(pRmdObject->sndRecContainerHandle,
nodeHandle);
rc = clOsalMutexUnlock(pRmdObject->
semaForSendHashTable);
fpTempPtr((CL_RMD_RC(CL_ERR_TIMEOUT)), cookie, message,
outMsgHdl);
clBufferDelete(&(message));
rc = clOsalMutexLock(pRmdObject->semaForSendHashTable);
}
}
}
}
}
rc = clOsalMutexUnlock(pRmdObject->semaForSendHashTable);
CL_ASSERT(rc == CL_OK);
CL_FUNC_EXIT();
return CL_OK;
}
static ClRcT
clLogSvrStreamEntryUnpackNAdd(ClLogSvrEoDataT *pSvrEoEntry,
ClLogSvrCommonEoDataT *pSvrCommonEoEntry,
ClBufferHandleT msg,
ClUint32T dsId)
{
ClRcT rc = CL_OK;
SaNameT streamName = {0};
SaNameT streamScopeNode = {0};
ClUint32T compTableSize = 0;
ClCntNodeHandleT hSvrStreamNode = CL_HANDLE_INVALID_VALUE;
ClLogStreamKeyT *pStreamKey = NULL;
ClStringT shmName = {0};
ClStringT fileName = {0};
ClStringT fileLocation = {0};
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogSvrStreamTableGet(pSvrEoEntry);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrStreamTableCreate(): rc[0x %x]\n", rc));
return rc;
}
rc = clXdrUnmarshallSaNameT(msg, &streamName);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallSaNameT(): rc[0x %x]\n", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("streamName: %*s", streamName.length, streamName.value));
rc = clXdrUnmarshallSaNameT(msg, &streamScopeNode);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallSaNameT(): rc[0x %x]\n", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("streamScopeNode: %*s", streamScopeNode.length, streamScopeNode.value));
rc = clXdrUnmarshallClStringT(msg, &fileName);
if(CL_OK != rc)
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClStringT(): rc[%#x]\n", rc));
return rc;
}
rc = clXdrUnmarshallClStringT(msg, &fileLocation);
if(CL_OK != rc)
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClStringT(): rc[%#x]\n", rc));
return rc;
}
rc = clXdrUnmarshallClUint32T(msg, &compTableSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]\n", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("compSize : %u", compTableSize));
rc = clLogStreamKeyCreate(&streamName, &streamScopeNode, pSvrCommonEoEntry->maxStreams, &pStreamKey);
if( CL_OK != rc )
{
return rc;
}
rc = clLogShmNameCreate(&streamName,&streamScopeNode,&shmName);
if( CL_OK != rc )
{
return rc;
}
clLogInfo("LOG","CRT","Recreating log stream [%*s] shared memory [%*s] located at [%*s] from persistent checkpoint",streamName.length,streamName.value,shmName.length,shmName.pValue,streamScopeNode.length, streamScopeNode.value);
rc = clLogSvrStreamEntryAdd(pSvrEoEntry, pSvrCommonEoEntry, pStreamKey, &shmName, &hSvrStreamNode);
clHeapFree(shmName.pValue);
shmName.pValue=NULL;
shmName.length=0;
if (CL_ERR_DUPLICATE == CL_GET_ERROR_CODE(rc)) /* But if it is a duplicate stream should we do the items below? (if so we need to load hSvrStreamNode...) */
{
return rc;
}
if( CL_OK != rc )
{
clLogStreamKeyDestroy(pStreamKey);
return rc;
}
rc = clLogSvrCompEntryRecreate(pSvrCommonEoEntry, pSvrEoEntry,hSvrStreamNode, msg, compTableSize);
if(( CL_OK != rc )&&(CL_ERR_DUPLICATE != CL_GET_ERROR_CODE(rc)))
{
CL_LOG_CLEANUP(clCntNodeDelete(pSvrEoEntry->hSvrStreamTable, hSvrStreamNode), CL_OK);
return rc;
}
rc = clLogSvrShmOpenNFlusherCreate(pSvrEoEntry, &streamName, &streamScopeNode, &fileName, &fileLocation, hSvrStreamNode, dsId);
if (( CL_OK != rc )&&(CL_ERR_DUPLICATE != CL_GET_ERROR_CODE(rc)))
{
CL_LOG_DEBUG_ERROR(("clLogSvrShmOpenAndFlusherCreate(): rc[0x %x]\n", rc));
CL_LOG_CLEANUP(clCntNodeDelete(pSvrEoEntry->hSvrStreamTable, hSvrStreamNode), CL_OK);
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static ClRcT
clLogMasterStreamTableRecreate(ClLogSvrCommonEoDataT *pCommonEoEntry,
ClBufferHandleT hFileEntryBuf,
ClLogFileDataT *pFileData)
{
ClRcT rc = CL_OK;
ClLogStreamKeyT streamKey = {{0}};
ClLogStreamKeyT *pStreamKey = NULL;
ClLogMasterStreamDataT *pStreamData = NULL;
ClCntNodeHandleT hStreamNode = CL_HANDLE_INVALID_VALUE;
ClUint32T bitNum = 0;
ClLogMasterEoDataT *pMasterEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogMasterEoEntryGet(&pMasterEoEntry, &pCommonEoEntry);
if( CL_OK != rc )
{
return rc;
}
rc = clXdrUnmarshallSaNameT(hFileEntryBuf, &(streamKey.streamName));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
rc = clXdrUnmarshallSaNameT(hFileEntryBuf, &(streamKey.streamScopeNode));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
rc = clLogStreamKeyCreate(&streamKey.streamName, &streamKey.streamScopeNode,
pCommonEoEntry->maxStreams, &pStreamKey);
if( CL_OK != rc )
{
return rc;
}
pStreamData = (ClLogMasterStreamDataT*) clHeapCalloc(1, sizeof(ClLogMasterStreamDataT));
if( NULL == pStreamData )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clLogStreamKeyDestroy(pStreamKey);
return rc;
}
rc = clXdrUnmarshallClUint64T(hFileEntryBuf, &(pStreamData->streamMcastAddr));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint64T(): rc[0x %x]", rc));
clHeapFree(pStreamData);
clLogStreamKeyDestroy(pStreamKey);
return rc;
}
rc = clXdrUnmarshallClUint16T(hFileEntryBuf, &(pStreamData->streamId));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint16T(): rc[0x %x]", rc));
clHeapFree(pStreamData);
clLogStreamKeyDestroy(pStreamKey);
return rc;
}
rc = clCntNodeAddAndNodeGet(pFileData->hStreamTable,
(ClCntKeyHandleT) pStreamKey,
(ClCntDataHandleT) pStreamData,
NULL, &hStreamNode);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeAdd(): rc[0x %x]", rc));
clHeapFree(pStreamData);
clLogStreamKeyDestroy(pStreamKey);
return rc;
}
/* Find out the partiuclar stream is still valid */
if( strncmp(gStreamScopeGlobal, (const ClCharT *)pStreamKey->streamScopeNode.value,
pStreamKey->streamScopeNode.length)
&&
CL_FALSE == clLogMasterStreamIsValid(&pStreamKey->streamScopeNode))
{
/*
* marking this as invalid by assigining CL_IOC_RESERVED_ADDRESS
* so that streamMcastAddr will not be allocated & bit will not be set
* numActive streams count also will be valid
*/
pStreamData->streamMcastAddr = CL_IOC_RESERVED_ADDRESS;
clLogNotice(CL_LOG_AREA_FILE_OWNER, CL_LOG_CTX_FO_INIT,
"Invalidating the stream [%.*s:%.*s]",
pStreamKey->streamScopeNode.length, pStreamKey->streamScopeNode.value,
pStreamKey->streamName.length, pStreamKey->streamName.value);
}
if( CL_IOC_RESERVED_ADDRESS != pStreamData->streamMcastAddr )
{
bitNum = pStreamData->streamMcastAddr - pMasterEoEntry->startMcastAddr;
CL_LOG_DEBUG_TRACE(("bitNUm: %d pStreamData->streamMcastAddr : %lld \n", bitNum,
pStreamData->streamMcastAddr));
rc = clBitmapBitSet(pMasterEoEntry->hAllocedAddrMap, bitNum);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBitmapBitClear()"));
CL_LOG_CLEANUP(clCntNodeDelete(pFileData->hStreamTable, hStreamNode), CL_OK);
}
pFileData->nActiveStreams++;
clLogInfo(CL_LOG_AREA_MASTER, CL_LOG_CTX_CKPT_READ,
"Active stream [%.*s:%.*s] has been added",
pStreamKey->streamScopeNode.length, pStreamKey->streamScopeNode.value,
pStreamKey->streamName.length, pStreamKey->streamName.value);
}
CL_LOG_DEBUG_TRACE(("Exit"));
return CL_OK;
}
ClRcT _clTxnAgentProcessMgrCmd(
CL_IN ClBufferHandleT inMsgHandle,
CL_IN ClBufferHandleT outMsgHandle,
CL_IN ClTxnMessageHeaderT *pMsgHdr)
{
ClRcT rc = CL_OK;
ClTxnCmdT tCmd = {.resp = CL_OK };
ClTxnCommHandleT commHandle = NULL;
ClUint32T mCount = pMsgHdr->msgCount;
ClTimeT t1, t2;
CL_FUNC_ENTER();
clLogDebug("AGT", NULL,
"Received processing cmd from TM. Message count [%d]",
pMsgHdr->msgCount);
t1 = clOsalStopWatchTimeGet();
while ( (CL_OK == tCmd.resp) && (pMsgHdr->msgCount > 0) )
{
pMsgHdr->msgCount--;
rc = VDECL_VER(clXdrUnmarshallClTxnCmdT, 4, 0, 0)(inMsgHandle, &tCmd);
switch (tCmd.cmd)
{
case CL_TXN_CMD_INIT:
rc = clTxnAgentTxnDefnReceive(tCmd, inMsgHandle);
if(CL_OK != rc)
{
clLogError("AGT", "MTA",
"Failed to process init command from manager, rc=[0x%x]",
rc);
/* Construct payload to send response back to server */
clTxnMutexLock(clTxnAgntCfg->actMtx);
/* tCmd.resp = rc; */
rc = clTxnCommIfcNewSessionCreate(CL_TXN_MSG_AGNT_RESP,
pMsgHdr->srcAddr,
CL_TXN_SERVICE_AGENT_RESP_RECV,
NULL, CL_TXN_RMD_DFLT_TIMEOUT,
CL_TXN_COMMON_ID, /* Value is 0x1 */
&commHandle);
if (CL_OK == rc)
{
rc = clTxnCommIfcSessionAppendTxnCmd(commHandle, &tCmd);
if (CL_OK != rc)
{
clLogError("AGT", NULL,
"Failed to append cmd in the response with error [0x%x]",
rc);
clTxnMutexUnlock(clTxnAgntCfg->actMtx);
break;
}
rc = clTxnCommIfcSessionRelease(commHandle);
if (CL_OK != rc)
{
clLogError("AGT", NULL,
"Failed to release session with error[0x%x]",
rc);
clTxnMutexUnlock(clTxnAgntCfg->actMtx);
break;
}
clTxnMutexUnlock(clTxnAgntCfg->actMtx);
}
else
clLogError("AGT", "ATM",
"Failed to create new session for key [Node:0x%x,Port:0x%x]",
pMsgHdr->srcAddr.nodeAddress, pMsgHdr->srcAddr.portId);
break;
}
/* Request for the first time */
if(mCount == (pMsgHdr->msgCount + 1) )
{
rc = _clTxnAgentTxnStart(tCmd);
if(CL_OK != rc)
{
/*tCmd.resp = rc; */
clLogError("AGT", "MTA",
"Failed to start transaction[0x%x:0x%x], rc=[0x%x]",
tCmd.txnId.txnMgrNodeAddress,
tCmd.txnId.txnId,
rc);
break;
}
clLogDebug("AGT", "MTA",
"Transaction[0x%x:0x%x] started",
tCmd.txnId.txnMgrNodeAddress,
tCmd.txnId.txnId);
}
break;
case CL_TXN_CMD_PREPARE:
case CL_TXN_CMD_1PC_COMMIT:
case CL_TXN_CMD_2PC_COMMIT:
case CL_TXN_CMD_ROLLBACK:
rc = clTxnAgentProcessJob(pMsgHdr, tCmd, outMsgHandle, &commHandle);
if(CL_OK != rc)
{
/* tCmd.resp = rc; */
clLog(CL_LOG_ERROR, "AGT", NULL,
"Error in processing cmd [%s] from server. rc [0x%x]",
_clTxnCmdNameGet(tCmd.cmd), rc);
}
if(!pMsgHdr->msgCount &&
( (tCmd.cmd == CL_TXN_CMD_ROLLBACK) ||
(tCmd.cmd == CL_TXN_CMD_2PC_COMMIT) )
)
{
rc = _clTxnAgentTxnStop(tCmd);
if(CL_OK != rc)
{
/* tCmd.resp = rc; */
clLogError("AGT", "MTA",
"Failed to stop transaction[0x%x:0x%x], rc=[0x%x]",
tCmd.txnId.txnMgrNodeAddress,
tCmd.txnId.txnId, rc);
}
else
clLogDebug("AGT", "MTA",
"Transaction[0x%x:0x%x] stopped",
tCmd.txnId.txnMgrNodeAddress,
tCmd.txnId.txnId);
}
/* Remove the joblist when ROLLBACK or COMMIT is complete */
if( (tCmd.cmd == CL_TXN_CMD_ROLLBACK) ||
(tCmd.cmd == CL_TXN_CMD_2PC_COMMIT) )
{
ClTxnDefnPtrT pTxnDefn = NULL;
clLogDebug("AGT", NULL,
"Received remove cmd from server");
rc = clTxnDbTxnDefnGet(clTxnAgntCfg->activeTxnMap,
tCmd.txnId, &pTxnDefn);
if(CL_OK == rc)
{
if(1 < pTxnDefn->jobCount)
{
rc = clTxnAppJobRemove(pTxnDefn, tCmd.jobId);
if(CL_OK != rc)
{
ClNameT name = {0};
clCpmComponentNameGet(0, &name);
clLog(CL_LOG_ERROR, "AGT", NULL,
"REMOVE cmd received. Error in removing the job information for component [%s] rc [0x%x]",
name.value, rc);
return rc;
}
}
else if(1 == pTxnDefn->jobCount) /* This is the last job, delete the entire txn list */
{
ClCntNodeHandleT nodeHandle;
rc = clCntNodeFind(
clTxnAgntCfg->activeTxnMap,
(ClCntKeyHandleT )&(tCmd.txnId),
&nodeHandle);
if(rc == CL_OK)
{
rc = clCntNodeDelete(clTxnAgntCfg->activeTxnMap, nodeHandle);
if(CL_OK != rc)
{
clLog(CL_LOG_ERROR, "AGT", NULL,
"REMOVE cmd received. Error in deleting txn defn for txnId [0x%x] rc [0x%x]",
tCmd.txnId.txnId, rc);
return rc;
}
}
}
else
{
clLog(CL_LOG_ERROR, "AGT", NULL,
"Remove cmd received. There is no txndefn corresponding to txnId [0x%x]. Jobcount [%d]\n",
tCmd.txnId.txnId, pTxnDefn->jobCount);
}
}
}
break;
default:
clLog(CL_LOG_ERROR, "AGT", NULL,
"Invalid command received from TM [0x%x]", tCmd.cmd);
rc = CL_ERR_INVALID_PARAMETER;
break;
}
}
if((tCmd.cmd != CL_TXN_CMD_REMOVE_JOB) && commHandle)
{
rc = clTxnCommIfcReadMessage(commHandle, outMsgHandle);
if(CL_OK != rc)
{
clLogError("AGT", NULL,
"Failed to write the response with error [0x%x]",
rc);
}
else
clLogDebug("AGT", "ATM",
"Successfully sent response back");
t2 = clOsalStopWatchTimeGet();
clLogDebug("AGT", NULL,
"Time taken to complete command[%d], [%lld]usecs",
tCmd.cmd, (t2-t1) );
}
if (CL_OK != rc)
{
rc = CL_GET_ERROR_CODE(rc);
}
CL_FUNC_EXIT();
return (rc);
}
ClRcT
clLogSOStreamEntryUnpackNAdd(ClLogSvrCommonEoDataT *pCommonEoData,
ClBufferHandleT msg)
{
ClRcT rc = CL_OK;
ClUint32T size = 0;
ClUint32T count = 0;
SaNameT streamName = {0};
SaNameT streamScopeNode = {0};
ClLogStreamOwnerDataIDLT soData = {0};
ClLogStreamKeyT *pStreamKey = NULL;
ClCntHandleT hStreamTable = CL_HANDLE_INVALID_VALUE;
ClLogStreamOwnerDataT *pStreamOwnerData = NULL;
ClCntNodeHandleT hStreamOwnerNode = CL_HANDLE_INVALID_VALUE;
ClLogStreamScopeT streamScope;
ClLogSOEoDataT *pSoEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
memset(&streamScope,0,sizeof(ClLogStreamScopeT));
rc = clXdrUnmarshallSaNameT(msg, &streamName);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("streamName: %*s", streamName.length,
streamName.value));
rc = clXdrUnmarshallSaNameT(msg, &streamScopeNode);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("streamScopeNode: %*s", streamScopeNode.length,
streamScopeNode.value));
rc = clLogStreamScopeGet(&streamScopeNode, &streamScope);
if( CL_OK != rc )
{
return rc;
}
CL_LOG_DEBUG_TRACE(("streamScope: %d \n", streamScope));
rc = VDECL_VER(clXdrUnmarshallClLogStreamOwnerDataIDLT, 4, 0, 0)(msg, &soData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
rc = clLogStreamOwnerStreamTableGet(&pSoEoEntry, streamScope);
if( CL_OK != rc )
{
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
return rc;
}
rc = clLogSOLock(pSoEoEntry, streamScope);
if( CL_OK != rc )
{
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
return rc;
}
rc = clLogStreamKeyCreate(&streamName, &streamScopeNode,
pCommonEoData->maxStreams, &pStreamKey);
if( CL_OK != rc )
{
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
hStreamTable = (CL_LOG_STREAM_GLOBAL == streamScope)
? pSoEoEntry->hGStreamOwnerTable
: pSoEoEntry->hLStreamOwnerTable ;
rc = clLogStreamOwnerEntryAdd(hStreamTable, streamScope, pStreamKey,
&hStreamOwnerNode);
if( CL_OK != rc )
{
clHeapFree(pStreamKey);
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
rc = clCntNodeUserDataGet(hStreamTable, hStreamOwnerNode,
(ClCntDataHandleT *) &pStreamOwnerData);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode), CL_OK);
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
pStreamOwnerData->nodeStatus = CL_LOG_NODE_STATUS_INIT;
pStreamOwnerData->streamId = soData.streamId;
pStreamOwnerData->streamMcastAddr = soData.streamMcastAddr;
pStreamOwnerData->dsId = soData.dsId;
pStreamOwnerData->isNewStream = soData.isNewStream;
pStreamOwnerData->openCnt = soData.openCnt;
pStreamOwnerData->ackerCnt = soData.ackerCnt;
pStreamOwnerData->nonAckerCnt = soData.nonAckerCnt;
clLogStreamAttributesCopy(&soData.streamAttr,
&pStreamOwnerData->streamAttr, CL_TRUE);
CL_LOG_DEBUG_TRACE(("streamId : %hu", soData.streamId));
CL_LOG_DEBUG_TRACE(("streamMcastAddr: %llu", soData.streamMcastAddr));
rc = clLogStreamOwnerFilterInfoUnpack(msg, pStreamOwnerData);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode), CL_OK);
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
rc = clXdrUnmarshallClUint32T(msg, &size);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode), CL_OK);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("compSize : %u", size));
for(count = 0; count < size; count++)
{
rc = clLogCompEntryUnpackNAdd(msg, pStreamOwnerData);
if( CL_OK != rc )
{
if(CL_GET_ERROR_CODE(rc) == CL_ERR_DUPLICATE)
{
rc = CL_OK;
}
else
{
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode),
CL_OK);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
}
}
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
