ClRcT clRmdPrivateDataSet(void *data)
{
if (!data)
{
return CL_RMD_RC(CL_ERR_NULL_POINTER);
}
return clOsalTaskDataSet(clRmdPrivateDataKey, (ClOsalTaskDataT) data);
}
ClRcT clRmdPrivateDataGet(void **data)
{
ClOsalTaskDataT *pThreadData = (ClOsalTaskDataT *) data;
if (!data)
{
return CL_RMD_RC(CL_ERR_NULL_POINTER);
}
return clOsalTaskDataGet(clRmdPrivateDataKey, pThreadData);
}
static ClUint32T recvHashFunction(ClCntKeyHandleT key)
{
ClUint32T hashVal;
CL_FUNC_ENTER();
if (key == 0)
{
RMD_DBG2((" RMD Invalid Key is passed\n"));
CL_FUNC_EXIT();
return (CL_RMD_RC(CL_ERR_INVALID_PARAMETER));
}
CL_FUNC_EXIT();
hashVal =
( ((ClRmdRecvKeyT *) key)->msgId & RMD_RECV_BUCKETS_MASK );
return (hashVal);
}
static ClInt32T recvKeyCompare(ClCntKeyHandleT key1, ClCntKeyHandleT key2)
{
ClInt32T cmpResult = 0;
CL_FUNC_ENTER();
if (key1 == 0 || key2 == 0)
{
RMD_DBG2((" RMD Invalid Key is passed\n"));
CL_FUNC_EXIT();
return (CL_RMD_RC(CL_ERR_INVALID_PARAMETER));
}
cmpResult = memcmp((void *) key1, (void *) key2, sizeof(ClRmdRecvKeyT));
CL_FUNC_EXIT();
return cmpResult;
}
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;
}
/*
* Paket are added in the record after converting them in the nw order so msgid
* here is network order. Called with lock held.
*/
ClRcT clRmdCreateAndAddRmdSendRecord(ClEoExecutionObjT *pThis,
ClIocAddressT destAddr,
ClUint32T hdrLen,
ClBufferHandleT outMsgHdl,
ClUint32T flags, ClRmdOptionsT *pOptions,
ClRmdAsyncOptionsT *pAsyncOptions,
ClBufferHandleT message,
ClUint64T msgId, ClUint32T payloadLen,
ClRmdRecordSendT ** ppSendRec)
{
ClRmdRecordSendT *rec;
ClRcT retVal = CL_OK;
ClRcT retCode = 0;
/*
* it will be called only for async
*/
CL_FUNC_ENTER();
rec = (ClRmdRecordSendT*) clHeapAllocate((ClUint32T) sizeof(ClRmdRecordSendT));
if (rec == NULL)
{
CL_FUNC_EXIT();
return (CL_RMD_RC(CL_ERR_NO_MEMORY));
}
rec->flags = flags;
rec->hdrLen = hdrLen;
rec->recType.asyncRec.rcvMsg = NULL;
rec->recType.asyncRec.outLen = payloadLen;
rec->recType.asyncRec.priority = pOptions->priority;
rec->recType.asyncRec.destAddr = destAddr;
rec->recType.asyncRec.sndMsgHdl = message;
rec->recType.asyncRec.timerID = 0;
rec->recType.asyncRec.outMsgHdl = outMsgHdl;
/*
* options can't be 0 as we are creating and passing it
*/
rec->recType.asyncRec.noOfRetry = pOptions->retries;
rec->recType.asyncRec.timeout = pOptions->timeout;
rec->recType.asyncRec.cookie = pAsyncOptions->pCookie;
rec->recType.asyncRec.func = pAsyncOptions->fpCallback;
RMD_DBG4((" RMD CALL is Async and reply needed create the timer\n"));
retVal =
createAsyncSendTimer(&rec->recType.asyncRec,(ClPtrT)(ClWordT)msgId);
if (retVal != CL_OK)
{
clHeapFree(rec);
CL_FUNC_EXIT();
return retVal;
}
retVal =
clCntNodeAdd(((ClRmdObjT *) pThis->rmdObj)->sndRecContainerHandle,
(ClPtrT)(ClWordT)msgId, (ClCntDataHandleT) rec, NULL);
if (retVal == CL_OK) *ppSendRec = rec;
else
{
RMD_DBG4((" RMD createandaddrec:node add failed1."
" Delete timer and return.\n"));
/*
* Free the timer additionally for Async Call
*/
if (flags & CL_RMD_CALL_ASYNC)
retCode = clTimerDeleteAsync(&rec->recType.asyncRec.timerID);
clHeapFree(rec);
}
CL_FUNC_EXIT();
return retVal;
}
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;
}
ClRcT clRmdObjClose(ClRmdObjHandleT p)
{
#if 0 // Don't know why safplus_amf process hang at clOsalMutexLock(pRmdObject->semaForRecvHashTable)
ClRcT retCode = CL_OK;
ClRmdObjT *pRmdObject = NULL;
CL_FUNC_ENTER();
pRmdObject = (ClRmdObjT *) p;
if (NULL == pRmdObject)
{
RMD_DBG1((" RMD Invalid rmd handle in objclose\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
/*
* Avoid deleting the mutexes so its still valid in case any context is abusing the terminate
* and initiating or not quitting the rmd sends.
*/
retCode = clOsalMutexDelete(pRmdObject->semaForRecvHashTable);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD Recv mutex delete failed\n"));
}
retCode = clOsalMutexDelete(pRmdObject->semaForSendHashTable);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD Send mutex delete failed\n"));
}
clOsalMutexLock(pRmdObject->semaForRecvHashTable);
retCode = clCntDelete(pRmdObject->rcvRecContainerHandle);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD rcv hash table destroy failed\n"));
}
pRmdObject->rcvRecContainerHandle = 0;
clOsalMutexUnlock(pRmdObject->semaForRecvHashTable);
clOsalMutexLock(pRmdObject->semaForSendHashTable);
retCode = clCntDelete(pRmdObject->sndRecContainerHandle);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD snd hash table destroy failed\n"));
}
pRmdObject->sndRecContainerHandle = 0;
clOsalMutexUnlock(pRmdObject->semaForSendHashTable);
retCode = clHandleDatabaseDestroy(pRmdObject->responseCntxtDbHdl);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD snd hash table destroy failed\n"));
}
pRmdObject->responseCntxtDbHdl = 0;
/*
* Don't release the rmd context to respect abusers or initiators of rmd send outside
* terminate callback contexts.
*/
clHeapFree(pRmdObject);
#endif
CL_FUNC_EXIT();
return (CL_OK);
}
ClRcT clRmdObjInit(ClRmdObjHandleT *p)
{
ClRcT retCode = CL_OK;
ClRmdObjT *pRmdObject = NULL;
//unsigned long timeStamp = 0;
struct timeval tm1;
#ifdef DEBUG
static ClUint8T rmdAddedTodbgComp = CL_FALSE;
if (CL_FALSE == rmdAddedTodbgComp)
{
retCode = dbgAddComponent(COMP_PREFIX, COMP_NAME, COMP_DEBUG_VAR_PTR);
rmdAddedTodbgComp = CL_TRUE;
if (CL_OK != retCode)
{
clLogError("OBG","INI","dbgAddComponent FAILED ");
CL_FUNC_EXIT();
return retCode;
}
}
#endif
CL_FUNC_ENTER();
if (NULL == p)
{
RMD_DBG1((" RMD Invalid Object handle passed\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
retCode = clOsalInitialize(NULL);
retCode = clTimerInitialize(NULL);
pRmdObject = (ClRmdObjT *) clHeapAllocate(sizeof(ClRmdObjT));
if (NULL == pRmdObject)
{
RMD_DBG1((" RMD No Memory\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_NO_MEMORY)));
}
gettimeofday(&tm1, NULL);
//timeStamp = tm1.tv_sec * 1000000 + tm1.tv_usec;
pRmdObject->msgId = 1;
retCode = clOsalMutexCreate(&pRmdObject->semaForSendHashTable);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD send Mutex creation failed\n"));
CL_FUNC_EXIT();
return (retCode);
}
retCode = clOsalMutexCreate(&pRmdObject->semaForRecvHashTable);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD recv Mutex creation failed\n"));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return (retCode);
}
retCode =
clCntHashtblCreate(NUMBER_OF_RECV_BUCKETS, recvKeyCompare,
recvHashFunction, recvHashDeleteCallBack,
recvHashDeleteCallBack, CL_CNT_UNIQUE_KEY,
&pRmdObject->rcvRecContainerHandle);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD send Hash table creation failed\n"));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForRecvHashTable));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return (retCode);
}
retCode =
clCntHashtblCreate(NUMBER_OF_SEND_BUCKETS, sendKeyCompare,
sendHashFunction, sendHashDeleteCallBack,
sendHashDestroyCallBack, CL_CNT_UNIQUE_KEY,
&pRmdObject->sndRecContainerHandle);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD recv Hash table creation failed\n"));
IGNORE_RETURN(clCntDelete(pRmdObject->rcvRecContainerHandle));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForRecvHashTable));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return (retCode);
}
pRmdObject->responseCntxtDbHdl = 0;
retCode = clHandleDatabaseCreate(NULL, &pRmdObject->responseCntxtDbHdl);
if (retCode != CL_OK)
{
RMD_DBG1((" RMD Sync Handle Database create failed\n"));
IGNORE_RETURN(clCntDelete(pRmdObject->sndRecContainerHandle));
IGNORE_RETURN(clCntDelete(pRmdObject->rcvRecContainerHandle));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForRecvHashTable));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return retCode;
}
pRmdObject->numAtmostOnceEntry = 0;
pRmdObject->lastAtmostOnceCleanupTime = clOsalStopWatchTimeGet();
pRmdObject->rmdStats.nRmdCalls = 0;
pRmdObject->rmdStats.nFailedCalls = 0;
pRmdObject->rmdStats.nResendRequests = 0;
pRmdObject->rmdStats.nRmdReplies = 0;
pRmdObject->rmdStats.nBadReplies = 0;
pRmdObject->rmdStats.nRmdRequests = 0;
pRmdObject->rmdStats.nBadRequests = 0;
pRmdObject->rmdStats.nCallTimeouts = 0;
pRmdObject->rmdStats.nDupRequests = 0;
pRmdObject->rmdStats.nAtmostOnceCalls = 0;
pRmdObject->rmdStats.nResendReplies = 0;
pRmdObject->rmdStats.nReplySend = 0;
pRmdObject->rmdStats.nRmdCallOptimized = 0;
*p = (ClRmdObjHandleT) pRmdObject;
CL_FUNC_EXIT();
return (CL_OK);
}
