ClRcT _clTxnAgentAppendActiveJob(CL_IN   ClBufferHandleT  outMsg)
{
    ClRcT                   rc = CL_OK;
    ClTxnDefnT              *pTxnDefn;
    ClCntNodeHandleT        currTxnNode;
    ClCharT                 pOutMsg[1024];
    
    CL_FUNC_ENTER();
   
    rc = clCntFirstNodeGet(clTxnAgntCfg->activeTxnMap, &currTxnNode);
    
    while (rc == CL_OK)
    {
        ClCntNodeHandleT    nodeTxn;
        ClCntNodeHandleT    currJobNode;
        ClTxnAppJobDefnT    *pNewTxnJob;
        
        /* Retrieve data-node for node */
        rc = clCntNodeUserDataGet(clTxnAgntCfg->activeTxnMap, currTxnNode,
                                           (ClCntDataHandleT *)&pTxnDefn);
        if(CL_OK != rc)
        {
            clLogError("AGT", "CLI",
                    "User data get failed with error [0x%x]", rc);
            
            return rc;
        }
        
        rc = clCntFirstNodeGet(pTxnDefn->jobList, &currJobNode);
        
        while (rc == CL_OK)
        {
            ClCntNodeHandleT        nodeJob;
        
            /* Retrieve data-node for node */
            rc = clCntNodeUserDataGet(pTxnDefn->jobList, currJobNode,
                                           (ClCntDataHandleT *)&pNewTxnJob);
            pOutMsg[0] = '\0';
            sprintf(pOutMsg,
                    "   0x%x:0x%x\t|   0x%x\t|   %30s \n",
                    pTxnDefn->serverTxnId.txnMgrNodeAddress, pTxnDefn->serverTxnId.txnId,
                    pNewTxnJob->jobId.jobId, gCliTxnStatusStr[pNewTxnJob->currentState]);
 
            clXdrMarshallArrayClUint8T(&pOutMsg, strlen((char*)pOutMsg), outMsg, 0);
  
            nodeJob = currJobNode;
            rc = clCntNextNodeGet(pTxnDefn->jobList, nodeJob, &currJobNode);
        }
        
        nodeTxn = currTxnNode;
        rc = clCntNextNodeGet(clTxnAgntCfg->activeTxnMap, nodeTxn, &currTxnNode);
    }
    if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
        rc = CL_OK;

    CL_FUNC_EXIT();
    return(rc);
}
コード例 #2
0
ClRcT cpmInvocationGetWithLock(ClInvocationT invocationId,
                               ClUint32T *cbType,
                               void **data)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT cntNodeHandle = 0;
    ClCpmInvocationT *invocationData = NULL;

    /*
     * Check the input parameter 
     */
    if ((data == NULL) || (cbType == NULL))
        CL_CPM_CHECK(CL_LOG_SEV_ERROR, ("Invalid parameter passed \n"), CL_CPM_RC(CL_ERR_NULL_POINTER));

    rc = clCntNodeFind(gpClCpm->invocationTable, (ClCntKeyHandleT)&invocationId, &cntNodeHandle);
    if (rc != CL_OK)
        goto failure;

    rc = clCntNodeUserDataGet(gpClCpm->invocationTable, cntNodeHandle, (ClCntDataHandleT *) &invocationData);
    if (rc != CL_OK)
        goto failure;

    *data = invocationData->data;
    CL_CPM_INVOCATION_CB_TYPE_GET(invocationId, *cbType);

    return rc;

  failure:
    return rc;
}
ClRcT _clGmsDbFind(
           CL_IN    const ClGmsDbT*  const  gmsDb,
           CL_IN    const ClGmsDbTypeT     type,
           /* Suppressing coverity warning for pass by value with below comment */
           // coverity[pass_by_value]
           CL_IN    const ClGmsDbKeyT      key,
           CL_INOUT void** const           data)
{    
    ClRcT   rc = CL_OK;
    ClCntKeyHandleT cntKey = NULL;
    ClCntNodeHandleT nodeData = NULL;

    if (gmsDb == (const void *)NULL)
        return CL_ERR_NULL_POINTER;
    
    rc = _clGmsDbGetKey(type, key, &cntKey);

    if (rc != CL_OK) return rc;

    rc = clCntNodeFind(gmsDb->htbl[type], cntKey,
                       (ClCntNodeHandleT*) &nodeData);

    if (rc != CL_OK) return rc;

    rc = clCntNodeUserDataGet((ClCntHandleT) gmsDb->htbl[type],
                                    nodeData, (ClCntDataHandleT*)data);
    return rc;
}
コード例 #4
0
/*
 * Insert the class tab entry into the class id table.
 */
static ClRcT 
omClassEntryReload (ClCharT *pClassName, ClOmClassTypeT classId)
{
	ClRcT		rc = CL_OK;
    ClOmClassControlBlockT *pClassTab = NULL;
    ClCntNodeHandleT nodeHandle = 0;

    CL_FUNC_ENTER();

    if(!pClassName)
    {
        rc = CL_OM_SET_RC(CL_OM_ERR_NULL_PTR);
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("NULL PTR PASSED"));
        CL_FUNC_EXIT();
        return rc;
    }

	CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("OM entry reload for class = %s, class type %d", pClassName, classId));

    /*
     * First check if the class id entry is already present in the om class id table.
     */
    if(clCntNodeFind(ghOmClassHashTbl, (ClCntKeyHandleT)(ClWordT)classId, &nodeHandle) == CL_OK)
        return CL_OK;

	/* Add this class entry into the OM class lookup table */
	rc = clCntNodeFind(ghOmClassNameHashTbl, (ClCntKeyHandleT)pClassName, &nodeHandle);
	if (rc != CL_OK)
    {
		CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Unable to find OM Class name [%s] entry in om class table",
                                        pClassName));
		return (rc);
    }
    
    rc = clCntNodeUserDataGet(ghOmClassNameHashTbl, nodeHandle, (ClCntDataHandleT*)&pClassTab);
    if(rc != CL_OK)
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Unable to get data for OM Class [%s] from om class name table",
                                        pClassName));
        return rc;
    }

    /*
     * Insert this entry into the class id table.
     */
    pClassTab->eMyClassType = classId;

    rc = clCntNodeAdd(ghOmClassHashTbl, (ClCntKeyHandleT)(ClWordT)pClassTab->eMyClassType,
                      (ClCntDataHandleT)pClassTab, NULL);
    if(rc != CL_OK)
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Unable to add entry [%#x] for class [%s] to OM class id table",
                                        classId, pClassName));
        return rc;
    }

   	CL_FUNC_EXIT();
	return (rc);
}
static ClRcT
clLogSvrSOFGResponseProcess(ClLogFilterT  *pStreamFilter,
                            ClPtrT        pCookie)
{
    ClRcT                  rc                 = CL_OK;
    ClLogSvrEoDataT        *pSvrEoEntry       = NULL;
    ClCntNodeHandleT       hStreamOwnerNode   = (ClCntNodeHandleT) pCookie;
    ClLogSvrStreamDataT    *pStreamData       = NULL;
    ClLogSvrCommonEoDataT  *pSvrCommonEoEntry = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

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

    rc = clOsalMutexLock_L(&pSvrEoEntry->svrStreamTableLock);
    if( CL_OK != rc )
    {
        return rc;
    }

    rc = clCntNodeUserDataGet(pSvrEoEntry->hSvrStreamTable, hStreamOwnerNode,
                              (ClCntDataHandleT *) &pStreamData);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK);
        return rc;
    }

    rc = clLogServerStreamMutexLock(pStreamData);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clOsalMutexLock(): rc[0x %x]\n", rc));
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK);
        return rc;
    }
    CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK);

    /*
     * Log Server will not intimate the client about this filter update,
     * as it is recreating the state for itself and filter may or may
     * not have been updated during that transient period.
     */
    rc = clLogFilterAssign(pStreamData->pStreamHeader, pStreamFilter);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clLogFilterAssign(): rc[0x %x]\n", rc));
    }

    CL_LOG_CLEANUP(clLogServerStreamMutexUnlock(pStreamData),CL_OK);

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
ClRcT _clCorNodeNameToMoIdGet(ClNameT *nodeName, ClCorNodeDataPtrT *dataNode)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT nodeHandle = 0;
    ClNameT *tempName = NULL;

	if(nodeName == NULL)
		return CL_COR_SET_RC(CL_COR_ERR_NULL_PTR);

    /* Get the data from the hash table */

    CL_DEBUG_PRINT(CL_DEBUG_TRACE,(" Node find for node Name  %s", nodeName->value));

    /* Do the node find and get the node handle for a particular node name. Now walk all the 
     * node for that particular node handle type.
     */
    rc = clCntNodeFind(nodeNameToMoIdTableHandle, (ClCntKeyHandleT)nodeName, &nodeHandle);   
    if(CL_OK != rc)
    {
        CL_DEBUG_PRINT(CL_DEBUG_TRACE,("Failed to get the node Handle for the Node Name %s. rc [0x%x]", nodeName->value, rc));
        return rc;
    }

    while(nodeHandle != 0)
    {
        rc = clCntNodeUserKeyGet(nodeNameToMoIdTableHandle, nodeHandle, (ClCntKeyHandleT *) &tempName);
        if (rc != CL_OK)
        {
            CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Failed to get the user key from the node handle. rc[0x%x]", rc));
            break;
        }

        CL_DEBUG_PRINT(CL_DEBUG_TRACE,("Got the Nodename %s", tempName->value));
        rc = clCntNodeUserDataGet(nodeNameToMoIdTableHandle, nodeHandle, (ClCntDataHandleT *)dataNode);
        if(rc != CL_OK)
        {
            CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Failed to get the user data from the node handle. rc [0x%x]", rc));
            break;
        }

        if((strcmp (nodeName->value, (*dataNode)->nodeName.value)) == 0)
        {
            CL_DEBUG_PRINT(CL_DEBUG_TRACE,("Got the MoId for a Node Name %s", (*dataNode)->nodeName.value));
            return CL_OK;
        } 
        
        rc = clCntNextNodeGet(nodeNameToMoIdTableHandle, nodeHandle, &nodeHandle);  
        if(rc != CL_OK)
        {
            CL_DEBUG_PRINT(CL_DEBUG_TRACE,("Failed to get the next node handle. rc[0x%x]", rc));
            break;
        }
    }

    if(CL_OK != rc)
        CL_COR_RETURN_ERROR(CL_DEBUG_TRACE, "Could not get MOId from the node name", rc);    
    return CL_OK;
}
コード例 #7
0
ClRcT cpmNodeFindLocked(SaUint8T *name, ClCpmLT **cpmL)
{
    ClUint16T nodeKey = 0;
    ClCntNodeHandleT hNode = 0;
    ClCpmLT *tempNode = NULL;
    ClUint32T rc = CL_OK, numNode=0;

    rc = clCksm16bitCompute((ClUint8T *) name, strlen((const ClCharT*)name), &nodeKey);
    CL_CPM_CHECK_2(CL_LOG_SEV_ERROR, CL_CPM_LOG_2_CNT_CKSM_ERR, name, rc, rc,
                   CL_LOG_HANDLE_APP);

    rc = clCntNodeFind(gpClCpm->cpmTable, (ClPtrT)(ClWordT)nodeKey, &hNode);
    CL_CPM_CHECK_3(CL_LOG_SEV_ERROR, CL_CPM_LOG_3_CNT_ENTITY_SEARCH_ERR, "node",
                   name, rc, rc, CL_LOG_HANDLE_APP);

    rc = clCntKeySizeGet(gpClCpm->cpmTable, (ClPtrT)(ClWordT)nodeKey,
                         &numNode);
    CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_CNT_KEY_SIZE_GET_ERR, rc, rc,
                   CL_LOG_HANDLE_APP);

    while (numNode > 0)
    {
        rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode,
                                  (ClCntDataHandleT *) &tempNode);
        CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_CNT_NODE_USR_DATA_GET_ERR,
                       rc, rc, CL_LOG_HANDLE_APP);
        if (!strcmp(tempNode->nodeName, (const ClCharT*)name))
        {
            *cpmL = tempNode;
            goto done;
        }
        if(--numNode)
        {
            rc = clCntNextNodeGet(gpClCpm->cpmTable,hNode,&hNode);
            if(rc != CL_OK)
            {
                break;
            }
        }
    }

    rc = CL_CPM_RC(CL_ERR_DOESNT_EXIST);
    CL_CPM_CHECK_3(CL_LOG_SEV_ERROR, CL_CPM_LOG_3_CNT_ENTITY_SEARCH_ERR,
                   "node", name, rc, rc, CL_LOG_HANDLE_APP);

done:
    return CL_OK;

failure:
    return rc;
}
/**
 *  Returns an OM class entry.
 *
 *  This function returns a pointer to an OM class entry given 
 * OM class Id.
 *                                                                        
 *  @param omClassKey - OM class type
 *
 *  @returns 
 *    Pointer to class control block
 */
ClOmClassControlBlockT *
clOmClassEntryGet(ClOmClassTypeT omClassKey)
{
	ClRcT			rc = CL_OK;
#ifdef CL_DEBUG
	ClUint8T		aFuncName[] = "clOmClassEntryGet()";
#endif
	ClCntNodeHandleT tempNodeHandle = 0;
	ClOmClassControlBlockT 		*pClassEntry = 0;

    CL_FUNC_ENTER();

	if ((rc = omClassTypeValidate(omClassKey)) != CL_OK)
	{
		CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Invalid input OM class (rc = 0x%x)!\r\n", 
			aFuncName, rc));
		CL_ASSERT(NULL);
		CL_FUNC_EXIT();
		return NULL;
	}

	/* find the node for this MO ID */
	if ((rc = clCntNodeFind(ghOmClassHashTbl, 
		(ClCntKeyHandleT)(ClWordT)omClassKey, &tempNodeHandle)) != CL_OK)
		{
		if (CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
			{
			CL_DEBUG_PRINT(CL_DEBUG_INFO, ("%s: Node does not exist for OM class "
				"(0x%x), with rc 0x%x!\r\n", aFuncName, omClassKey, rc));
			}
		else
			{
			CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to find node for OM class "
				"(0x%x), with rc 0x%x!\r\n", aFuncName, omClassKey, rc));
			}
		return NULL;
		}
	/* now get the OM handle for this MO ID */
	if ((rc = clCntNodeUserDataGet(ghOmClassHashTbl, 
		tempNodeHandle, (ClCntDataHandleT *)&pClassEntry)) != CL_OK)
		{
		CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to get the OM class entry from the "
			"node for OM class 0x%x, with rc 0x%x!\r\n", aFuncName, 
			omClassKey, rc));
		CL_ASSERT(NULL);
		return  NULL;
		}
 	
   	return pClassEntry;
}
ClRcT _clTxnAgentAppendServices(CL_IN   ClBufferHandleT  outMsg)
{
    ClRcT                   rc = CL_OK;
    ClTxnAgentCompServiceInfoT  *pCompInstance;
    ClCntNodeHandleT        currNode;
    ClCharT                 pOutMsg[1024];
    
    CL_FUNC_ENTER();
   
    rc = clCntFirstNodeGet(clTxnAgntCfg->compServiceMap, &currNode);
    
    while (rc == CL_OK)
    {
        ClCntNodeHandleT        node;
        /* Retrieve data-node for node */
        rc = clCntNodeUserDataGet(clTxnAgntCfg->compServiceMap, currNode,
                                       (ClCntDataHandleT *)&pCompInstance);
        if(CL_OK != rc)
        {
            clLogError("AGT", "CLI",
                    "User data get failed with error [0x%x]", rc);
            return rc;
        }

         pOutMsg[0] = '\0';

        if(pCompInstance->serviceCapability == CL_TXN_AGENT_SERVICE_2PC)
        {
            sprintf(pOutMsg,
                    "   %6d\t|   2PC Capable  \n",
                    pCompInstance->serviceType);
        }
        else if(pCompInstance->serviceCapability == CL_TXN_AGENT_SERVICE_1PC)
        {
            sprintf(pOutMsg,
                    "   %6d\t|   1PC Capable  \n",
                    pCompInstance->serviceType);
        }

        clXdrMarshallArrayClUint8T(&pOutMsg, strlen((char*)pOutMsg), outMsg, 0);
        
        node = currNode;
        rc = clCntNextNodeGet(clTxnAgntCfg->compServiceMap, node, &currNode);
    }
    if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
        rc = CL_OK;
    
    CL_FUNC_EXIT();
    return(rc);
}
コード例 #10
0
ClUint32T cpmNodeFindByNodeId(ClUint32T nodeId, ClCpmLT **cpmL)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT cpmNode = 0;
    ClUint32T cpmLCount = 0;
    ClCpmLT *tempCpmL = NULL;
    ClUint32T found = 0;

    cpmLCount = gpClCpm->noOfCpm;
    if (gpClCpm->pCpmConfig->cpmType == CL_CPM_GLOBAL && cpmLCount != 0)
    {
        rc = clCntFirstNodeGet(gpClCpm->cpmTable, &cpmNode);
        CL_CPM_CHECK_2(CL_LOG_SEV_ERROR, CL_CPM_LOG_2_CNT_FIRST_NODE_GET_ERR, "CPM-L", rc, rc, CL_LOG_HANDLE_APP);

        while (cpmLCount)
        {
            rc = clCntNodeUserDataGet(gpClCpm->cpmTable, cpmNode, (ClCntDataHandleT *) &tempCpmL);
            CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_CNT_NODE_USR_DATA_GET_ERR, rc, rc, CL_LOG_HANDLE_APP);

            if (tempCpmL->pCpmLocalInfo)
            {
                if ((ClUint32T) tempCpmL->pCpmLocalInfo->nodeId == nodeId)
                {
                    *cpmL = tempCpmL;
                    found = 1;
                    break;
                }
            }
            cpmLCount--;

            if (cpmLCount)
            {
                rc = clCntNextNodeGet(gpClCpm->cpmTable, cpmNode, &cpmNode);
                CL_CPM_CHECK_2(CL_LOG_SEV_ERROR, CL_CPM_LOG_2_CNT_NEXT_NODE_GET_ERR, "CPM-L", rc, rc, CL_LOG_HANDLE_APP);
            }
        }
    }
    if(found == 1)
        return CL_OK;
    else
        return CL_CPM_RC(CL_ERR_DOESNT_EXIST);

  failure:
    *cpmL = NULL;
    return rc;
}
ClRcT clCntNonUniqueKeyFind(ClCntHandleT container, ClCntKeyHandleT key, ClCntDataHandleT givenData,
                            ClInt32T (*cmp)(ClCntDataHandleT data1, ClCntDataHandleT data2), 
                            ClCntDataHandleT *pDataHandle)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT node = 0;
    ClCntNodeHandleT nextNode = 0;
    ClCntDataHandleT data = 0;
    ClUint32T sz = 0;

    if(!container || !key || !givenData || !cmp || !pDataHandle)
        return CL_CNT_RC(CL_ERR_INVALID_PARAMETER);

    *pDataHandle = 0;

    rc = clCntNodeFind(container, key, &node);
    if(rc != CL_OK) return rc;

    rc = clCntKeySizeGet(container, key, &sz);
    if(rc != CL_OK) return rc;
    
    while(sz-- > 0 && node)
    {
        rc = clCntNodeUserDataGet(container, node, &data);
        if(rc != CL_OK)
            return rc;
        nextNode = 0;
        if(sz > 0)
        {
            rc = clCntNextNodeGet(container, node, &nextNode);
            if(rc != CL_OK)
                nextNode = 0;
        }
        if(!cmp(givenData, data))
        {
            *pDataHandle = data;
            return CL_OK;
        }
        node = nextNode;
    }
    
    return CL_CNT_RC(CL_ERR_NOT_EXIST);
}
コード例 #12
0
ClRcT  _clGmsDbGetFirst(
            CL_IN    const ClGmsDbT* const    gmsDb,
            CL_IN    const ClGmsDbTypeT       type,
            CL_OUT   ClCntNodeHandleT** const gmsOpaque,
            CL_INOUT void** const             data)
{
    ClRcT   rc = CL_OK;

    /* Get the first node which is an internal pointer
     * to the container data structure.
     */
    if ((gmsDb == (const void *)NULL) || (data == NULL) || (gmsOpaque == NULL))
    {
        return CL_ERR_NULL_POINTER;
    }

    rc = clCntFirstNodeGet((ClCntHandleT) gmsDb->htbl[type],
                            (ClCntNodeHandleT*) gmsOpaque);

    if (rc ==  CL_CNT_RC(CL_ERR_NOT_EXIST))
    {
        *data = NULL;
        return CL_OK;
    }

    if (rc != CL_OK) return rc;

    /* Get the real data 
     */

    rc = clCntNodeUserDataGet((ClCntHandleT) gmsDb->htbl[type],
                                    (ClCntNodeHandleT)*gmsOpaque,
                                    (ClCntDataHandleT*)(data));

    if (rc ==  CL_CNT_RC(CL_ERR_NOT_EXIST))
    {
        *data = NULL;
        return CL_OK;
    }

    return rc;
}
コード例 #13
0
ClRcT   _clGmsNameIdDbFind(ClCntHandleT  *dbPtr,
                           ClNameT       *name,
                           ClGmsGroupIdT *id)
{
    ClRcT   rc = CL_OK;
    ClGmsDbKeyT key = {{0}};
    ClCntKeyHandleT cntKey = NULL;
    ClCntNodeHandleT nodeData = NULL;
    ClGmsNodeIdPairT*   node = NULL;

    if (dbPtr == NULL)
    {
        return CL_ERR_NULL_POINTER;
    }

    memcpy(&key.name, name, sizeof(ClNameT));
    rc = _clGmsDbGetKey(CL_GMS_NAME_ID_DB, key, &cntKey);

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

    rc = clCntNodeFind(*dbPtr, cntKey, (ClCntNodeHandleT*) &nodeData);

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

    rc = clCntNodeUserDataGet(*dbPtr,
            nodeData, (ClCntDataHandleT*)&node);

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

    *id =node->groupId;
    return rc;
}
コード例 #14
0
ClRcT cpmInvocationDeleteInvocation(ClInvocationT invocationId)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT cntNodeHandle = 0;
    ClCpmInvocationT *invocationData = NULL;

    clOsalMutexLock(gpClCpm->invocationMutex);

    rc = clCntNodeFind(gpClCpm->invocationTable,
                       (ClCntKeyHandleT)&invocationId, &cntNodeHandle);
    if (rc != CL_OK)
        goto withLock;

    rc = clCntNodeUserDataGet(gpClCpm->invocationTable, cntNodeHandle,
                              (ClCntDataHandleT *) &invocationData);
    if (rc != CL_OK)
        goto withLock;

    rc = clCntNodeDelete(gpClCpm->invocationTable, cntNodeHandle);
    if (rc != CL_OK)
        goto withLock;

    if( (invocationData->flags & CL_CPM_INVOCATION_DATA_COPIED))
    {
        clHeapFree(invocationData->data);
    }

    clHeapFree(invocationData);

    clOsalMutexUnlock(gpClCpm->invocationMutex);

    clLogDebug("INVOCATION", "DEL", "Deleted invocation [%#llx]", invocationId);

    return rc;

  withLock:
    clOsalMutexUnlock(gpClCpm->invocationMutex);
    return rc;
}
コード例 #15
0
ClRcT   _clGmsDbGetNext(
            CL_IN       const ClGmsDbT*    const   gmsDb,
            CL_IN       const ClGmsDbTypeT         type,
            CL_INOUT    ClCntNodeHandleT** const   gmsOpaque,
            CL_OUT      void**             const   data)
{
    ClRcT   rc = CL_OK;
    ClCntNodeHandleT    *gmsOldOpaque = NULL;   

    if ((gmsDb == (const void *)NULL) || (data == NULL) || (gmsOpaque == NULL))
    {
        return CL_ERR_NULL_POINTER;
    }

    gmsOldOpaque = *gmsOpaque;

    rc = clCntNextNodeGet(gmsDb->htbl[type], (ClCntNodeHandleT) gmsOldOpaque, 
                                                (ClCntNodeHandleT*)gmsOpaque);

    if (rc ==  CL_CNT_RC(CL_ERR_NOT_EXIST))
    {
        *data = NULL;
        return CL_OK;
    }

    if (rc != CL_OK) return rc;

    rc = clCntNodeUserDataGet((ClCntHandleT) gmsDb->htbl[type],
                                         (ClCntNodeHandleT)*gmsOpaque,
                                            (ClCntDataHandleT*)(data));

    if (rc ==  CL_CNT_RC(CL_ERR_NOT_EXIST))
    {
        *data = NULL;
        return CL_OK;
    }

    return rc;
}
ClRcT
clCntDataForKeyGet(ClCntHandleT      containerHandle,
                   ClCntKeyHandleT   userKey,
                   ClCntDataHandleT  *pUserData)
{
  ClCntNodeHandleT  containerNode = CL_HANDLE_INVALID_VALUE;
  CclContainer_t    *pContainer   = NULL;
  ClRcT             errorCode     = CL_OK;

  nullChkRet(pUserData);
  *pUserData = CL_HANDLE_INVALID_VALUE;

  pContainer = (CclContainer_t *) containerHandle;
  nullChkRet(pContainer);
  if(pContainer->validContainer != CONTAINER_ID)
  {
    returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid");
  }

  if(pContainer->isUniqueFlag == 0) 
  {
      returnCntError(CL_ERR_NOT_IMPLEMENTED,
              "This feature is not applicaple for non unique container");
  }

  errorCode = clCntNodeFind(containerHandle, userKey, &containerNode);
  if(errorCode != CL_OK)
  {
      returnCntError(CL_ERR_NOT_EXIST, "Key doesn't exist");
  }

  errorCode = clCntNodeUserDataGet(containerHandle, containerNode, pUserData);
  if(errorCode != CL_OK)
  {
    return(errorCode);
  }

  return(CL_OK);
}
/*
 * Function - clLogStreamOwnerCheckpoint()
 *  - Based on scope , Checkpoint the data
 */
ClRcT
clLogStreamOwnerCheckpoint(ClLogSOEoDataT     *pSoEoEntry,
                           ClLogStreamScopeT  streamScope,
                           ClCntNodeHandleT   hStreamOwnerNode,
                           ClLogStreamKeyT    *pStreamKey)
{
    ClRcT             rc         = CL_OK;
    ClCntHandleT          hStreamTable      = CL_HANDLE_INVALID_VALUE;
    ClLogStreamOwnerDataT *pStreamOwnerData = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

    hStreamTable = (CL_LOG_STREAM_GLOBAL == streamScope)
        ? pSoEoEntry->hGStreamOwnerTable 
        : pSoEoEntry->hLStreamOwnerTable ;
    rc = clCntNodeUserDataGet(hStreamTable, hStreamOwnerNode, 
                              (ClCntDataHandleT *) &pStreamOwnerData);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_TRACE(("clCntNodeFind(): rc[0x %x]", rc));
        return rc;
    }    
    if( CL_LOG_STREAM_GLOBAL == streamScope )
    {
        clLogStreamOwnerGlobalCheckpoint(pSoEoEntry, &pStreamKey->streamName,
                                         &pStreamKey->streamScopeNode, 
                                         pStreamOwnerData);
    }    
    else
    {
        clLogStreamOwnerLocalCheckpoint(pSoEoEntry, &pStreamKey->streamName,
                                        &pStreamKey->streamScopeNode,
                                        pStreamOwnerData);
    }    

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}    
ClRcT
clLogStreamDataDump(ClHandleDatabaseHandleT  hDb,
                    ClLogStreamHandleT       hStream,
                    ClPtrT                   pCookie)
{
    ClRcT                   rc            = CL_OK;
    ClLogStreamHandleDataT  *pData        = NULL;
    ClLogClntStreamDataT    *pStreamInfo  = NULL;
    ClLogClntEoDataT        *pClntEoEntry = NULL;
    ClCharT                 **ppRet       = (ClCharT**) pCookie;
    ClCharT                 ret[MAX_DEBUG_DISPLAY];
    ClCharT                 p[MAX_DEBUG_DISPLAY];


    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clLogClntEoEntryGet(&pClntEoEntry);
    if( CL_OK != rc )
    {
        return rc;
    }

    rc = clHandleCheckout(hDb, hStream, (void **) (&pData));
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clHandleCheckout(): rc[0x %x]", rc));
        return rc;
    }

    memset(ret, '\0', MAX_DEBUG_DISPLAY);
    memset(p, '\0', MAX_DEBUG_DISPLAY);
    
    if( CL_LOG_STREAM_HANDLE == pData->type )
    {
        snprintf(ret, MAX_DEBUG_DISPLAY, "Stream handle: %#llX\nStreamNode: %p\n",
                hStream, (ClPtrT) pData->hClntStreamNode);

        
        rc = clCntNodeUserDataGet(pClntEoEntry->hClntStreamTable,
                                  pData->hClntStreamNode,
                                  (ClCntDataHandleT *) &pStreamInfo);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));
            return rc;
        }

        snprintf(p,MAX_DEBUG_DISPLAY, "Stream Header: %p\n",
                (ClCharT *) pStreamInfo->pStreamHeader);
        strncat(ret, p, CL_MIN(strlen(p), (MAX_DEBUG_DISPLAY-strlen(ret)-1)));

        snprintf(p,MAX_DEBUG_DISPLAY, "Shm Name: %.*s", pStreamInfo->shmName.length,
                pStreamInfo->shmName.pValue);
        strncat(ret, p, CL_MIN(strlen(p), (MAX_DEBUG_DISPLAY-strlen(ret)-1)));
        
        rc = clHandleCheckin(hDb, hStream);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clHandleCheckin(): rc[0x %x]", rc));
            return rc;
        }

        *ppRet = (ClCharT*) clHeapAllocate(strlen(ret) + 1);
        if( NULL == *ppRet )
        {
            CL_LOG_DEBUG_ERROR(("clHeapAllocate(): rc[0x %x]", rc));
            return rc;
        }

        snprintf(*ppRet, strlen(ret)+1, ret);
    }

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
ClRcT
clLogHandlerDataDump(ClHandleDatabaseHandleT hDb, ClStreamHandleT hHandler,
                    void *pCookie)
{
    ClRcT                   rc            = CL_OK;
    ClLogHandlerHandleDataT *pData        = NULL;
    ClLogClntHandlerNodeT   *pHandlerInfo = NULL;
    ClLogClntEoDataT        *pClntEoEntry = NULL;
    ClUint32T               bitmapLen     = 0;
    ClCharT                 s[256];

    CL_LOG_DEBUG_TRACE(("Enter"));

    rc = clLogClntEoEntryGet(&pClntEoEntry);
    if( CL_OK != rc )
    {
        return rc;
    }

    rc = clHandleCheckout(hDb, hHandler, (void **) (&pData));
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clHandleCheckout(): rc[0x %x]", rc));
        return rc;
    }

    if( CL_LOG_HANDLER_HANDLE == pData->type )
    {
        CL_LOG_DEBUG_TRACE(("Handler handle: %d\nInit handle: %d"
                            " Handler Flag%d\n" , hStream,
                            pData->hLog, pData->handlerFlags));


        rc = clCntNodeUserDataGet(pClntEoEntry->hStreamHandlerTable,
                                  pData->hClntHandlerNode,
                                  (ClCntDataHandleT *) &pHandlerInfo);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));
            return rc;
        }

        sprintf(s, pHandlerInfo->streamName.length, "%s",
                pHandlerInfo->streamName.value);
        CL_LOG_DEBUG_TRACE(("Stream Name: %s\n", s));

        sprintf(s, pHandlerInfo->nodeName.length, "%s",
                pHandlerInfo->nodeName.value);
        CL_LOG_DEBUG_TRACE(("Node Name: %s\n", s));

        bitmapLen = clBitmapLen(pStreamInfo->hStreamBitmap);
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clBitmapLen(): rc[0x %x]", rc));
            return rc;
        }

        CL_LOG_DEBUG_TRACE(("hStreamBitmap:\n"));

        for( i = 0; i < bitmapLen; i++ )
        {
            if( clBitmapIsBitSet(pData->hStreamBitmap, i, &rc) )
            {
                CL_LOG_DEBUG_TRACE(("%d ", 1));
            }
            else
            {
                CL_LOG_DEBUG_TRACE(("%d ", 0));
            }
        }

    }

    rc = clHandleCheckin(hDb, hStream);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clHandleCheckin(): rc[0x %x]", rc));
        return rc;
    }

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
static ClRcT
__clCntWalk(ClCntHandleT        containerHandle,
            ClCntWalkCallbackT  fpUserWalkCallback,
            ClCntArgHandleT     userDataArg,
            ClInt32T            dataLength,
            ClBoolT failSafe)
{
    CclContainer_t       *pContainer   = NULL;
    ClCntNodeHandleT     containerNode = CL_HANDLE_INVALID_VALUE;
    ClCntNodeHandleT     nextContainerNode = CL_HANDLE_INVALID_VALUE;
    ClCntDataHandleT     userData      = CL_HANDLE_INVALID_VALUE;
    ClCntKeyHandleT      userKey       = CL_HANDLE_INVALID_VALUE;
    BaseLinkedListNode_t *pTemp        = NULL;
    ClRcT                errorCode     = CL_OK;
 
    nullChkRet(fpUserWalkCallback);

    pContainer = (CclContainer_t *) containerHandle;
    nullChkRet(pContainer);

    if(pContainer->validContainer != CONTAINER_ID)
    {
        returnCntError(CL_ERR_INVALID_HANDLE, "Passed container handle is invalid");
    }
  
    errorCode = clCntFirstNodeGet (containerHandle, &containerNode);
    if(errorCode != CL_OK)
    { 
        if((CL_GET_ERROR_CODE(errorCode)) == CL_ERR_NOT_EXIST) 
        {
            /* If the container is empty it means we dont have to walk anymore.
             * Hence return OK.
             */
            return (CL_OK);
        }
        return(errorCode);	  
    }

    while (containerNode)
    {
        pTemp = (BaseLinkedListNode_t*) containerNode;
        if(clCntNextNodeGet(containerHandle, containerNode, &nextContainerNode) != CL_OK)
        {
            nextContainerNode = 0;
        }
        if ((pTemp->pRbeExpression == NULL) || (clRuleExprEvaluate(pTemp->pRbeExpression, (ClUint32T*) userDataArg, dataLength)))
        {
            errorCode = clCntNodeUserKeyGet (containerHandle, containerNode, &userKey);
            errorCode = clCntNodeUserDataGet (containerHandle, containerNode, &userData);
  
            errorCode = fpUserWalkCallback(userKey, userData, userDataArg,dataLength);
            if(!failSafe && (CL_OK != errorCode))
            {
                return (errorCode);
            }
        }
        containerNode = nextContainerNode;
    }

    return(CL_OK);
}
static ClRcT rmdSendTimerFunc(void *pData)
{
    ClCntNodeHandleT    nodeHandle;
    ClRmdRecordSendT    *rec         = NULL;
    ClRcT               rc;
    ClRcT               retCode      = 0;
    ClRmdObjT           *pRmdObject;
    ClRmdAsyncCallbackT fpTempPtr;
    void                *cookie;
    ClBufferHandleT     outMsgHdl;
    ClEoExecutionObjT   *pThis       = NULL;
    ClUint64T           msgId        = (ClUint32T)(ClWordT) pData;

    CL_FUNC_ENTER();
    if (pData == NULL)
    {
        return (CL_RMD_RC(CL_ERR_INVALID_BUFFER));
    }
    rc = clEoMyEoObjectGet(&pThis);

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

    pRmdObject = (ClRmdObjT *) (pThis->rmdObj);
    if (pRmdObject == NULL)
    {
        return (CL_RMD_RC(CL_ERR_INVALID_BUFFER));
    }

    rc = clOsalMutexLock(pRmdObject->semaForSendHashTable);
    CL_ASSERT(rc == CL_OK);
    clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 0");
    rc = clCntNodeFind(pRmdObject->sndRecContainerHandle, (ClPtrT)(ClWordT)msgId,
                       &nodeHandle);
    if (rc == CL_OK)
    {
        clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 1");

        rc = clCntNodeUserDataGet(pRmdObject->sndRecContainerHandle, nodeHandle,
                                  (ClCntDataHandleT *) &rec);
        if (rc == CL_OK)
        {
            clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 2");
            if (rec)
            {
                /*
                 * Disabling retries for ASYNC since we dont want
                 * to land up in duplicate send mess as anyway we have
                 * accounted for the retries while creating the async timer.
                 */
                if (0 && rec->recType.asyncRec.noOfRetry > 0)
                {
                    /*
                     * key is part of record so no need to free just reuse
                     */
                    retCode = resendMsg(rec, pRmdObject, pThis);
                }
                else
                {
                    /*
                     * key is part of record so no need to free, it will be
                     * freed by hash delete callback
                     */
                    RMD_STAT_INC(pRmdObject->rmdStats.nCallTimeouts);
                    retCode = clTimerDeleteAsync(&rec->recType.asyncRec.timerID);
                    if (rec->recType.asyncRec.func)
                    {
                        /*
                         * unlocking it as callback func can make the rmd call
                         */
                        ClBufferHandleT message;

                        fpTempPtr = rec->recType.asyncRec.func;
                        cookie = rec->recType.asyncRec.cookie;
                        outMsgHdl = rec->recType.asyncRec.outMsgHdl;
                        message = rec->recType.asyncRec.sndMsgHdl;
                        clBufferHeaderTrim(message, rec->hdrLen);
                        rc = clCntNodeDelete(pRmdObject->sndRecContainerHandle,
                                             nodeHandle);
                        rc = clOsalMutexUnlock(pRmdObject->
                                               semaForSendHashTable);
                        fpTempPtr((CL_RMD_RC(CL_ERR_TIMEOUT)), cookie, message,
                                  outMsgHdl);
                        clBufferDelete(&(message));
                        rc = clOsalMutexLock(pRmdObject->semaForSendHashTable);
                    }
                }
            }
        }
    }

    rc = clOsalMutexUnlock(pRmdObject->semaForSendHashTable);
    CL_ASSERT(rc == CL_OK);
    CL_FUNC_EXIT();
    return CL_OK;

}
static ClRcT cpmNodeRmv(ClCharT *nodeName)
{
    ClRcT rc = CL_OK;
    ClUint16T nodeKey = 0;
    ClCntNodeHandleT hNode = 0;
    ClUint32T numNode = 0;
    ClCpmLT *cpm = NULL;
    ClBoolT done = CL_NO;
    if (!nodeName)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "NULL pointer passed.");
        goto failure;
    }

    rc = clCksm16bitCompute((ClUint8T *)nodeName,
                            strlen(nodeName),
                            &nodeKey);
    if (CL_OK != rc)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "Failed to compute checksum for node, "
                   "error [%#x]",
                   rc);
        goto failure;
    }

    clOsalMutexLock(gpClCpm->cpmTableMutex);

    rc = clCntNodeFind(gpClCpm->cpmTable,
                       (ClCntKeyHandleT)(ClWordT)nodeKey,
                       &hNode);
    if (CL_OK != rc)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "Failed to find node [%s], error [%#x]",
                   nodeName,
                   rc);
        goto unlock;
    }

    rc = clCntKeySizeGet(gpClCpm->cpmTable,
                         (ClCntKeyHandleT)(ClWordT)nodeKey,
                         &numNode);
    if (CL_OK != rc)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "Unable to get key size, error [%#x]",
                   rc);
        goto unlock;
    }

    while (numNode > 0)
    {
        rc = clCntNodeUserDataGet(gpClCpm->cpmTable,
                                  hNode,
                                  (ClCntNodeHandleT *) &cpm);
        if (CL_OK != rc)
        {
            clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                       "Unable to get user data, error [%#x]",
                       rc);
            goto unlock;
        }

        if (!strncmp(nodeName, cpm->nodeName, CL_MAX_NAME_LENGTH-1))
        {
            clCntNodeDelete(gpClCpm->cpmTable, hNode);
            done = CL_YES;
            break;
        }

        if (--numNode)
        {
            rc = clCntNextNodeGet(gpClCpm->cpmTable, hNode, &hNode);
            if (CL_OK != rc)
            {
                break;
            }
        }
    }

    if (!done)
    {
        rc = CL_CPM_RC(CL_ERR_DOESNT_EXIST);
        goto unlock;
    }

    --gpClCpm->noOfCpm;

    clOsalMutexUnlock(gpClCpm->cpmTableMutex);

    /*
     * Delete from slot table
     */
    clOsalMutexLock(&gpClCpm->cpmMutex);
    if(cpmSlotClassDelete(nodeName) != CL_OK)
    {
        clLogWarning("CPM", "MGMT", "Slot class delete failed for node [%s]", nodeName);
    }
    clOsalMutexUnlock(&gpClCpm->cpmMutex);

    return CL_OK;

unlock:
    clOsalMutexUnlock(gpClCpm->cpmTableMutex);
failure:
    return rc;
}
コード例 #23
0
ClRcT cpmPrintDBXML(FILE *fp)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT cpmNode = 0;
    ClUint32T cpmLCount = 0;
    ClCpmLT *cpmL = NULL;

    fprintf(fp,"<cpm>\n");

    /*
     * Walk through the cpm table to find and display SCs 
     */
    clOsalMutexLock(gpClCpm->cpmTableMutex);
    cpmLCount = gpClCpm->noOfCpm;
    if (gpClCpm->pCpmConfig->cpmType == CL_CPM_GLOBAL && cpmLCount != 0)
    {
        rc = clCntFirstNodeGet(gpClCpm->cpmTable, &cpmNode);
        if(rc != CL_OK)
        {
            clLogError(CPM_LOG_AREA_DB,CPM_LOG_CTX_DB_XML,CL_CPM_LOG_2_CNT_FIRST_NODE_GET_ERR, "CPM-L", rc);
            clLogWrite((CL_LOG_HANDLE_APP), (CL_LOG_SEV_DEBUG), NULL, CL_CPM_LOG_2_CNT_FIRST_NODE_GET_ERR, ("CPM-L"), (rc));
            goto out_unlock;
        }

        while (cpmLCount)
        {
            rc = clCntNodeUserDataGet(gpClCpm->cpmTable, cpmNode,
                                    (ClCntDataHandleT *) &cpmL);

            if(rc != CL_OK)
            {
                clLogError(CPM_LOG_AREA_DB,CPM_LOG_CTX_DB_XML,CL_CPM_LOG_1_CNT_NODE_USR_DATA_GET_ERR, rc);
                clLogWrite((CL_LOG_HANDLE_APP), (CL_LOG_SEV_DEBUG), NULL, CL_CPM_LOG_1_CNT_NODE_USR_DATA_GET_ERR, rc);
                goto out_unlock;
            }

            if (cpmL->pCpmLocalInfo)
            {
                /*
                 * If the node is a SC, display its data 
                 */
                if(!strcmp((const ClCharT *)cpmL->nodeType.value, (const ClCharT *)gpClCpm->pCpmLocalInfo->nodeType.value)
                    || (ClUint32T) cpmL->pCpmLocalInfo->nodeId == gpClCpm->activeMasterNodeId
                    || (ClUint32T) cpmL->pCpmLocalInfo->nodeId == gpClCpm->deputyNodeId)
                {
                    fprintf(fp,"<node value=\"%s\">\n",cpmL->pCpmLocalInfo->nodeName);
                    fprintf(fp,"<id value=\"%d\"/>\n",cpmL->pCpmLocalInfo->nodeId);
                    fprintf(fp,"<ha_state value=\"%s\"/>\n",(ClUint32T) cpmL->pCpmLocalInfo->nodeId == gpClCpm->activeMasterNodeId ? "active" : "standby");
                    fprintf(fp,"</node>\n");
                }
            }

            cpmLCount--;

            if (cpmLCount)
            {
                rc = clCntNextNodeGet(gpClCpm->cpmTable, cpmNode, &cpmNode);
                if(rc != CL_OK)
                {
                    clLogError(CPM_LOG_AREA_DB,CPM_LOG_CTX_DB_XML,CL_CPM_LOG_2_CNT_NEXT_NODE_GET_ERR, "CPM-L", rc);
                    clLogWrite((CL_LOG_HANDLE_APP), (CL_LOG_SEV_DEBUG), NULL, CL_CPM_LOG_2_CNT_NEXT_NODE_GET_ERR, ("CPM-L"), (rc));
                    goto out_unlock;
                }
            }
        }
    }

    rc = CL_OK;
    out_unlock:
    clOsalMutexUnlock(gpClCpm->cpmTableMutex);

    fprintf(fp,"</cpm>\n");
    return rc;
}
ClRcT _cpmClusterConfigList(ClInt32T argc, ClCharT **retStr)
{
    ClCpmLT *cpmL = NULL;
    ClRcT rc = CL_OK;
    ClCntNodeHandleT hNode = 0;
    ClUint32T cpmLCount = 0;
    ClCharT tempStr[256];
    ClCharT *tmpStr = NULL;
    ClBufferHandleT message;

    rc = clBufferCreate(&message);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to create message \n"), rc);

    if (argc != ONE_ARGUMENT)
    {
        sprintf(tempStr, "Usage: clusterList");
        rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                        strlen(tempStr));
        CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc);
        goto done;
    }

    /*
     * Print the local stuff first 
     */
    sprintf(tempStr, "%s\n", "nodeName | status | iocAddress | iocPort ");
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                    strlen(tempStr));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    sprintf(tempStr, "%s\n",
            "-----------------------------------------------------------------------");
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                    strlen(tempStr));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    /*
     * Now even the CPM/G information is stored in the list.
     * So no need of printing the above information.
     */
#if 0
    if (gpClCpm->pCpmLocalInfo->status == CL_CPM_EO_DEAD)
        sprintf(tempStr, "%10s | DEAD | %8d |   0x%x\n",
                gpClCpm->pCpmLocalInfo->nodeName,
                gpClCpm->pCpmLocalInfo->cpmAddress.nodeAddress,
                gpClCpm->pCpmLocalInfo->cpmAddress.portId);
    else
        sprintf(tempStr, "%10s | ALIVE | %8d |   0x%x\n",
                gpClCpm->pCpmLocalInfo->nodeName,
                gpClCpm->pCpmLocalInfo->cpmAddress.nodeAddress,
                gpClCpm->pCpmLocalInfo->cpmAddress.portId);
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                    strlen(tempStr));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
#endif
    /*_cpmListAllSU();*/
    /*
     * Get all the CPMs one by one and delete the stuff.
     */
    rc = clCntFirstNodeGet(gpClCpm->cpmTable, &hNode);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get first cpmTable Node %x\n", rc),
                 rc);
    rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode,
                              (ClCntDataHandleT *) &cpmL);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get container Node data %x\n", rc),
                 rc);
    cpmLCount = gpClCpm->noOfCpm;

    while (cpmLCount)
    {
        if (cpmL->pCpmLocalInfo != NULL)
        {
            if (cpmL->pCpmLocalInfo->status == CL_CPM_EO_DEAD)
            {
                sprintf(tempStr, "%10s | DEAD  | %8d |   0x%x\n",
                        cpmL->nodeName,
                        cpmL->pCpmLocalInfo->cpmAddress.nodeAddress,
                        cpmL->pCpmLocalInfo->cpmAddress.portId);
            }
            else
            {
                sprintf(tempStr, "%10s | ALIVE | %8d |   0x%x\n",
                        cpmL->nodeName,
                        cpmL->pCpmLocalInfo->cpmAddress.nodeAddress,
                        cpmL->pCpmLocalInfo->cpmAddress.portId);
            }
            rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                            strlen(tempStr));
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
        }
        else
        {
            sprintf(tempStr, "%10s \n", cpmL->nodeName);
            rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                            strlen(tempStr));
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
        }
#if 0
        rc = clCntFirstNodeGet(cpmL->suTable, &hSU);
        CL_CPM_CHECK(CL_DEBUG_ERROR,
                     ("Unable to get first su Node in cpmL %x\n", rc), rc);
        if (cpmL->pCpmLocalInfo != NULL)
            clOsalPrintf("%10s | %8d | %8d | 0x%8x| 0x%8x \n",
                         cpmL->pCpmLocalInfo->nodeName,
                         cpmL->pCpmLocalInfo->status,
                         cpmL->pCpmLocalInfo->nodeId,
                         cpmL->pCpmLocalInfo->cpmAddress.nodeAddress,
                         cpmL->pCpmLocalInfo->cpmAddress.portId);
        else
            clOsalPrintf("%10s \n", cpmL->nodeName);

        suCount = cpmL->noOfsu;
        while (suCount)
        {
            rc = clCntNodeUserDataGet(cpmL->suTable, hSU,
                                      (ClCntDataHandleT *) &su);
            CL_CPM_CHECK(CL_DEBUG_ERROR,
                         ("Unable to get first container su Node data %x\n",
                          rc), rc);

            clOsalPrintf("\t %10s |%15s |%11s |%16s \n", su->suName,
                         _cpmPresenceStateNameGet(su->suPresenceState),
                         _cpmOperStateNameGet(su->suOperState),
                         _cpmReadinessStateNameGet(su->suReadinessState));
            tempCompRef = su->suCompList;
            while (tempCompRef != NULL)
            {
                clOsalPrintf
                    ("-----------------------------------------------------------------------\n");
                clOsalPrintf("\t\t%10s %14d |%15s |%11s |%16s \n",
                             tempCompRef->ref->compConfig->compName,
                             tempCompRef->ref->compRestartCount,
                             _cpmPresenceStateNameGet(tempCompRef->ref->
                                                      compPresenceState),
                             _cpmOperStateNameGet(tempCompRef->ref->
                                                  compOperState),
                             _cpmReadinessStateNameGet(tempCompRef->ref->
                                                       compReadinessState));
                tempCompRef = tempCompRef->pNext;
            }
            suCount--;
            if (suCount)
            {
                rc = clCntNextNodeGet(cpmL->suTable, hSU, &hSU);
                CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node  Data \n"),
                             rc);
            }
        }
#endif
        sprintf(tempStr, "%s",
                "-----------------------------------------------------------------------\n");
        rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                        strlen(tempStr));
        CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
        cpmLCount--;
        if (cpmLCount)
        {
            rc = clCntNextNodeGet(gpClCpm->cpmTable, hNode, &hNode);
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node  Data \n"),
                         rc);
            rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode,
                                      (ClCntDataHandleT *) &cpmL);
            CL_CPM_CHECK(CL_DEBUG_ERROR,
                         ("Unable to get container Node data %d\n", rc), rc);
        }
    }

    /*
     * Bug 4986 :
     * Moved the code to NULL terminate the string
     * below the done: label, so that the usage string
     * written to the buffer is also NULL terminated.
     */
  done:
    /*
     * NULL terminate the string 
     */
    sprintf(tempStr, "%s", "\0");
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, 1);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    rc = clBufferFlatten(message, (ClUint8T **) &tmpStr);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to flatten message \n"), rc);

    *retStr = tmpStr;

    clBufferDelete(&message);
    return rc;

  failure:
    clBufferDelete(&message);
    return rc;
}
static ClRcT cpmComponentRmv(ClCharT *compName)
{
    ClRcT rc = CL_OK;
    ClUint16T compKey = 0;
    ClCntNodeHandleT hNode = 0;
    ClUint32T numNode = 0;
    ClCpmComponentT *comp = NULL;
    ClBoolT done = CL_NO;
    SaNameT entity = {0};

    if (!compName)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "NULL pointer passed.");
        goto failure;
    }

    rc = clCksm16bitCompute((ClUint8T *)compName,
                            strlen(compName),
                            &compKey);
    if (CL_OK != rc)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "Failed to compute checksum for component, "
                   "error [%#x]",
                   rc);
        goto failure;
    }
    saNameSet(&entity, compName);
    /*
     * Clear pending invocations for the component being removed.
     */
    (void)cpmInvocationClearCompInvocation(&entity);
    clOsalMutexLock(gpClCpm->compTableMutex);
    clOsalMutexLock(&gpClCpm->compTerminateMutex);

    rc = clCntNodeFind(gpClCpm->compTable,
                       (ClCntKeyHandleT)(ClWordT)compKey,
                       &hNode);
    if (CL_OK != rc)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "Failed to find component [%s], error [%#x]",
                   compName,
                   rc);
        goto unlock;
    }

    rc = clCntKeySizeGet(gpClCpm->compTable,
                         (ClCntKeyHandleT)(ClWordT)compKey,
                         &numNode);
    if (CL_OK != rc)
    {
        clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                   "Unable to get key size, error [%#x]",
                   rc);
        goto unlock;
    }

    while (numNode > 0)
    {
        rc = clCntNodeUserDataGet(gpClCpm->compTable,
                                  hNode,
                                  (ClCntNodeHandleT *) &comp);
        if (CL_OK != rc)
        {
            clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM,
                       "Unable to get user data, error [%#x]",
                       rc);
            goto unlock;
        }

        if (!strncmp(compName,
                     comp->compConfig->compName,
                     CL_MAX_NAME_LENGTH-1))
        {
            clCntNodeDelete(gpClCpm->compTable, hNode);
            done = CL_YES;
            break;
        }

        if (--numNode)
        {
            rc = clCntNextNodeGet(gpClCpm->compTable, hNode, &hNode);
            if (CL_OK != rc)
            {
                break;
            }
        }
    }

    if (!done)
    {
        rc = CL_CPM_RC(CL_ERR_DOESNT_EXIST);
        goto unlock;
    }
    
    --gpClCpm->noOfComponent;

    clOsalMutexUnlock(&gpClCpm->compTerminateMutex);
    clOsalMutexUnlock(gpClCpm->compTableMutex);

    return CL_OK;

unlock:
    clOsalMutexUnlock(&gpClCpm->compTerminateMutex);
    clOsalMutexUnlock(gpClCpm->compTableMutex);
failure:
    return rc;
}
ClRcT _clCpmComponentListAll(ClInt32T argc, ClCharT **retStr)
{
    ClCntNodeHandleT hNode = 0;
    ClCpmComponentT *comp = NULL;
    ClUint32T rc = CL_OK, count;
    ClCpmEOListNodeT *eoList = NULL;
    ClCharT state[10] = "\0";
    ClCharT status[10] = "\0";
    ClCharT tempStr[256];
    ClCharT *tmpStr = NULL;
    ClBufferHandleT message;
    ClCharT cpmCompName[CL_MAX_NAME_LENGTH] = {0};
    
    rc = clBufferCreate(&message);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to create message %x\n", rc), rc);

    if (argc != ONE_ARGUMENT)
    {
        rc = clBufferNBytesWrite(message, (ClUint8T *) STR_AND_SIZE("Usage: compList"));
        CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc);
        rc = CL_CPM_RC(CL_ERR_INVALID_PARAMETER);
        goto done;
    }

    count = gpClCpm->noOfComponent;
    snprintf(cpmCompName,
             CL_MAX_NAME_LENGTH-1,
             "%s_%s",
             CL_CPM_COMPONENT_NAME,
             gpClCpm->pCpmLocalInfo->nodeName);

    rc = clCntFirstNodeGet(gpClCpm->compTable, &hNode);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get First component \n"), rc);

    rc = clBufferNBytesWrite(message, (ClUint8T *) STR_AND_SIZE("################### List Of Components ########################\n"));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode,(ClCntDataHandleT *) &comp);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node  Data \n"), rc);

    rc = clBufferNBytesWrite(message, STR_AND_SIZE("        CompName              | compId  |  eoPort  |   PID   | RestartCount  | PresenceState\n"));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    rc = clBufferNBytesWrite(message, STR_AND_SIZE("\t\t     ID |     Port |     Name  |    Health |Recv Threads \n"));   
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    rc = clBufferNBytesWrite(message, STR_AND_SIZE("========================================================================================\n"));    
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    while (count)
    {
        
        if (strcmp(comp->compConfig->compName, cpmCompName)!=0)  /* Skip if it is the CPM component */
        {
            
            eoList = comp->eoHandle;

            int len = sprintf(tempStr, "%30s| 0x%x | 0x%x |%8d |%14d |%15s\n",
                              comp->compConfig->compName, comp->compId,
                              comp->eoPort, comp->processId, comp->compRestartCount,
                              _cpmPresenceStateNameGet(comp->compPresenceState));
            
            if (comp->compConfig->compProperty != CL_AMS_COMP_PROPERTY_SA_AWARE)
            {

                if(!eoList || !eoList->eoptr)
                {
                    len += snprintf(tempStr + len, sizeof(tempStr) - len, 
                                    "\t\t   0x%x  |  0x%x   |%10s |%10s |%04d \n",
                                    0, 0, "-", "-", 0);
                }
            }

            rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,len);
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

            while (eoList != NULL && eoList->eoptr != NULL)
            {
                compMgrStateStatusGet(eoList->status, eoList->eoptr->state, status, sizeof(status),
                                      state, sizeof(state));
                int noOfThreads = (eoList->eoptr->appType == CL_EO_USE_THREAD_FOR_RECV) ? eoList->eoptr->noOfThreads + 1: eoList->eoptr->noOfThreads;

                int len = sprintf(tempStr, "\t\t   0x%llx  |  0x%x   |%10s |%10s |%04d \n",
                                  eoList->eoptr->eoID, eoList->eoptr->eoPort,
                                  eoList->eoptr->name, status,
                                  noOfThreads);
                rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, len);
                CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
                eoList = eoList->pNext;
            }
        
            rc = clBufferNBytesWrite(message, STR_AND_SIZE("-----------------------------------------------------------------------------------------\n"));
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);
        
        }
        
        count--;
        if (count)
        {
            rc = clCntNextNodeGet(gpClCpm->compTable, hNode, &hNode);
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to Get Node  Data %x\n", rc), rc);

            rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode, (ClCntDataHandleT *) &comp);
            CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to Get Node user Data %x\n", rc), rc);
        }

    }

    /*
     * Bug 4986 :
     * Moved the code to NULL terminate the string
     * below the done: label, so that the usage string
     * written to the buffer is also NULL terminated.
     */
done:
    /*
     * NULL terminate the string 
     */
    rc = clBufferNBytesWrite(message, (ClUint8T *) "\0", 1);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    rc = clBufferFlatten(message, (ClUint8T **) &tmpStr);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to flatten the message \n"), rc);

    *retStr = tmpStr;
    
    clBufferDelete(&message);
    return rc;

failure:
    clBufferDelete(&message);
    return rc;
}
ClRcT clCpmExecutionObjectListShow(ClInt32T argc,
                                   ClIocNodeAddressT compAddr,
                                   ClUint32T flag,
                                   ClEoIdT eoId,
                                   ClCharT **retStr)
{
    /*
     * ClCpmEOListNodeT* ptr = gpClCpm->eoList;
     */
    ClCpmEOListNodeT *ptr = NULL;
    ClCharT name[32] = "\0";
    ClCharT state[10] = "\0";
    ClCharT status[10] = "\0";
    ClUint32T compCount = 0;
    ClCntNodeHandleT hNode = 0;
    ClCpmComponentT *comp = NULL;
    ClRcT rc = CL_OK;
    ClCharT tempStr[256];
    ClCharT *tmpStr = NULL;
    ClBufferHandleT message = 0;

    rc = clBufferCreate(&message);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to create message %x\n", rc), rc);

    if (argc != ONE_ARGUMENT)
    {
        sprintf(tempStr, "Usage: EOShow");
        rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                        strlen(tempStr));
        CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc);
        goto done;
    }


    sprintf(tempStr,
            "\n   ID  |   Port   |   Name    |   Health   |   EO State   | Recv Threads ");
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                    strlen(tempStr));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc);

    sprintf(tempStr,
            "\n ===================================================================== ");
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                    strlen(tempStr));
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc);

    /*
     * take the semaphore 
     */
    if ((rc = clOsalMutexLock(gpClCpm->eoListMutex)) != CL_OK)
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                       ("Could not get Lock successfully------\n"));

    rc = clCntFirstNodeGet(gpClCpm->compTable, &hNode);
    CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("Unable to Get First component \n"), rc);

    rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode,
                              (ClCntDataHandleT *) &comp);
    CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("Unable to Get Node  Data \n"), rc);

    compCount = gpClCpm->noOfComponent;
    while (compCount != 0)
    {
        ptr = comp->eoHandle;

        if (flag == 0)
        {
            while (ptr != NULL && ptr->eoptr != NULL)
            {
                strcpy(name, ptr->eoptr->name);
                /*
                 * Obtain the state and status in string format 
                 */
                compMgrStateStatusGet(ptr->status, ptr->eoptr->state, status, sizeof(status),
                                      state, sizeof(state));
                if (ptr->eoptr->appType == CL_EO_USE_THREAD_FOR_RECV)
                    sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d ",
                            ptr->eoptr->eoID, ptr->eoptr->eoPort, name, status,
                            state, (ptr->eoptr->noOfThreads + 1));
                else
                    sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d ",
                            ptr->eoptr->eoID, ptr->eoptr->eoPort, name, status,
                            state, ptr->eoptr->noOfThreads);
                rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,
                                                strlen(tempStr));
                CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR,
                                  ("\n Unable to write message \n"), rc);
                ptr = ptr->pNext;
            }
        }
        else
        {
            while (ptr != NULL && ptr->eoptr != NULL)
            {
                if (ptr->eoptr->eoID == eoId)
                {
                    /*
                     * obtain the state and status in string format 
                     */
                    compMgrStateStatusGet(ptr->status, ptr->eoptr->state,
                                          status, sizeof(status), state, sizeof(state));
                    strcpy(name, ptr->eoptr->name);

                    if (ptr->eoptr->appType == CL_EO_USE_THREAD_FOR_RECV)
                        sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d | ",
                                ptr->eoptr->eoID, ptr->eoptr->eoPort, name,
                                status, state, ptr->eoptr->noOfThreads + 1);
                    else
                        sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d | ",
                                ptr->eoptr->eoID, ptr->eoptr->eoPort, name,
                                status, state, ptr->eoptr->noOfThreads);
                    rc = clBufferNBytesWrite(message,
                                                    (ClUint8T *) tempStr,
                                                    strlen(tempStr));
                    CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR,
                                      ("\n Unable to write message \n"), rc);
                    break;
                }
                ptr = ptr->pNext;
            }
#if 0
            if (ptr == NULL)
                CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("EOID not found\n"));
#endif
        }
        compCount--;
        if (compCount)
        {
            rc = clCntNextNodeGet(gpClCpm->compTable, hNode, &hNode);
            CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR,
                              ("\n Unable to Get Node  Data \n"), rc);
            rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode,
                                      (ClCntDataHandleT *) &comp);
            CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR,
                              ("\n Unable to Get Node  Data \n"), rc);
        }
    }
    /*
     * Release the semaphore 
     */
    rc = clOsalMutexUnlock(gpClCpm->eoListMutex);
    CL_CPM_CHECK(CL_DEBUG_ERROR,
                 ("COMP_MGR: Could not UnLock successfully------\n"), rc);

    /*
     * Bug 4986 :
     * Moved the code to NULL terminate the string
     * below the done: label, so that the usage string
     * written to the buffer is also NULL terminated.
     */
  done:
    /*
     * NULL terminate the string 
     */
    sprintf(tempStr, "%s", "\0");
    rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, 1);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc);

    /*
     * Construct the return buffer 
     */
    rc = clBufferFlatten(message, (ClUint8T **) &tmpStr);
    CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to flatten the message \n"), rc);

    *retStr = tmpStr;
    
    clBufferDelete(&message);

    return (CL_OK);

  withlock:
    /*
     * Release the semaphore 
     */
    rc = clOsalMutexUnlock(gpClCpm->eoListMutex);
    CL_CPM_CHECK(CL_DEBUG_ERROR,
                 ("COMP_MGR: Could not UnLock successfully------\n"), rc);
  failure:
    clBufferDelete(&message);
    return rc;
}
ClRcT
clLogClntStreamWriteWithHeader(ClLogClntEoDataT    *pClntEoEntry,
                               ClLogSeverityT      severity,
                               ClUint16T           serviceId,
                               ClUint16T           msgId,
                               const ClCharT             *pMsgHeader,
                               va_list             args,
                               ClCntNodeHandleT    hClntStreamNode)
{
    ClRcT                 rc              = CL_OK;
    ClLogClntStreamDataT  *pClntData      = NULL;
    ClLogStreamHeaderT    *pStreamHeader  = NULL;
    ClUint8T              *pStreamRecords = NULL;
    ClUint32T             nUnAcked        = 0;
    ClUint32T             nDroppedRecords = 0;
    ClUint8T              *pBuffer        = NULL;
    ClUint32T             recordSize = 0;

    CL_LOG_DEBUG_TRACE(("Enter"));
    CL_LOG_DEBUG_VERBOSE(("Severity: %d ServiceId: %hu MsgId: %hu CompId: %u",
                          severity, serviceId, msgId, pClntEoEntry->compId));

    rc = clCntNodeUserDataGet(pClntEoEntry->hClntStreamTable,  hClntStreamNode,
                              (ClCntDataHandleT *) &pClntData);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));
        return rc;
    }
    pStreamHeader  = pClntData->pStreamHeader;
    pStreamRecords = pClntData->pStreamRecords;
#ifdef NO_SAF
    ClLogStreamKeyT         *pUserKey     = NULL;
    rc = clCntNodeUserKeyGet(pClntEoEntry->hClntStreamTable,
    		                 hClntStreamNode,
                             (ClCntKeyHandleT *) &pUserKey);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clCntNodeUserKeyGet(): rc[0x %x]", rc));
        return rc;
    }
    ClInt32T recSize= pClntData->recSize;
#define __UPDATE_RECORD_SIZE do {                  \
        if(recSize < nbytes )                   \
            recSize = nbytes;                   \
        recSize -= nbytes;                      \
        if(!recSize)                            \
            return CL_OK;                       \
    }while(0)
    ClUint16T streamId = 10;
    ClUint64T sequenceNum = pUserKey->sequenceNum;
    ClUint32T clientId = pClntEoEntry->clientId;
    ClUint8T* pRecord=clHeapAllocate(recSize);
    ClTimeT           timeStamp     = 0;
    ClUint8T          *pRecStart    = pRecord;
    ClUint16T         tmp           = 1;
    ClUint8T          endian        = *(ClUint8T *) &tmp;
    memset(pRecord, 0, recSize);
    if( CL_LOG_MSGID_PRINTF_FMT == msgId )
    {
        ClInt32T nbytes = 0;
        if(recSize < LOG_ASCII_MIN_REC_SIZE ) /* just a minimum record size taking care of the headers*/
        {
            printf("LOG record size has to be minimum [%d] bytes. Got [%d] bytes\n", LOG_ASCII_MIN_REC_SIZE, recSize);
            return CL_LOG_RC(CL_ERR_INVALID_PARAMETER);
        }
        /*
         * In ASCII logging, we dont need header, so just keeping only the
         * required fields
         */
        nbytes = snprintf((ClCharT *)pRecord, recSize, LOG_ASCII_HDR_FMT, endian, severity & 0x1f);
        pRecord += nbytes;
        __UPDATE_RECORD_SIZE;
        {
            ClCharT *pSeverity = (ClCharT *)clLogSeverityStrGet(severity);
            ClCharT c = 0;
            ClInt32T hdrLen = 0;
            ClInt32T len = 0;
            va_list argsCopy;
            ClCharT *pFmtStr ;
            va_copy(argsCopy, args);
            pFmtStr = va_arg(argsCopy, ClCharT *);
            if(pMsgHeader && pMsgHeader[0])
            {
                hdrLen = snprintf(&c, 1, "%s.%05lld : %6s) ",
                                  pMsgHeader, sequenceNum, pSeverity ? pSeverity : "DEBUG");
                if(hdrLen < 0) hdrLen = 0;
            }
            len = vsnprintf(&c, 1, pFmtStr, argsCopy);
            va_end(argsCopy);
            if(len < 0) len = 0;
            hdrLen = CL_MIN(hdrLen, recSize - LOG_ASCII_HDR_LEN - LOG_ASCII_DATA_LEN - 1);
            len = CL_MIN(len, recSize - LOG_ASCII_HDR_LEN - LOG_ASCII_DATA_LEN - hdrLen - 1);
            nbytes = snprintf((ClCharT*)pRecord, recSize - 1, LOG_ASCII_HDR_LEN_FMT, hdrLen);
            pRecord += nbytes;
            __UPDATE_RECORD_SIZE;
            nbytes = snprintf((ClCharT*)pRecord, recSize - 1, LOG_ASCII_DATA_LEN_DELIMITER_FMT, len);
            pRecord += nbytes;
            __UPDATE_RECORD_SIZE;
            if(pMsgHeader && pMsgHeader[0])
            {
                nbytes = snprintf((ClCharT*)pRecord, recSize - 1, "%s.%05lld : %6s) ",
                                  pMsgHeader, sequenceNum, pSeverity ? pSeverity : "DEBUG");
                if(nbytes < 0) nbytes = 0;
                pRecord += nbytes;
                __UPDATE_RECORD_SIZE;
            }
            pFmtStr = va_arg(args, ClCharT *);
            nbytes = vsnprintf((ClCharT*)pRecord, recSize - 1, pFmtStr, args);
            if(nbytes < 0) nbytes = 0;
        }
    }
ClRcT
clLogClntStreamOpen(ClLogHandleT        hLog,
                    SaNameT             *pStreamName,
                    SaNameT             *pNodeName,
                    ClStringT           *pShmName,
                    ClUint32T           shmSize,
                    ClLogStreamHandleT  *phStream,
                    ClUint32T           recSize)
{
    ClRcT                 rc              = CL_OK;
    ClLogClntEoDataT      *pClntEoEntry   = NULL;
    ClBoolT               addedTable      = CL_FALSE;
    ClBoolT               addedEntry      = CL_FALSE;
    ClCntNodeHandleT      hClntStreamNode = CL_HANDLE_INVALID_VALUE;
    ClLogClntStreamDataT  *pUserData      = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));

    CL_LOG_PARAM_CHK((NULL == pStreamName), CL_LOG_RC(CL_ERR_NULL_POINTER));
    CL_LOG_PARAM_CHK((NULL == pNodeName), CL_LOG_RC(CL_ERR_NULL_POINTER));
    CL_LOG_PARAM_CHK((NULL == pShmName), CL_LOG_RC(CL_ERR_NULL_POINTER));
    CL_LOG_PARAM_CHK((sizeof(ClLogStreamHeaderT) > shmSize),
                      CL_LOG_RC(CL_ERR_INVALID_PARAMETER));
    CL_LOG_PARAM_CHK((NULL == phStream), CL_LOG_RC(CL_ERR_NULL_POINTER));

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

    rc = clOsalMutexLock_L(&(pClntEoEntry->clntStreamTblLock));
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clOsalMutexLock(): rc[0x %x]", rc));
        return rc;
    }

    if( CL_HANDLE_INVALID_VALUE == pClntEoEntry->hClntStreamTable )
    {
        rc = clCntHashtblCreate(pClntEoEntry->maxStreams,
                                clLogStreamKeyCompare,
                                clLogStreamHashFn,
                                clLogClntStreamDeleteCb,
                                clLogClntStreamDeleteCb,
                                CL_CNT_UNIQUE_KEY,
                                &(pClntEoEntry->hClntStreamTable));
        if( CL_OK != rc )
        {
            CL_LOG_DEBUG_ERROR(("clCntHashtblCreate(): rc[0x %x]", rc));
            CL_LOG_CLEANUP(
                clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),CL_OK);
            return rc;
        }
        addedTable = CL_TRUE;
        CL_LOG_DEBUG_VERBOSE(("Created the HashTable"));
    }

    rc = clLogClntStreamEntryGet(pClntEoEntry, pStreamName, pNodeName,
                                 pShmName, shmSize, &hClntStreamNode,
                                 &addedEntry);
    if( CL_OK != rc)
    {
        if( CL_TRUE == addedTable )
        {
            CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
        }
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
                       CL_OK);
        return rc;
    }
    CL_LOG_DEBUG_VERBOSE(("Got the stream entry"));

    rc = clLogHandleStreamHandleCreate(hLog, hClntStreamNode, phStream);
    if( CL_OK != rc)
    {
        if( CL_TRUE == addedEntry )
        {
            CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
                                           hClntStreamNode), CL_OK);
        }
        if( CL_TRUE == addedTable )
        {
            CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
        }
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
                       CL_OK);
        return rc;
    }
    CL_LOG_DEBUG_VERBOSE(("Created the streamhandle"));

    rc = clCntNodeUserDataGet(pClntEoEntry->hClntStreamTable, hClntStreamNode,
                              (ClCntDataHandleT *) &pUserData);
    if( CL_OK != rc )
    {
        CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB,
                                             *phStream), CL_OK);
        *phStream = CL_HANDLE_INVALID_VALUE;
        if( CL_TRUE == addedEntry )
        {
            CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
                                           hClntStreamNode), CL_OK);
        }

        if( CL_TRUE == addedTable )
        {
            CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
        }
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
                       CL_OK);
        return rc;
    }
#ifdef NO_SAF
    pUserData->recSize=recSize;
#endif
    CL_LOG_DEBUG_VERBOSE(("Got stream entry"));
    rc = clBitmapBitSet(pUserData->hStreamBitmap, CL_HDL_IDX(*phStream));
    if( CL_OK != rc )
    {
        CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phStream),
                       CL_OK);
        *phStream = CL_HANDLE_INVALID_VALUE;
        if( CL_TRUE == addedEntry )
        {
            CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
                                           hClntStreamNode), CL_OK);
        }

        if( CL_TRUE == addedTable )
        {
            CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
        }
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
                       CL_OK);
        return rc;
    }
    CL_LOG_DEBUG_VERBOSE(("Updated stream bitmap"));

    rc = clLogHandleInitHandleStreamAdd(hLog, *phStream);
    if( CL_OK != rc )
    {
        CL_LOG_CLEANUP(clBitmapBitClear(pUserData->hStreamBitmap, CL_HDL_IDX(*phStream)),
                       CL_OK);
        CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phStream),
                       CL_OK);
        *phStream = CL_HANDLE_INVALID_VALUE;
        if( CL_TRUE == addedEntry )
        {
            CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
                                           hClntStreamNode), CL_OK);
        }

        if( CL_TRUE == addedTable )
        {
            CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
        }
        CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
                       CL_OK);
        return rc;
    }
    CL_LOG_DEBUG_VERBOSE(("Updated init handle"));

    rc = clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock));
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clOsalMutexUnlock(): rc[0x %x]", rc));
        return rc;
    }

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
}
コード例 #30
0
ClRcT cpmInvocationClearCompInvocation(SaNameT *compName)
{
    ClRcT rc = CL_OK;
    ClCntNodeHandleT nodeHandle, nextNodeHandle;
    ClCpmInvocationT *invocationData = NULL;
    void *data = NULL;

    /*
     * Check the input parameter 
     */
    if (!compName)
    {
        CL_CPM_CHECK(CL_LOG_SEV_ERROR, ("Invalid parameter passed \n"),
                     CL_CPM_RC(CL_ERR_NULL_POINTER));
    }

    clOsalMutexLock(gpClCpm->invocationMutex);

    rc = clCntFirstNodeGet(gpClCpm->invocationTable, &nodeHandle);
    if (rc != CL_OK)
        goto withLock;


    while (nodeHandle)
    {

        rc = clCntNodeUserDataGet(gpClCpm->invocationTable, nodeHandle,
                                  (ClCntDataHandleT *) &invocationData);

        if (rc != CL_OK)
            goto withLock;

        rc = clCntNextNodeGet(gpClCpm->invocationTable, nodeHandle,
                              &nextNodeHandle);

        if((data = invocationData->data))
        {
            ClUint32T matched = 0;
            if ((invocationData->flags & CL_CPM_INVOCATION_AMS))
            {
                matched = !strncmp((const ClCharT *) (((ClAmsInvocationT*) data)->compName.value), (const ClCharT *) compName->value,
                                ((ClAmsInvocationT*) data)->compName.length);
            }
            else if ((invocationData->flags & CL_CPM_INVOCATION_CPM))
            {
                matched = !strncmp((const ClCharT *) (((ClCpmComponentT*) data)->compConfig->compName), (const ClCharT *) compName->value,
                                compName->length);
            }
            
            if(matched)
            {
                clLogDebug("INVOCATION", "CLEAR", "Clearing invocation for component [%.*s] "
                           "invocation [%#llx]", compName->length, compName->value, invocationData->invocation);
                if (clCntNodeDelete(gpClCpm->invocationTable, nodeHandle) != CL_OK)
                    goto withLock;
                if( (invocationData->flags & CL_CPM_INVOCATION_DATA_COPIED) )
                    clHeapFree(data);
                clHeapFree(invocationData);
            }
        }
        if (CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST)
            break;

        if (rc != CL_OK)
            goto withLock;

        nodeHandle = nextNodeHandle;

    }

    clOsalMutexUnlock(gpClCpm->invocationMutex);
    return CL_OK;

    withLock:
    failure:
    clOsalMutexUnlock(gpClCpm->invocationMutex);
    return rc;
}