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; }
/** * 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; }
/* * This function shall change when the CPM has a devoted queue to handle the death & leave * Notifications. The pRecvParam shall be of use then for queuing. */ ClRcT clEoProcessIocRecvPortNotification(ClEoExecutionObjT* pThis, ClBufferHandleT eoRecvMsg, ClUint8T priority, ClUint8T protoType, ClUint32T length, ClIocPhysicalAddressT srcAddr) { ClRcT rc = CL_OK; ClIocNotificationT notificationInfo = {0}; ClUint32T msgLength = sizeof(ClIocNotificationT); ClIocNotificationIdT notificationId = 0; ClUint32T protoVersion = 0; CL_EO_LIB_VERIFY(); rc = clBufferNBytesRead(eoRecvMsg, (ClUint8T *)¬ificationInfo, &msgLength); if (rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("EO: clBufferNBytesRead() Failed, rc=[0x%x]\n", rc)); goto out_delete; } protoVersion = ntohl(notificationInfo.protoVersion); if(protoVersion != CL_IOC_NOTIFICATION_VERSION) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("EO: Ioc recv notification received with version [%d]. Supported [%d]\n", protoVersion, CL_IOC_NOTIFICATION_VERSION)); goto out_delete; } notificationId = ntohl(notificationInfo.id); switch(notificationId) { case CL_IOC_SENDQ_WM_NOTIFICATION: if(gIsNodeRepresentative == CL_FALSE) { CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Got sendq wm notification for non-node representative\n")); rc = CL_EO_RC(CL_ERR_BAD_OPERATION); goto out_delete; } /*fall through*/ case CL_IOC_COMM_PORT_WM_NOTIFICATION: { ClIocNodeAddressT nodeId = 0; ClIocPortT portId = ntohl(notificationInfo.nodeAddress.iocPhyAddress.portId); ClIocNodeAddressT nodeAddress = ntohl(notificationInfo.nodeAddress.iocPhyAddress.nodeAddress); CL_CPM_IOC_ADDRESS_SLOT_GET(nodeAddress,nodeId); rc = clEoIocWMNotification(CL_CID_IOC,portId,nodeId,¬ificationInfo); if (rc != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("EO: clEoIocWMNotification() Failed, rc=[0x%x]\n", rc)); goto out_delete; } } break; case CL_IOC_NODE_ARRIVAL_NOTIFICATION: case CL_IOC_NODE_LINK_UP_NOTIFICATION: case CL_IOC_COMP_ARRIVAL_NOTIFICATION: /* Need to add functionality if the components wants a specific operation...*/ clEoClientNotification(¬ificationInfo); rc = CL_OK; break; case CL_IOC_NODE_LEAVE_NOTIFICATION: case CL_IOC_NODE_LINK_DOWN_NOTIFICATION: case CL_IOC_COMP_DEATH_NOTIFICATION: rc = clBufferDelete(&eoRecvMsg); CL_ASSERT(rc == CL_OK); rc = clRmdDatabaseCleanup(pThis->rmdObj, ¬ificationInfo); clEoClientNotification(¬ificationInfo); return rc; default: CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Invalid notification id[%d]\n", notificationId)); rc = CL_EO_RC(CL_ERR_BAD_OPERATION); goto out_delete; } out_delete: clBufferDelete(&eoRecvMsg); 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; }