mbuflib.c

VXWORKS源代码

/* mbufLib.c - BSD mbuf interface library */

/* Copyright 1984 - 2001 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01i,15oct01,rae  merge from truestack ver 01l, base 01h
01h,25aug98,n_s  corrected error handling of buffer allocate calls. spr #22104
01g,19sep97,vin  added clBlk specific code, changed pointers to refcounts
		 of clusters to refcounts since refcount has been moved to
                 clBlk
01f,12aug97,vin	 changed mBlkGet to take _pNetDpool
01e,22nov96,vin  added cluster support replaced m_get(..) with mBlkGet(..).
01d,29aug96,vin  made the code use only m_get.
01c,06jun96,vin  made compatible with BSD4.4 mbufs.
01b,13nov95,dzb  changed to validate mbufId.type off MBUF_VALID (SPR #4066).
01a,08nov94,dzb  written.
*/

/*
DESCRIPTION
This library contains routines to create, build, manipulate, and
delete BSD mbufs.  It serves as a back-end to the zbuf API provided
by zbufLib.

Note: The user should protect mbufs before calling these routines.  For many
      operations, it may be appropriate to guard with the spl semaphore.

NOMANUAL
*/

/* includes */

#include "vxWorks.h"
#include "zbufLib.h"
#include "mbufLib.h"
#include "errnoLib.h"
#include "intLib.h"
#include "stdlib.h"
#include "memPartLib.h"

#ifdef VIRTUAL_STACK
#include "netinet/vsLib.h"
#endif

/* globals */

MBUF_ID			_mbufIdHead = NULL;	/* Head ID of free chain */

/* locals */

LOCAL BOOL		mbufInit = FALSE;	/* library initialized ? */
LOCAL MBUF_DESC		mbufDescHead = NULL;	/* Head of free desc list */

/* declare mbuf interface function table */

LOCAL ZBUF_FUNC		mbufFunc =
    {
    (FUNCPTR) _mbufCreate,
    (FUNCPTR) _mbufDelete,
    (FUNCPTR) _mbufInsert,
    (FUNCPTR) _mbufInsertBuf,
    (FUNCPTR) _mbufInsertCopy,
    (FUNCPTR) _mbufExtractCopy,
    (FUNCPTR) _mbufCut,
    (FUNCPTR) _mbufSplit,
    (FUNCPTR) _mbufDup,
    (FUNCPTR) _mbufLength,
    (FUNCPTR) _mbufSegFind,
    (FUNCPTR) _mbufSegNext,
    (FUNCPTR) _mbufSegPrev,
    (FUNCPTR) _mbufSegData,
    (FUNCPTR) _mbufSegLength
    };

/* static function declarations */

LOCAL void		_mbufBufFree (MBUF_DESC mbufDesc, VOIDFUNCPTR freeRtn,
                            int freeArg);
LOCAL MBUF_SEG *	_mbufSegFindPrev (MBUF_ID mbufId, MBUF_SEG mbufSeg,
		            int *pOffset);

/*******************************************************************************
*
* _mbufLibInit - initialize the BSD mbuf interface library
*
* This routine initializes the BSD mbuf interface library and publishes
* the mbufLib API to the caller.  Lists of free ID structures and
* free mbuf cluster descriptors are allocated in this routine.
*
* The mbufLib API func table "mbufFunc" is published to the caller upon
* completion of initialization.  Typically, this func table is used by
* the zbuf facility to call mbuf routines within this library to perform
* buffering operations.  Even though the zbuf interface defines the ZBUF_FUNC
* struct, it doesn't necessarily mean that zbufs must be present.  This
* library may be used even if zbufs have been scaled out of the system.
*
* RETURNS:
* A pointer to a func table containing the mbufLib API,
* or NULL if the mbuf interface could not be initialized.
*
* NOMANUAL
*/

void * _mbufLibInit (void)
    {
    int			ix;			/* counter for list init */

    if (mbufInit == TRUE)			/* already initialized ? */
        return ((void *) &mbufFunc);

    if ((_mbufIdHead = (MBUF_ID) KHEAP_ALLOC((sizeof (struct mbufId) *
	MBUF_ID_INC))) == NULL)			/* alloc space for ID list */
        return (NULL);

    if ((mbufDescHead = (MBUF_DESC) KHEAP_ALLOC((sizeof (struct mbufDesc) *
	MBUF_DESC_INC))) == NULL)		/* alloc space for desc list */
	{
	KHEAP_FREE((char *)_mbufIdHead);
        return (NULL);
	}
	
    /* divide up into an sll of free mbuf ID's, _mbufIdHead as the head */

    for (ix = 0; ix < (MBUF_ID_INC - 1); ix++)
        _mbufIdHead[ix].mbufIdNext = &_mbufIdHead[ix + 1];
    _mbufIdHead[ix].mbufIdNext = NULL;

    /* divide up into an sll of free buf desc, mbufDescHead as the head */

    for (ix = 0; ix < (MBUF_DESC_INC - 1); ix++)
        mbufDescHead[ix].mbufDescNext = &mbufDescHead[ix + 1];
    mbufDescHead[ix].mbufDescNext = NULL;

    mbufInit = TRUE;				/* init successful */

    return ((void *) &mbufFunc);		/* return mbuf func table */
    }

/*******************************************************************************
*
* _mbufCreate - create an empty mbuf ID
*
* This routine creates an mbuf ID, which remains empty (i.e., does not
* contain any mbufs) until mbufs are added by the mbuf insertion routines.
* Operations performed on mbufs require an mbuf ID, which is returned by
* this routine.
*
* RETURNS:
* An mbuf ID, or NULL if an mbuf ID could not be created.
*
* SEE ALSO: _mbufCreate
*
* NOMANUAL
*/

MBUF_ID _mbufCreate (void)
    {
    MBUF_ID		mbufId;			/* obtained mbuf ID */
    int			ix;			/* counter for list init */
    int			lockKey = intLock ();	/* int lock cookie */

    if ((mbufId = _mbufIdHead) != NULL)		/* free list empty ? */
        {
        _mbufIdHead = mbufId->mbufIdNext;	/* pop first ID off list */
        intUnlock (lockKey);

        mbufId->type = MBUF_VALID;		/* init new ID type */
        mbufId->mbufHead = NULL;		/* init new ID head */
        }
    else					/* list is empty */
	{
        intUnlock (lockKey);

        if ((mbufId = (MBUF_ID) KHEAP_ALLOC((sizeof (struct mbufId) *
            MBUF_ID_INC))) != NULL)		/* alloc more IDs */
            {
            for (ix = 0; ix < (MBUF_ID_INC - 1); ix++)	/* into an sll */
                mbufId[ix].mbufIdNext = &mbufId[ix + 1];

            lockKey = intLock ();
            mbufId[ix].mbufIdNext = _mbufIdHead;
            _mbufIdHead = mbufId->mbufIdNext;	/* hook head onto new list */
            intUnlock (lockKey);

            mbufId->type = MBUF_VALID;		/* init new ID type */
            mbufId->mbufHead = NULL;		/* init new ID head */
            }
        }

    return (mbufId);				/* return new ID */
    }

/*******************************************************************************
*
* _mbufDelete - delete an mbuf ID and free any associated mbufs
*
* This routine will free any mbufs associated with <mbufId>, then
* delete the mbuf ID itself.  <mbufId> should not be used after this
* routine executes successfully.
*
* RETURNS:
* OK, or ERROR if the mbuf ID could not be deleted.
*
* SEE ALSO: _mbufCreate
*
* NOMANUAL
*/

STATUS _mbufDelete
    (
    MBUF_ID		mbufId		/* mbuf ID to free */
    )
    {
    /* already free ? */
    
    if (mbufId == NULL || mbufId->type != MBUF_VALID)		
	{
	errno = S_mbufLib_ID_INVALID;		/* invalid if already free */
	return (ERROR);
	}

    MBUF_ID_DELETE(mbufId);			/* delete mbuf ID */

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

/*******************************************************************************
*
* _mbufInsert - insert an mbuf chain into another mbuf chain
*
* This routine inserts all <mbufId2> mbufs into <mbufId1> at the
* specified byte location
*
* The location of insertion is specified by <mbufSeg> and <offset>.  Note
* that insertion within a chain occurs before the byte location specified
* by <mbufSeg> and <offset>.  Additionally, note that <mbufSeg> and <offset>
* must be "NULL" and "0", respectively, when inserting into an empty mbuf ID.
*
* After all the <mbufId2> mbufs are inserted into <mbufId1>, the mbuf ID
* <mbufId2> is deleted.  <mbufId2> should not be used after this routine
* executes successfully.
*
* RETURNS:
* The mbuf pointer associated with the first inserted mbuf,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufInsert
    (
    MBUF_ID		mbufId1,	/* mbuf ID to insert <mbufId2> into */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset,		/* relative byte offset */
    MBUF_ID		mbufId2		/* mbuf ID to insert into <mbufId1> */
    )
    {
    MBUF_ID		mbufIdNew;		/* dummy ID for dup operation */
    MBUF_SEG *		pMbufPrev;		/* mbuf prev to insert */
    MBUF_SEG		mbufEnd;		/* last Id2 mbuf */
    int			maxLen = MBUF_END;	/* offset for last Id2 byte */

    /* find the mbuf ptr previous to the point of insertion */

    if ((pMbufPrev = _mbufSegFindPrev (mbufId1, mbufSeg, &offset)) == NULL)
        return (NULL);

    if ((mbufEnd = _mbufSegFind (mbufId2, NULL, &maxLen)) == NULL)
	return (NULL);				/* find end mbuf of Id2 */

    if (offset == 0)				/* if prepend... */
	{
	mbufEnd->m_next = *pMbufPrev;
	*pMbufPrev = mbufId2->mbufHead;
        }
    else					/* else insert... */
        {
	mbufSeg = *pMbufPrev;			/* find insertion mbuf */

        if ((mbufIdNew = _mbufDup (mbufId1, mbufSeg, offset,
            mbufSeg->m_len - offset)) == NULL)
            return (NULL);			/* dup later portion */

        mbufSeg->m_len = offset;		/* shorten to first portion */
        mbufIdNew->mbufHead->m_next = mbufSeg->m_next;
        mbufEnd->m_next = mbufIdNew->mbufHead;	/* insert Id2 */
        mbufSeg->m_next = mbufId2->mbufHead;
        MBUF_ID_DELETE_EMPTY(mbufIdNew);	/* delete dup ID */
	}

    mbufEnd = mbufId2->mbufHead;		/* save head for return */

    if (mbufId2->type == MBUF_VALID)
	{
        MBUF_ID_DELETE_EMPTY(mbufId2);		/* delete ref to Id2 */
	}

    return (mbufEnd);				/* return inserted mbuf */
    }

/*******************************************************************************
*
* _mbufInsertBuf - create a cluster from a buffer and insert into an mbuf chain
*
* This routine creates an mbuf cluster from the user buffer <buf> and
* inserts it at the specified byte location in <mbufId>.
*
* The location of insertion is specified by <mbufSeg> and <offset>.  Note
* that insertion within a chain occurs before the byte location specified
* by <mbufSeg> and <offset>.  Additionally, note that <mbufSeg> and <offset>
* must be "NULL" and "0", respectively, when inserting into an empty mbuf ID.
*
* The user provided free routine <freeRtn> will be called when the mbuf
* cluster created from <buf> is not being referenced by any more mbufs.
* If <freeRtn> is NULL, the mbuf will function normally, except that the
* user will not be notified when no more mbufs reference cluster containing
* <buf>.  <freeRtn> will be called from the context of the task that last
* references the cluster.  <freeRtn> should be declared as follows:
* .CS
*       void freeRtn
*           (
*           caddr_t     buf,    /@ pointer to user buffer @/
*           int         freeArg /@ user provided argument to free routine @/
*           )
* .CE
*
* RETURNS:
* The mbuf pointer associated with the inserted mbuf cluster,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufInsertBuf
    (
    MBUF_ID		mbufId,		/* mbuf	ID which buffer is inserted */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset,		/* relative byte offset */
    caddr_t		buf,		/* user buffer for mbuf cluster */
    int			len,		/* number of bytes to insert */
    VOIDFUNCPTR		freeRtn,	/* user free routine */
    int			freeArg		/* argument to free routine */
    )
    {
    MBUF_ID		mbufIdNew;		/* mbuf ID containing <buf> */
    MBUF_DESC 		mbufDesc;		/* desc for <buf> cluster */
    MBUF_SEG		mbufNew;		/* mbuf for <buf> cluster */
    CL_BLK_ID		pClBlk;			/* pointer to cluster blk */
    int			lockKey;		/* int lock cookie */
    int			ix;			/* counter for list init */

    if (len <= 0)				/* have to insert some bytes */
        {
	errno = S_mbufLib_LENGTH_INVALID;
	return (NULL);
	}

    MBUF_ID_CREATE (mbufIdNew);			/* create new mbuf ID for buf */
    if (mbufIdNew == NULL)
	return (NULL);

    lockKey = intLock ();

    if ((mbufDesc = mbufDescHead) != NULL)	/* free list empty ? */
        {
        mbufDescHead = mbufDesc->mbufDescNext;	/* pop first desc off list */
        intUnlock (lockKey);
	}
    else					/* list is empty */
	{
        intUnlock (lockKey);

	if ((mbufDesc = (MBUF_DESC) KHEAP_ALLOC((sizeof (struct mbufDesc) *
	    MBUF_DESC_INC))) != NULL)		/* alloc more desc's */
            {
            for (ix = 0; ix < (MBUF_DESC_INC - 1); ix++)
                mbufDesc[ix].mbufDescNext = &mbufDesc[ix + 1];

            lockKey = intLock ();
            mbufDesc[ix].mbufDescNext = mbufDescHead;
            mbufDescHead = mbufDesc->mbufDescNext;/* hook head onto new list */
            intUnlock (lockKey);
	    }
        }

    if (mbufDesc == NULL)			/* able to get a new desc ? */
	{
        MBUF_ID_DELETE_EMPTY(mbufIdNew);
	return (NULL);
	}

    mbufDesc->buf = buf;

    /* get mbuf for cluster */
    
    if ( (mbufNew = mBlkGet (_pNetDpool, M_WAIT, MT_DATA)) == NULL)
        {
	/* release on fail */

	lockKey = intLock ();
	mbufDescHead = mbufDesc;
	intUnlock (lockKey);

	MBUF_ID_DELETE_EMPTY (mbufIdNew);		
	return (NULL);
	}

    pClBlk = clBlkGet (_pNetDpool, M_WAIT); 
    
    if (pClBlk == NULL)			/* out of cl Blks */
        {
        m_free (mbufNew);

	lockKey = intLock ();
	mbufDescHead = mbufDesc;
	intUnlock (lockKey);

	MBUF_ID_DELETE_EMPTY (mbufIdNew);		
	return (NULL);
        }

    mbufNew->pClBlk		= pClBlk;

    /* build <buf> into an mbuf cluster */
    mbufNew->m_data		= buf;
    mbufNew->m_len		= len;
    mbufNew->m_flags		|= M_EXT;
    mbufNew->m_extBuf		= buf;
    mbufNew->m_extSize		= len;
    mbufNew->m_extFreeRtn	= (FUNCPTR) _mbufBufFree;
    mbufNew->m_extRefCnt	= 1;
    mbufNew->m_extArg1		= (int) mbufDesc;
    mbufNew->m_extArg2		= (int) freeRtn;
    mbufNew->m_extArg3		= freeArg;

    mbufIdNew->mbufHead = mbufNew;		/* put cluster into new ID */

    /* insert the new mbuf ID with <buf> into <mbufId> */

    if ((mbufSeg = _mbufInsert (mbufId, mbufSeg, offset, mbufIdNew)) == NULL)
	{
        mbufNew->m_extArg2 = (int)NULL;		/* don't call freeRtn on fail */
        MBUF_ID_DELETE(mbufIdNew);
	}

    return (mbufSeg);				/* return inserted mbuf */
    }

/*******************************************************************************
*
* _mbufBufFree - free a user cluster buffer
*
* This routine is called when a cluster buffer is deleted, and no other
* mbuf clusters share the buffer space.  This routine calls the user free
* routine connected in _mbufInsertBuf(), then pushes the buffer decsriptor
* back onto the desc free list.
*
* RETURNS:
* N/A
*
* NOMANUAL
*/

LOCAL void _mbufBufFree
    (
    MBUF_DESC		mbufDesc,	/* desc of mbuf to free */
    VOIDFUNCPTR		freeRtn,	/* user free routine */
    int			freeArg		/* argument to free routine */
    )
    {
    int			lockKey;		/* int lock cookie */

    if (freeRtn != NULL)			/* call free rtn if present */