ixosbuflib.c

INTEL IXP425的VXWORKS BSP

/* ixBufLib.c - network buffer library */

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

/*
modification history
--------------------
    - adapt from netBufLib.c 
    - cache line alignement
    - tune for optimal performances 

*/

/*
DESCRIPTION

This library contains routines that you can use to organize and maintain
a memory pool that consists of pools of `mBlk' structures, pools of `clBlk'
structures, and pools of clusters.  The `mBlk' and `clBlk' structures
are used to manage the clusters.  The clusters are containers for the data
described by the `mBlk' and `clBlk' structures.

These structures and the various routines of this library constitute a
buffering API that has been designed to meet the needs both of network 
protocols and network device drivers.
 
The `mBlk' structure is the primary vehicle for passing data between
a network driver and a protocol.  However, the `mBlk' structure must
first be properly joined with a `clBlk' structure that was previously
joined with a cluster.  Thus, the actual vehicle for passing data is
not merely an `mBlk' structure but an `mBlk'-`clBlk'-cluster
construct.
 
To use this feature, include the following component:
INCLUDE_NETWRS_NETBUFLIB


INCLUDE FILES: netBufLib.h

*/

/* includes */

#include "vxWorks.h"
#include "stdlib.h"
#include "intLib.h"
#include "string.h"
#include "semaphore.h"
#include "memLib.h"
#include "errnoLib.h"
#include "netBufLib.h"
#include "private/semLibP.h"
#include "netinet/if_ether.h"
#include "memPartLib.h"
#include "logLib.h"

#include "IxOsBufLib.h"

/* defines */
#undef NETBUF_DEBUG


/* mBlk size */
#define MBLK_SIZE               ROUND_UP((M_BLK_SZ + sizeof(long)), \
                                         _CACHE_ALIGN_SIZE)
/* cLBlk size */
#define CLBLK_SIZE              ROUND_UP(CL_BLK_SZ, _CACHE_ALIGN_SIZE)

/* global */

IMPORT VOIDFUNCPTR	_pNetBufCollect; /* protocol specific routine */

/* extern */

IMPORT int ffsMsb ();

/* forward declarations */
LOCAL STATUS ixAlignedPoolInit (NET_POOL_ID pNetPool, M_CL_CONFIG *pMclBlkConfig,
                                CL_DESC *pClDescTbl, int clDescTblNumEnt, BOOL fromKheap);
LOCAL M_BLK_ID 		ixMBlkCarve (NET_POOL_ID pNetPool, int num,
                                    char * pool);
LOCAL CL_BLK_ID 	ixClBlkCarve (int num, char * pool);
LOCAL CL_BUF_ID 	ixClPoolCarve (CL_POOL_ID pClPool, int num, int clSize,
                                      char * pool);
LOCAL STATUS 		ixMemPoolInit (int num, int unitSize, int headerSize,
                                      char * memArea);
LOCAL void		ixMBlkFree (NET_POOL_ID pNetPool, M_BLK_ID pMblk);
LOCAL void 		ixClBlkFree (CL_BLK_ID pClBlk);
LOCAL void 		ixClusterFree (NET_POOL_ID pNetPool, char * pClBuf);
LOCAL M_BLK_ID 		ixMBlkClFree (NET_POOL_ID pNetPool, M_BLK_ID pMblk);
LOCAL M_BLK_ID 		ixMBlkGet (NET_POOL_ID pNetPool, int canWait,
                                  UCHAR type);
LOCAL CL_BLK_ID		ixClBlkGet (NET_POOL_ID pNetPool, int canWait);
LOCAL char *	 	ixClusterGet (NET_POOL_ID pNetPool, CL_POOL_ID pClPool);
LOCAL STATUS 		ixMClGet (NET_POOL_ID pNetPool, M_BLK_ID pMblk,
                                 int bufSize, int canWait, BOOL bestFit);
LOCAL CL_POOL_ID 	ixClPoolIdGet (NET_POOL_ID pNetPool, int bufSize,
                                      BOOL bestFit);

LOCAL POOL_FUNC ixFuncTbl =		/* pool function table */
    {
	ixAlignedPoolInit,
	ixMBlkFree,
	ixClBlkFree,
	ixClusterFree,
	ixMBlkClFree,
	ixMBlkGet,
	ixClBlkGet,
	ixClusterGet,
	ixMClGet,
	ixClPoolIdGet,
    };

/*
 * this is a global pointer to a function table provided as a back door
 * for users who want to use a different allocation scheme for defaults
 * By initializing this _pNetPoolFuncTbl at runtime before initialization of
 * the network stack, one can change the default function table.  The system
 * pools use the default function table.
 */
   
POOL_FUNC * 	_pIxOsBufLibPoolFuncTbl = &ixFuncTbl;


/*******************************************************************
 * Get the amount of memory required to create 
 * an aligned buff pool 
 */
UINT32
ixAlignedPoolDataSize(int count, int size)
{
    return _CACHE_ALIGN_SIZE + 
	count * ROUND_UP(size, _CACHE_ALIGN_SIZE);
}

/* Get the amount of memory required to create 
 * an aligned buff pool 
*/
UINT32 
ixAlignedPoolMbufSize(int count)
{
    return _CACHE_ALIGN_SIZE +
	(count * MBLK_SIZE) + 
	_CACHE_ALIGN_SIZE +
	(count * CLBLK_SIZE);
}



/***********************************************************************
*  
* ixAlignedPoolInit - initialize the net pool
*
* This function initializes a net pool
*
* RETURNS: OK or ERROR.
*
* NOMANUAL
*/

LOCAL STATUS ixAlignedPoolInit
    (
    NET_POOL_ID		pNetPool,	/* pointer to a net pool */
    M_CL_CONFIG *	pMclBlkConfig,	/* pointer to mBlk,clBlk config */
    CL_DESC *		pClDescTbl,	/* pointer to cluster desc table */
    int			clDescTblNumEnt, /* number of cluster desc entries */
    BOOL                fromKheap       /* 1:KHEAP_ALLOC  0:malloc/calloc (ignored) */
    )
    {
    CL_DESC * 		pClDesc;	/* pointer to the cluster descriptor */
    int clBufSize;                      /* size of the buff after alignment */
    int requiredMemory;
    char * 		memArea;

    if (clDescTblNumEnt != 1)
    {
	return ERROR;
    }

    bzero ((char *) pNetPool->clTbl, sizeof (pNetPool->clTbl));

    if ((pNetPool->pPoolStat = (M_STAT *) calloc (1, sizeof (M_STAT))) == 
	NULL)
	return (ERROR);

    pNetPool->pmBlkHead = NULL;

    if (pMclBlkConfig != NULL)	/* if mbuf config is specified */
        {

	    requiredMemory = 
		_CACHE_ALIGN_SIZE +
		(pMclBlkConfig->mBlkNum *  MBLK_SIZE) +
		_CACHE_ALIGN_SIZE +
		(pMclBlkConfig->clBlkNum * CLBLK_SIZE);

	    if (pMclBlkConfig->memSize < requiredMemory)
	    {
            errno = S_netBufLib_MEMSIZE_INVALID;
            goto poolInitError;
            }

        /* initialize the memory pool */

        if (ixMemPoolInit (pMclBlkConfig->mBlkNum, M_BLK_SZ, sizeof(void *),
                          pMclBlkConfig->memArea
                          ) != OK)
            {
            goto poolInitError;
            }

        /* carve up the mBlk pool */

        pNetPool->pmBlkHead = ixMBlkCarve (
        				 pNetPool,
                                         pMclBlkConfig->mBlkNum,
                                         pMclBlkConfig->memArea
                                         );

        /* increment free mBlks  and number of mBlks */
        pNetPool->mBlkCnt		      = pMclBlkConfig->mBlkNum;
        pNetPool->mBlkFree		      = pMclBlkConfig->mBlkNum;
        pNetPool->pPoolStat->mTypes [MT_FREE] = pMclBlkConfig->mBlkNum;
        pNetPool->pPoolStat->mNum 	      = pMclBlkConfig->mBlkNum;

        memArea = (char * )((int)pMclBlkConfig->memArea +
			    _CACHE_ALIGN_SIZE +
			    (pMclBlkConfig->mBlkNum * MBLK_SIZE));

        if (pMclBlkConfig->clBlkNum > 0)
            {
            /* initialize the memory pool */

            if (ixMemPoolInit (pMclBlkConfig->clBlkNum,CLBLK_SIZE,0,memArea)
                != OK)
                goto poolInitError;


            pNetPool->pClBlkHead = ixClBlkCarve (
                                               pMclBlkConfig->clBlkNum,
                                               memArea
                                               );

            if (pNetPool->pClBlkHead == NULL)
                goto poolInitError;
            }
        }

    pClDesc = pClDescTbl;

    /* arrange buf size to deal with 32 bytes alignment */
    clBufSize = ROUND_UP(pClDesc->clSize, _CACHE_ALIGN_SIZE);

    if (pClDesc->clSize < 64)
        {
#ifdef NETBUF_DEBUG
        logMsg ("poolInit -- Invalid cluster size\n", 0, 0, 0, 0, 0, 0);
#endif /* NETBUF_DEBUG */
        errno = S_netBufLib_CLSIZE_INVALID;
        goto poolInitError;
        }

    if ((pNetPool->clTbl[0] = (CL_POOL *) calloc (1, sizeof(CL_POOL))) == 
	NULL)
	{
#ifdef NETBUF_DEBUG
	logMsg ("poolInit -- cluster pool allocation\n", 0, 0, 0, 0, 0, 0);
#endif /* NETBUF_DEBUG */
	errno = S_netBufLib_NO_SYSTEM_MEMORY;
	goto poolInitError;
	}

    pNetPool->clTbl[0]->clSize = pClDesc->clSize;
    pNetPool->clTbl[0]->pNetPool = pNetPool;

    requiredMemory = _CACHE_ALIGN_SIZE + pClDesc->clNum * clBufSize;

    if (pClDesc->memSize < requiredMemory)
        {
        errno = S_netBufLib_MEMSIZE_INVALID;
        goto poolInitError;
        }

    if (ixMemPoolInit (pClDesc->clNum, clBufSize, 0, pClDesc->memArea) != OK)
        {
        goto poolInitError;
        }

    pNetPool->clTbl[0]->pClHead = ixClPoolCarve (pNetPool->clTbl[0], 
						 pClDesc->clNum,
						 clBufSize, 
						 (char *)pClDesc->memArea);

    if (pNetPool->clTbl[0]->pClHead == NULL)
        {
        goto poolInitError;
        }

    pNetPool->clTbl[0]->clNum     = pClDesc->clNum;
    pNetPool->clTbl[0]->clNumFree = pClDesc->clNum;

    return (OK);

    poolInitError:

    netPoolDelete (pNetPool);
    return (ERROR);
    }

/*******************************************************************************
*
* ixMBlkCarve - carve up the mBlk pool.
*
* This function carves the the mBlks from a pre allocated pool.
*
* RETURNS: M_BLK_ID or NULL.
*
* NOMANUAL
*/

LOCAL M_BLK_ID ixMBlkCarve
    (
    NET_POOL_ID		pNetPool,	/* pointer to net pool */
    int 		num,		/* number of units to allocate */
    char *		pool		/* pre allocated memory area */
    )
    {
    M_BLK_ID		pMblk = NULL;
    int 		ix;
    M_BLK_ID *		ppMblk;

    ppMblk = &pMblk;

    /* align the mblks on a 32 byte boundary */
    pool = (char *)(ROUND_UP((unsigned int)pool + sizeof (void *),
		    _CACHE_ALIGN_SIZE)) - sizeof (void *);

    for (ix = 0; ix < num; ++ix)
	{
	*ppMblk 		 = (M_BLK_ID) (pool + sizeof (void *));
        *((NET_POOL_ID *)(pool)) = pNetPool;
	(*ppMblk)->mBlkHdr.mType = MT_FREE;
        ppMblk 			 = &((*ppMblk)->mBlkHdr.mNext);
	pool 			 += MBLK_SIZE;
	}
    *ppMblk = NULL;
    return (pMblk);
    }

/*******************************************************************************
*
* ixClBlkCarve - carve up the clBlk pool.
*
* This function carves the the clBlks from a pre allocated pool.
*
* RETURNS: CL_BLK_ID or NULL.
*
* NOMANUAL
*/

LOCAL CL_BLK_ID ixClBlkCarve
    (
    int 		num,		/* number of units to allocate */
    char *		pool		/* pre allocated memory area */
    )
    {
    CL_BLK_ID		pClBlk = NULL;
    int 		ix;
    CL_BLK_ID *		ppClBlk;

    ppClBlk = &pClBlk;

    for (ix = 0; ix < num; ++ix)
	{
	*ppClBlk = (CL_BLK_ID) (pool);
        ppClBlk  = &((*ppClBlk)->clNode.pClBlkNext);
	pool 	 += CLBLK_SIZE;
	}
    *ppClBlk = NULL;
    return (pClBlk);
    }

/*******************************************************************************
*
* ixClPoolCarve - carve up the cluster pool
*
* This function carves the clusters from a pre allocated pool.
* Each cluster maintains an 4 byte header info.  This header info contains
* a place to hold the pointer to the cluster pool.
* This header info is prepended to the cluster buffer
* and is hidden from the user.  The header info is used at the time of
* freeing the cluster.  This function returns the pointer the cluster buffer
* chain.
*
* RETURNS: CL_BUF_ID or NULL.
*
* NOMANUAL
*/

LOCAL CL_BUF_ID ixClPoolCarve
    (
    CL_POOL_ID		pClPool,	/* pointer to the cluster pool */
    int 		num,		/* number of units to allocate */
    int			clSize,		/* cluster size */
    char *		pool		/* pre allocated memory area */
    )
    {
    CL_BUF_ID		pClBuf = NULL; 	/* pointer to cluster buffer */
    FAST int 		ix;		/* counter */
    CL_BUF_ID *		ppClBuf;	/* ptr to ptr to cluster buffer */

    ppClBuf = &pClBuf;

    /* align the clusters on a 32 byte boundary */
    pool = (char *)(ROUND_UP((unsigned int)pool,
		    _CACHE_ALIGN_SIZE));

    for (ix = 0; ix < num; ix++)
    {
	*ppClBuf		 = (CL_BUF_ID) (pool);
        ppClBuf 		 = &((*ppClBuf)->pClNext);
	pool 			 += clSize;
    }
    *ppClBuf = NULL;

    return (pClBuf);
    }

/*******************************************************************************
*
* ixMemPoolInit - initialize the memory
*
* This function initialized the memory passed to it.
*
* RETURNS: OK or ERROR.
*
* NOMANUAL
*/

LOCAL STATUS ixMemPoolInit
    (
    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));