distnodelib.c

VXWORKS源代码

                }
            return (ERROR);
            }

        case DIST_CTL_CRASHED_HOOK:
            {
            for (i = 0; i < DIST_NODE_MAX_HOOKS; i++)
                {
                if (distNodeCrashedHook[i] == NULL)
                    {
                    distNodeCrashedHook[i] = (FUNCPTR) arg;
                    return (OK);
                    }
                }
            return (ERROR);
            }

        case DIST_CTL_GET_LOCAL_ID:
            return (distNodeLocalId);

        case DIST_CTL_GET_LOCAL_STATE:
            return (distNodeLocalState);

        case DIST_CTL_NACK_SUPPORT:
            if ((BOOL) arg != TRUE && (BOOL) arg != FALSE)
                return (ERROR);
            distNodeSupportNACK = (BOOL) arg;
            return (OK);

        case DIST_CTL_PGGYBAK_BRDCST_SUPPORT:
            if ((BOOL) arg != TRUE && (BOOL) arg != FALSE)
                return (ERROR);
            distNodeSupportPBB = (BOOL) arg;
            return (OK);

        case DIST_CTL_PGGYBAK_UNICST_SUPPORT:
            if ((BOOL) arg != TRUE && (BOOL) arg != FALSE)
                return (ERROR);
            distNodeSupportPBU = (BOOL) arg;
            return (OK);

        default:
            errnoSet (S_distLib_UNKNOWN_REQUEST);
            return (ERROR);
        }
    }

/***************************************************************************
*
* distNodeSendBootstrap - send a bootstrap packet (VxFusion option)
*
* This routine sends a bootstrap packet.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, if packet sent.
* NOMANUAL
*/

LOCAL STATUS distNodeSendBootstrap
    (
    DIST_NODE_ID dest,     /* destination node */
    int          type,     /* bootstrap type */
    int          timeout   /* xmit timeout */
    )
    {
    DIST_TBUF_HDR * pTBufHdr;
    DIST_PKT_BOOT * pPkt;
    DIST_TBUF *     pTBuf;
    
    if ((pTBufHdr = DIST_TBUF_HDR_ALLOC ()) == NULL)
        return (ERROR);             /* out of TBufs */

    pTBufHdr->tBufHdrPrio = DIST_BOOTSTRAP_PRIO;
    pTBufHdr->tBufHdrDest = dest;
    pTBufHdr->tBufHdrOverall = sizeof (*pPkt);
    pTBufHdr->tBufHdrTimo = timeout;
    
    
    if ((pTBuf = DIST_TBUF_ALLOC ()) == NULL)
        {
        DIST_TBUF_FREEM (pTBufHdr);
        return (ERROR);                /* out of TBufs */
        }
        
    pTBuf->tBufFlags = DIST_TBUF_FLAG_HDR | DIST_TBUF_FLAG_BROADCAST;
    pTBuf->tBufType = DIST_TBUF_TTYPE_BOOTSTRAP;
    pTBuf->tBufSeq = 0;
    pTBuf->tBufNBytes = sizeof (*pPkt);

    pPkt = (DIST_PKT_BOOT *) pTBuf->pTBufData;
    

    DIST_TBUF_ENQUEUE (pTBufHdr, pTBuf);

    pPkt->pktBootType = (UINT8) type;
    return (distNodePktSend (pTBufHdr));
    }

/***************************************************************************
*
* distNodeBootstrap - broadcast a bootstrap packet (VxFusion option)
*
* This routine broadcasts a bootstrap packet.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, if broadcast succeeds.
* NOMANUAL
*/

STATUS distNodeBootstrap
    (
    int    timeout   /* xmit timeout */
    )
    {
    STATUS status;
    status = distNodeSendBootstrap (DIST_IF_BROADCAST_ADDR,
                                    DIST_BOOTING_REQ, timeout);
    return (status);
    }

/***************************************************************************
*
* distNodeFindById - find node in node database (VxFusion option)
*
* This routine tries to find the information node with node id <nodeId>
* in the node database.
*
* This routine takes <distNodeDbLock>.  Usually, it will be called with
* the lock already taken, but not always, so the lock is taken here
* to be safe.
*
* RETURNS: Pointer to the node entry, or NULL if not found.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* NOMANUAL
*/

LOCAL DIST_NODE_DB_NODE * distNodeFindById
    (
    DIST_NODE_ID    nodeId   /* ID of node to find */
    )
    {
    DIST_NODE_DB_NODE   distNodeMatch;
    DIST_NODE_DB_NODE * pDistNodeFound;

    distNodeMatch.nodeId = nodeId;
    
    DIST_NODE_DB_LOCK;

    pDistNodeFound =
       (DIST_NODE_DB_NODE *) hashTblFind (distNodeDbId,
                                          (HASH_NODE *) &distNodeMatch,
                                          KEY_CMP_ARG);
    DIST_NODE_DB_UNLOCK;

    return (pDistNodeFound);
    }

/***************************************************************************
*
* distNodeCreate - create a new node (VxFusion option)
*
* This routine creates a new node with id <distNodeId>.
* distNodeCreate() returns a pointer to the DB entry.
*
* This function takes the DB node database lock before inserting the
* node into the database.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: Pointer to node, or NULL.
* NOMANUAL
*/

DIST_NODE_DB_NODE * distNodeCreate
    (
    DIST_NODE_ID    nodeId,   /* ID for new node */
    int             state     /* state of new node */
    )
    {
    DIST_NODE_DB_NODE * pNodeNew;
    DIST_NODE_BFLD *    pBFld;
    int                 sz;

    /* This node is new to the database. */

#ifdef DIST_NODE_REPORT
    distLog("distNodeCreate: Creating node 0x%lx with state %d\n",
            nodeId, state);
#endif

    /* allocate needed space; quit if we can't get it */
    
    pNodeNew = (DIST_NODE_DB_NODE *) malloc (sizeof (DIST_NODE_DB_NODE));
    if (pNodeNew == NULL)
        {
        distStat.memShortage++;
        return (NULL);
        }

    sz = DIST_NODE_BFLD_SIZEOF (DIST_IF_RNG_BUF_SZ);
    pBFld = (DIST_NODE_BFLD *) malloc (4 * sz);
    if (pBFld == NULL)
        {
        free(pNodeNew);          /* no memory leaks here */
        distStat.memShortage++;
        return (NULL);
        }

    /* now fill in DIST_NODE_DB_NODE info */

    bzero ((char *) pNodeNew, sizeof (DIST_NODE_DB_NODE));
    pNodeNew->nodeId = nodeId;
    pNodeNew->nodeBroadcast.commAckLastRecvd = (INT16) winSub (0, 1);
    pNodeNew->nodeState = state;

    distNodeNumNodesAll++;

    if (DIST_NODE_STATE_IS_ALIVE (state))
        distNodeNumNodesAlive++;

    if (state == DIST_NODE_STATE_OPERATIONAL)
        distNodeNumNodesOperational++;

    pNodeNew->nodeState = state;


    bzero ((char *) pBFld, 2 * sz);
    pNodeNew->nodeUnicast.pCommCompleted = pBFld;
    pNodeNew->nodeBroadcast.pCommCompleted = ((char *) pBFld) + sz;
    
    /* now link the node into the data base */
    
    DIST_NODE_DB_LOCK;

    hashTblPut (distNodeDbId, (HASH_NODE *)pNodeNew);

    DIST_NODE_DB_UNLOCK;

    return (pNodeNew);
    }

/***************************************************************************
*
* distNodeSetState - set state of a node (VxFusion option)
*
* This routine is used to change the state of a node.  It is only called
* from two places in distNodeReassemble() which takes the node DB lock.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: N/A
* NOMANUAL
*/

LOCAL void distNodeSetState
    (
    DIST_NODE_DB_NODE * pNode,     /* node */
    int                 newState   /* new state */
    )
    {
    int             curState = pNode->nodeState;
    DIST_NODE_ID    nodeId   = pNode->nodeId;
    int             i;

#ifdef DIST_DIAGNOSTIC
    if (curState != newState)
        distLog ("distNodeSetState: state of node 0x%lx shifts from %s to %s\n",
                 nodeId,
                 distNodeStateToName (curState),
                 distNodeStateToName (newState));
#endif

    if ((! DIST_NODE_STATE_IS_ALIVE (curState)) &&
         DIST_NODE_STATE_IS_ALIVE (newState))
        {
        distNodeNumNodesAlive++;
        }
        
    if (DIST_NODE_STATE_IS_ALIVE (curState) &&
        (! DIST_NODE_STATE_IS_ALIVE (newState)))
        {
        distNodeNumNodesAlive--;
        }

    if (curState < DIST_NODE_STATE_OPERATIONAL &&
            newState == DIST_NODE_STATE_OPERATIONAL)
        {

        distNodeNumNodesOperational++;

        for (i = 0; i < DIST_NODE_MAX_HOOKS; i++)
            {
            if (distNodeOperationalHook[i] != NULL)
                (* (distNodeOperationalHook[i])) (nodeId);
            }

        pNode->nodeState = newState;
        return;
        }

    if (curState == DIST_NODE_STATE_OPERATIONAL &&
        newState < DIST_NODE_STATE_OPERATIONAL)
        {
        distNodeNumNodesOperational--;

        if (newState == DIST_NODE_STATE_CRASHED)
            {
            for (i = 0; i < DIST_NODE_MAX_HOOKS; i++)
                {
                if (distNodeCrashedHook[i] != NULL)
                    (* (distNodeCrashedHook[i])) (nodeId);
                }
            }

        pNode->nodeState = newState;
        return;
        }

    pNode->nodeState = newState;
    }

/***************************************************************************
*
* distNodeOperational - sets a node to be alive (VxFusion option)
*
* This routine changes the state of the node with the id <distNodeId>
* to OPERATIONAL.
*
* This routine takes <distNodeDbLock>.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: Pointer to node, or NULL.
* NOMANUAL
*/

DIST_NODE_DB_NODE * distNodeOperational
    (
    DIST_NODE_ID   distNodeId  /* node ID */
    )
    {
    DIST_NODE_DB_NODE * pNodeFound;
    int                 i;

    DIST_NODE_DB_LOCK;
     
    if ((pNodeFound = distNodeFindById (distNodeId)) != NULL)
        {

        /*
         * This node is already in the node database. If state is already
         * OPERATIONAL, do nothing - we even have not recognized the absence.
         */

        if (! DIST_NODE_IS_ALIVE (pNodeFound))
            distNodeNumNodesAlive++;

        if (pNodeFound->nodeState < DIST_NODE_STATE_OPERATIONAL)
            {

#ifdef DIST_DIAGNOSTIC
        distLog ("distNodeOperational: Set node 0x%lx to state OPERATIONAL\n",
                distNodeId);
#endif
            distNodeNumNodesOperational++;

            for (i = 0; i < DIST_NODE_MAX_HOOKS; i++)
                {
                if (distNodeOperationalHook[i] != NULL)
                    (* (distNodeOperationalHook[i])) (distNodeId);
                }
            }

        pNodeFound->nodeState = DIST_NODE_STATE_OPERATIONAL;
        }
    
    DIST_NODE_DB_UNLOCK;
    
    return (pNodeFound);
    }

/***************************************************************************
*
* distNodeCrashed - sets a node to be dead (VxFusion option)
*
* This routine changes the state of the node with the id <distNodeId>
* to CRASHED.
*
* This routine takes <distNodeDbLock>.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: Pointer to node, or NULL.
* NOMANUAL
*/

DIST_NODE_DB_NODE * distNodeCrashed
    (
    DIST_NODE_ID    distNodeId  /* node ID */
    )
    {
    DIST_NODE_DB_NODE * pNodeFound;
    int                 i;

    /* you cannot kill the broadcast node */
    
    if (distNodeId == DIST_IF_BROADCAST_ADDR)
        return (NULL);
    
    DIST_NODE_DB_LOCK;

    /* find the node */

    if ((pNodeFound = distNodeFindById (distNodeId)) != NULL)
        {

        if (DIST_NODE_IS_ALIVE (pNodeFound))
            distNodeNumNodesAlive--;

        if (pNodeFound->nodeState >= DIST_NODE_STATE_OPERATIONAL)
            {

#ifdef DIST_DIAGNOSTIC
        distLog ("distNodeCrashed: Set node 0x%lx to state CRASHED\n",
                distNodeId);
#endif