distnamelib.c

VXWORKS源代码

        }
#else
    distNameRmtAdd (DIST_IF_BROADCAST_ADDR, name, nameLen, value,
                    valueLen, type);
#endif

    return (OK);    /* return OK, always */
    }

/***************************************************************************
*
* distNameLclAdd - bind name to value in local name database (VxFusion option)
*
* This routine binds a name to a given value in name database. If <type>
* is a distributed object preprocess and postprocess identifier.
*
* NOTE: Before calling distNameLclAdd(), nameLen and valueLen
* must been tested to prevent overflows.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, if successful.
*
* NOMANUAL
*/

LOCAL STATUS distNameLclAdd
    (
    char *         name,     /* name to enter in database */
    int            nameLen,  /* strlen (name) */
    void *         value,    /* value associated with name */
    int            valueLen, /* size of value in bytes */
    DIST_NAME_TYPE type      /* type associated with name */
    )
    {
    DIST_NAME_DB_NODE * pDbNode;
    DIST_OBJ_NODE *     pObjNode;
    void *              pVal;
    MSG_Q_ID            msgQId;

    /* Preprocessing */

    switch (type)
        {
        case T_DIST_MSG_Q:
            {
            /*
             * A little tricky, what we do here: user gives us a
             * message queue id. Check if it is a distributed
             * message id. If not, return ERROR.
             * Create a new DIST_OBJ_NODE and copy distributed
             * id to new DIST_OBJ_NODE. Return the new MSG_Q_ID
             * (which is in fact another reference to the MSG_Q_ID,
             * the user gave us).
             */

            msgQId = *((MSG_Q_ID *) value);

            if (!ID_IS_DISTRIBUTED (msgQId))
                return (ERROR);    /* not a distributed message queue */
            if (DIST_OBJ_VERIFY (msgQId) == ERROR)
                return (ERROR);

            pObjNode = MSG_Q_ID_TO_DIST_OBJ_NODE (msgQId);
            if (! IS_DIST_MSG_Q_OBJ (pObjNode))
                return (ERROR); /* legal object id, but not a message queue */

            pVal = &(pObjNode->objNodeUniqId);
            valueLen = sizeof (pObjNode->objNodeUniqId);

            break;
            }
        default:
            pVal = value;
        }

    /* Local database update (raw part). */

    pDbNode = distNameLclAddRaw (name, nameLen, pVal, valueLen, type);
    if (pDbNode == NULL)
        return (ERROR);

    /* Postprocessing */

    switch (type)
        {
        case T_DIST_MSG_Q:
            *((MSG_Q_ID *) value) = *((MSG_Q_ID *) &pDbNode->value);
        }

    return (OK);
    }

/***************************************************************************
*
* distNameBurst - burst out name database (VxFusion option)
*
* This routine is used by INCO to update the remote name database on
* node <nodeId>. All entries in the database are transmitted.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, if successful.
*
* NOMANUAL
*/

STATUS distNameBurst
    (
    DIST_NODE_ID    nodeId    /* node receiving burst */
    )
    {
    DIST_NAME_BURST    burst;

    burst.burstNodeId = nodeId;
    burst.burstStatus = OK;

    distNameEach ((FUNCPTR) distNameBurstOne, (int) &burst);

    return (burst.burstStatus);
    }

/***************************************************************************
*
* distNameBurstOne - burst out single name database entry (VxFusion option)
*
* This routine bursts out a single database entry to a node.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: TRUE, if burst out successful
*
* NOMANUAL
*/

LOCAL BOOL distNameBurstOne
    (
    DIST_NAME_DB_NODE * pNode,   /* node receiving burst */
    DIST_NAME_BURST *   pBurst   /* the entry to send */
    )
    {
    char    *name = (char *) &pNode->symName;

    if ((pBurst->burstStatus = distNameRmtAdd (pBurst->burstNodeId,
            name, strlen (name), &pNode->value, pNode->valueLen,
            pNode->type)) == ERROR)
        return (FALSE);

    return (TRUE);
    }

/***************************************************************************
*
* distNameRmtAdd - bind name to value in remote name databases (VxFusion option)
*
* This routine adds or updates a name/value pair in a remote node.
*
* NOTE: Before calling distNameRmtAdd(), nameLen and valueLen
* must been tested to prevent overflows.
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, if successful.
*
* NOMANUAL
*/

LOCAL STATUS distNameRmtAdd
    (
    DIST_NODE_ID    nodeId,     /* node to address */
    char *          name,       /* name to enter in database */
    int             nameLen,    /* strlen (name) */
    void *          value,      /* value associated with name */
    int             valueLen,   /* size of value in bytes */
    DIST_NAME_TYPE  type        /* type associated with name */
    )
    {
    DIST_NAME_TYPE_ALL    valNet;
    DIST_PKT_DNDB_ADD     pktDndbAdd;
    DIST_IOVEC            IOVec[3];
    STATUS                status;
    void *                pValNet;
    DIST_OBJ_UNIQ_ID *    pObjUniqId;
    DIST_OBJ_NODE *       pObjNode;
    MSG_Q_ID              msgQId;

    /*
     * We have to copy data, since some processors allow
     * memory requests to non-aligned addresses, others
     * don't.
     */

    switch (type)
        {
        case T_DIST_UINT8:
            {
            pValNet = value;
            break;
            }
        case T_DIST_UINT16:
            {
            bcopy (value, (char *) &(valNet.uint16), valueLen);
            valNet.uint16 = htons (valNet.uint16);
            pValNet = &(valNet.uint16);
            break;
            }
        case T_DIST_NODE:
        case T_DIST_FLOAT:
        case T_DIST_UINT32:
            {
            bcopy (value, (char *) &(valNet.uint32), valueLen);
            valNet.uint32 = htonl (valNet.uint32);
            pValNet = &valNet.uint32;
            break;
            }
        case T_DIST_UINT64:
        case T_DIST_DOUBLE:
            {
            bcopy (value, (char *) &(valNet.uint64), valueLen);
            pValNet = distHton64((uint32_t*)&(valNet.uint64),type);
            break;
            }
        case T_DIST_MSG_Q:        /* complex objects go here */
            {
            /*
             * A little tricky, what we do here: user gives us a
             * message queue id. Check if it is a distributed
             * message id. If not, return ERROR.
             * Get the distributed (unique!) id instead of the
             * local MSG_Q_ID (local pointer).
             */

            msgQId = *((MSG_Q_ID *) value);

            if (!ID_IS_DISTRIBUTED (msgQId))
                return (ERROR);    /* not a distributed message queue */
            if (DIST_OBJ_VERIFY (msgQId) == ERROR)
                return (ERROR);

            pObjNode = MSG_Q_ID_TO_DIST_OBJ_NODE (msgQId);
            if (! IS_DIST_MSG_Q_OBJ (pObjNode))
                return (ERROR); /* legal object id, but not a message queue */

            bcopy ((char *) &(pObjNode->objNodeUniqId),
                   (char *) &(valNet.objUniqId),
                   sizeof (pObjNode->objNodeUniqId));

            pObjUniqId = (DIST_OBJ_UNIQ_ID *) &(valNet.objUniqId);
            pObjUniqId->objUniqReside    = htonl (pObjUniqId->objUniqReside);
            pObjUniqId->objUniqId        = htonl (pObjUniqId->objUniqId);

            pValNet = pObjUniqId;
            valueLen = sizeof (*pObjUniqId);
            break;
            }
        default:
            pValNet = value;    /* user defined, do not know what to do */
        }

    /* Remote database update. */

    pktDndbAdd.dndbAddHdr.pktType = DIST_PKT_TYPE_DNDB;
    pktDndbAdd.dndbAddHdr.pktSubType = DIST_PKT_TYPE_DNDB_ADD;
    pktDndbAdd.dndbAddType = htons (type);
    pktDndbAdd.dndbAddValueLen = (UINT8) valueLen;
    pktDndbAdd.dndbAddNameLen = (UINT8) nameLen;

    IOVec[0].pIOBuffer = &pktDndbAdd;
    IOVec[0].IOLen = DIST_PKT_HDR_SIZEOF (DIST_PKT_DNDB_ADD);
    IOVec[1].pIOBuffer = pValNet;
    IOVec[1].IOLen = valueLen;
    IOVec[2].pIOBuffer = name;
    IOVec[2].IOLen = nameLen;

    status = distNetIOVSend (nodeId, &IOVec[0], 3, WAIT_FOREVER,
            DIST_PKT_DNDB_PRIO);

    return (status);
    }

/***************************************************************************
*
* distNameFind - find an object by name in the local database (VxFusion option)
*
* This routine searches the distributed name database for an object matching
* a specified <name>. If the object is found, a pointer to the value and its
* type are copied to the address pointed to by <pValue> and <pType>.
* If the type is T_DIST_MSG_Q, the identifier returned can be used with
* generic message queue handling routines in msgQLib, such as msgQSend(), 
* msgQReceive(), and msgQNumMsgs().
*
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, or ERROR if the search fails.
*
* ERRNO:
* \is
* \i S_distNameLib_NAME_TOO_LONG
* The name to be found in the database is too long.
* \i S_distNameLib_INVALID_WAIT_TYPE
* The wait type should be either NO_WAIT or WAIT_FOREVER .
* \ie
*/

STATUS distNameFind
    (
    char *           name,    /* name to search for            */
    void **          pValue,  /* where to return ptr to value */
    DIST_NAME_TYPE * pType,   /* where to return type  */
    int              waitType /* NO_WAIT or WAIT_FOREVER       */
    )
    {
    DIST_NAME_DB_NODE * pNode;
    DIST_NAME_DB_NODE   matchNode;
    int                 nameLen;

    if ((nameLen = strlen (name)) > DIST_NAME_MAX_LENGTH)
        {
        errnoSet (S_distNameLib_NAME_TOO_LONG);
        return (ERROR);    /* name too long */
        }

    if (waitType != NO_WAIT && waitType != WAIT_FOREVER)
        {
        errnoSet (S_distNameLib_INVALID_WAIT_TYPE);
        return (ERROR); /* wait type is invalid */
        }

    bcopy (name, (char *) &matchNode.symName, nameLen + 1);

again:

    distNameLclLock();

    pNode = (DIST_NAME_DB_NODE *) hashTblFind (distNameDbId,
            (HASH_NODE *)&matchNode, KEY_CMP_ARG);

    distNameLclUnlock();

    if (!pNode)
        {
        if (waitType == WAIT_FOREVER)
            {
            /* object not found; we have to wait ... */
            distNameLclBlockOnAdd();
            goto again;
            }
        else
            return (ERROR);    /* object not found */
        }
    
    *pType = pNode->type;
    *pValue = &pNode->value;

    return (OK);
    }

/***************************************************************************
*
* distNameFindByValueAndType - look up the name of an object by value and type (VxFusion option)
*
* This routine searches the distributed name database for an object matching
* a specified <value> and <type>. If the object is found, its name is 
* copied to the address pointed to by <name>.
*
* NOTE:
* Unlike the smNameFindByValue() routine, used with the shared-memory 
* objects name database, this routine must know the type of the object
* being searched for. Searching on the value only might not return a
* unique object.
* 
* AVAILABILITY
* This routine is distributed as a component of the unbundled distributed
* message queues option, VxFusion.
*
* RETURNS: OK, or ERROR if the search fails.
*