endnetbuflib.c

操作系统vxworks平台下end设备的驱动程序,支持多种芯片,支持多种cpu

    int 		num,		/* number of units to allocate */
    int			unitSize,	/* size of each unit */
    int			headerSize,	/* hidden header size */
    char *		memArea		/* pre allocated memory area */
    )
    {
    if (((int) unitSize & ~(sizeof (void *) - 1)) != unitSize )
        {
        errno = S_netBufLib_MEMSIZE_UNALIGNED;
        return (ERROR);				/* unaligned size */
        }

    unitSize += headerSize;		/* adjust for NET_POOL_ID */

    if (memArea == NULL)
        {
        errno = S_netBufLib_MEMAREA_INVALID;
        return (ERROR);
        }

    if (((int) memArea & ~(sizeof (void *) - 1)) != (int)memArea )
        {
        errno = S_netBufLib_MEM_UNALIGNED;
        return (ERROR);				/* unaligned memory */
        }

    bzero ((char *)memArea, (num * unitSize));

    return (OK);
    }

/*******************************************************************************
*
* _endMBlkFree - free the given mBlk
*
* This function frees the given mBlk and returns it to the mBlk pool.
*
* RETURNS: N/A
*
* NOMANUAL
*/

LOCAL void _endMBlkFree
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    M_BLK_ID	 	pMblk		/* mBlk to free */
    )
    {
    FAST int		ms;

    pMblk->mBlkHdr.mNextPkt 	= NULL;

    ms = intLock ();
    pNetPool->pPoolStat->mTypes [pMblk->mBlkHdr.mType]--;
    pNetPool->pPoolStat->mTypes [MT_FREE]++;
    pMblk->mBlkHdr.mType 	= MT_FREE;
    pMblk->mBlkHdr.mNext 	= pNetPool->pmBlkHead;
    pNetPool->pmBlkHead 	= pMblk; /* add the mbuf to the free list */

    intUnlock (ms);
    }

/*******************************************************************************
*
* _endClBlkFree - free the given cluster Blk
*
* This function frees the given clBlk and returns it to the cluster Blk pool.
*
* RETURNS: N/A
*
* NOMANUAL
*/

LOCAL void _endClBlkFree
    (
    CL_BLK_ID	 	pClBlk		/* clBlk to free */
    )
    {
    FAST int		level;
    CL_BUF_ID		pClBuf;
    NET_POOL_ID		pNetPool;	/* pointer to the net pool */
    
    pNetPool = pClBlk->pNetPool;
    pClBuf   = (CL_BUF_ID)pClBlk->clNode.pClBuf;

    level = intLock ();			/* lock interrupts briefly */
    if (pClBuf == NULL)			/* no cluster attached */
        goto returnClBlk;

    else if (--(pClBlk->clRefCnt) == 0)
        {
        if (pClBlk->pClFreeRtn != NULL)
            {	/* call the free routine if associated with one */
            intUnlock (level);
 
	    (*pClBlk->pClFreeRtn) (pClBlk->clFreeArg1, pClBlk->clFreeArg2,
                                   pClBlk->clFreeArg3);
            level = intLock ();
            }
        else
            {
            _endClFree (pNetPool, (char *)pClBuf);
	    }
        goto returnClBlk;
	}
    else
        goto clBlkFreeEnd;

    returnClBlk:
    /* free the cluster blk and add it to the free list */
    pClBlk->clNode.pClBlkNext 	= pNetPool->pClBlkHead;
    pNetPool->pClBlkHead 	= pClBlk;

    clBlkFreeEnd:

    intUnlock (level);
    }

/*******************************************************************************
*
* _endClFree - free a  cluster of a given size.
*
* This function frees a cluster of given size in a net pool
*
* RETURNS: N/A
*
* NOMANUAL
*/

LOCAL void _endClFree
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    char * 		pClBuf		/* pointer to the cluster buffer */
    )
    {
    FAST int		level;
    END_CL_POOL *       pEndClPool;

    pEndClPool = (END_CL_POOL *)pNetPool->clTbl[0];
 
    level = intLock ();

    if (pEndClPool->clPool.clNumFree < pEndClPool->clPool.clNum)
        {
        pEndClPool->clPool.clNumFree++;
        pEndClPool->clFreeArray[pEndClPool->clPool.clNumFree] = (UINT32)pClBuf;
        }
    intUnlock (level);
    }

/*******************************************************************************
*
* _endMBlkClFree - free an mBlk/cluster pair.
*
* This function frees a mBlk/cluster pair.  This function returns a pointer
* to the next mBlk which is connected to the current one.  This routine will
* free the cluster only if it is attached to the mBlk.
*
* RETURNS: M_BLK_ID or NULL.
*
* NOMANUAL
*/

LOCAL M_BLK_ID _endMBlkClFree
    (
    NET_POOL_ID		pNetPool,	/* pointer to net pool */
    M_BLK_ID 		pMblk		/* pointer to the mBlk */
    )
    {
    M_BLK_ID		pMblkNext;	/* pointer to the next mBlk */

    if (pMblk->mBlkHdr.mType == MT_FREE)
        {
#ifdef NETBUF_DEBUG
        logMsg ("mBlkClFree -- Invalid mBlk\n", 0, 0, 0, 0, 0, 0);
#endif /* NETBUF_DEBUG */
        errno = S_netBufLib_MBLK_INVALID;
        return (NULL);
        }

    pMblkNext = pMblk->mBlkHdr.mNext;

    /* free the cluster first if it is attached to the mBlk */

    if (M_HASCL(pMblk))
        netClBlkFree (pMblk->pClBlk->pNetPool, pMblk->pClBlk);

    _endMBlkFree (pNetPool, pMblk); 		/* free the mBlk */

    return (pMblkNext);

    }

/*******************************************************************************
*
* _endMBlkGet - get a free mBlk
*
* This routine returns a free mBlk if one is available. If the <canWait>
* parameter is set to M_WAIT and an mBlk is not immediately available, the
* routine repeats the allocation attempt after calling any installed garbage
* collection routine.
*
* RETURNS: M_BLK_ID or NULL if none available
*
* NOMANUAL
*/

LOCAL M_BLK_ID _endMBlkGet
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    int			canWait,	/* M_WAIT/M_DONTWAIT */
    UCHAR		type		/* mBlk type */
    )
    {
    M_BLK_ID	 	pMblk = NULL;	/* pointer to mbuf */
    int 		level;		/* level of interrupt */

    reTry:
    level = intLock();			/* lock interrupts very briefly */

    if ((pMblk = pNetPool->pmBlkHead) != NULL)
        {
        pNetPool->pmBlkHead = pMblk->mBlkHdr.mNext;
        pNetPool->pPoolStat->mTypes [MT_FREE]--;
        pNetPool->pPoolStat->mTypes [type]++;
        intUnlock (level); 			/* unlock interrupts */

        if (pMblk->mBlkHdr.mType != MT_FREE)
            {
#ifdef NETBUF_DEBUG
            logMsg("mBlkGet free error:\n", 0, 0, 0, 0, 0, 0);
#endif /* NETBUF_DEBUG */
            errno = S_netBufLib_MBLK_INVALID;
            return (NULL);
            }

        pMblk->mBlkHdr.mType	= type;
        pMblk->mBlkHdr.mNext 	= NULL;
        pMblk->mBlkHdr.mNextPkt = NULL;
        pMblk->mBlkHdr.mFlags 	= 0;
        }
    else /* if (canWait != M_ISR) */
        {
        if (canWait == M_WAIT)
            {
            if (_pNetBufCollect)
                {
                intUnlock (level);			/* unlock interrupts */
                (*_pNetBufCollect) (pNetPool->pPoolStat);
		canWait = M_DONTWAIT;
                goto reTry;
                }
            }
        pNetPool->pPoolStat->mDrops++;
        intUnlock (level);
	errnoSet (S_netBufLib_NO_POOL_MEMORY);
        }
    return (pMblk);
    }

/*******************************************************************************
*
* _endClBlkGet - get a free clBlk
*
* This routine returns a free clBlk if one is available. If the <canWait>
* parameter is set to M_WAIT and a clBlk is not immediately available, the
* routine repeats the allocation attempt after calling any installed garbage
* collection routine.
*
* RETURNS: CL_BLK_ID or NULL.
*
* NOMANUAL
*/

LOCAL CL_BLK_ID _endClBlkGet
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    int			canWait		/* M_WAIT/M_DONTWAIT */
    )
    {
    CL_BLK_ID	 	pClBlk = NULL;	/* pointer to mbuf */
    int 		level;		/* level of interrupt */

    reTry:
    level = intLock();			/* lock interrupts very briefly */
    if ((pClBlk = pNetPool->pClBlkHead) != NULL)
        {
        pNetPool->pClBlkHead = pClBlk->clNode.pClBlkNext;
        intUnlock (level); 			/* unlock interrupts */

        pClBlk->clNode.pClBuf = NULL;
        pClBlk->pClFreeRtn    = NULL;
        pClBlk->clRefCnt      = 0;
        pClBlk->pNetPool      = pNetPool; 	/* netPool originator */
        }
    else /* if (canWait != M_ISR) */
        {
        if (canWait == M_WAIT)
            {
            if (_pNetBufCollect)
                {
                intUnlock (level);			/* unlock interrupts */
                (*_pNetBufCollect) (pNetPool->pPoolStat);
		canWait = M_DONTWAIT;
                goto reTry;
                }
            }
        intUnlock (level);
       	errnoSet (S_netBufLib_NO_POOL_MEMORY);
	}

    return (pClBlk);
    }

/*******************************************************************************
*
* _endClusterGet - get a new cluster of a given cluster pool.
*
* This function returns a cluster given a pool pointer.  The reference count
* for the cluster is incremented.
*
* RETURNS: pointer to a cluster or NULL
*
* NOMANUAL
*/

LOCAL char * _endClusterGet
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    CL_POOL_ID 		pClPool 	/* ptr to the cluster pool */
    )
    {
    int		  level;			/* level of interrupt */
    CL_BUF_ID	  pClBuf;			/* ptr to the cluster buffer */
    END_CL_POOL * pEndClPool;

    pEndClPool = (END_CL_POOL *)pClPool;

    level = intLock (); 			/* lock interrupts briefly */

    if (pClPool->clNumFree > 0)
        {
        pClBuf = (CL_BUF_ID)pEndClPool->clFreeArray[pClPool->clNumFree];
        pClPool->clNumFree--;
        }
    else
        {
        intUnlock (level);
        return (NULL);
        }

    pClPool->clUsage++;				/* increment the usage count */

    intUnlock (level);

    return ((char *)pClBuf);
    }

/*******************************************************************************
*
* endMClGet - get a new mBlk/cluster pair.
*
* This function gets a free cluster from the NET_POOL and joins it with
* the mBlk passed to it.  An mBlk must be pre allocated and passed to this
* function.
*
* RETURNS: OK or ERROR.
*
* NOMANUAL
*/

LOCAL STATUS _endMClGet
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    M_BLK_ID	 	pMblk, 		/* mBlk to embed the cluster in */
    int			bufSize,	/* size of the buffer to get */
    int			canWait,	/* wait or dontwait */
    BOOL		bestFit		/* TRUE/FALSE */
    )
    {
    CL_BUF_ID		pClBuf = NULL; 	/* pointer to the cluster buffer */
    CL_BLK_ID		pClBlk = NULL; 	/* pointer to the cluster blk */
    FAST int 		ms; 		/* integer for level */
    END_CL_POOL *       pEndClPool;

    /* check pMblk */
    if ((pMblk == NULL) || ((pClBlk = _endClBlkGet (pNetPool, canWait)) == NULL))
	goto mClGetError;

    /* get the pool pointer */
    if ((pEndClPool = (END_CL_POOL *)pNetPool->clTbl [0]) == NULL)
	{
#ifdef NETBUF_DEBUG
	logMsg ("endMClGet: Invalid cluster type\n", 0, 0, 0, 0, 0, 0);
#endif /* NETBUF_DEBUG */
        errno = S_netBufLib_CLSIZE_INVALID;
	goto mClGetError;
	}
    
    reTry:
    ms = intLock(); 			/* lock interrupts briefly */

       if (pEndClPool->clPool.clNumFree == 0)
        {
        if (canWait == M_WAIT)	/* want for buffers */
            {
            if (_pNetBufCollect)
                {
                intUnlock (ms);
                (*_pNetBufCollect) (pNetPool->pPoolStat);
		canWait = M_DONTWAIT;
                goto reTry;
                }
            }
        }

     if ((pClBuf =(CL_BUF_ID) _endClusterGet(pNetPool, 
                                             (CL_POOL_ID)pEndClPool)) != NULL)
        intUnlock (ms);
    else
	{
	pNetPool->pPoolStat->mDrops++;	/* no. times failed to find space */
        intUnlock (ms);
	errnoSet (S_netBufLib_NO_POOL_MEMORY);
	goto mClGetError;
	}

    pMblk->mBlkHdr.mData  = (caddr_t) pClBuf;
    pMblk->mBlkHdr.mFlags |= M_EXT;
    pClBlk->clNode.pClBuf = (caddr_t) pClBuf;
    pClBlk->clSize	  = pEndClPool->clPool.clSize;
    pClBlk->pClFreeRtn	  = NULL;
    pClBlk->clRefCnt	  = 1;
    pMblk->pClBlk 	  = pClBlk;

    return (OK); 		/* return OK */

    mClGetError:
    if (pClBlk != NULL)
        _endClBlkFree (pClBlk);

    return (ERROR); 		/* return ERROR */
    }

/*******************************************************************************
*
* endClPoolIdGet - return a pool Id for a given cluster Size
*
* This function returns a poolID for a given cluster Size.
* If this returns NULL then the corresponding pool has not been initialized.
*
* RETURNS: CL_POOL_ID or NULL.
*
* NOMANUAL
*/

LOCAL CL_POOL_ID _endClPoolIdGet
    (
    NET_POOL_ID		pNetPool,	/* pointer to the net pool */
    int 		bufSize,	/* size of the buffer */
    BOOL		bestFit		/* TRUE/FALSE */
    )
    {
    return (pNetPool->clTbl [0]);
    }