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;
}
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;
}
ClRcT clDebugPrintFinalize(ClDebugPrintHandleT* handle, char** buf)
{
ClUint32T len = 0;
ClRcT rc = CL_OK;
ClBufferHandleT* msg = (ClBufferHandleT*)handle;
if (NULL == buf)
{
return CL_DEBUG_RC(CL_ERR_NULL_POINTER);
}
rc = clBufferLengthGet(*msg, &len);
if (CL_OK != rc)
{
return rc;
}
*buf = (char*)clHeapAllocate(len + 1);
if (CL_OK != rc)
{
return CL_DEBUG_RC(CL_ERR_NO_MEMORY);
}
rc = clBufferNBytesRead(*msg, (ClUint8T*)*buf, &len);
if (CL_OK != rc)
{
clHeapFree(*buf);
*buf = NULL;
return rc;
}
(*buf)[len] = '\0';
clBufferDelete(msg);
*msg = 0;
return rc;
}
ClRcT corAmfObjectCreate(ClUint32T entityId, ClAmsEntityT *entity, ClCorMOIdT *pMoId)
{
ClRcT rc = CL_OK;
ClBufferHandleT msg = 0;
ClUint32T moIdBufferLen = 0;
ClUint8T *moIdBuffer = NULL;
ClCorMOIdT tempMoId;
ClCorMOServiceIdT svcId = CL_COR_SVC_ID_PROVISIONING_MANAGEMENT;
ClCorAttributeValueListT attrValueList = {0};
if(!gClAmfMibLoaded)
svcId = CL_COR_SVC_ID_AMF_MANAGEMENT;
/*
*Faster than a clone
*/
memcpy(&tempMoId, pMoId, sizeof(tempMoId));
rc = clCorObjectCreate(&sessionId, &tempMoId, NULL);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "COR MO object create for entity [%s] returned [%#x]",
entity->name.value, rc);
goto out;
}
rc = clCorMoIdServiceSet(&tempMoId, svcId);
CL_ASSERT(rc == CL_OK);
rc = corAmfEntityAttributeListGet(&entityId, entity, NULL, &attrValueList);
if(rc != CL_OK) goto out;
rc = clCorObjectCreateAndSet(&sessionId, &tempMoId, &attrValueList, NULL);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "COR MSO object create for entity [%s] returned [%#x]",
entity->name.value, rc);
goto out;
}
rc = clBufferCreate(&msg);
CL_ASSERT(rc == CL_OK);
rc = VDECL_VER(clXdrMarshallClCorMOIdT, 4, 0, 0)((ClUint8T*)&tempMoId, msg, 0);
CL_ASSERT(rc == CL_OK);
rc = clBufferLengthGet(msg, &moIdBufferLen);
CL_ASSERT(rc == CL_OK);
rc = clBufferFlatten(msg, &moIdBuffer);
CL_ASSERT(rc == CL_OK);
/*
* Now store this moid buffer into the entity user area for the entity key.
*/
rc = clAmsMgmtEntityUserDataSetKey(mgmtHandle, entity, &entity->name,
(ClCharT*)moIdBuffer, moIdBufferLen);
if(rc != CL_OK)
{
clLogError("COR", "AMF", "Entity user data set for [%s] returned [%#x]",
entity->name.value, rc);
goto out;
}
out:
if(attrValueList.pAttributeValue) clHeapFree(attrValueList.pAttributeValue);
if(moIdBuffer) clHeapFree(moIdBuffer);
if(msg) clBufferDelete(&msg);
return rc;
}
/**
* Serializer function for transaction state
*/
static ClRcT _clTxnServiceCkptTxnStatePack(
CL_IN ClUint32T dataSetId,
CL_OUT ClAddrT *ppData,
CL_OUT ClUint32T *pDataLen,
CL_IN ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClTxnTransactionIdT *pTxnId;
ClBufferHandleT msgHandle;
ClUint32T msgLen;
CL_FUNC_ENTER();
pTxnId = (ClTxnTransactionIdT *) cookie;
CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("To checkpoint recovery-log of txn 0x%x:0x%x",
pTxnId->txnMgrNodeAddress, pTxnId->txnId));
rc = clBufferCreate(&msgHandle);
if (CL_OK == rc)
{
rc = clTxnRecoveryLogPack(pTxnId, msgHandle);
*ppData = NULL;
*pDataLen = 0;
if (CL_OK == rc)
{
/* Copy the state-information from message-buffer to ppData */
rc = clBufferLengthGet(msgHandle, &msgLen);
}
if (CL_OK == rc)
{
*pDataLen = msgLen;
*ppData = (ClInt8T *) clHeapAllocate(msgLen);
if ( *ppData == NULL )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to allocate memory"));
rc = CL_ERR_NO_MEMORY;
}
}
if (CL_OK == rc)
{
rc = clBufferNBytesRead(msgHandle, (ClUint8T *) *ppData, &msgLen);
if (CL_OK != rc)
{
clHeapFree(*ppData);
*pDataLen = 0x0;
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("Failed to pack/serialize txn-defn[0x%x:0x%x] for ckpt. rc:0x%x",
pTxnId->txnMgrNodeAddress, pTxnId->txnId, rc));
rc = CL_GET_ERROR_CODE(rc);
}
}
rc = clBufferDelete(&msgHandle);
}
CL_FUNC_EXIT();
return (rc);
}
/**
* Internal function to pack/prepare state oa given transaction
*/
static ClRcT _clTxnServiceCkptTxnPack(
CL_IN ClUint32T dataSetId,
CL_OUT ClAddrT *ppData,
CL_OUT ClUint32T *pDataLen,
CL_IN ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClTxnDefnT *pTxnDefn;
ClBufferHandleT txnStateBuf;
ClUint32T msgLen;
CL_FUNC_ENTER();
pTxnDefn = (ClTxnDefnT *) cookie;
if (pTxnDefn == NULL)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Null argument"));
CL_FUNC_EXIT();
return (CL_ERR_NULL_POINTER);
}
CL_DEBUG_PRINT(CL_DEBUG_TRACE,
("Packing for data-set 0x%x for txn[0x%x:0x%x]", dataSetId,
pTxnDefn->serverTxnId.txnMgrNodeAddress, pTxnDefn->serverTxnId.txnId));
/* Validate between dataSetId and txn-Id */
#if 0
if ( (dataSetId - CL_TXN_CKPT_TXN_DATA_SET_ID_OFFSET) != pTxnId->txnId)
{
CL_TXN_RETURN_RC(CL_ERR_INVALID_PARAMETER,
("Invalid data-set(0x%x) for transaction-id(0x%x)\n",
dataSetId, pTxnId->txnId));
}
#endif
rc = clBufferCreate (&txnStateBuf);
if (CL_OK == rc)
{
rc = clTxnStreamTxnCfgInfoPack (pTxnDefn, txnStateBuf);
*ppData = NULL;
*pDataLen = 0;
if (CL_OK == rc)
{
/* Copy the state-information from message-buffer to ppData */
rc = clBufferLengthGet(txnStateBuf, &msgLen);
}
if (CL_OK == rc)
{
*pDataLen = msgLen;
*ppData = (ClInt8T *) clHeapAllocate(msgLen);
if ( *ppData == NULL )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to allocate memory"));
rc = CL_ERR_NO_MEMORY;
}
}
if (CL_OK == rc)
{
rc = clBufferNBytesRead(txnStateBuf, (ClUint8T *) *ppData, &msgLen);
if (CL_OK != rc)
{
clHeapFree(*ppData);
*pDataLen = 0x0;
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("Failed to pack/serialize txn-defn[0x%x:0x%x] for ckpt. rc:0x%x",
pTxnDefn->serverTxnId.txnMgrNodeAddress, pTxnDefn->serverTxnId.txnId, rc));
rc = CL_GET_ERROR_CODE(rc);
}
}
rc = clBufferDelete(&txnStateBuf);
}
CL_FUNC_EXIT();
return (rc);
}
/**
* Internal Function - used to pack/prepare data-set for checkpointing
* transaction-service
*/
static ClRcT _clTxnServiceCkptAppStatePack(
CL_IN ClUint32T dataSetId,
CL_OUT ClAddrT *ppData,
CL_OUT ClUint32T *pDataLen,
CL_IN ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClBufferHandleT txnSrvcStateBuff;
CL_FUNC_ENTER();
/* Walk through the list of transactions available in activeTxnMap.
For each transaction, call clTxnStreamTxnCfgInfoPack()
For the received message-buffer, append it to the master message-buffer.
*/
if ( (ppData == NULL) || (pDataLen == NULL) )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Null arguements"));
CL_FUNC_EXIT();
return CL_ERR_NULL_POINTER;
}
rc = clBufferCreate (&txnSrvcStateBuff);
if (CL_OK == rc)
{
clXdrMarshallClUint32T( &(clTxnServiceCfg->txnIdCounter), txnSrvcStateBuff, 0);
/* Copy to buffer */
*pDataLen = 0;
*ppData = NULL;
if (CL_OK == rc)
{
ClUint32T ckptDataLen;
rc = clBufferLengthGet(txnSrvcStateBuff, &ckptDataLen);
if ( (CL_OK == rc) && ( ckptDataLen != 0) )
{
*ppData = (ClAddrT) clHeapAllocate(ckptDataLen);
*pDataLen = ckptDataLen;
if ( *ppData != NULL )
{
rc = clBufferNBytesRead(txnSrvcStateBuff,
(ClUint8T *) *ppData, &ckptDataLen);
if (CL_OK != rc)
{
*pDataLen = 0x0;
clHeapFree(*ppData);
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to create txn-service checkpoint. rc:0x%x", rc));
rc = CL_GET_ERROR_CODE(rc);
}
}
else
{
rc = CL_ERR_NO_MEMORY;
}
}
else
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("Error while packing or no data rc:0x%x data-len:0%x", rc, ckptDataLen));
}
}
rc = clBufferDelete(&txnSrvcStateBuff);
}
CL_FUNC_EXIT();
return (rc);
}
ClRcT clEvtCpmReplyCb(ClUint32T data, ClBufferHandleT inMsgHandle,
ClBufferHandleT outMsgHandle)
{
ClUint32T rc = CL_OK;
#if 0
ClCpmLcmResponseT response = { {0, 0}, 0 };
ClUint32T msgLength = 0;
ClCharT logmsg[CL_MAX_NAME_LENGTH] = { 0 };
ClCharT requesttype[CL_MAX_NAME_LENGTH] = { 0 };
CL_FUNC_ENTER();
rc = clBufferLengthGet(inMsgHandle, &msgLength);
if (msgLength == sizeof(ClCpmLcmResponseT))
{
rc = clBufferNBytesRead(inMsgHandle, (ClUint8T *) &response,
&msgLength);
if (rc != CL_OK)
{
clOsalPrintf("Unable to read the message. \n");
goto failure;
}
}
else
{
clOsalPrintf("Buffer read failure !\n");
goto failure;
}
printf("Received reply for %s...\n", response.name);
switch (response.requestType)
{
case CL_CPM_HEALTHCHECK:
strcpy(requesttype, "CL_CPM_HEALTHCHECK");
break;
case CL_CPM_TERMINATE:
strcpy(requesttype, "CL_CPM_TERMINATE");
break;
case CL_CPM_PROXIED_INSTANTIATE:
strcpy(requesttype, "CL_CPM_PROXIED_INSTANTIATE");
break;
case CL_CPM_PROXIED_CLEANUP:
strcpy(requesttype, "CL_CPM_PROXIED_CLEANUP");
break;
case CL_CPM_EXTN_HEALTHCHECK:
strcpy(requesttype, "CL_CPM_EXTN_HEALTHCHECK");
break;
case CL_CPM_INSTANTIATE:
strcpy(requesttype, "CL_CPM_INSTANTIATE");
break;
case CL_CPM_CLEANUP:
strcpy(requesttype, "CL_CPM_CLEANUP");
break;
case CL_CPM_RESTART:
strcpy(requesttype, "CL_CPM_RESTART");
break;
default:
strcpy(requesttype, "Invalid request");
break;
}
sprintf(logmsg, "%s %s request %s.\n", response.name, requesttype,
response.returnCode == CL_OK ? "success" : "failure");
printf(logmsg);
CL_FUNC_EXIT();
return CL_OK;
failure:
CL_FUNC_EXIT();
#endif
printf("Invoked the Callback for CPM API succesfully\n\r\n");
return rc;
}
static ClRcT
clLogSvrStreamEntryPack(ClUint32T dsId,
ClAddrT *ppBuffer,
ClUint32T *pBuffSize,
ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE;
ClCntNodeHandleT svrStreamNode = cookie;
ClLogSvrEoDataT *pSvrEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == ppBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pBuffSize), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrEoEntryGet(): rc[0x %x]\n", rc));
return rc;
}
rc = clBufferCreate(&msg);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
return rc;
}
rc = clLogSvrStreamInfoPack(pSvrEoEntry, svrStreamNode, msg);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrStreamInfoPack(): rc[0x %x]", rc));
clBufferDelete(&msg);
return rc;
}
rc = clBufferLengthGet(msg, pBuffSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));
clBufferDelete(&msg);
return rc;
}
*ppBuffer = (ClAddrT) clHeapCalloc(*pBuffSize, sizeof(ClUint8T));
if( NULL == *ppBuffer )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc(): rc[0x %x]", rc));
clBufferDelete(&msg);
return rc;
}
rc = clBufferNBytesRead(msg, (ClUint8T *)*ppBuffer, pBuffSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
clHeapFree(*ppBuffer);
clBufferDelete(&msg);
return rc;
}
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static ClRcT
clLogSvrDsIdMapPack(ClUint32T dsId,
ClAddrT *ppBuffer,
ClUint32T *pBuffSize,
ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClLogSvrEoDataT *pSvrEoEntry = (ClLogSvrEoDataT *) cookie;
ClBufferHandleT inMsg = CL_HANDLE_INVALID_VALUE;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == ppBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pSvrEoEntry), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((CL_LOG_DSID_START != dsId),
CL_LOG_RC(CL_ERR_INVALID_PARAMETER));
rc = clBufferCreate(&inMsg);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
return rc;
}
rc = clXdrMarshallClUint32T(&pSvrEoEntry->nextDsId, inMsg, 0);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
clBufferDelete(&inMsg);
return rc;
}
rc = clLogBitmapPack(pSvrEoEntry->hDsIdMap, inMsg);
if( CL_OK != rc )
{
clBufferDelete(&inMsg);
return rc;
}
rc = clBufferLengthGet(inMsg, pBuffSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));
clBufferDelete(&inMsg);
return rc;
}
*ppBuffer = (ClAddrT) clHeapCalloc(*pBuffSize, sizeof(ClUint8T));
if( NULL == *ppBuffer )
{
clBufferDelete(&inMsg);
CL_LOG_DEBUG_ERROR(("clHeapCalloc(): rc[0x %x]", rc));
return rc;
}
rc = clBufferNBytesRead(inMsg,(ClUint8T *) *ppBuffer, pBuffSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
clHeapFree(*ppBuffer);
clBufferDelete(&inMsg);
return rc;
}
CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static ClRcT
clLogMasterFileEntryPack(ClLogMasterEoDataT *pMasterEoEntry,
ClCntNodeHandleT hFileNode,
ClCkptSectionIdT *pSecId,
ClUint8T **ppBuffer,
ClUint32T *pBufferLen)
{
ClBufferHandleT hFileEntryBuf = CL_HANDLE_INVALID_VALUE;
ClLogFileKeyT *pFileKey = NULL;
ClLogFileDataT *pFileData = NULL;
ClRcT rc = CL_OK;
ClVersionT version = { CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION };
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clCntNodeUserKeyGet(pMasterEoEntry->hMasterFileTable, hFileNode, (ClCntKeyHandleT *) &pFileKey);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeUserKeyGet(): rc[0x %x]", rc));
return rc;
}
rc = clCntNodeUserDataGet(pMasterEoEntry->hMasterFileTable, hFileNode, (ClCntDataHandleT *) &pFileData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));
return rc;
}
rc = clLogMasterFileEntrySecIdGet(pFileKey, pSecId);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogMasterFileEntrySecIdGet(): rc[0x %x]", rc));
return rc;
}
rc = clBufferCreate(&hFileEntryBuf);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
clHeapFree(pSecId->id);
return rc;
}
rc = clXdrMarshallClVersionT(&version, hFileEntryBuf, 0);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallClVersionT(): rc[%#x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
clHeapFree(pSecId->id);
return rc;
}
rc = clLogMasterFileKeyPack(pFileKey, hFileEntryBuf);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogMasterFileKeyPack(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
clHeapFree(pSecId->id);
return rc;
}
rc = clLogMasterFileDataPack(pFileData, hFileEntryBuf);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogMasterFileDataPack(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
clHeapFree(pSecId->id);
return rc;
}
rc = clBufferLengthGet(hFileEntryBuf, pBufferLen);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet: rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
clHeapFree(pSecId->id);
return rc;
}
/* rc = clBufferFlatten(hFileEntryBuf, ppBuffer); */
*ppBuffer = (ClUint8T*) clHeapCalloc(*pBufferLen, sizeof(ClCharT));
if( NULL == *ppBuffer )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
clHeapFree(pSecId->id);
return rc;
}
rc = clBufferNBytesRead(hFileEntryBuf, (ClUint8T *) *ppBuffer, pBufferLen);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferFlatten(): rc[0x %x]", rc));
clHeapFree(*ppBuffer);
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
clHeapFree(pSecId->id);
return rc;
}
CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static ClRcT clLogMasterEoEntryCheckpoint(ClLogMasterEoDataT *pMasterEoEntry)
{
ClRcT rc = CL_OK;
ClBufferHandleT hEoEntryBuf = CL_HANDLE_INVALID_VALUE;
ClUint8T *pBuffer = NULL;
ClUint32T bufferLen = 0;
ClVersionT version = { CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION };
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clBufferCreate(&hEoEntryBuf);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
return rc;
}
rc = clXdrMarshallClVersionT(&version, hEoEntryBuf, 0);
if( CL_OK != rc)
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallClVersionT(): rc[%#x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK);
return rc;
}
rc = clXdrMarshallClUint16T(&(pMasterEoEntry->nextStreamId),
hEoEntryBuf, 0);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint16T(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK);
return rc;
}
rc = clBufferLengthGet(hEoEntryBuf, &bufferLen);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet: rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK);
return rc;
}
rc = clBufferFlatten(hEoEntryBuf, &pBuffer);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferFlatten(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK);
return rc;
}
rc = clCkptSectionOverwrite(pMasterEoEntry->hCkpt, &gLogMasterDefaultSectionId, pBuffer, bufferLen);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCkptSectionOverwrite(): rc[0x %x]", rc));
}
clHeapFree(pBuffer);
CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clLogSODsIdMapPack(ClUint32T dsId,
ClAddrT *pBuffer,
ClUint32T *pSize,
ClPtrT cookie)
{
ClRcT rc = CL_OK;
ClLogSOEoDataT *pSoEoEntry = NULL;
ClBufferHandleT msg = 0;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK( (CL_LOG_DSID_START != dsId),
CL_LOG_RC(CL_ERR_INVALID_PARAMETER));
CL_LOG_PARAM_CHK( (NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK( (NULL == pSize), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, NULL);
if( CL_OK != rc )
{
return rc;
}
rc = clBufferCreate(&msg);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
return rc;
}
rc = clXdrMarshallClUint32T(&pSoEoEntry->dsIdCnt, msg, 0);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
rc = clLogBitmapPack(pSoEoEntry->hDsIdMap, msg);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
rc = clBufferLengthGet(msg, pSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
*pBuffer = (ClAddrT)clHeapCalloc(*pSize, sizeof(ClInt8T));
if( NULL == *pBuffer )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
rc = clBufferNBytesRead(msg, (ClUint8T *) *pBuffer, pSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));
clHeapFree(*pBuffer);
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
return rc;
}
CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT clRmdParamSanityCheck(ClBufferHandleT inMsgHdl, /* Input
* Message */
ClBufferHandleT outMsgHdl, /* Output
* Message */
ClUint32T flags, /* Flags */
ClRmdOptionsT *pOptions, /* Optional Parameters
* for RMD Call */
ClRmdAsyncOptionsT *pAsyncOptions) /* Optional
* Async
* Parameters
* for RMD Call
*/
{
ClRcT rc;
ClUint32T size;
ClUint32T inBufLen = 0;
CL_FUNC_ENTER();
rc = clRmdMaxPayloadSizeGet(&size);
if (rc != CL_OK)
return rc;
if (inMsgHdl)
rc = clBufferLengthGet(inMsgHdl, &inBufLen);
if (rc != CL_OK)
{
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
if (inBufLen > size)
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
if (flags &
~(CL_RMD_CALL_ASYNC | CL_RMD_CALL_NEED_REPLY | CL_RMD_CALL_ATMOST_ONCE |
RMD_CALL_MSG_ASYNC | CL_RMD_CALL_DO_NOT_OPTIMIZE |
CL_RMD_CALL_NON_PERSISTENT | CL_RMD_CALL_IN_SESSION |
CL_RMD_CALL_ORDERED
))
{
RMD_DBG2((" RMD INVALID FLAGS 1\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
if (inMsgHdl != 0)
{
if (inBufLen == 0)
{
RMD_DBG2((" RMD INVALID input buffer len 1 \n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
}
if (flags & CL_RMD_CALL_ASYNC)
{
if (pAsyncOptions == NULL)
{
if (flags & CL_RMD_CALL_NEED_REPLY)
{
RMD_DBG2((" RMD INVALID Outbuff parametrs for async 1\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
}
else
{
if (pAsyncOptions->fpCallback == NULL)
{
if (flags & CL_RMD_CALL_NEED_REPLY)
{
RMD_DBG2((" RMD INVALID Outbuff parametrs for async 2\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
}
}
}
else
{
if (pAsyncOptions)
if (pAsyncOptions->fpCallback || pAsyncOptions->pCookie)
{
RMD_DBG2((" RMD INVALID Outbuff parametrs for sync 1\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
}
if (pOptions && (pOptions->retries > _clRmdConfig.maxRetries))
{
RMD_DBG2((" RMD INVALID Options retries2\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
CL_FUNC_EXIT();
return CL_OK;
}
int clGmsSendMsg(ClGmsViewMemberT *memberNodeInfo,
ClGmsGroupIdT groupId,
ClGmsMessageTypeT msgType,
ClGmsMemberEjectReasonT ejectReason,
ClUint32T dataSize,
ClPtrT dataPtr)
{
mar_req_header_t header = {0};
struct VDECL(req_exec_gms_nodejoin) req_exec_gms_nodejoin = {{0}};
struct iovec req_exec_gms_iovec = {0};
int result = -1;
ClRcT rc = CL_OK;
ClUint32T clusterVersion = 0;
ClBufferHandleT bufferHandle = 0;
ClUint8T *message = NULL;
ClUint32T length = 0;
ClPtrT temp = NULL;
rc = clNodeCacheMinVersionGet(NULL, &clusterVersion);
if(clusterVersion >= CL_VERSION_CODE(5, 0, 0)
&&
clAspNativeLeaderElection())
{
clLog(DBG, OPN, AIS,
"Skipped sending msgtype [%d] since node cache is used to form the cluster view",
msgType);
return 0;
}
if (rc != CL_OK)
{
clLog(ERROR,OPN,AIS,
"Error while getting version from the version cache. rc 0x%x",rc);
curVer.releaseCode = CL_RELEASE_VERSION;
curVer.majorVersion = CL_MAJOR_VERSION;
curVer.minorVersion = CL_MINOR_VERSION;
}
else
{
curVer.releaseCode = CL_VERSION_RELEASE(clusterVersion);
curVer.majorVersion = CL_VERSION_MAJOR(clusterVersion);
curVer.minorVersion = CL_VERSION_MINOR(clusterVersion);
}
/* Get the version and send it */
req_exec_gms_nodejoin.version.releaseCode = curVer.releaseCode;
req_exec_gms_nodejoin.version.majorVersion = curVer.majorVersion;
req_exec_gms_nodejoin.version.minorVersion = curVer.minorVersion;
/* For now we send message without caring about version. Later on
* we need to change it accordingly */
switch(msgType)
{
case CL_GMS_CLUSTER_JOIN_MSG:
case CL_GMS_CLUSTER_LEAVE_MSG:
case CL_GMS_CLUSTER_EJECT_MSG:
clLog(DBG,OPN,AIS,
"Sending cluster %s multicast message",
msgType == CL_GMS_CLUSTER_JOIN_MSG ? "join":
msgType == CL_GMS_CLUSTER_LEAVE_MSG ? "leave" : "eject");
req_exec_gms_nodejoin.ejectReason = ejectReason;
memcpy (&req_exec_gms_nodejoin.specificMessage.gmsClusterNode, &memberNodeInfo->clusterMember,
sizeof (ClGmsClusterMemberT));
req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle;
break;
case CL_GMS_GROUP_CREATE_MSG:
case CL_GMS_GROUP_DESTROY_MSG:
case CL_GMS_GROUP_JOIN_MSG:
case CL_GMS_GROUP_LEAVE_MSG:
clLog(DBG,OPN,AIS,
"Sending group %s multicast message",
msgType == CL_GMS_GROUP_CREATE_MSG ? "create" :
msgType == CL_GMS_GROUP_DESTROY_MSG ? "destroy" :
msgType == CL_GMS_GROUP_JOIN_MSG ? "join" : "leave");
memcpy (&req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode,
&memberNodeInfo->groupMember,
sizeof (ClGmsGroupMemberT));
memcpy (&req_exec_gms_nodejoin.specificMessage.groupMessage.groupData,
&memberNodeInfo->groupData,
sizeof(ClGmsGroupInfoT));
req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle;
break;
case CL_GMS_COMP_DEATH:
clLog(DBG,OPN,AIS,
"Sending comp death multicast message");
memcpy (&req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode,
&memberNodeInfo->groupMember,
sizeof (ClGmsGroupMemberT));
req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle;
break;
case CL_GMS_LEADER_ELECT_MSG:
clLog(DBG,OPN,AIS,
"Sending leader elect multicast message");
memcpy (&req_exec_gms_nodejoin.specificMessage.gmsClusterNode, &memberNodeInfo->clusterMember,
sizeof (ClGmsClusterMemberT));
req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle;
break;
case CL_GMS_SYNC_MESSAGE:
clLog(DBG,OPN,AIS,
"Sending gms synch multicast message");
req_exec_gms_nodejoin.dataPtr = dataPtr;
break;
case CL_GMS_GROUP_MCAST_MSG:
memcpy (&req_exec_gms_nodejoin.specificMessage.mcastMessage.groupInfo.gmsGroupNode,
&memberNodeInfo->groupMember,
sizeof (ClGmsGroupMemberT));
memcpy (&req_exec_gms_nodejoin.specificMessage.mcastMessage.groupInfo.groupData,
&memberNodeInfo->groupData,
sizeof(ClGmsGroupInfoT));
req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle;
req_exec_gms_nodejoin.specificMessage.mcastMessage.userDataSize = dataSize;
req_exec_gms_nodejoin.dataPtr = dataPtr;
break;
default:
clLog(DBG,OPN,AIS,
"Requested wrong message to be multicasted. Message type %d",
msgType);
return CL_GMS_RC(CL_ERR_INVALID_PARAMETER);
}
req_exec_gms_nodejoin.gmsMessageType = msgType;
req_exec_gms_nodejoin.gmsGroupId = groupId;
/* Create a buffer handle and marshall the eliments */
rc = clBufferCreate(&bufferHandle);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"Failed to create buffer while sending message on totem. rc 0x%x",rc);
return rc;
}
rc = marshallReqExecGmsNodeJoin(&req_exec_gms_nodejoin,bufferHandle);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"Failed to marshall the data while sending message on totem. rc 0x%x",rc);
goto buffer_delete_return;
}
rc = clBufferLengthGet(bufferHandle, &length);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"Failed to get buffer length. rc 0x%x",rc);
goto buffer_delete_return;
}
rc = clBufferFlatten(bufferHandle, &message);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"clBufferFlatten failed with rc 0x%x",rc);
goto buffer_delete_return;
}
header.id = SERVICE_ID_MAKE (GMS_SERVICE, MESSAGE_REQ_EXEC_GMS_NODEJOIN);
header.size = length + sizeof(mar_req_header_t);
/* We need to prepend the total message length in the beginning of the
* message so that we can find the length while unmarshalling */
temp = clHeapAllocate(header.size);
if (temp == NULL)
{
clLogError(OPN,AIS,
"Failed to allocate memory while sending the message");
goto buffer_delete_return;
}
memcpy(temp,&header, sizeof(mar_req_header_t));
memcpy(temp+sizeof(mar_req_header_t), message, length);
req_exec_gms_iovec.iov_base = temp;
req_exec_gms_iovec.iov_len = length + sizeof(mar_req_header_t);
result = totempg_groups_mcast_joined (openais_group_handle, &req_exec_gms_iovec, 1, TOTEMPG_AGREED);
clLog(DBG,OPN,AIS,
"Done with sending multicast message of type %d",msgType);
buffer_delete_return:
if (message != NULL)
clHeapFree(message);
if (temp != NULL)
clHeapFree(temp);
clBufferDelete(&bufferHandle);
return result;
}
static int gms_nodejoin_send (void)
{
/* For now this function sends only latest version. It needs to be
* modified in future when version changes */
/* Send the join message with given version */
mar_req_header_t header = {0};
struct VDECL(req_exec_gms_nodejoin) req_exec_gms_nodejoin;
struct iovec req_exec_gms_iovec;
ClGmsClusterMemberT thisGmsClusterNode;
int result;
ClRcT rc = CL_OK;
ClUint32T clusterVersion;
ClBufferHandleT bufferHandle = 0;
ClUint8T *message = NULL;
ClPtrT temp = NULL;
ClUint32T length = 0;
rc = clNodeCacheMinVersionGet(NULL, &clusterVersion);
if (rc != CL_OK)
{
clLog(ERROR,OPN,AIS,
"Error while getting version from the version cache. rc 0x%x",rc);
curVer.releaseCode = CL_RELEASE_VERSION;
curVer.majorVersion = CL_MAJOR_VERSION;
curVer.minorVersion = CL_MINOR_VERSION;
} else {
curVer.releaseCode = CL_VERSION_RELEASE(clusterVersion);
curVer.majorVersion = CL_VERSION_MAJOR(clusterVersion);
curVer.minorVersion = CL_VERSION_MINOR(clusterVersion);
}
clLog(DBG,OPN,AIS,
"This node is sending join message for version %d, %d, %d",
curVer.releaseCode, curVer.majorVersion, curVer.minorVersion);
/* Get the version and send it */
req_exec_gms_nodejoin.version.releaseCode = curVer.releaseCode;
req_exec_gms_nodejoin.version.majorVersion = curVer.majorVersion;
req_exec_gms_nodejoin.version.minorVersion = curVer.minorVersion;
_clGmsGetThisNodeInfo(&thisGmsClusterNode);
// node join is send for default cluster group - 0
req_exec_gms_nodejoin.gmsGroupId = 0;
memcpy (&req_exec_gms_nodejoin.specificMessage.gmsClusterNode, &thisGmsClusterNode, sizeof (ClGmsClusterMemberT));
req_exec_gms_nodejoin.gmsMessageType = CL_GMS_CLUSTER_JOIN_MSG;
/* Create a buffer handle and marshall the elements */
rc = clBufferCreate(&bufferHandle);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"Failed to create buffer while sending message on totem. rc 0x%x",rc);
return rc;
}
rc = marshallReqExecGmsNodeJoin(&req_exec_gms_nodejoin,bufferHandle);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"Failed to marshall the data while sending message on totem. rc 0x%x",rc);
goto buffer_delete_return;
}
rc = clBufferLengthGet(bufferHandle, &length);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"Failed to get buffer length. rc 0x%x",rc);
goto buffer_delete_return;
}
rc = clBufferFlatten(bufferHandle, &message);
if (rc != CL_OK)
{
clLogError(OPN,AIS,
"clBufferFlatten failed with rc 0x%x",rc);
goto buffer_delete_return;
}
/* We need to prepend the total message length in the beginning of the
* message so that we can find the length while unmarshalling */
temp = clHeapAllocate(length + sizeof(mar_req_header_t));
if (temp == NULL)
{
clLogError(OPN,AIS,
"Failed to allocate memory while sending the message");
goto buffer_delete_return;
}
header.id = SERVICE_ID_MAKE (GMS_SERVICE, MESSAGE_REQ_EXEC_GMS_NODEJOIN);
header.size = length + sizeof(mar_req_header_t);
memcpy(temp,&header,sizeof(mar_req_header_t));
memcpy(temp+sizeof(mar_req_header_t), message, length);
req_exec_gms_iovec.iov_base = temp;
req_exec_gms_iovec.iov_len = length + sizeof(mar_req_header_t);
clLog(DBG,OPN,AIS,
"Sending node join from this node in sync_process");
result = totempg_groups_mcast_joined (openais_group_handle, &req_exec_gms_iovec, 1, TOTEMPG_AGREED);
buffer_delete_return:
if (message != NULL)
clHeapFree(message);
if (temp != NULL)
clHeapFree(temp);
clBufferDelete(&bufferHandle);
return result;
}
