一种SDN路由转发流表实现方法

最新推荐文章于 2022-12-08 13:19:45 发布
最新推荐文章于 2022-12-08 13:19:45 发布
阅读量1.1w 收藏 14
点赞数 4
分类专栏： 虚拟化 WLAN 路由器 文章标签： 虚拟化 路由器 SDN WLAN 路由表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leoufung/article/details/49773385
版权
虚拟化 同时被 3 个专栏收录
141 篇文章 34 订阅
订阅专栏
路由器
4 篇文章 0 订阅
订阅专栏
WLAN
1 篇文章 0 订阅
订阅专栏

 

1.        背景与需求

1.1    背景

传统上，路由器采用Radix树进行IP路由存储，但是到了SDN中，流表的key不一定是IP地址，所以就需要对路由表的存储更换一种算法，可以达到快速增、删、改、查的效果。由于KEY的类型不确定，设置无法比较大小，所以Hash表是一种不错的选择。

一般的HASH表都是通过数组（哈希桶）和链表的组合而成，如下图所示。数据元素的key通过给定的hash算法计算出所在数组的索引号，然后再将数据元素插入对应的链中。这种HASH表的特点是结构简单，便于管理，但是由于链表是顺序访问且节点是临时分配，无法达到路由表的使用性能，所以就需要一种增强型路由表来用于路由器的流表管理。同时，软路由类型的路由器一般都是基于多核进行开发的，所以路由表需要在多核间进行共享，并且同时需要保证路由表在多核间的一致性。这种增强型的HASH表叫做EHASH(Enhanced Hash Table)


图 1  传统HASH表

 

1.2需求

EHASH路由流表需求如下：

a.      可以快速分配出路由元素

b.      在冲突链上快速查找

c.      可以对HASH进行统计计数

d.      多个转发核间共享路由流表数据

e.      多个转发核间以最高速度进行互斥访问

 

1.3设计思路

目前SDN路由器采用虚拟化的方案，会有多台负责数据转发的虚拟机，每个虚拟机中都会有一个或多个转发核。为了在所有的转发核间共享路由转发流表，需要在Hypervisor层上管理一个很大的内存，这块内存可以在各个虚拟机中访问到。具体Hypervisor的内存管理方式不是本文描述的重点，只要知道路由转发流表所用的内存都是从这块共享内存中分配出来的即可。

为了满足快速查找需求，采用HASH作为主体算法，通过HASH来进行快速查找；为了满足快速分配和快速访问的需求，这里采用利用数组预分配表项资源，通过数组索引来快速的访问内存，因为是预分配所以需要提前消耗比较大的共享内存，是一种典型的空间换时间的算法。

 

EHASH的算法结构如下图所示:


图 2 EHASH算法结构

 

图 3 Pool区域初始化为数组链表

 

HASH桶数组用来完成HASH，经过HASH函数计算后的key就是HASH桶数组的索引。HASH桶数组元素就是冲突链的表头。通过NextIndex指向该HASH值的冲突链。如果NextIndex为全F，那么就表示该HASH值对应的HASH元素上没有冲突链。HASH桶数组叫做主表，即MainTable，其中的数组元素都从MAIN_TABLE内存区分配出来。

         如上面图所示，Pool内存区会整个初始化为一个大数组，通过NextIndex会将这个大数组连接为一个大的链表。NextIndex存储的内容是一个元素在POOL_TABLE内存区数组中的索引下标。所有的冲突链上的元素都是从POOL_TABLE内存区上分配出来，当冲突节点被释放收，会修改释放节点的NextIndex，使其连接到Pool内存数组的下一个空闲元素上。

         当多个插入的数据对应了同一个HASH KEY的时候，就会在同一个HASH KEY上形成冲突链。冲突链叫做PoolTable，所有的冲突链上的元素都是从POOL_TABLE内存区上分配出来。冲突链的第一个数据存储在HASH桶数组元素中，然后通过NextIndex指向冲突链的下一个元素；同理，下一个元素通过NextIndex指向再下一个冲突链元素，如此类推，直到最后一个冲突链元素，最后一个冲突链元素的NextIndex为0xFFFFFFFF，表示链表没有更多的元素了。通过NextIndex指向下一个元素在Pool内存数组中的索引下标，将预分配好的离散的数组元素组合成为一个链表。

         为了满足多转发核间对路由表的互斥访问，所以需要通过锁来进行保护。同时因为路由流表的读操作多余写操作，所以通过读写锁对内存进行保护。如前文所述，目前采用虚拟化方案，会存取多个OS，所以锁使用内存也是在Hypervisor维护的共享内存上。这样所有的虚拟机都可以正常访问到所，以便互斥地访问路由流表资源。

         同时对EHASH增加了统计表，如下图所示。统计表同HASH桶的元素一一对应，也就是说和HASH桶的大小相同。统计表中的每个元素记录了冲突链上冲突元素的数量，以及历史上该HASH KEY冲突的最大数量。通过观察统计数量，可以发现冲突最多的HASH KEY，从而调整HASH KEY的算法，使其对数据散列的更加平衡。


图 4 EHASH统计表

 

 

2.        主要数据结构

 

2.1共享内存布局

如前文所述，目前采用虚拟化方案，会存取多个负责转发的虚拟机，为了让多个虚拟机之间共享路由转发流表等信息，需要在Hypervisor层上管理一块内存，这块内存可以在各个虚拟机中访问到。共享内存布局如下所示


图 5 共享内存布局

 

  • MAIN_TABLE 内存区：EHASH的HASH桶的元素的内存。Addr为内存区其实地址，Len为内存区长度。
  • POOL_TABLE 内存区：EHASH的冲突链元素的内存。Addr为内存区其实地址，Len为内存区长度。
  • STATISTICS_TABLE 内存区：EHASH统计表元素的内存。Addr为内存区其实地址，Len为内存区长度。
  • SPINLOCK_TABLE 内存区：EHASH表自旋锁内存。Addr为内存区其实地址，Len为内存区长度。
  • WRLOCK_TABLE 内存区： EHASH表读写锁内存。Addr为内存区其实地址，Len为内存区长度。

 

每个内存区都被视为是数组，而且内存区是相邻的，所以通过数组元素的地址，可以元素下标索引值，也可以通过元素下标索引值计算出元素对应的地址。数组元素索引和元素地址转换通过如下两个宏可以完成：

  • EHASH_NODE_ENTRY：通过内存区基地址和元素索引，计算得到元素的地址；
  • EHASH_NODE_INDEX: 通过内存区基地址和元素地址，计算得到元素在数组中的索引下标

相关代码如下：

#define EHASH_NODE_ENTRY(base,index,entrysize,type)  \
    (((index) == EHASH_INDEX_INVALID) ? NULL :((type *)((u32)(base) + (index) * (entrysize))))
 
/*得到指定为值off处元素的Index值*/
#define EHASH_NODE_INDEX(base,off,entrysize)  \
        (((u32)(off) -(u32)(base))/(entrysize))

 

 

2.2EHASH管理结构


图 6 EHASH关键管理结构

 

EHASH_S结构是EHASH表的表管理结构，主要成员如下：

  • pHashMainTbl：指向MAIN_TABLE内存区，将该内存区视为数组，每个数组元素为HASH表的节点数据。
  • pHashPool: 指向POOL_TABLE内存区，将该内存区视为数组，每个数组元素为HASH表的节点数据。当有HASH节点从POOL_TABLE内存区中分配出去，该指针指向POOL_TABLE内存区中下一个空闲的数组元素。
  • pHashStatTbl：指向STATISTICS_TABLE内存区，将该内存区视为数组，每个数组元素为HASH表统计数据结构。
  • pHashMainRwLockTbl：指向WRLOCK_TABLE内存区，将该内存区视为数组，每个数组元素为HASH表的读写锁结构。
  • pHashGlbResSpinlock：指向SPINLOCK_TABLE内存区，将该内存区视为数组，每个数组元素为HASH表的自旋锁结构。
  • pfEntryDataInitFunc(): HASH表节点数据初始化接口，把外部拷贝的数据填充到HASH表的节点中。
  • pfEntryDataClear()：HASH表节点数据清除接口
  • pfStatEntryAdd(): HASH统计表中统计节点计数增加接口。
  • pfStatEntryDel(): HASH统计表中统计节点计数减少接口。
  • pfHashWriteLock():对HASH表上读锁。
  • pfHashWriteUnLock():对HASH表解除读锁。

EHASH_NODE_S结构是HASH节点的管理结构，在EHASH_NODE_S结构后紧接着的是具体的业务数据，HASH节点的KEY来自于具体的业务数据。EHASH_NODE_S结构和其后跟着的业务数据一起构成了HASH表的节点数据。主要成员如下：

  • ucValid：标明该节点的数据是否有效，当冲POOL_TABLE内存区分配出来的时候，ucValid会被标记为1，释放到POOL_TABLE中的时候，ucValid被设定为0。修改节点数据前ucValid设为0，然后修改数据，修改后再将ucValid设定为1.
  • ulNextIndex：下一个元素在POOL_TABLE内存数组中的数组下标。POOL_TABLE内存数组通过ulNextIndex将一个个离散或相邻的数组元素串联成为一个链表。链表最后一个元素的ulNextIndex为0xFFFFFFFF

 

EHASH_STAT_S结构是EHASH统计表的元素，EHASH统计表的每个元素对应一个EHASH表的HASH KEY，统计表同HASH桶的元素一一对应。统计表中的每个元素记录了冲突链上冲突元素的数量，以及历史上该HASH KEY冲突的最大数量。主要成员有：

  • usHistoryMaxNum：历史上该HASH KEY冲突的最大数量
  • usCurMaxNum：该HASH KEY上当前冲突元素的数量

 

相关核心代码如下：

typedef struct tagEHASH_NODE
{
    volatile u8 ucValid;
    u8 ucRsvd1;
    u16 usRsvd2;
    volatile u32 ulNextIndex;
} EHASH_NODE_S;
 
typedef struct tagEHASH_STAT
{
    u16 usHistoryMaxNum;
    u16 usCurMaxNum;
} EHASH_STAT_S;
 
typedef EHASH_NODE_S EHASH_BACKET_S;
 
typedef struct tagEHASH
{
    EHASH_BACKET_S *pHashMainTbl;
    EHASH_NODE_S *pHashPool;
    EHASH_STAT_S *pHashStatTbl;
 
    u32 ulSize;
    u32 ulPoolSize;
    u32 ulStatSize;
    u32 ulEntrySize;
    u32 ulStatEntrySize;
 
    u32(*pfEhashKey)();
    s32(*pfEhashCmp)();
    void (*pfEntryDataInitFunc)(void *, void *);
    void (*pfEntryDataClear)(void *, u32);
    void (*pfStatEntryAdd)(void *, u32);
void (*pfStatEntryDel)(void *, u32);
 
    u32 ulCount;
    void *pHashMainRwLockTbl;     /*读写锁基地址*/
    u32 ulRwLockEntrySize;        /*一个读写锁占用的内存大小*/
    void *pHashGlbResSpinlock;    /*全局资源锁*/
 
              /*hash锁操作*/
    void (*pfHashReadLock)(void *, u32);
    void (*pfHashReadUnLock)(void *, u32);
    void (*pfHashWriteLock)(void *, u32);
    void (*pfHashWriteUnLock)(void *, u32);
    void (*pfGlbResSpinLock)();
    void (*pfGlbResSpinUnLock)();
} EHASH_S;

3.        EHASH关键流程

3.1冲突节点分配流程

HASH表冲突节点的从POOL_TABLE内存区中分配得到的，分配流程如下


图 7 冲突节点分配流程

核心代码如下：

/*从哈希资源表中分配一个新节点(EHASH模块的内部函数)*/
EHASH_NODE_S *hashEntryAlloc(EHASH_S *pstEhcb)
{
    EHASH_NODE_S *pstNewNode = NULL;
    EHASH_NODE_S *pstHashPool = NULL;
    u32 ulEntrySize = pstEhcb->ulEntrySize;
 
    (*pstEhcb->pfGlbResSpinLock)(pstEhcb);  /*锁一把*/
 
    pstHashPool = pstHashPool = pstEhcb->pHashPool;
    if (pstHashPool != NULL)
    {
        pstNewNode = pstHashPool;
        pstHashPool = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, pstNewNode->ulNextIndex, ulEntrySize, EHASH_NODE_S);
        pstNewNode->ulNextIndex = EHASH_INDEX_INVALID;
        pstEhcb->pHashPool = pstHashPool;
 
        /*添加成功，记录添加个数*/
        pstEhcb->ulCount++;
 
        (*pstEhcb->pfGlbResSpinUnLock)(pstEhcb);  /*解锁*/
        return pstNewNode;
    }
    else
    {
        (*pstEhcb->pfGlbResSpinUnLock)(pstEhcb);  /*解锁*/
        return NULL;
    }
}



3.2冲突节点释放流程 

HASH表冲突节点的需要释放到POOL_TABLE内存区中，释放流程如下：

图 8 冲突节点释放流程

 

核心代码如下：

/*向哈希资源表中释放一个节点(EHASH模块的内部函数)*/
void hashEntryFree(EHASH_S *pstEhcb, EHASH_NODE_S *pstNode)
{
    EHASH_NODE_S *pstHashPool = NULL;
 
    if (pstEhcb == NULL || pstNode == NULL)
    {
        return;
    }
 
    (*pstEhcb->pfGlbResSpinLock)(pstEhcb);  /*锁一把*/
 
    pstHashPool = pstEhcb->pHashPool;
    /*冲突表用光的情况下，要判断pstHashPool == NULL的情况*/
    if (NULL != pstHashPool)
    {
        pstNode->ulNextIndex = EHASH_NODE_INDEX(pstEhcb->pHashMainTbl, pstHashPool, pstEhcb->ulEntrySize);
        pstEhcb->pHashPool = pstNode;
    }
    else
    {
        pstNode->ulNextIndex = EHASH_INDEX_INVALID;
        pstEhcb->pHashPool = pstNode;
    }
 
    pstEhcb->ulCount--;
 
(*pstEhcb->pfGlbResSpinUnLock)(pstEhcb);  /*解锁*/
 
    return;
}


3.3哈希表资源初始化流程

初始化HASH表所用的所有资源，包括回调函数，共享内存区等，流程如下：

图 9 哈希表资源初始化流程

 

核心代码如下：

/*
 *创建哈希表
 *该函数实际上只创建了哈希控制块，这是因为使用EHASH模块所创建的哈希表用于多核
 *共享，所以只需要在主核上初始化哈希表项资源，从核只需初始化好哈希控制块即可。
 *基于上述原因，EHASH模块将哈希控制块的初始化与哈希表项初始化分割开。在主核上
 *需要依次调用EHASH_HashNew()和EHASH_HashTblInit()来完成初始化动作；而在从核
 *上只需调用EHASH_HashNew()函数创建哈希控制块即可操纵哈希表了。
 */
EHASH_S * EHASH_HashNew(u32(*pfEhashKey)(), s32(*pfEhashCmp)(),
                        void (*pfEntryDataInitFunc)(void *, void *),
                        void*(*pfMallocFunc)(u32), void (*pfEntryDataClear)(void *, u32),
                        void (*pfStatEntryAdd)(void *, u32), void (*pfStatEntryDel)(void *, u32))
{
    EHASH_S *pstEhcb = NULL;
 
    if (pfMallocFunc == NULL || pfEhashKey == NULL || pfEhashCmp == NULL
            || pfEntryDataInitFunc == NULL || pfEntryDataClear == NULL)
    {
        return NULL;
    }
             
    pstEhcb = (EHASH_S *)pfMallocFunc(sizeof(EHASH_S));
    if (pstEhcb == NULL)
    {
        return NULL;
    }
 
    pstEhcb->pfEhashKey = pfEhashKey;
    pstEhcb->pfEhashCmp = pfEhashCmp;
    pstEhcb->pfEntryDataInitFunc = pfEntryDataInitFunc;
    pstEhcb->pfEntryDataClear = pfEntryDataClear;
 
    /*初始化统计函数*/
    if (pfStatEntryAdd == NULL)
    {
        pstEhcb->pfStatEntryAdd = EHASH_HashCommonStatAdd;
    }
    else
    {
        pstEhcb->pfStatEntryAdd = pfStatEntryAdd;
    }
 
    if (pfStatEntryDel == NULL)
    {
        pstEhcb->pfStatEntryDel = EHASH_HashCommonStatDel;
    }
    else
    {
        pstEhcb->pfStatEntryDel = pfStatEntryDel;
    }
 
    /*初始化读写锁和spinlock的接口函数*/
    pstEhcb->pfHashReadLock    = EHASH_HashReadLock;
    pstEhcb->pfHashReadUnLock  = EHASH_HashReadUnLock;
    pstEhcb->pfHashWriteLock   = EHASH_HashWriteLock;
    pstEhcb->pfHashWriteUnLock = EHASH_HashWriteUnLock;
    pstEhcb->pfGlbResSpinLock  = EHASH_GlbResSpinLock;
    pstEhcb->pfGlbResSpinUnLock = EHASH_GlbResSpinUnLock;
    return pstEhcb;
}
 
/*
 *初始化哈希主表和哈希资源表
 *pEhashMainTblAddr指向待初始化的哈希主表的首地址
 *ulSize为哈希主表的大小，即通常我们所说的哈希表大小
 *pEhashPoolAddr指向待初始化的哈希资源表的首地址，哈希资源表其实就是一个由哈
 *希空闲节点所组成的大链表
 *ulPoolSize为哈希资源表的大小
 *ulEntrySize为当前初始化的哈希表中每一个哈希节点的实际大小
 */
s32 EHASH_HashTblInit(EHASH_S *pstEhcb,
                      void *pEhashMainTblAddr, u32 ulSize,
                      void *pEhashPoolAddr, u32 ulPoolSize,
                      u32 ulEntrySize, void *pEhashStatTblAddr,
                      u32 ulStatSize, u32 ulStatEntrySize,
                      void *pMainRwLockTblAddr, u32 ulRwLockEntrySize,
                      void *pEhashResSpinlock)
{
    if (pstEhcb == NULL || pEhashMainTblAddr == NULL || pEhashPoolAddr == NULL
            || pEhashStatTblAddr == NULL)
    {
        return ERROR;
    }
 
    if (pMainRwLockTblAddr == NULL || pEhashResSpinlock == NULL)
    {
        return ERROR;
    }
    pstEhcb->pHashMainTbl = pEhashMainTblAddr;
    pstEhcb->pHashPool = pEhashPoolAddr;
    pstEhcb->pHashStatTbl = pEhashStatTblAddr;
 
    pstEhcb->ulSize = ulSize;
    pstEhcb->ulPoolSize = ulPoolSize;
    pstEhcb->ulStatSize = ulStatSize;
    pstEhcb->ulEntrySize = ulEntrySize;
    pstEhcb->ulStatEntrySize = ulStatEntrySize;
 
    /*add by dengjunjun_107 on 2012-4-10 支持ehash的锁机制，资源链用spinlock，ehash链用rwlock begin*/
    pstEhcb->pHashMainRwLockTbl = pMainRwLockTblAddr;
    pstEhcb->ulRwLockEntrySize = ulRwLockEntrySize;
    pstEhcb->pHashGlbResSpinlock = pEhashResSpinlock;
    return OK;
}
s32 EHASH_HashTblResInit(EHASH_S *pstEhcb)
{
    u32 ulSize = pstEhcb->ulSize;
    u32 ulPoolSize = pstEhcb->ulPoolSize;
    u32 ulStatSize = pstEhcb->ulStatSize;
    u32 ulEntrySize = pstEhcb->ulEntrySize;
    u32 ulStatEntrySize = pstEhcb->ulStatEntrySize;
    EHASH_NODE_S *pstEhashNode = NULL;
    s32 i = 0;
    cvmx_rwlock_wp_lock_t *pstMainRwLockTbl = NULL;
    cvmx_spinlock_t * pstGlbResSpinlock = NULL;
 
    if (pstEhcb == NULL || pstEhcb->pHashMainTbl == NULL || pstEhcb->pHashPool == NULL
            || pstEhcb->pHashStatTbl == NULL)
    {
        return ERROR;
}
 
    if (pstEhcb->pHashMainRwLockTbl == NULL || pstEhcb->pHashMainRwLockTbl == NULL)
    {
        return ERROR;
    }
 
    bzero(pstEhcb->pHashMainTbl, (ulSize * ulEntrySize));
    for (i = 0, pstEhashNode = pstEhcb->pHashMainTbl; i < ulSize; i++)
    {
        pstEhashNode = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, i, ulEntrySize, EHASH_NODE_S);
        pstEhashNode->ulNextIndex = EHASH_INDEX_INVALID;
    }
 
    bzero(pstEhcb->pHashPool, (ulPoolSize * ulEntrySize));
    for (i = 0, pstEhashNode = pstEhcb->pHashPool; i < (ulPoolSize - 1); i++)
    {
        pstEhashNode->ulNextIndex = ulSize + i + 1;
        pstEhashNode = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, pstEhashNode->ulNextIndex, ulEntrySize, EHASH_NODE_S);
    }
    pstEhashNode->ulNextIndex = EHASH_INDEX_INVALID;
 
    /*清零 统计表信息,统计*/
    bzero(pstEhcb->pHashStatTbl, (ulStatSize * ulStatEntrySize));
 
    UOS_ASSERT(sizeof(cvmx_rwlock_wp_lock_t) <= pstEhcb->ulRwLockEntrySize);
    /*初始化hash主表的读写锁*/
    pstMainRwLockTbl = (cvmx_rwlock_wp_lock_t *) pstEhcb->pHashMainRwLockTbl;
    for (i = 0; i < ulSize; i++)
    {
        cvmx_rwlock_wp_init(&pstMainRwLockTbl[i]);
    }
 
    /*初始化资源表的全局spinlock*/
    pstGlbResSpinlock = (cvmx_spinlock_t *)pstEhcb->pHashGlbResSpinlock;
    cvmx_spinlock_init(pstGlbResSpinlock);
    return OK;
}



3.4哈希查找流程 

输入为指定要查找的内容，该内容中含所有关键字KEY，通过KEY可以计算得到散列值HASH KEY，在EHASH中进行查找，如果找到那么返回找到的元素，流程如下：

图 10哈希查找流程

 

核心代码如下：

/*
 *哈希查找函数，pstEhcb指向哈希表控制块，pEhashEntryData指向待查找的数据
 *哈希查找函数通常会被控制面和数据面的代码一起使用，旨在实现无阻塞的哈希
 *查找。
 */
void * EHASH_HashSearch(EHASH_S *pstEhcb, void *pEhashEntryData)
{
    u32 ulKey;
    EHASH_BACKET_S *pstHashBacket = NULL;
    EHASH_NODE_S *mp = NULL;
    u32 ulEntrySize = pstEhcb->ulEntrySize;
    u8 ucFlag = 0;
 
    ulKey = (*pstEhcb->pfEhashKey)(pEhashEntryData);
    (*pstEhcb->pfHashReadLock)(pstEhcb, ulKey);
    pstHashBacket = (EHASH_BACKET_S *)((void *)pstEhcb->pHashMainTbl + ulEntrySize * ulKey);
 
    for (mp = pstHashBacket;
            (mp != NULL && mp->ucValid == 1);
            mp = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, mp->ulNextIndex, ulEntrySize, EHASH_NODE_S))
    {
        if ((*pstEhcb->pfEhashCmp)(mp, pEhashEntryData) == 0)
        {
            ucFlag = 1;
            break;
        }
    }
    (*pstEhcb->pfHashReadUnLock)(pstEhcb, ulKey);
    if (ucFlag)
    {
        return mp;
    }
    else
    {
        return NULL;
    }
}


5.5向哈希表中插入一个新节点

输入为要插入的内容，该内容中含所有关键字KEY，通过KEY可以计算得到散列值HASH KEY。最终函数将带插入的内容插入到HASH表中。流程如下


图 11 向哈希表中插入一个新节点

 

核心代码如下：

/*
 *向哈希表中压入一个新节点，pstEhcb指向哈希表控制块，pfInitFunc函数指针用于
 *为不同数据类型的哈希节点进行初始化，pEhashEntryData用于为新创建的节点提供
 *数据。
 */
s32 EHASH_HashPush(EHASH_S *pstEhcb, void *pEhashEntryData)
{
    u32 ulKey;
    u8 ucFlag = 0;
    EHASH_BACKET_S *pstHashBacket = NULL;
    EHASH_STAT_S *pstHashStatBacket = NULL;
    EHASH_NODE_S *mp, *pstNewNode = NULL;
    u32 ulEntrySize = pstEhcb->ulEntrySize;
    u32 ulStatEntrySize = pstEhcb->ulStatEntrySize;
 
    ulKey = (*pstEhcb->pfEhashKey)(pEhashEntryData);
 
    (*pstEhcb->pfHashWriteLock)(pstEhcb, ulKey);
 
    pstHashStatBacket = EHASH_NODE_ENTRY(pstEhcb->pHashStatTbl, ulKey, ulStatEntrySize, EHASH_STAT_S);
    pstHashBacket = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, ulKey, ulEntrySize, EHASH_BACKET_S);
 
    for (mp = pstHashBacket;
            (mp != NULL && mp->ucValid == 1);
            mp = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, mp->ulNextIndex, ulEntrySize, EHASH_NODE_S))
    {
        if ((*pstEhcb->pfEhashCmp)(mp, pEhashEntryData) == 0)
        {
            ucFlag = 1;
            break;
        }
    }
 
    if (ucFlag == 1)
    {
        /*既然是push操作，且找到了相同的节点，那么直接用新的数据覆盖旧的数据，
         *在内层实现覆盖更新操作，是否需要覆盖更新则可在外部进行判断，这样可以
         *更新时如果发现节点存在，不需要将原有节点删除，只需要将原有节点中需要
         *保存的部分内容以及需要更新的内容push入即可，也保证了更新操作在锁的保护
         *下*/
        bcopy((void *)(pEhashEntryData + sizeof(EHASH_NODE_S)), (void *)(mp + 1),
              (ulEntrySize - sizeof(EHASH_NODE_S)));
        (*pstEhcb->pfHashWriteUnLock)(pstEhcb, ulKey);
        return OK;
}
 
    if (pstHashBacket->ucValid == 0)    /*在空表中添加节点*/
    {
        (*pstEhcb->pfEntryDataInitFunc)(pstHashBacket, pEhashEntryData);
        pstHashBacket->ucValid = 1;
    }
    else    /*在冲突表中添加节点*/
    {
        pstNewNode = hashEntryAlloc(pstEhcb);
        if (pstNewNode == NULL)
        {
            UOS_ASSERT(0);
            (*pstEhcb->pfHashWriteUnLock)(pstEhcb, ulKey);
            return ERROR;
        }
 
        (*pstEhcb->pfEntryDataInitFunc)(pstNewNode, pEhashEntryData);
        pstNewNode->ucValid = 1;
 
        for (mp = pstHashBacket;
                (mp->ucValid == 1 && mp->ulNextIndex != EHASH_INDEX_INVALID);
                mp = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, mp->ulNextIndex, ulEntrySize, EHASH_NODE_S));
 
        pstHashBacket->ucValid = 0;
 
        mp->ucValid = 0;
        mp->ulNextIndex = EHASH_NODE_INDEX(pstEhcb->pHashMainTbl, pstNewNode, ulEntrySize);
 
        mp->ucValid = 1;
        pstHashBacket->ucValid = 1;
    }
 
    /*增加节点，回调统计信息*/
    (*pstEhcb->pfStatEntryAdd)(pstHashStatBacket, ulStatEntrySize);
    (*pstEhcb->pfHashWriteUnLock)(pstEhcb, ulKey);
 
    return OK;
}



3.6从哈希表中弹出(删除)指定节点 

输入为要删除的内容，该内容中含所有关键字KEY，通过KEY可以计算得到散列值HASH KEY。最终函数将从HASH表中删除指定内容的节点。流程如下

 

图 12 从哈希表中弹出(删除)指定节点

 

核心代码如下:

/*
 *从哈希表中弹出(删除)待查找的节点，pstEhcb指向哈希表控制块，pEhashEntryData
 *指向待查找的数据。
 */
s32 EHASH_HashPull(EHASH_S *pstEhcb, void *pEhashEntryData)
{
    u32 ulKey;
    EHASH_BACKET_S *pstHashBacket = NULL;
    EHASH_STAT_S *pstHashStatBacket = NULL;
    EHASH_NODE_S *mp, *pstPrevNode = NULL;
    u32 ulEntrySize = pstEhcb->ulEntrySize;
    u32 ulStatEntrySize = pstEhcb->ulStatEntrySize;
 
    ulKey = (*pstEhcb->pfEhashKey)(pEhashEntryData);
 
    (*pstEhcb->pfHashWriteLock)(pstEhcb, ulKey);
 
    pstHashStatBacket =  (EHASH_STAT_S *)((void *)pstEhcb->pHashStatTbl  + ulStatEntrySize * ulKey);
    pstHashBacket =  (EHASH_BACKET_S *)((void *)pstEhcb->pHashMainTbl + ulEntrySize * ulKey);
 
    if ((*pstEhcb->pfEhashCmp)(pstHashBacket, pEhashEntryData) == 0)
    {
        if (pstHashBacket->ulNextIndex == EHASH_INDEX_INVALID)    /*Cond.1 无冲突链的情况下删除首节点*/
        {
            pstHashBacket->ucValid = 0;
            /*bzero((void *)pstHashBacket, ulEntrySize);*/
            pstHashBacket->ulNextIndex = EHASH_INDEX_INVALID;
            (*pstEhcb->pfEntryDataClear)((void*)pstHashBacket, pstEhcb->ulEntrySize);
        }
        else    /*Cond.2 存在冲突链的情况下删除首节点*/
        {
            mp = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, pstHashBacket->ulNextIndex, ulEntrySize, EHASH_NODE_S);
            pstHashBacket->ucValid = 0;
            /*在删除主表节点时将数据块初始化一下，将冲突节点内容拷入到主节点中，*/
            (*pstEhcb->pfEntryDataInitFunc)(pstHashBacket, mp);
            pstHashBacket->ulNextIndex = mp->ulNextIndex;
            pstHashBacket->ucValid = 1;
            mp->ucValid = 0;
            (*pstEhcb->pfEntryDataClear)((void*)mp, pstEhcb->ulEntrySize);
            hashEntryFree(pstEhcb, mp);
        }
    }
    else
    {
        u8 ucFlag = 0;
        for (mp = pstHashBacket, pstPrevNode = NULL;
                (mp != NULL && mp->ucValid == 1);
                mp = EHASH_NODE_ENTRY(pstEhcb->pHashMainTbl, mp->ulNextIndex, ulEntrySize, EHASH_NODE_S))
        {
            if ((*pstEhcb->pfEhashCmp)(mp, pEhashEntryData) == 0)
            {
                ucFlag = 1;
                break;
            }
            pstPrevNode = mp;
        }
 
        if (ucFlag == 0)
        {
            (*pstEhcb->pfHashWriteUnLock)(pstEhcb, ulKey);
            return ERROR;
        }
 
        /*查找到待弹出的节点*/
        if (mp->ulNextIndex == EHASH_INDEX_INVALID)   /*Cond.3 冲突链存在的情况下删除尾节点*/
        {
            pstHashBacket->ucValid = 0;
            mp->ucValid = 0;
            pstPrevNode->ucValid = 0;
            pstPrevNode->ulNextIndex = EHASH_INDEX_INVALID;
            pstPrevNode->ucValid = 1;
            pstHashBacket->ucValid = 1;
            (*pstEhcb->pfEntryDataClear)((void*)mp, pstEhcb->ulEntrySize);
            hashEntryFree(pstEhcb, mp);
        }
        else    /*Cond.4 冲突链存在的情况下删除中间节点*/
        {
            pstHashBacket->ucValid = 0;
            mp->ucValid = 0;
            pstPrevNode->ucValid = 0;
            pstPrevNode->ulNextIndex = mp->ulNextIndex;
            pstPrevNode->ucValid = 1;
            pstHashBacket->ucValid = 1;
            (*pstEhcb->pfEntryDataClear)((void*)mp, pstEhcb->ulEntrySize);
            hashEntryFree(pstEhcb, mp);
        }
    }
 
    (*pstEhcb->pfHashWriteUnLock)(pstEhcb, ulKey);
    /*删除节点，回调统计信息*/
    (*pstEhcb->pfStatEntryDel)(pstHashStatBacket, ulStatEntrySize);
 
    return OK;
}


leoufung
关注
专栏目录
netvirt-DVR路由流表分析
rtmdk的博客
09-25 1042
Dvr 流表分析阅读本文前请参考阅读netvirt-浮动ip之流表实现分析，分析环境都是基于该文档中的物理环境。本文档流表分析所依据的物理拓扑图和流表管道如下： 如上图，tap设备“：”后面为openflow端口号1.东西向流表分析1.1 同子网，同计算节点虚拟机间互访虚拟机A: 192.168.100.4 compute1虚拟机B：192.168.100.5 compute1192.168.
网络路由与SDN
fanqiliang630的博客
12-13 2329
文章目录1. **路由**技术1.1 分组交付（forwarding）1.1.1 直接交付和间接交付1.2 路由算法1.2.1 路由算法的评价指标1.2.2 路由选择算法的分类1.2.3 路由表的生成1.2.3.1 网络号与主机号的计算方式1.2.3.2 路由表的生成原理1.2.4 IP路由汇聚:1.2.4.1 最长前缀匹配原则(longest-prefix matching):1.2.5 自治系统与路由选择协议:1.2.5.1 RIPng路由信息协议1.2.5.2 OSPFv3 最短路径优先协议1.2.5
流表
明天你好
07-02 3124
如前文所述，OpenFlow的设计目标之一就是将网络设备的控制功能与转发功能进行分离，进而将控制功能全部集中到远程的控制器上完成，而OpenFlow交换机只负责在本地做简单高速的数据转发。在OpenFlow交换机的运行过程中，其数据转发的依据就是流表。 所谓流表，其实可被视作是OpenFlow对网络设备的数据转发功能的一种抽象。在传统网络设备中，交换机和路由器的数据转发需要依赖设备中保存的二层MAC地址转发表或者三层IP地址路由表，而OpenFlow交换机中使用的流表也是如此，不过在它的表项中整合了网络中
【网络基础】路由表，分组转发算法
Cout_Sev
05-09 7035
路由表概念，分组转发算法
openvswitch的转发数据面datapath中的流表源码分析
魏言华的博客
08-30 808
1.datapath的底层数据结构关系 流表采用hash的方式排列存放，流表的hash头结点存储数据结构如下 该hash 桶的初始化函数alloc_buckets (),生成的数据格式可参考如下 2 流表创建流程分析 2.1 flow table数据结构 1> flow_table流表结构, 每个datapath都有一个流表 2> table_instance流表实例, 其中的buckets用来存放具体的flow条目,存储方式参见FlexArray ...
多路径：使用Ryu和Pyretic SDN控制器进行多路径路由
02-05
在现代网络环境中，软件定义网络（SDN）已经成为一种重要的架构，它将控制平面与数据平面分离，使得网络管理更加灵活和可编程。多路径路由是SDN中的一个关键特性，能够利用网络中的多条路径来提高带宽、平衡负载以及...
论文研究-基于OpenFlow的SDN网络路由算法设计与实现 .pdf
08-16
SDN（Software Defined Networking）即软件定义网络，是一种新兴的网络架构设计思想，它通过将网络的控制层与数据转发层进行解耦，以实现更加集中化的网络控制和灵活的网络管理。SDN的核心组件包括：控制器...
基于SDN的大数据分析的认知路由资源的设计与实现。
03-18
1. SDN（软件定义网络）：SDN是一种新型的网络架构理念，它的核心思想是将网络设备的控制层与数据转发层分离。控制层负责网络的管理和决策，而数据转发层则负责数据包的处理和传输。这种分离允许网络管理员通过软件...
22、通用转发和SDN
单俞浩的博客
05-23 1509
一、网络层功能 1、转发：对于从某个端口来的分组转发到合适的输出端口，数据平面 2、路由：决定分组从源端口到目标端口的路径（路由选择算法）,控制平面 这种功能称之为 垂直集成 的方式，每个路由器即执行控制平面，又执行数据平面。控制平面：路由器上运行路由协议实体，自己查路由表，自己做路由通告寻找下一跳。然后交给IP协议实体，由IP协议实体对到来的分组进行转发：数据平面 3、数据平面和控制平面 IP转发：对于到来的分组按照路由表决定如何转发，数据平面 路由：决定路径、计算路由表，处于控制平面，是传统的转发方式
SDN
weixin_44233888的博客
03-21 2443
背景 传统网络是分布式控制的架构，每台设备都是独立收集网络信息，独立计算，并且都只关心自己的选路。 目的 SDN的提出，是为了应对当前网络中面临的扩展困难，灵活性不够等发展瓶颈问题，其主要目的是简化网络配置、管理， 促进网络向动态灵活的方向演化。 转控分离是啥 将基础硬件与业务实现分离，硬件仅负责数据转发和存储 简单说路由表、MAC表（路由协议）就是控制平面，FIB表就是转发平面 数据平面负责数据处理、转发和状态收集（负责产生和维护路由信息以及标签信息）等。其核心设备为交换机，可以是物理交换机，也可以是虚拟
路由表和转发表以及SDN的open-flow table表的区别
最新发布
yxg520s的博客
12-08 1886
1.路由表 路由信息最终要存储在用于路由器的主机或者专业路由器上，存放这些信息的地方称为路由表。其中最低包含三元素：目标地址，掩码，下一跳。1.1.查询路由表的开销 有人认为查询路由表是一件和交换机查询MAC地址一样的事，那就大错特错了，查询MAC地址/端口对是一种固定的数据查找，MAC地址都是固定的48字节，而IP地址呢，自从CIDR出现以后，地址成了“无类”的了，因此任意位的掩码都能成为正确的掩码，另外，聪明的管理员想出了路由汇聚，这些家伙将负担转嫁给了系统的实现者，从而系统实现者必须实现“最长掩码”匹
MAC表、ARP表、IP路由表区别比较
阿杰
05-12 3874
作用 生成方式 组成 存在地方 MAC表 数据链路层转发（交换机根据数据帧的目的MAC地址查看MAC表，根据表项由相应接口转发出去） 根据数据帧的源MAC进行学习（数据帧从那个接口进来的，就把该接口以及该帧的源MAC学习记录下来） MAC地址、接口、VLAN、时间、类型等 交换机 ARP表 数据封装（根据目的IP地址，查ARP表获取目的MAC地址，封装目的MAC地址信息） ARP请求、响应 IP、MAC、接口 PC机 IP路由表 网络层转发（路由器根据目的IP地址，查询IP路由表找...
OpenFlow基础入门知识
dwj_daiwenjie的博客
02-17 4266
本文进行讨论的是OpenFlow 1.0和OpenFlow 1.3的基本知识 Overview： Openflow 1.0： 安全通道+单张流表+ipv4 Openflow 1.3： 安全通道+多级流表（流水线pipeline）+组表+测量表+ipv6+.....   流（flow） 1.流由管理员定义，根据不同的流执行不同的策略 2.在一段时间内，经过同一个网络的一系列具有相同...
吃透计算机网络（四）
二豪码字
02-23 1438
网络层能够被分为两个相互作用的部分:数据平面和控制平面 数据平面：即网络中每台路由器的功能，该数据平面决定到达路由器输入链路之一的数据报如何转发到路由器的输出链路之一。 控制平台：即网络范围的逻辑，该控制平面能控制数据报沿着源主机到目的主机到端到端路径中路由器之间的路由方式。 数据平面的主要作用是从其输入链路向其输出链路转发数据报，控制平面的主要作用是协调这些本地的路由转发动作，使得数据报沿着源和目的之间的路由路劲最终进行端到端传送。 网络层的主要功能有两个：转发和路由选择 转发：当一个分组到达路由器的一条
SDN OpenFlow1.0and1.3协议基础
PotatpSu的博客
03-02 4231
OpenFlow1.0交换机流表 OpenFlow交换机中的转发表称为流表（Flow Table），列表中的每个条目称为表项，每个表项包括三个域，包头域（header field），计数器（counters），行动（actions）。 包头域Head Fields： 数据包匹配特征： 一层：交换机入端口（Ingress Port） 二层：源MAC地址（Ether source）、目的MAC地址（Ether dst）、以太网类型（Ether Type）、VLAN标签（VLAN id）、VLAN优先级（VL.
SDN-流表分析与增删改查
关注网络安全、云原生安全
02-28 8621
目录 基于OpenFlow的SDN网络 拓扑代码——mytopo.py 流表操作 查看流表 删除流表 添加流表 基于OpenFlow的SDN网络 基于OpenFlow的SDN网络 上图以主机h1向网络发送数据包时的情况为例，若发送给主机h2，则路线为①②③⑥，每条路径的解释见图注。若读者没有了解过OpenFlow协议，请参考下面的文章，可以看看里面的数据结构，以及Packeti...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值