/** * @file IxEthDBDBMem.c * * @brief Memory handling routines for the MAC address database *  * @par * IXP400 SW Release version 2.0 *  * -- Copyright Notice -- *  * @par * Copyright 2001-2005, Intel Corporation. * All rights reserved. *  * @par * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. Neither the name of the Intel Corporation nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. *  * @par * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. *  * @par * -- End of Copyright Notice -- */#include "IxEthDB_p.h"IX_ETH_DB_PRIVATE HashNode *nodePool     = NULL;IX_ETH_DB_PRIVATE MacDescriptor *macPool = NULL;IX_ETH_DB_PRIVATE MacTreeNode *treePool  = NULL;IX_ETH_DB_PRIVATE HashNode nodePoolArea[NODE_POOL_SIZE];IX_ETH_DB_PRIVATE MacDescriptor macPoolArea[MAC_POOL_SIZE];IX_ETH_DB_PRIVATE MacTreeNode treePoolArea[TREE_POOL_SIZE];IX_ETH_DB_PRIVATE IxOsalMutex nodePoolLock;IX_ETH_DB_PRIVATE IxOsalMutex macPoolLock;IX_ETH_DB_PRIVATE IxOsalMutex treePoolLock;#define LOCK_NODE_POOL   { ixOsalMutexLock(&nodePoolLock, IX_OSAL_WAIT_FOREVER); }#define UNLOCK_NODE_POOL { ixOsalMutexUnlock(&nodePoolLock); }#define LOCK_MAC_POOL    { ixOsalMutexLock(&macPoolLock, IX_OSAL_WAIT_FOREVER); }#define UNLOCK_MAC_POOL  { ixOsalMutexUnlock(&macPoolLock); }#define LOCK_TREE_POOL   { ixOsalMutexLock(&treePoolLock, IX_OSAL_WAIT_FOREVER); }#define UNLOCK_TREE_POOL { ixOsalMutexUnlock(&treePoolLock); }/* private function prototypes */IX_ETH_DB_PRIVATE MacDescriptor* ixEthDBPoolAllocMacDescriptor(void);IX_ETH_DB_PRIVATE void ixEthDBPoolFreeMacDescriptor(MacDescriptor *macDescriptor);/** * @addtogroup EthMemoryManagement * * @{ *//** * @brief initializes the memory pools used by the ethernet database component * * Initializes the hash table node, mac descriptor and mac tree node pools. * Called at initialization time by @ref ixEthDBInit(). * * @internal */IX_ETH_DB_PUBLICvoid ixEthDBInitMemoryPools(void){    int local_index;    /* HashNode pool */    ixOsalMutexInit(&nodePoolLock);    for (local_index = 0 ; local_index < NODE_POOL_SIZE ; local_index++)    {        HashNode *freeNode = &nodePoolArea[local_index];        freeNode->nextFree = nodePool;        nodePool           = freeNode;    }    /* MacDescriptor pool */    ixOsalMutexInit(&macPoolLock);    for (local_index = 0 ; local_index < MAC_POOL_SIZE ; local_index++)    {        MacDescriptor *freeDescriptor = &macPoolArea[local_index];        freeDescriptor->nextFree = macPool;        macPool                  = freeDescriptor;    }    /* MacTreeNode pool */    ixOsalMutexInit(&treePoolLock);    for (local_index = 0 ; local_index < TREE_POOL_SIZE ; local_index++)    {        MacTreeNode *freeNode = &treePoolArea[local_index];        freeNode->nextFree = treePool;        treePool           = freeNode;    }}/** * @brief allocates a hash node from the pool * * Allocates a hash node and resets its value. * * @return the allocated hash node or NULL if the pool is empty * * @internal */IX_ETH_DB_PUBLICHashNode* ixEthDBAllocHashNode(void){    HashNode *allocatedNode = NULL;    if (nodePool != NULL)    {        LOCK_NODE_POOL;        allocatedNode = nodePool;        nodePool      = nodePool->nextFree;        UNLOCK_NODE_POOL;        memset(allocatedNode, 0, sizeof(HashNode));    }    return allocatedNode;}/** * @brief frees a hash node into the pool * * @param hashNode node to be freed * * @internal */IX_ETH_DB_PUBLICvoid ixEthDBFreeHashNode(HashNode *hashNode){    if (hashNode != NULL)    {        LOCK_NODE_POOL;        hashNode->nextFree = nodePool;        nodePool           = hashNode;        UNLOCK_NODE_POOL;    }}/** * @brief allocates a mac descriptor from the pool * * Allocates a mac descriptor and resets its value. * This function is not used directly, instead @ref ixEthDBAllocMacDescriptor() * is used, which keeps track of the pointer reference count. * * @see ixEthDBAllocMacDescriptor() *  * @warning this function is not used directly by any other function * apart from ixEthDBAllocMacDescriptor() * * @return the allocated mac descriptor or NULL if the pool is empty * * @internal */IX_ETH_DB_PRIVATEMacDescriptor* ixEthDBPoolAllocMacDescriptor(void){    MacDescriptor *allocatedDescriptor = NULL;    if (macPool != NULL)    {        LOCK_MAC_POOL;        allocatedDescriptor = macPool;        macPool             = macPool->nextFree;        UNLOCK_MAC_POOL;        memset(allocatedDescriptor, 0, sizeof(MacDescriptor));    }    return allocatedDescriptor;}/** * @brief allocates and initializes a mac descriptor smart pointer * * Uses @ref ixEthDBPoolAllocMacDescriptor() to allocate a mac descriptor * from the pool and initializes its reference count. * * @see ixEthDBPoolAllocMacDescriptor() * * @return the allocated mac descriptor or NULL if the pool is empty * * @internal */IX_ETH_DB_PUBLICMacDescriptor* ixEthDBAllocMacDescriptor(void){    MacDescriptor *allocatedDescriptor = ixEthDBPoolAllocMacDescriptor();    if (allocatedDescriptor != NULL)    {        LOCK_MAC_POOL;        allocatedDescriptor->refCount++;        UNLOCK_MAC_POOL;    }    return allocatedDescriptor;}/** * @brief frees a mac descriptor back into the pool * * @param macDescriptor mac descriptor to be freed * * @warning this function is not to be called by anyone but * ixEthDBFreeMacDescriptor() * * @see ixEthDBFreeMacDescriptor() * * @internal */IX_ETH_DB_PRIVATEvoid ixEthDBPoolFreeMacDescriptor(MacDescriptor *macDescriptor){    LOCK_MAC_POOL;    macDescriptor->nextFree = macPool;    macPool                 = macDescriptor;    UNLOCK_MAC_POOL;}/** * @brief frees or reduces the usage count of a mac descriptor smart pointer * * If the reference count reaches 0 (structure is no longer used anywhere) * then the descriptor is freed back into the pool using ixEthDBPoolFreeMacDescriptor(). * * @see ixEthDBPoolFreeMacDescriptor() * * @internal */IX_ETH_DB_PUBLICvoid ixEthDBFreeMacDescriptor(MacDescriptor *macDescriptor){    if (macDescriptor != NULL)    {        LOCK_MAC_POOL;        if (macDescriptor->refCount > 0)        {            macDescriptor->refCount--;            if (macDescriptor->refCount == 0)            {                UNLOCK_MAC_POOL;                ixEthDBPoolFreeMacDescriptor(macDescriptor);            }            else            {                UNLOCK_MAC_POOL;            }        }        else        {            UNLOCK_MAC_POOL;        }    }}/** * @brief clones a mac descriptor smart pointer * * @param macDescriptor mac descriptor to clone * * Increments the usage count of the smart pointer * * @returns the cloned smart pointer * * @internal */IX_ETH_DB_PUBLICMacDescriptor* ixEthDBCloneMacDescriptor(MacDescriptor *macDescriptor){    LOCK_MAC_POOL;    if (macDescriptor->refCount == 0)    {        UNLOCK_MAC_POOL;        return NULL;    }