static ClRcT
clLogSvrDsIdMapRecreate(ClUint32T  dsId,
                        ClAddrT    pBuffer,
                        ClUint32T  buffSize,
                        ClPtrT     pCookie)
{
    ClRcT            rc           = CL_OK;
    ClLogSvrEoDataT  *pSvrEoEntry = NULL;
    ClBufferHandleT  inMsg        = CL_HANDLE_INVALID_VALUE;

    CL_LOG_DEBUG_TRACE(("Enter"));

    CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));
    CL_LOG_PARAM_CHK((CL_LOG_DSID_START != dsId),
                     CL_LOG_RC(CL_ERR_INVALID_PARAMETER));

    rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);
    if( CL_OK != rc )
    {
        return rc;
    }

    rc = clBufferCreate(&inMsg);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
        return rc;
    }
    rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);
        return rc;
    }

    rc = clXdrUnmarshallClUint32T(inMsg, &pSvrEoEntry->nextDsId);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]\n", rc));
        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);
        return rc;
    }
    CL_LOG_DEBUG_VERBOSE(("DsIdCnt: %d", pSvrEoEntry->nextDsId));

    rc = clLogBitmapUnpack(inMsg, pSvrEoEntry->hDsIdMap);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clLogBitmapUnpack(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);
        return rc;
    }
    CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
ClRcT clCorAmfMoIdGet(const ClCharT *name,
                      ClAmsEntityTypeT type,
                      ClCorMOIdT *pMoId)
{
    ClAmsEntityT entity = {0};
    ClBufferHandleT msg = 0;
    ClRcT rc = CL_OK;
    ClVersionT version = {'B', 0x1, 0x1};
    ClCharT *data = NULL;
    ClUint32T dataLen = 0;
    ClCorObjectHandleT objHandle;

    if(!name || !pMoId) return CL_COR_SET_RC(CL_ERR_INVALID_PARAMETER);

    if(!mgmtHandle)
    {
        rc = clAmsMgmtInitialize(&mgmtHandle, NULL, &version);
        if(rc != CL_OK) return rc;
    }

    entity.type = type;
    clNameSet(&entity.name, name);
    ++entity.name.length;
    rc = clAmsMgmtEntityUserDataGetKey(mgmtHandle, &entity, &entity.name, &data, &dataLen);
    if(rc != CL_OK)
    {
        clLogError("FLT", "REPAIR", "Entity data get for [%s] returned [%#x]",
                   entity.name.value, rc);
        goto out_free;
    }
    rc = clBufferCreate(&msg);
    CL_ASSERT(rc == CL_OK);
    rc = clBufferNBytesWrite(msg, (ClUint8T*)data, dataLen);
    CL_ASSERT(rc == CL_OK);
    
    rc = VDECL_VER(clXdrUnmarshallClCorMOIdT, 4, 0, 0)(msg, pMoId);
    CL_ASSERT(rc == CL_OK);
    
    clBufferDelete(&msg);

    clLogNotice("COR", "AMF", "MOID for faulty entity [%s] ", entity.name.value);
    clCorMoIdShow(pMoId);
    
    /*
     * Validating moid
     */
    rc = clCorObjectHandleGet(pMoId, &objHandle);
    CL_ASSERT(rc == CL_OK);

    out_free:
    if(msg) clBufferDelete(&msg);
    if(data) clHeapFree(data);

    return rc;
}
static ClRcT
clLogMasterFileEntryRecover(ClLogMasterEoDataT      *pMasterEoEntry,
                            ClCkptIOVectorElementT  *pIoVector,
                            ClUint32T               *pErrIndex)
{
    ClRcT                rc            = CL_OK;
    ClBufferHandleT      hFileEntryBuf = CL_HANDLE_INVALID_VALUE;
    ClVersionT version = {0};

    CL_LOG_DEBUG_TRACE(("Enter: size %lld", pIoVector->readSize));

    rc = clBufferCreate(&hFileEntryBuf);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
        return rc;
    }

    rc = clBufferNBytesWrite(hFileEntryBuf, (ClUint8T*) pIoVector->dataBuffer, pIoVector->readSize);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
        return rc;
    }

    rc = clXdrUnmarshallClVersionT(hFileEntryBuf, &version);

    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClVersionT(): rc[%#x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);
        return rc;
    }

    switch(CL_VERSION_CODE(version.releaseCode, version.majorVersion, version.minorVersion))
    {
    case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION):
    {
        rc = fileEntryRecoverBaseVersion(pMasterEoEntry, hFileEntryBuf);
    }
    break;
    default:
        rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH);
        clLogError("FILE", "RECOVER", "Version [%d.%d.%d] unsupported",
                   version.releaseCode, version.majorVersion, version.minorVersion);
        break;
    }

    CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK);

    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
clLogSODsIdMapRecreate(ClUint32T  dsId,
                       ClAddrT    pBuffer,
                       ClUint32T  size,
                           ClPtrT      cookie)
{
    ClRcT                   rc        = CL_OK;
    ClBufferHandleT        msg            = CL_HANDLE_INVALID_VALUE;
    ClLogSOEoDataT         *pSoEoEntry    = NULL; 
    ClLogSvrCommonEoDataT  *pCommonEoData = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

    CL_LOG_PARAM_CHK((CL_LOG_SO_DSID_START != dsId),
                     CL_LOG_RC(CL_ERR_INVALID_PARAMETER));
    CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));

    rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, &pCommonEoData);
    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 = clBufferNBytesWrite(msg, (ClUint8T *) pBuffer, size); 
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        return rc;
    }

    rc = clXdrUnmarshallClUint32T(msg, &pSoEoEntry->dsIdCnt);
    if( CL_OK != rc )
    {
       CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));
       CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        return rc;
    }    
    CL_LOG_DEBUG_VERBOSE(("dsIdCnt : %d", pSoEoEntry->dsIdCnt));

    rc = clLogBitmapUnpack(msg, pSoEoEntry->hDsIdMap);

    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);

    CL_LOG_DEBUG_TRACE(("Exit: rc[0x %x]", rc));
    return rc;
}    
ClRcT
clLogMasterCompTableStateRecover(ClLogMasterEoDataT  *pMasterEoEntry,
                                 ClUint8T            *pBuffer,
                                 ClUint32T           dataSize)
{
    ClRcT            rc       = CL_OK;
    ClBufferHandleT  msg      = CL_HANDLE_INVALID_VALUE;
    ClUint32T versionCode = 0;

    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clBufferCreate(&msg);
    if(CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
        return rc;
    }
    rc = clBufferNBytesWrite(msg, pBuffer, dataSize);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        return rc;
    }

    rc = clXdrUnmarshallClUint32T(msg, &versionCode);
    if( CL_OK != rc)
    {
        CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[%#x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        return rc;
    }
    switch(versionCode)
    {

    case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION):
    {
        rc = compTableStateRecoverBaseVersion(msg);
    }
    break;

    default:
        clLogError("COMP", "TBL-RECOVER", "Version [%d.%d.%d] is not supported",
                   CL_VERSION_RELEASE(versionCode), CL_VERSION_MAJOR(versionCode),
                   CL_VERSION_MINOR(versionCode));
        rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH);
    }

    clBufferDelete(&msg);

    return rc;
}
ClRcT
clNameContextCkptDeserializer(ClUint32T   dsId,
                              ClAddrT     pBuffer,
                              ClUint32T   size,
                              ClPtrT cookie)
{
    ClRcT           rc    = CL_OK;
    ClBufferHandleT inMsg = 0;

    CL_NAME_DEBUG_TRACE(("Enter"));
    if( CL_NAME_CONTEXT_GBL_DSID != dsId )
    {        
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, 
                ("dsId is not proper\n"));
        return CL_NS_RC(CL_ERR_INVALID_PARAMETER);
    }    
    if( NULL == pBuffer )
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                 ("Passed Value is NULL"));
        return CL_NS_RC(CL_ERR_NULL_POINTER);
    }    
    rc = clBufferCreate(&inMsg);
    if( CL_OK != rc )
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, 
                  ("clBufferCreate() : rc[0x %x]", rc));
        return rc;
    }    
    rc = clBufferNBytesWrite(inMsg, (ClUint8T *)pBuffer, size); 
    if( CL_OK != rc )
    {
        clBufferDelete(&inMsg);
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                ("clBufferNBytesWrite(): rc[0x %x]", rc));
        return rc;
    }    
    rc = clNameContextCkptNameUnpack(inMsg);
    if( CL_OK != rc )
    {
        clBufferDelete(&inMsg);
        return rc;
    }    
    if( CL_OK != (rc = clBufferDelete(&inMsg)) ) 
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                ("clBufferDelete(): rc[0x %x]", rc));
    }    

    CL_NAME_DEBUG_TRACE(("Exit"));
    return rc;
}    
ClRcT clNodeCacheLeaderIocSend(ClIocNodeAddressT currentLeader, ClIocAddressT *dstAddr)
{
    ClRcT rc = CL_OK;
    ClIocSendOptionT sendOption = {CL_IOC_HIGH_PRIORITY,0,0,CL_IOC_PERSISTENT_MSG,200 };
    ClIocPhysicalAddressT compAddr = { CL_IOC_BROADCAST_ADDRESS,  CL_IOC_CPM_PORT };
    ClTimerTimeOutT delay = {  0,  200 };
    ClUint32T i = 0;
    ClBufferHandleT message = 0;
    ClEoExecutionObjT *eoObj = NULL;
    ClIocNotificationT notification;
    
    memset(&notification,0,sizeof(ClIocNotificationT));
    notification.protoVersion = htonl(CL_IOC_NOTIFICATION_VERSION);
    notification.id = (ClIocNotificationIdT) htonl(CL_IOC_NODE_ARRIVAL_NOTIFICATION);
    notification.nodeAddress.iocPhyAddress.nodeAddress = htonl(clIocLocalAddressGet());
    notification.nodeAddress.iocPhyAddress.portId = htonl(CL_IOC_GMS_PORT);

    clEoMyEoObjectGet(&eoObj);

    while(!eoObj && i++ <= 3)
    {
        clEoMyEoObjectGet(&eoObj);
        clOsalTaskDelay(delay);
    }

    if(!eoObj)
    {
        clLogWarning("CAP", "ARP", "Could not send current leader update since EO still uninitialized.");
        return CL_ERR_NOT_INITIALIZED;
    }

    clBufferCreate(&message);

    currentLeader = htonl(currentLeader);
    rc = clBufferNBytesWrite(message, (ClUint8T *)&notification, sizeof(ClIocNotificationT));
    rc |= clBufferNBytesWrite(message, (ClUint8T*)&currentLeader, sizeof(currentLeader));
    if (rc != CL_OK)
    {
        clLogError("CAP", "ARP", "clBufferNBytesWrite failed with rc = %#x", rc);
        clBufferDelete(&message);
        return rc;
    }

    rc = clIocSend(eoObj->commObj, message, CL_IOC_PORT_NOTIFICATION_PROTO, dstAddr, &sendOption);

    clBufferDelete(&message);

    return rc;

}
static ClRcT
clLogSvrStreamEntryRecreate(ClUint32T  dsId,
                            ClAddrT    pBuffer,
                            ClUint32T  buffSize,
                            ClPtrT     cookie)
{

    ClRcT                  rc                 = CL_OK;
    ClLogSvrEoDataT        *pSvrEoEntry       = NULL;
    ClBufferHandleT        inMsg              = CL_HANDLE_INVALID_VALUE;
    ClLogSvrCommonEoDataT  *pSvrCommonEoEntry = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

    CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER));

    rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry);
    if( CL_OK != rc )
    {
        return rc;
    }

    rc = clBufferCreate(&inMsg);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
        return rc;
    }
    rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);
        return rc;
    }

    rc = clLogSvrStreamEntryUnpackNAdd(pSvrEoEntry, pSvrCommonEoEntry, inMsg, dsId);
    if( CL_OK != rc )
    {
        CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);
        return rc;
    }

    CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK);

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
static void GetTimeAsyncCallback_4_0_0(ClRcT rc, void *pIdlCookie, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl)
{
    ClIdlCookieT* pCookie = (ClIdlCookieT*)pIdlCookie;
    ClRcT retVal = CL_OK;
    acTimeT_4_0_0  current;

    memset(&(current), 0, sizeof(acTimeT_4_0_0));


    if (CL_OK == rc)
    {
        retVal = clXdrUnmarshallacTimeT_4_0_0(outMsgHdl, &(current));
        if (CL_OK != retVal)
        {
            goto L0;
        }
    }

    if (rc != CL_OK)
    {
        retVal = rc;
    }
    clprintf(CL_LOG_SEV_INFO,"Get Time RPC Async [ From External App]: [%02d:%02d:%02d]",current.hour,current.minute,current.second);
    ((Alarm_clock_EOGetTimeAsyncCallbackT_4_0_0)(pCookie->actualCallback))(pCookie->handle, &(current), retVal, pCookie->pCookie);
    goto L1;

L1:

L0:  clHeapFree(pCookie);
     clBufferDelete(&outMsgHdl);
     return;
}
ClRcT clDebugResponseSend(ClRmdResponseContextHandleT responseHandle,
                          ClBufferHandleT *pOutMsgHandle,
                          ClCharT *respBuffer,
                          ClRcT retCode)
{
    ClRcT rc = CL_OK;
    ClBufferHandleT outMsgHandle = 0;
    if(!responseHandle)
        return CL_DEBUG_RC(CL_ERR_INVALID_PARAMETER);

    if(pOutMsgHandle)
    {
        outMsgHandle = *pOutMsgHandle;
        *pOutMsgHandle = 0;
    }
    rc = clDebugResponseMarshall(respBuffer, retCode, outMsgHandle);
    if(rc != CL_OK)
    {
        if(outMsgHandle)
        {
            if(clBufferDelete(&outMsgHandle) != CL_OK)
                clHeapFree((void*)outMsgHandle);
        }
        return rc;
    }
    rc = clRmdSyncResponseSend(responseHandle, outMsgHandle, retCode);
    return rc;
}
ClRcT
clLogClntStreamListUnpack(ClUint32T         numStreams,
                          ClUint32T         buffLen,
                          ClUint8T          *pBuffer,
                          ClLogStreamInfoT  **ppLogStreams)
{
    ClRcT            rc  = CL_OK;
    ClBufferHandleT  msg = CL_HANDLE_INVALID_VALUE;

    CL_LOG_DEBUG_TRACE(("Enter"));

    *ppLogStreams = clHeapCalloc(numStreams, sizeof(ClLogStreamInfoT));
    if( NULL == *ppLogStreams )
    {
        CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
        return CL_LOG_RC(CL_ERR_NO_MEMORY);
    }

    rc = clBufferCreate(&msg);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc));
        clHeapFree(*ppLogStreams);
        return rc;
    }
    rc = clBufferNBytesWrite(msg, pBuffer, buffLen);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        clHeapFree(*ppLogStreams);
        return rc;
    }

    rc = clLogClntStreamListGet(msg, *ppLogStreams);
    if( CL_OK != rc )
    {
        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        clHeapFree(*ppLogStreams);
        return rc;
    }

    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
   
    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
ClRcT clRmdReceiveAsyncReply(ClEoExecutionObjT *pThis,
                             ClBufferHandleT rmdRecvMsg,
                             ClUint8T priority, ClUint8T protoType,
                             ClUint32T length, ClIocPhysicalAddressT srcAddr)
{
    ClRmdPktT msg = {{ {0} }};
    ClRcT rc = CL_OK;
    ClRmdAckSendContextT sendContext = {0};
    ClUint32T size = 0;

    clRmdDumpPkt("received async reply", rmdRecvMsg);
    RMD_DBG4(("  RMD receive Async Reply\n"));

    rc = clBufferReadOffsetSet(rmdRecvMsg, 0, CL_BUFFER_SEEK_SET);
    rc = clRmdUnmarshallRmdHdr(rmdRecvMsg, &msg.ClRmdHdr, &size);
    if(rc != CL_OK)
    {
        clBufferDelete(&rmdRecvMsg);
        RMD_DBG3((" %s: Bad Message, rc 0x%x", __FUNCTION__, rc));
        return rc;
    }

    CL_RMD_VERSION_VERIFY(msg.ClRmdHdr, rc);
    if (rc != CL_OK)
    {
        clBufferDelete(&rmdRecvMsg);
        return CL_OK;
    }

    rc = rmdHandleAsyncReply(pThis, &msg, size, &srcAddr, priority, protoType,
                             rmdRecvMsg);

    sendContext.srcAddr = srcAddr;
    sendContext.priority = priority;
    sendContext.ClRmdHdr = msg.ClRmdHdr;
    rc = rmdAckSend(pThis,&sendContext);
    if(rc != CL_OK) {
      clLogTrace("ACK","ASYN","Error in rmdAckSend for async. rc = 0x%x.\n",rc);
    }

#if RMD_FILTER_CLEANUP
    clRMDCheckAndCallCommPortCleanup(pThis);
#endif
    return CL_OK;
}
static void clMsgGroupMembershipUpdateAsyncCallback_4_0_0(ClRcT rc, void *pIdlCookie, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl)
{
    ClIdlCookieT* pCookie = (ClIdlCookieT*)pIdlCookie;
    ClRcT retVal = CL_OK;
    ClMsgSyncActionT_4_0_0  syncAct;
    ClNameT  pGroupName;
    ClNameT  pQueueName;
    ClUint16T  updateCkpt;

    memset(&(syncAct), 0, sizeof(ClMsgSyncActionT_4_0_0));
    memset(&(pGroupName), 0, sizeof(ClNameT));
    memset(&(pQueueName), 0, sizeof(ClNameT));
    memset(&(updateCkpt), 0, sizeof(ClUint16T));


    retVal = clXdrUnmarshallClMsgSyncActionT_4_0_0(inMsgHdl, &(syncAct));
    if (CL_OK != retVal)
    {
        goto L0;
    }

    retVal = clXdrUnmarshallClNameT(inMsgHdl, &(pGroupName));
    if (CL_OK != retVal)
    {
        goto L1;
    }

    retVal = clXdrUnmarshallClNameT(inMsgHdl, &(pQueueName));
    if (CL_OK != retVal)
    {
        goto L2;
    }

    retVal = clXdrUnmarshallClUint16T(inMsgHdl, &(updateCkpt));
    if (CL_OK != retVal)
    {
        goto L3;
    }

    if (rc != CL_OK)
    {
        retVal = rc;
    }

    ((MsgIdlClMsgGroupMembershipUpdateAsyncCallbackT_4_0_0)(pCookie->actualCallback))(pCookie->handle, syncAct, &(pGroupName), &(pQueueName), updateCkpt, retVal, pCookie->pCookie);
    goto L4;

L4: 
L3: 
L2: 
L1: 

L0:  clHeapFree(pCookie);
     clBufferDelete(&outMsgHdl);
     return;
}
/*
 * Function - clLogStreamOwnerLocalCheckpoint()
 * - Do Local Checkpointing.
 * - If the dataset is not yet created, create the dataSet
 * - Write onto it.
 */
ClRcT
clLogStreamOwnerLocalCheckpoint(ClLogSOEoDataT         *pSoEoEntry,
                                SaNameT                *pStreamName,
                                SaNameT                *pStreamScopeNode,
                                ClLogStreamOwnerDataT  *pStreamOwnerData)
{
    ClRcT                  rc              = CL_OK;
    ClBufferHandleT     msg               = CL_HANDLE_INVALID_VALUE;
    ClLogSvrCommonEoDataT  *pCommonEoData = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData);
    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 = clLogStreamOwnerEntryPack(pStreamName, pStreamScopeNode, 
                                   pStreamOwnerData, msg);
    if( CL_OK != rc )
    {
        CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        return rc;
    }    
    rc = clCkptLibraryCkptDataSetWrite(pCommonEoData->hLibCkpt,
                                        (SaNameT *) &gSOLocalCkptName, 
                                        pStreamOwnerData->dsId,
                                        msg);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(( "clCkptLibraryCkptDataSetWrite(): rc[0x %x]", rc));
    }    
    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);
        
    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}    
ClRcT clCpmEventPayLoadExtract(ClEventHandleT eventHandle,
                               ClSizeT eventDataSize,
                               ClCpmEventTypeT cpmEventType,
                               void *payLoad)
{
    ClRcT rc = CL_OK;
    ClBufferHandleT payLoadMsg = 0;
    void *eventData = NULL;

    eventData = clHeapAllocate(eventDataSize);
    if (eventData == NULL)
    {
        clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_SEV_DEBUG, CL_CPM_CLIENT_LIB,
                   CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED);
        CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR, ("Unable to malloc \n"),
                         CL_CPM_RC(CL_ERR_NO_MEMORY));
    }
    rc = clEventDataGet (eventHandle, eventData,  &eventDataSize);
    if (rc != CL_OK)
    {
        clOsalPrintf("Event Data Get failed. rc=[0x%x]\n", rc);
        goto failure;
    }

    rc = clBufferCreate(&payLoadMsg);
    CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_BUF_CREATE_ERR, rc, rc,
                   CL_LOG_HANDLE_APP);
    rc = clBufferNBytesWrite(payLoadMsg, (ClUint8T *)eventData,
                             eventDataSize);
    CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_BUF_WRITE_ERR, rc, rc,
                   CL_LOG_HANDLE_APP);

    switch(cpmEventType)
    {
    case CL_CPM_COMP_EVENT:
        rc = VDECL_VER(clXdrUnmarshallClCpmEventPayLoadT, 4, 0, 0)(payLoadMsg, payLoad);
        CL_CPM_CHECK_0(CL_LOG_SEV_ERROR, CL_LOG_MESSAGE_0_INVALID_BUFFER, rc,
                       CL_LOG_HANDLE_APP);
        break;
    case CL_CPM_NODE_EVENT:
        rc = VDECL_VER(clXdrUnmarshallClCpmEventNodePayLoadT, 4, 0, 0)(payLoadMsg, payLoad);
        CL_CPM_CHECK_0(CL_LOG_SEV_ERROR, CL_LOG_MESSAGE_0_INVALID_BUFFER, rc,
                       CL_LOG_HANDLE_APP);
        break;
    default:
        clOsalPrintf("Invalid event type received.\n");
        goto failure;
        break;
    }

failure:
    clBufferDelete(&payLoadMsg);
    clHeapFree(eventData);
    return rc;
}
ClRcT clAmsMgmtCCBBatchFinalize(ClAmsMgmtCCBBatchHandleT *batchHandle)
{
    ClAmsMgmtCCBBatchT *batch = NULL;
    if(!batchHandle || !(batch = (ClAmsMgmtCCBBatchT*)*batchHandle))
        return CL_AMS_RC(CL_ERR_INVALID_PARAMETER);
    if(batch->buffer)
        clBufferDelete(&batch->buffer);
    clHeapFree(batch);
    *batchHandle = (ClAmsMgmtCCBBatchHandleT)0;
    return CL_OK;
}
static ClRcT amsMgmtCCBBatchBufferInitialize(ClAmsMgmtCCBBatchT *batch)
{
    ClRcT rc = CL_OK;

    if(batch->buffer)
    {
        rc |= clBufferDelete(&batch->buffer);
        if(rc != CL_OK)
            goto out;
        batch->buffer = 0;
    }
    rc |= clBufferCreate(&batch->buffer);
    if(rc != CL_OK)
        goto out;
    batch->items = 0;
    batch->version = CL_VERSION_CURRENT;
    clNodeCacheMinVersionGet(NULL, &batch->version);
    rc = clXdrMarshallClUint32T(&batch->version, batch->buffer, 0);
    if(rc != CL_OK)
    {
        goto out_free;
    }
    rc = clBufferWriteOffsetGet(batch->buffer, &batch->itemsOffset);
    if(rc != CL_OK)
    {
        goto out_free;
    }
    rc = clXdrMarshallClUint32T(&batch->items, batch->buffer, 0);
    if(rc != CL_OK)
    {
        goto out_free;
    }
    goto out;

    out_free:
    clBufferDelete(&batch->buffer);
    batch->buffer = 0;
 
    out:
    return rc;
}
ClRcT
clLogSOStreamEntryRecreate(ClUint32T  dsId,
                           ClAddrT    pBuffer,
                           ClUint32T  size,
                           ClPtrT     cookie)
{
    ClRcT                  rc              = CL_OK;
    ClBufferHandleT        msg            = CL_HANDLE_INVALID_VALUE;
    ClLogSvrCommonEoDataT  *pCommonEoData = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData);
    if( CL_OK != rc )
    {
        return rc;
    }    

    rc = clBufferCreate(&msg);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferCreate()"));
        return rc;
    }    
    rc = clBufferNBytesWrite(msg, (ClUint8T *) pBuffer, size);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc));
        clBufferDelete(&msg);
        return rc;
    }    
    rc = clLogSOStreamEntryUnpackNAdd(pCommonEoData, msg);

    CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK);

    if(CL_GET_ERROR_CODE(rc) == CL_ERR_DUPLICATE)
        rc = CL_OK;

    CL_LOG_DEBUG_TRACE(("Exit: rc[0x %x]", rc));
    return rc;
}
Example #20
0
/*
 * This function was added as additional cleanup is necessary
 * in the case of Async calls. This was done as a part of the
 * fix for BUG 4080. The in and out msg handles were not 
 * released at the time of finalize if the async callback
 * wasn't invoked.
 */
static void sendHashDestroyCallBack(ClCntKeyHandleT userKey,
                                   ClCntDataHandleT userData)
{
    ClRmdRecordSendT *rec = (ClRmdRecordSendT *) userData;

    if ((userData)&&(rec->flags & CL_RMD_CALL_ASYNC))
    {
        /*
         * The buffers must be deleted as the callback hasn't been
         * invoked. This is to avoid any leaks at the time of RMD
         * Finalize when responses are expected back. (BUG 4080)
         */
        if(rec->recType.asyncRec.sndMsgHdl)
            clBufferDelete(&(rec->recType.asyncRec.sndMsgHdl));
        if(rec->recType.asyncRec.outMsgHdl)
            clBufferDelete(&(rec->recType.asyncRec.outMsgHdl));        
    }
    
    
    sendHashDeleteCallBack(userKey,userData);
}
ClRcT clRmdReceiveAsyncRequest(ClEoExecutionObjT *pThis,
                               ClBufferHandleT rmdRecvMsg,
                               ClUint8T priority, ClUint8T protoType,
                               ClUint32T length, ClIocPhysicalAddressT srcAddr)
{
    ClRmdPktT msg = {{ {0} }};
    ClRcT rc = CL_OK;
    ClUint32T size = 0;
    
    clRmdDumpPkt("Received Async Req", rmdRecvMsg);
    RMD_DBG4(("  RMD receive Request\n"));

    rc = clBufferReadOffsetSet(rmdRecvMsg, 0, CL_BUFFER_SEEK_SET);
    rc = clRmdUnmarshallRmdHdr(rmdRecvMsg, &msg.ClRmdHdr, &size);
    if (rc != CL_OK)            /* read result is not ok */
    {
        clBufferDelete(&rmdRecvMsg);
        RMD_DBG3((" %s: Bad Message\n", __FUNCTION__));
        return CL_OK;
    }

    CL_RMD_VERSION_VERIFY(msg.ClRmdHdr, rc);
    if (rc != CL_OK)
    {
        clBufferDelete(&rmdRecvMsg);
        return CL_OK;
    }

    rc = rmdHandleAsyncRequest(pThis, &msg, &srcAddr, priority, protoType,
                               rmdRecvMsg);
    clBufferDelete(&rmdRecvMsg);
#if RMD_FILTER_CLEANUP
    clRMDCheckAndCallCommPortCleanup(pThis);
#endif

    return CL_OK;
}
/**
 * Internal function to unpack saved state of a transaction
 * from checkpoint
 */
static ClRcT _clTxnServiceCkptTxnUnpack(
    CL_IN   ClUint32T   dataSetId,
    CL_IN   ClAddrT     pData,
    CL_IN   ClUint32T   dataLen,
    CL_IN   ClPtrT      cookie)
{
    ClRcT                   rc = CL_OK;
    ClBufferHandleT  txnStateBuf;
    ClTxnDefnT              *pTxnDefn;

    CL_FUNC_ENTER();

    CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("To unpack data-set 0x%x\n", dataSetId));
    rc = clBufferCreate(&txnStateBuf);

    if (CL_OK == rc)
    {
        rc = clBufferNBytesWrite(txnStateBuf, (ClUint8T *)pData, dataLen);

        if (CL_OK == rc)
        {
            rc = clTxnStreamTxnCfgInfoUnpack(txnStateBuf, &pTxnDefn);
        }

        if ( (CL_OK == rc) &&
                ((pTxnDefn->serverTxnId.txnId + CL_TXN_CKPT_TXN_DATA_SET_ID_OFFSET) == dataSetId) )
        {
            /* Add this definition into txnDefnDb */
            rc = clTxnRecoverySessionUpdate (pTxnDefn);
        }
        else
        {
            if (CL_OK == rc)
                rc = CL_ERR_INVALID_PARAMETER;
        }

        rc = clBufferDelete(&txnStateBuf);

    }
    if (CL_OK != rc)
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                       ("Failed to extract transaction definition from data-set[0x%x], rc:0x%x", dataSetId, rc));
        rc = CL_GET_ERROR_CODE(rc);
    }

    CL_FUNC_EXIT();
    return (rc);
}
static void clMsgClientsTrackCallbackAsyncCallback_4_0_0(ClRcT rc, void *pIdlCookie, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl)
{
    ClIdlCookieT* pCookie = (ClIdlCookieT*)pIdlCookie;
    ClRcT retVal = CL_OK;
    ClHandleT  clientHandle;
    SaNameT  pGroupName;
    SaMsgQueueGroupNotificationBufferT_4_0_0  pNotification;

    memset(&(clientHandle), 0, sizeof(ClHandleT));
    memset(&(pGroupName), 0, sizeof(SaNameT));
    memset(&(pNotification), 0, sizeof(SaMsgQueueGroupNotificationBufferT_4_0_0));


    retVal = clXdrUnmarshallClHandleT(inMsgHdl, &(clientHandle));
    if (CL_OK != retVal)
    {
        goto L0;
    }

    retVal = clXdrUnmarshallSaNameT(inMsgHdl, &(pGroupName));
    if (CL_OK != retVal)
    {
        goto L1;
    }

    retVal = clXdrUnmarshallSaMsgQueueGroupNotificationBufferT_4_0_0(inMsgHdl, &(pNotification));
    if (CL_OK != retVal)
    {
        goto L2;
    }

    if (rc != CL_OK)
    {
        retVal = rc;
    }

    ((MsgCltClMsgClientsTrackCallbackAsyncCallbackT_4_0_0)(pCookie->actualCallback))(pCookie->handle, clientHandle, &(pGroupName), &(pNotification), retVal, pCookie->pCookie);
    goto L3;

L3: 
L2: 
L1: 

L0:  clHeapFree(pCookie);
     clBufferDelete(&outMsgHdl);
     return;
}
static void clMsgQDatabaseUpdateAsyncCallback_4_0_0(ClRcT rc, void *pIdlCookie, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl)
{
    ClIdlCookieT* pCookie = (ClIdlCookieT*)pIdlCookie;
    ClRcT retVal = CL_OK;
    ClMsgSyncActionT_4_0_0  syncupType;
    ClMsgQueueCkptDataT_4_0_0  queueData;
    ClUint16T  updateCkpt;

    memset(&(syncupType), 0, sizeof(ClMsgSyncActionT_4_0_0));
    memset(&(queueData), 0, sizeof(ClMsgQueueCkptDataT_4_0_0));
    memset(&(updateCkpt), 0, sizeof(ClUint16T));


    retVal = clXdrUnmarshallClMsgSyncActionT_4_0_0(inMsgHdl, &(syncupType));
    if (CL_OK != retVal)
    {
        goto L0;
    }

    retVal = clXdrUnmarshallClMsgQueueCkptDataT_4_0_0(inMsgHdl, &(queueData));
    if (CL_OK != retVal)
    {
        goto L1;
    }

    retVal = clXdrUnmarshallClUint16T(inMsgHdl, &(updateCkpt));
    if (CL_OK != retVal)
    {
        goto L2;
    }

    if (rc != CL_OK)
    {
        retVal = rc;
    }

    ((MsgIdlClMsgQDatabaseUpdateAsyncCallbackT_4_0_0)(pCookie->actualCallback))(pCookie->handle, syncupType, &(queueData), updateCkpt, retVal, pCookie->pCookie);
    goto L3;

L3: 
L2: 
L1: 

L0:  clHeapFree(pCookie);
     clBufferDelete(&outMsgHdl);
     return;
}
/**
 * Internal Function - extracts transaction-service state from checkpoint data-set
 */
static ClRcT _clTxnServiceCkptAppStateUnpack(
    CL_IN   ClUint32T   dataSetId,
    CL_IN   ClAddrT     pData,
    CL_IN   ClUint32T   dataLen,
    CL_IN   ClPtrT      cookie)
{
    ClRcT                   rc = CL_OK;
    ClBufferHandleT  txnStateMsgBuf;
    ClUint32T               txnIdCounter;

    CL_FUNC_ENTER();

    CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("To restore state of transaction-service\n"));

    rc = clBufferCreate(&txnStateMsgBuf);
    if (CL_OK == rc)
    {
        rc = clBufferNBytesWrite(txnStateMsgBuf, (ClUint8T *) pData, dataLen);

        if (CL_OK == rc)
        {
            rc = clXdrUnmarshallClUint32T(txnStateMsgBuf, &txnIdCounter);
        }

        if (CL_OK == rc)
        {
            CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Updating txnId Counter to 0x%x", txnIdCounter));
            clTxnServiceCfg->txnIdCounter = txnIdCounter;
        }

        if (CL_OK != rc)
        {
            CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                           ("Failed to restore transaction service state. Could result in inconsistent operation. rc:0x%x", rc));
            rc = CL_GET_ERROR_CODE(rc);
        }

        rc = clBufferDelete(&txnStateMsgBuf);

    }
    CL_FUNC_EXIT();
    return (rc);
}
Example #26
0
static void recvHashDeleteCallBack(ClCntKeyHandleT userKey,
                                   ClCntDataHandleT userData)
{
    ClRmdRecordRecvT *recvRecord = (ClRmdRecordRecvT *) userData;

    CL_FUNC_ENTER();


    if (userData)
    {
        if (recvRecord->msg)
        {
            clBufferDelete(&(recvRecord->msg));
        }
        clHeapFree((void *) userData);
    }

    CL_FUNC_EXIT();
}
static void _ckptSectionCheckAsyncCallback_5_0_0(ClRcT rc, void *pIdlCookie, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl)
{
    ClIdlCookieT* pCookie = (ClIdlCookieT*)pIdlCookie;
    ClRcT retVal = CL_OK;
    ClHandleT  ckptHandle;
    ClCkptSectionIdT_4_0_0  pSecId;

    memset(&(ckptHandle), 0, sizeof(ClHandleT));
    memset(&(pSecId), 0, sizeof(ClCkptSectionIdT_4_0_0));


    retVal = clXdrUnmarshallClHandleT(inMsgHdl, &(ckptHandle));
    if (CL_OK != retVal)
    {
        goto L0;
    }

    retVal = clXdrUnmarshallClCkptSectionIdT_4_0_0(inMsgHdl, &(pSecId));
    if (CL_OK != retVal)
    {
        goto L1;
    }

    if (rc != CL_OK)
    {
        retVal = rc;
    }

    ((CkptEo_ckptSectionCheckAsyncCallbackT_5_0_0)(pCookie->actualCallback))(pCookie->handle, ckptHandle, &(pSecId), retVal, pCookie->pCookie);
    goto L2;

L2: 
L1: 

L0:  clHeapFree(pCookie);
     clBufferDelete(&outMsgHdl);
     return;
}
static void clCkptLeaderAddrUpdateAsyncCallback_4_0_0(ClRcT rc, void *pIdlCookie, ClBufferHandleT inMsgHdl, ClBufferHandleT outMsgHdl)
{
    ClIdlCookieT* pCookie = (ClIdlCookieT*)pIdlCookie;
    ClRcT retVal = CL_OK;
    ClUint32T  masterAddr;
    ClUint32T  deputyAddr;

    memset(&(masterAddr), 0, sizeof(ClUint32T));
    memset(&(deputyAddr), 0, sizeof(ClUint32T));


    retVal = clXdrUnmarshallClUint32T(inMsgHdl, &(masterAddr));
    if (CL_OK != retVal)
    {
        goto L0;
    }

    retVal = clXdrUnmarshallClUint32T(inMsgHdl, &(deputyAddr));
    if (CL_OK != retVal)
    {
        goto L1;
    }

    if (rc != CL_OK)
    {
        retVal = rc;
    }

    ((CkptEoClCkptLeaderAddrUpdateAsyncCallbackT_4_0_0)(pCookie->actualCallback))(pCookie->handle, masterAddr, deputyAddr, retVal, pCookie->pCookie);
    goto L2;

L2: 
L1: 

L0:  clHeapFree(pCookie);
     clBufferDelete(&outMsgHdl);
     return;
}
ClRcT clAmsMgmtCCBBatchInitialize(ClAmsMgmtHandleT mgmtHandle, ClAmsMgmtCCBBatchHandleT *batchHandle)
{
    ClAmsMgmtCCBBatchT *batch = NULL;
    ClRcT rc = CL_OK;

    batch = clHeapCalloc(1, sizeof(*batch));
    CL_ASSERT(batch != NULL);

    rc = amsMgmtCCBBatchBufferInitialize(batch);
    if(rc != CL_OK)
        goto out_free;

    *batchHandle = (ClAmsMgmtCCBBatchHandleT)batch;
    goto out;

    out_free:
    if(batch->buffer)
        clBufferDelete(&batch->buffer);
    clHeapFree(batch);

    out:
    return rc;
}
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;
}