mbuflib.c

This is a source code of VxWorks

        (*freeRtn) (mbufDesc->buf, freeArg);

    lockKey = intLock ();

    mbufDesc->mbufDescNext = mbufDescHead;	/* push desc onto free list */
    mbufDescHead = mbufDesc;

    intUnlock (lockKey);
    }

/*******************************************************************************
*
* _mbufInsertCopy - copy buffer data into an mbuf chain
*
* This routine copies <len> bytes of data from the user buffer <buf> and
* inserts it at the specified byte location in <mbufId>.  The user buffer
* is in no way tied to the mbuf chain after this operation; a separate copy
* of the data is made.
*
* 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.
*
* RETURNS:
* The mbuf pointer associated with the first inserted mbuf,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufInsertCopy
    (
    MBUF_ID		mbufId,		/* mbuf	ID into which data is copied */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset,		/* relative byte offset */
    caddr_t		buf,		/* buffer from which data is copied  */
    int			len		/* number of byte to copy */
    )
    {
    MBUF_ID		mbufIdNew;		/* dummy ID for dup operation */
    MBUF_SEG		mbufNew;		/* mbuf for copy */
    MBUF_SEG *		pMbufPrev;		/* mbuf previous to mbufNew */
    int			length;			/* length of each copy */

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

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

    pMbufPrev = &mbufIdNew->mbufHead;		/* init prev ptr to head */

    while (len)					/* while more to copy */
	{
	/* obtain a new mbuf with a data buffer pointed */

	if ( (mbufNew = mBufClGet (M_WAIT, MT_DATA, len, FALSE)) == NULL)
	    {
	    /* release on fail */

	    MBUF_ID_DELETE(mbufIdNew);		
	    return (NULL);
	    }

	length = min (len, mbufNew->m_extSize); /* num for copy */

        bcopy (buf, mtod (mbufNew, char *), length);

        buf += length;				/* bump to new buf position */
	len -= length;

	mbufNew->m_len = length;		/* set len to num copied */
        *pMbufPrev = mbufNew;                   /* hook prev into new */
	pMbufPrev = &mbufNew->m_next;           /* update prev mbuf ptr */
	}

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

    if ((mbufSeg = _mbufInsert (mbufId, mbufSeg, offset, mbufIdNew)) == NULL)
        {
	/* release on fail */

	MBUF_ID_DELETE(mbufIdNew);		
	return (NULL);
	}

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

/*******************************************************************************
*
* _mbufExtractCopy - copy data from an mbuf chain to a buffer
*
* This routine copies <len> bytes of data from <mbufId> to the user
* buffer <buf>.
*
* The starting location of the copy is specified by <mbufSeg> and <offset>.
*
* The number of bytes to be copied is given by <len>.  If this parameter
* is negative, or is larger than the number of bytes in the chain after the
* specified byte location, the rest of the chain will be copied. 
* The bytes to be copied may span more than one mbuf.
*
* RETURNS:
* The number of bytes copied from the mbuf chain to the buffer,
* or ERROR if the operation failed.
*
* NOMANUAL
*/

int _mbufExtractCopy
    (
    MBUF_ID		mbufId,		/* mbuf	ID from which data is copied */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset,		/* relative byte offset */
    caddr_t		buf,		/* buffer into which data is copied */
    int			len		/* number of bytes to copy */
    )
    {
    caddr_t		buf0 = buf;		/* save starting position */
    int			length;			/* length of each copy */

    /* find the starting location for copying */

    if ((mbufSeg = _mbufSegFind (mbufId, mbufSeg, &offset)) == NULL)
	return (ERROR);

    if (len < 0)				/* negative = rest of chain */
	len = INT_MAX;

    while (len && (mbufSeg != NULL))		/* while more to copy */
	{
        length = min (len, (mbufSeg->m_len - offset));	/* num for copy */

        bcopy (mtod (mbufSeg, char *) + offset, buf, length);

        buf += length;				/* bump to new buf position */
        len -= length;
	mbufSeg = mbufSeg->m_next;		/* bump to next mbuf in chain */
	offset = 0;				/* no more offset */
	}

    return ((int) buf - (int) buf0);		/* return num bytes copied */
    }

/*******************************************************************************
*
* _mbufCut - cut bytes from an mbuf chain
*
* This routine deletes <len> bytes from <mbufId> starting at the specified
* byte location.
*
* The starting location of deletion is specified by <mbufSeg> and <offset>.
*
* The number of bytes to be cut is given by <len>.  If this parameter
* is negative, or is larger than the number of bytes in the chain after the
* specified byte location, the rest of the chain will be deleted.
* The bytes to be deleted may span more than one mbuf.  If all the bytes
* in any one mbuf are deleted, then the mbuf will be returned to the
* system.  No mbuf may have zero bytes left in it.  
*
* Deleting bytes out of the middle of an mbuf will cause the mbuf to
* be split into two mbufs.  The first mbuf will contain the portion
* of the mbuf before the deleted bytes, while the other mbuf will
* contain the end portion that remains after <len> bytes are deleted.
*
* This routine returns the mbuf pointer associated with the mbuf just
* after the deleted bytes.  In the case where bytes are cut off the end
* of an mbuf chain, a value of MBUF_NONE is returned.
*
* RETURNS:
* The mbuf pointer associated with the mbuf following the deleted bytes,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufCut
    (
    MBUF_ID		mbufId,		/* mbuf	ID from which bytes are cut */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset,		/* relative byte offset */
    int			len		/* number of bytes to cut */
    )
    {
    MBUF_ID		mbufIdNew;	/* dummy ID for dup operation */
    MBUF_SEG *		pMbufPrev;	/* mbuf prev deleted mbuf */
    int			length;		/* length of each cut */

    /* find the mbuf ptr previous to the cut */

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

    if ((mbufSeg = *pMbufPrev) == NULL)		/* find cut mbuf */
	{
	errno = S_mbufLib_SEGMENT_NOT_FOUND;
	return (NULL);
	}

    if (len < 0)				/* negative = rest of chain */
	len = INT_MAX;

    while (len && (mbufSeg != NULL))		/* while more to cut */
	{
        length = min (len, (mbufSeg->m_len - offset)); /* num for cut */
        len -= length;

        if (offset != 0)			/* if !cutting off front... */
	    {
	    if (mbufSeg->m_len != (offset + length))/* cut from middle*/
		{
	        /* duplicate portion remaining after bytes to be cut */

                if ((mbufIdNew = _mbufDup (mbufId, mbufSeg, offset + length,
		    mbufSeg->m_len - offset - length)) == NULL)
	            return (NULL);
		
                mbufIdNew->mbufHead->m_next = mbufSeg->m_next;
                mbufSeg->m_next = mbufIdNew->mbufHead;/* hook in saved data */
                mbufSeg->m_len = offset;	/* shorten to later portion */
                MBUF_ID_DELETE_EMPTY(mbufIdNew);/* delete dup ID */
		return (mbufSeg->m_next);	/* return next real mbuf */
		}
            else				/* cut to end */
                {
                mbufSeg->m_len -= length;	/* decrease by len deleted */
		pMbufPrev = &mbufSeg->m_next;	/* update previous */
		mbufSeg = mbufSeg->m_next;	/* bump current mbuf to next */
		}

	    offset = 0;				/* no more offset */
	    }
        else					/* cutting off front... */
            {
	    if (length == mbufSeg->m_len)	/* cutting whole mbuf ? */
		{
		mbufSeg = m_free (mbufSeg);	/* free and get next mbuf */
		*pMbufPrev = mbufSeg;		/* hook prev to next mbuf */
		}
            else				/* cut off front portion */
		{
		mbufSeg->m_data += length;	/* bump up offset */
	        mbufSeg->m_len -= length;	/* taken from front */
		}
            }
        }

    if (mbufSeg == NULL)			/* special case - cut off end */
	return (MBUF_NONE);

    return (mbufSeg);				/* return next real mbuf */
    }

/*******************************************************************************
*
* _mbufSplit - split an mbuf chain into two separate mbuf chains
*
* This routine splits <mbufId> into two separate chains at the specified
* byte location.  The first portion remains in <mbufId>, while the end
* portion is returned in a newly created mbuf ID.
*
* The location of the split is specified by <mbufSeg> and <offset>.
*
* RETURNS:
* The mbuf ID of a newly created chain containing the end portion of <mbufId>,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_ID _mbufSplit
    (
    MBUF_ID		mbufId,		/* mbuf	ID to split into two */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset		/* relative byte offset */
    )
    {
    MBUF_ID		mbufIdNew;		/* mbuf ID of later portion */
    MBUF_SEG *		pMbufPrev;		/* mbuf prev to insert */

    /* find the mbuf ptr previous to the split */

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

    if (offset == 0)				/* in middle of mbuf */
	{
        MBUF_ID_CREATE (mbufIdNew);		/* create ID for end portion */
        if (mbufIdNew == NULL)
	    return (NULL);

        mbufIdNew->mbufHead = *pMbufPrev;	/* hook in new head */
        *pMbufPrev = NULL;			/* tie off first portion */
	}
    else					/* split on mbuf boundary */
	{
        mbufSeg = *pMbufPrev;			/* find split mbuf */

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

        mbufIdNew->mbufHead->m_next = mbufSeg->m_next;
        mbufSeg->m_len = offset;
        mbufSeg->m_next = NULL;			/* tie off first portion */
	}

    return (mbufIdNew);				/* return ID for end */
    }

/*******************************************************************************
*
* _mbufDup - duplicate an mbuf chain
*
* This routine duplicates <len> bytes of <mbufId> starting at the specified
* byte location, and returns the mbuf ID of the newly created duplicate mbuf.
*
* The starting location of duplication is specified by <mbufSeg> and <offset>.
* The number of bytes to be duplicated is given by <len>.  If this
* parameter is negative, or is larger than the than the number of bytes
* in the chain after the specified byte location, the rest of the chain will
* be duplicated.
*
* Duplication of mbuf data only involves copying of the data when the mbuf
* is not a cluster.  If the mbuf to be duplicated is a cluster, the mbuf
* pointer information is duplicated, while the data is not.  This implies
* that that the mbuf data is shared among all clusters associated
* with a particular cluster data buffer.
*
* RETURNS:
* The mbuf ID of a newly created dupicate mbuf chain,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_ID _mbufDup
    (
    MBUF_ID		mbufId,		/* mbuf ID to duplicate */
    MBUF_SEG		mbufSeg,	/* mbuf base for <offset> */
    int			offset,		/* relative byte offset */
    int			len		/* number of bytes to duplicate */
    )
    {
    MBUF_ID		mbufIdNew;	/* mbuf ID of duplicate */
    MBUF_SEG		mbufNew;	/* mbuf for duplicate */
    MBUF_SEG *		pMbufPrev;	/* mbuf prev to mbufNew */

    /* find the starting location for duplicate */

    if ((mbufSeg = _mbufSegFind (mbufId, mbufSeg, &offset)) == NULL)
        return (NULL);

    if (len < 0)				/* negative = rest of chain */
	len = INT_MAX;

    MBUF_ID_CREATE (mbufIdNew);			/* get ID for duplicate */
    if (mbufIdNew == NULL)
        return (NULL);

    pMbufPrev = &mbufIdNew->mbufHead;		/* init prev ptr to head */

    while (len && (mbufSeg != NULL))		/* while more to duplicate */
	{
	/* get mbuf for duplicate */
        if ( (mbufNew = mBlkGet (_pNetDpool, M_WAIT, mbufSeg->m_type)) == NULL)
	    {
	    /* release on fail */
	    
	    MBUF_ID_DELETE(mbufIdNew);		
	    return (NULL);
	    }

        mbufNew->m_len = min (len, (mbufSeg->m_len - offset));
        len -= mbufNew->m_len;			/* num to duplicate */

	/* copy the cluster header mbuf info to duplicate */
	mbufNew->m_data	= mtod (mbufSeg, char *)  + offset;
	mbufNew->m_flags	= mbufSeg->m_flags;
	mbufNew->m_ext	= mbufSeg->m_ext;

	/* bump share count */

	{
	int s = intLock ();
	++(mbufNew->m_extRefCnt);
	intUnlock (s);
	}
	    
	*pMbufPrev = mbufNew;			/* hook prev into duplicate */
        pMbufPrev = &mbufNew->m_next;		/* update prev mbuf ptr */
	mbufSeg = mbufSeg->m_next;		/* bump original chain */
	offset = 0;				/* no more offset */
	}

    return (mbufIdNew);				/* return ID of duplicate */
    }

/*******************************************************************************
*
* _mbufLength - determine the legnth in bytes of an mbuf chain
*
* This routine returns the number of bytes in the mbuf chain <mbufId>.
*
* RETURNS:
* The number of bytes in the mbuf chain,
* or ERROR if the operation failed
*
* NOMANUAL
*/

int _mbufLength
    (
    MBUF_ID		mbufId		/* mbuf	ID to find length of */
    )
    {
    MBUF_SEG		mbuf;
    int			length = 0;		/* total length */

    if (mbufId == NULL || 
	mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (ERROR);
	}

    for (mbuf = mbufId->mbufHead; mbuf != NULL; mbuf = mbuf->m_next)
        length += mbuf->m_len;

    return (length);				/* return total length */
    }

#if	FALSE
/*******************************************************************************
*
* _mbufSegJoin - coalesce two adjacent mbuf cluster fragments.
*
* This routine combines two or more contiguous mbufs into a single
* mbuf.  Such an operation is only feasible for joining mbufs
* that have the same freeRtn and freeArg, and that follow eachother in
* the chain.  This could be useful for coalescing mbufs fragmented
* by split operations.
* 
* Not in service yet -> not clear that it is a useful routine.
*
* NOMANUAL
*/

STATUS _mbufSegJoin
    (
    MBUF_ID		mbufId,		/* mbuf ID containing mbufs to join */
    MBUF_SEG		mbufSeg		/* first mbuf to join */
    )
    {
    MBUF_SEG		mbufNext;
    STATUS		status = ERROR;

    if (mbufId == NULL
	|| mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (ERROR);
	}

    if (mbufId->mbufHead == NULL)		/* is this chain empty ? */
        {	
	errno = S_mbufLib_ID_EMPTY;
	return (ERROR);
	}