mac同步与mlag结合

最新推荐文章于 2023-07-09 21:35:02 发布
最新推荐文章于 2023-07-09 21:35:02 发布
阅读量934 收藏 1
点赞数
分类专栏： mlag
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33352715/article/details/104388144
版权
  • mac老化机制 ：硬件老化，删除硬件mac，通告上层软件  

1.mac超时老化删除本地mac，保留mlag同步过来的mac

case MACSYN_MSG_RECVMACDEL:
            ret = macSynLocalNotifier(&message);

            if(message.pData != NULL)
                netMblkClChainFree((M_BLK_ID)message.pData);
            break;
/*本地网管和地址学习的处理函数*/
STATUS macSynLocalNotifier(tMacSynMsg *pMacSynMsg)
{
    tPhyIfInfo phyinfo;
    int32_t i =0, size = 0, msgType = 0, ret = OK;
    tHwMacAddrEntry *pHwMac =NULL, macAddr;
    M_BLK_ID pMblk = NULL;

    size = sizeof(tHwMacAddrEntry);
    pMblk = pMacSynMsg->pData;
    msgType = pMacSynMsg->pktHead.msgType;
    
    for(i=0; i<(pMacSynMsg->pktHead.dataLen/size); i++)     /*解析所有mac地址表项,  对于静态表项来说，只有一条*/
    {
        if((msgType== MACSYN_MSG_RECVMACADD)||(msgType== MACSYN_MSG_RECVMACDEL))
        {
            if(pMblk->mBlkHdr.mLen < size)
            {
                pHwMac = &macAddr;
                if(netMblkOffsetToBufCopy(pMblk, 0, (char *)pHwMac, size,(FUNCPTR) bcopy) < size)
                {
                    macSynPrintf(MACSYN_DBG_ERR,("\r\n macSynLocalNotifier: Failed to copy entry %d.", i));
            	    return ERROR;
                }

                pMblk  = pMblk->mBlkHdr.mNext;
            }
            else
            {
                pHwMac = (tHwMacAddrEntry *)((char *)pMblk->mBlkHdr.mData);

                pMblk->mBlkHdr.mLen  -= size;
                pMblk->mBlkHdr.mData += size;
            }
        }
        else
            pHwMac = &pMacSynMsg->pktHead.l2entry;

        bzero((void *)&phyinfo, sizeof(tPhyIfInfo));

        logical_to_phyical(&phyinfo, pHwMac->port[0]);
        pHwMac->sys = phyinfo.unit;

        if((pHwMac->mac[0] == 0x00)&&(pHwMac->mac[1] == 0x04)&&(pHwMac->mac[2] == 0x67))
            gMacFhnLocal = 1;
        
        if((gMacSynDebug & MACSYN_DBG_PKT)&&(gMacFhnLocal == 0))
            macSynEntryPrint(pHwMac);
        
        switch(pHwMac->keyType)
        {
        case HW_MACKEYTYPE_BRIDGE:
        case HW_MACKEYTYPE_VP:
            if((pHwMac->vlanId < 1)||(pHwMac->vlanId > 4094))
            {
                macSynPrintf(MACSYN_DBG_ERR,("\r\n macSynLocalNotifier: Bad vlan id %d.", pHwMac->vlanId));

                if((msgType == MACSYN_MSG_RECVMACADD)||(msgType == MACSYN_MSG_RECVMACDEL))
                    gSysMacSynStatis.macLocalNotifyVidErr++;
                continue;
            }
            break;
            
        default:
            break;
        }
		
        switch(msgType)
        {
        case MACSYN_MSG_RECVMACADD:
			/*macSynPrintf(MACSYN_DBG_ADD,("\r\n macSynLocalNotifier,mac:0x%02x%02x%02x%02x%02x%02x.",pHwMac->mac[0],
				pHwMac->mac[1],pHwMac->mac[2],pHwMac->mac[3],pHwMac->mac[4],pHwMac->mac[5]));*/
            if(macSynMacLocalAdd(pHwMac) != OK)
                break;
            
            gSysMacSynStatis.macLocalAddSuccess++;
            macSynStackEncode(pHwMac, MACSYN_SYNC_TYPEADD);
			macSynMlagEncode(pHwMac, MACSYN_SYNC_TYPEADD);
            break;
            
        case MACSYN_MSG_RECVMACDEL:
            if(macSynMacLocalDel(pHwMac) != OK)
                break;
            
            gSysMacSynStatis.macLocalDelSuccess++;
            macSynStackEncode(pHwMac, MACSYN_SYNC_TYPEDEL);
			macSynMlagEncode(pHwMac, MACSYN_SYNC_TYPEDEL);
            break;
            
        case MACSYN_MSG_ADDL2FDB:
            gSysMacSynStatis.macLocalL3AddCnt02++;
            if(macSynMacLocalAdd(pHwMac) != OK)
                return ERROR;
            
            gSysMacSynStatis.macLocalStaticAdd++;
            macSynStackEncode(pHwMac, MACSYN_SYNC_TYPEADD);
			macSynMlagEncode(pHwMac, MACSYN_SYNC_TYPEADD);
            break;
            
        case MACSYN_MSG_DELL2FDB:
            gSysMacSynStatis.macLocalL3DelCnt02++;
            if(macSynMacLocalDel(pHwMac) != OK)
                return ERROR;
            
            gSysMacSynStatis.macLocalStaticDel++;
            macSynStackEncode(pHwMac, MACSYN_SYNC_TYPEDEL);
			macSynMlagEncode(pHwMac, MACSYN_SYNC_TYPEDEL);
            break;
            
        default:
            break;
        }

        gMacFhnLocal = 0;
    }

    return OK;
}

case MACSYN_MSG_RECVMACDEL:
            if(macSynMacLocalDel(pHwMac) != OK)
                break;
            
            gSysMacSynStatis.macLocalDelSuccess++;      
            macSynStackEncode(pHwMac, MACSYN_SYNC_TYPEDEL);
            macSynMlagEncode(pHwMac, MACSYN_SYNC_TYPEDEL);
            break;
STATUS macSynMacLocalDel(tHwMacAddrEntry *pHwMac)
{
    tPhyIfInfo phyInfo;
    uint8_t ifName[64] = {0};
    int32_t ret = OK, value = USP_IF_ENABLE;
    tMacSynVlan *pMacSynVlan = NULL;
    tMacSynPort *pMacSynPort = NULL;
    tMacSynFdbNode *pMacSyn = NULL, macEntry;
    
    semTake(gSysMacSynInfo.semTree, WAIT_FOREVER);
    pMacSyn = macSynFdbNodeGet(pHwMac->mac, pHwMac->vlanId, pHwMac->keyType);
    if(pMacSyn == NULL)
    {
        gSysMacSynStatis.macLocalDelNotFound++;
        semGive(gSysMacSynInfo.semTree);
        
        macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalDel: Mac can NOT be found."));
        return ENOENT;
    }
    /*lisong add 20200120 for mlag;because this pHwMac */
    /*comes from driver without any idea about owner*/
    if(pMacSyn->l2Entry.owner == 1)
	{
		pHwMac->owner = 1;
		ret = macSynMacLocalAdd(&(pMacSyn->l2Entry));
		semGive(gSysMacSynInfo.semTree);
		return ret;
	}
	
    /*在双芯片或者堆叠环境的L2MOD模式下，同步到另一片芯片的mac条目会老化，这时需要重新添加一次*/
    if((pHwMac->port[0] == pMacSyn->l2Entry.port[0])&&(pHwMac->onuId != pMacSyn->l2Entry.onuId))
    {   
        bzero(&phyInfo, sizeof(tPhyIfInfo));

        if(sysIndexTrans((void*)pHwMac->port[0], SYS_LOGICAL2PHY_NUM, (void*)&phyInfo) != OK)
        {
            semGive(gSysMacSynInfo.semTree);
            macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalDel: Failed to get phyinfo."));
            return EACCES;
        }

        if((phyInfo.endType == USP_END_ETHAGG)
            &&((gSysMacSynInfo.coreDual == 0)||((gSysMacSynInfo.coreDual == 1)&&(((pHwMac->onuId-1)/2)!= ((pMacSyn->l2Entry.onuId-1)/2)))))
            goto MACDELETE;

         
        gSysMacSynStatis.macLocalDelAgedCnt++;
        ret = udr_driver_api(&pHwMac->port[0], udr_cmd_mac_set(UDR_CMD_MAC_L2ADDR), pHwMac);
        if(ret != OK)
        {  

             #if 0 /*hqs-2019-12-18 泰国true测试增加log，在工程版本中不开放*/
             zlog_write_logging(4, "[MSYN] macSynMacLocalAdd: Add HW error,ret=%d.",ret);
             #endif
            gSysMacSynStatis.macLocalDelAgedErr++;
            macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalDel: Add HW error, ret=%d.",ret));
        }
        semGive(gSysMacSynInfo.semTree);
        
        macSynPrintf(MACSYN_DBG_DEL, ("\r\n macSynMacLocalDel: anther core mac had been aged, then add it."));

        if(((pHwMac->mac[0] != 0x00)||(pHwMac->mac[1] != 0x04)||(pHwMac->mac[2] != 0x67))&&(gMacSynLog == 1))
            zlog_write_logging(6, "LOCAL AGED mac = %02x%02x:%02x%02x:%02x%02x, vid = %d, unit = %s, src = %d, new = %d.\r\n", pHwMac->mac[0], pHwMac->mac[1], pHwMac->mac[2], 
                pHwMac->mac[3], pHwMac->mac[4], pHwMac->mac[5], pHwMac->vlanId, uspIfUnit2Name(pHwMac->port[0], ifName, sizeof(ifName)), pMacSyn->l2Entry.onuId, pHwMac->onuId);

        return EAGAIN;
    }

MACDELETE:
    macSynPrintf(MACSYN_DBG_DEL, ("\r\n macSynMacLocalDel: Mac can be found."));

    macSynFdbNodeDel(pMacSyn);
    macSynCntDecrease(&pMacSyn->l2Entry);
    semGive(gSysMacSynInfo.semTree);

    if(pHwMac->type = HW_MAC_STICK) 
    {
       pHwMac->type = HW_MAC_STATIC; 
    }
	
    if((gSysMacSynInfo.coreDual == 1)||(pHwMac->type == HW_MAC_STATIC)||(gSysMacSynInfo.learnMode == 1)) 
    {
        macSynPrintf(MACSYN_DBG_DEL, ("\r\n macSynMacLocalDel: sync anther core.")); 

        if(pHwMac->l3Mac == 1)
            gSysMacSynStatis.macLocalL3DelCnt03++;
        
        ret = udr_driver_api(NULL, udr_cmd_mac_set(UDR_CMD_MAC_DEL), pHwMac);
        if((ret != OK)&&(ret != -7))
        {
            macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalDel: mac del error,ret=%d.",ret)); 
            gSysMacSynStatis.macLocalDelHwErr++;
            return ENOSYS;
        }

        if(pHwMac->l3Mac == 1)
            gSysMacSynStatis.macLocalL3DelCnt04++;
    }

    if(pHwMac->l3Mac == 1)
        gSysMacSynStatis.macLocalL3DelCnt05++;
    else if(pHwMac->port[0] != 0)
        gSwApiFunction.SwIfNotify((void *)pHwMac->port[0], SW_IF_MACDEL, pHwMac);

    if(((pHwMac->mac[0] != 0x00)||(pHwMac->mac[1] != 0x04)||(pHwMac->mac[2] != 0x67))&&(gMacSynLog == 1))
        zlog_write_logging(6, "LOCAL DEL mac = %02x%02x:%02x%02x:%02x%02x, vid = %d, unit = %s.\r\n", pHwMac->mac[0], pHwMac->mac[1],
            pHwMac->mac[2],pHwMac->mac[3],pHwMac->mac[4],pHwMac->mac[5], pHwMac->vlanId, uspIfUnit2Name(pHwMac->port[0], ifName, sizeof(ifName)));

    macSynPrintf(MACSYN_DBG_DEL, ("\r\n macSynMacLocalDel: Del mac entry successful."));
    return OK;
}

if(pMacSyn->l2Entry.owner == 1)/*lisong add 20200120 for mlag;because this pHwMac comes from driver without any idea about owner*/
	{
		pHwMac->owner = 1;
		ret = macSynMacLocalAdd(&(pMacSyn->l2Entry));
		semGive(gSysMacSynInfo.semTree);
		return ret;
	}
STATUS macSynMacLocalAdd(tHwMacAddrEntry *pHwMac)
{
    uint8_t ifName[64] = {0};
    int32_t ret = OK, value = 0, unit = 0;
	tMacSynFdbNode *pMacSyn = NULL, macEntry;
	tMacSynPort* pMacPort = NULL;
    
    semTake(gSysMacSynInfo.semTree, WAIT_FOREVER);

    pMacSyn = macSynFdbNodeGet(pHwMac->mac, pHwMac->vlanId, pHwMac->keyType);
    if(pMacSyn != NULL)
    {
        macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Mac entry is exist."));
        unit = pMacSyn->l2Entry.port[0];
        if(pMacSyn->l2Entry.type == pHwMac->type)  /*类型相同的mac表项*/
        {
            if(pHwMac->type == HW_MAC_DYNAMIC)
            {
                if(pMacSyn->l2Entry.port[0] == pHwMac->port[0]) /*相同的mac表项*/
                {
                    semGive(gSysMacSynInfo.semTree);
                    
                    macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Dynacmic mac is same."));
                    gSysMacSynStatis.macLocalAddSame++;
                    return EEXIST;
                }
                else 
                {
                    /*暂时不考虑mac地址漂移功能是否使能*/
                    macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Dynamic mac is NOT same, so replace it."));

                    memcpy(&pMacSyn->l2Entry, pHwMac, sizeof(tHwMacAddrEntry));
                    
                    semGive(gSysMacSynInfo.semTree);

                    if((gSysMacSynInfo.coreDual == 1)||(gSysMacSynInfo.learnMode == 1)) /*双芯片同步或者l2mode*/
                    {
                        ret = udr_driver_api(NULL, udr_cmd_mac_set(UDR_CMD_MAC_L2ADDR), pHwMac);
                        if(ret != OK)
                        { 
                            #if 0 /*hqs-2019-12-18 泰国true测试增加log，在工程版本中不开放*/
                            zlog_write_logging(4, "[MSYN] macSynMacLocalAdd: Add HW error,ret=%d.",ret);
                            #endif
                            macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalAdd: Add HW error,ret=%d.",ret)); 
                            gSysMacSynStatis.macLocalAddFlapErr++;
                            return ENOSYS;
                        }
                    }

                    if((pHwMac->l3Mac != 1) &&(pHwMac->port[0] != 0))
                        gSwApiFunction.SwIfNotify((void *)unit, SW_IF_MACCHANGE, pHwMac);

                    if(((pHwMac->mac[0] != 0x00)||(pHwMac->mac[1] != 0x04)||(pHwMac->mac[2] != 0x67))&&(gMacSynLog == 1))
                        zlog_write_logging(6, "LOCAL FLAPPING mac = %02x%02x:%02x%02x:%02x%02x, vid = %d, unit = %s.\r\n", pHwMac->mac[0], pHwMac->mac[1],
                            pHwMac->mac[2],pHwMac->mac[3],pHwMac->mac[4],pHwMac->mac[5], pHwMac->vlanId, uspIfUnit2Name(pHwMac->port[0], ifName, sizeof(ifName)));
                    
                    return OK;
                }
            }
            else
            {
                if((pMacSyn->l2Entry.port[0] == pHwMac->port[0])&&(pMacSyn->l2Entry.operation == pHwMac->operation))
                {
                    semGive(gSysMacSynInfo.semTree);
                    
                    macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalAdd: Static mac is same, do nothing."));
                    gSysMacSynStatis.macLocalAddSame++;
                    return EEXIST;
                }
                else
                {
                    if(pHwMac->type == HW_MAC_STATIC)

                    {
                        macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Static mac is NOT same, so replace it."));
                        
                        macSynCntDecrease(&pMacSyn->l2Entry);
                        macSynCntIncrease(pHwMac);

                        memcpy(&pMacSyn->l2Entry, pHwMac, sizeof(tHwMacAddrEntry));
                        semGive(gSysMacSynInfo.semTree);
                        
                        ret = udr_driver_api(NULL, udr_cmd_mac_set(UDR_CMD_MAC_L2ADDR), pHwMac);
                        if(ret != OK)
                        {
                             #if 0 /*hqs-2019-12-18 泰国true测试增加log，在工程版本中不开放*/
                            zlog_write_logging(4, "[MSYN] macSynMacLocalAdd: Add HW error,ret=%d.",ret);
                            #endif
                            macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalAdd: Add HW error,ret=%d.",ret)); 
                            gSysMacSynStatis.macLocalAddHwErr++;
                            return ENOSYS;
                        }
                        
                        if((pHwMac->l3Mac != 1) &&(pHwMac->port[0] != 0))
                            gSwApiFunction.SwIfNotify((void *)unit, SW_IF_MACCHANGE, pHwMac);
                    
                        return OK;
                    }
                    else
                    {
                        semGive(gSysMacSynInfo.semTree);
                        
                        zlog_output_logging(2, "\r\n %%Error: The same MAC address has been configured on another port."); 
                        return EEXIST;
                    }
                }
            }
        }
        else   /*类型不相同的mac表项*/
        {
            if(pHwMac->type == HW_MAC_DYNAMIC) /*目前不会出现该情况*/
            {
                gSysMacSynStatis.macLocalAddUnknownErr++;
                semGive(gSysMacSynInfo.semTree);

                macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalAdd: Dynamic replace static error.")); 
                return EAGAIN;

            }
            else if(pHwMac->type == HW_MAC_STICK)
            {
                semGive(gSysMacSynInfo.semTree);
                
                zlog_output_logging(2, "\r\n %%Error: The MAC address entry of another type already exists."); 
                return EEXIST; 
            }
            else
            {
                if(pMacSyn->l2Entry.type != HW_MAC_STICK)
                {
                    macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Static replaced dynamic."));
                    
                    macSynCntDecrease(&pMacSyn->l2Entry);
                    macSynCntIncrease(pHwMac);

                    memcpy(&pMacSyn->l2Entry, pHwMac, sizeof(tHwMacAddrEntry));
                    semGive(gSysMacSynInfo.semTree);
                    
                    ret = udr_driver_api(NULL, udr_cmd_mac_set(UDR_CMD_MAC_L2ADDR), pHwMac);
                    if(ret != OK)
                    {
                           #if 0 /*hqs-2019-12-18 泰国true测试增加log，在工程版本中不开放*/
                            zlog_write_logging(4, "[MSYN] macSynMacLocalAdd: Add HW error,ret=%d.",ret);
                            #endif
                        macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalAdd: Add HW error,ret=%d.",ret)); 
                        gSysMacSynStatis.macLocalAddHwErr++;
                        return ENOSYS;
                    }

                    if((pHwMac->l3Mac != 1) &&(pHwMac->port[0] != 0))
                        gSwApiFunction.SwIfNotify((void *)unit, SW_IF_MACCHANGE, pHwMac);
                    
                    return OK;
                }
                else
                {
                    semGive(gSysMacSynInfo.semTree);
                    
                    zlog_output_logging(2, "\r\n %%Error: The same MAC address has been configured on another port."); 
                    return EEXIST;                        
                }
            }
        }
    }
    
    macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Mac entry is NOT exist,add new."));

    bzero((void *)&macEntry, sizeof(tMacSynFdbNode));  
    memcpy(&macEntry.l2Entry, pHwMac, sizeof(tHwMacAddrEntry)); 

    if(((pMacPort = macSynStickyEnable(pHwMac->port[0], &value)) != NULL)&&(value == 1)&&((pHwMac->type == HW_MAC_DYNAMIC)||(pHwMac->type == HW_MAC_STICK)))
    {   
        if(pMacPort->stickCount == pMacPort->portSecurityLimitNum)
        {
            if(pHwMac->type == HW_MAC_DYNAMIC)
                udr_driver_api(NULL, udr_cmd_mac_set(UDR_CMD_MAC_DEL), pHwMac);
            else
                zlog_output_logging(2, "\r\n %%Error: Security mac number or sticky mac number reach the upper limit.");    

            semGive(gSysMacSynInfo.semTree);
            
            return ERROR;

        }
        
        pHwMac->type = HW_MAC_STATIC;
        macEntry.l2Entry.onuId = 0;
        macEntry.l2Entry.type  = HW_MAC_STICK;
    }

    if((gSysMacSynInfo.coreDual == 1)||(pHwMac->type == HW_MAC_STATIC)||(gSysMacSynInfo.learnMode == 1))
    {   
        if(pHwMac->l3Mac == 1)
            gSysMacSynStatis.macLocalL3AddCnt03++;
        
        ret = udr_driver_api(NULL, udr_cmd_mac_set(UDR_CMD_MAC_L2ADDR), pHwMac);
        if(ret != OK)
        {       
            semGive(gSysMacSynInfo.semTree);

             #if 0 /*hqs-2019-12-18 泰国true测试增加log，在工程版本中不开放*/
             zlog_write_logging(4, "[MSYN] macSynMacLocalAdd: Add HW error,ret=%d.",ret);
             #endif
             macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalAdd: Add HW error, ret=%d.",ret));
            gSysMacSynStatis.macLocalAddHwErr++;
            return ENOSYS;
        }

        if(pHwMac->l3Mac == 1)
            gSysMacSynStatis.macLocalL3AddCnt04++;
    }
    
    /*新的mac地址可以添加到树上。*/
#if 0 /*初始化提前*/
    bzero((void *)&macEntry, sizeof(tMacSynFdbNode)); 
    memcpy(&macEntry.l2Entry, pHwMac, sizeof(tHwMacAddrEntry));  
#endif

    if(macSynFdbNodeAdd(&macEntry) != OK)
    {
        semGive(gSysMacSynInfo.semTree);
        return ENOSPC;
    }

#if 0
    macSynCntIncrease(pHwMac);
#else
    macSynCntIncrease(&macEntry.l2Entry);
#endif

    semGive(gSysMacSynInfo.semTree);

    if(pHwMac->l3Mac == 1)
        gSysMacSynStatis.macLocalL3AddCnt05++;
    else if(pHwMac->port[0] != 0)
        gSwApiFunction.SwIfNotify((void *)pHwMac->port[0], SW_IF_MACADD, pHwMac);

    if(((pHwMac->mac[0] != 0x00)||(pHwMac->mac[1] != 0x04)||(pHwMac->mac[2] != 0x67))&&(gMacSynLog == 1))
        zlog_write_logging(6, "LOCAL ADD mac = %02x%02x:%02x%02x:%02x%02x, vid = %d, unit = %s.\r\n", pHwMac->mac[0], pHwMac->mac[1],
            pHwMac->mac[2],pHwMac->mac[3],pHwMac->mac[4],pHwMac->mac[5], pHwMac->vlanId, uspIfUnit2Name(pHwMac->port[0], ifName, sizeof(ifName)));

	macSynPrintf(MACSYN_DBG_ADD, ("\r\n macSynMacLocalAdd: Add mac successful."));

    return OK;
}

2.角色改变，删除所有mlag同步过来的mac和local mac，同时通告对端删除mlag学到的mac

        /*master or slaver role*/
		if(p_mlag_notify->role != 3)
		{		    
            memcpy(mlag_peer_mac,p_mlag_notify->peer_mac,6);
            mlag_peerlink = p_mlag_notify->peerlink;
		    if((p_mlag_notify->mlagId >= 1) && (p_mlag_notify->mlagId <= 64))
		    {
		    	bitListSet(mlag_group_role, p_mlag_notify->mlagId - 1);
		    }
		    devMaclFlushByMlag();
		    mlag_peerlink_first_port_set(mlag_peerlink);
		}
STATUS devMaclFlushByMlag()
{
	tHwMacAddrEntry macDel;
	int	ret;
	
	bzero(&macDel,sizeof(tHwMacAddrEntry));
	macDel.sys = 1;
	macDel.filterBits |= (1<<FDB_ACL_SYS) /*| (1<<FDB_ACL_MLAG)*/;
	macSynSetApi(NULL, HW_SYS_FLUSHL2FDB, &macDel, 0);
	return ret;
}

  case HW_SYS_FLUSHL2FDB: /*需要替换HWAPI的实现*/
        if(pHwMac == NULL)
        {
            macSynPrintf(MACSYN_DBG_EVT,("macSynSetApi: Invalid param, line %d.\r\n", __LINE__));
            return EINVAL;
        }

        macSynPrintf(MACSYN_DBG_EVT,("\r\n macSynSetApi: recv HL flush mac event(0x%x).",pHwMac->filterBits));
        
        message.pktHead.msgType = MACSYN_MSG_FLUSHL2FDB;
        message.pktHead.dataLen = sizeof(tHwMacAddrEntry);
        memcpy(&message.pktHead.l2entry, pHwMac, sizeof(tHwMacAddrEntry));

        if(msgQSend(gSysMacSynInfo.msgQ, (UINT1 *)&message ,sizeof(tMacSynMsg), NO_WAIT, MSG_PRI_NORMAL) == ERROR)
        {
            gSysMacSynStatis.macLocalFlushMsgErr++;
            return EBADMSG;
        }
        break;
 case MACSYN_MSG_FLUSHL2FDB:
            devMacLearnHandle(2);
            ret = macSynMacLocalFlush(&message.pktHead.l2entry);
            devMacLearnHandle(1);
            break;
STATUS macSynMacLocalFlush(tHwMacAddrEntry *pHwMac)
{
    int32_t ret = OK;
    tMacSynFdbNode *pMacFdbEntry = NULL,*prevEntry = NULL;

    if((pHwMac == NULL)||(pHwMac->filterBits == 0))
    	return EINVAL;
    
    semTake(gSysMacSynInfo.semTree,WAIT_FOREVER);
    pMacFdbEntry = (tMacSynFdbNode *)avl_first(&gSysMacSynInfo.avlFdbTree);
    while(pMacFdbEntry != NULL)
    {
        prevEntry = (tMacSynFdbNode *)avl_next(&gSysMacSynInfo.avlFdbTree, pMacFdbEntry);
/*
		if((pMacFdbEntry->l2Entry.owner == 1) && !(pHwMac->filterBits & (1<<FDB_ACL_MLAG)))
        {
        	pMacFdbEntry = prevEntry;
			printf("%s %d ,fiterbits:0x%x\r\n",__FUNCTION__,__LINE__,pHwMac->filterBits);
			continue;
        }
*/		
        if((pMacFdbEntry->l2Entry.l3Mac != 1)&&(macSynFilterMatch(pMacFdbEntry, pHwMac)))
        {
            avl_remove(&gSysMacSynInfo.avlFdbTree, pMacFdbEntry);
			
	        list_add((struct list_head *)&pMacFdbEntry->node, &gSysMacSynInfo.freeFdbTbl);

            macSynCntDecrease(&pMacFdbEntry->l2Entry);

            if(pMacFdbEntry->l2Entry.type == HW_MAC_STICK)   /*STICK MAC*/
            {
               pMacFdbEntry->l2Entry.type = HW_MAC_STATIC; 
            }
            
            ret = udr_driver_api(&pMacFdbEntry->l2Entry.port[0], udr_cmd_mac_set(UDR_CMD_MAC_DEL), &pMacFdbEntry->l2Entry);
            if((ret != OK)&&(ret != -7))
            {
                macSynPrintf(MACSYN_DBG_ERR, ("\r\n macSynMacLocalFlush: Mac del error, ret = %d.",ret)); 
                gSysMacSynStatis.macLoaclFlushHwErr++;
            }
			macSynPrintf(MACSYN_DBG_EVT, ("%s %d ,mac:0x%02x%02x%02x%02x%02x%02x\r\n",__FUNCTION__,__LINE__,pMacFdbEntry->l2Entry.mac[0],pMacFdbEntry->l2Entry.mac[1],pMacFdbEntry->l2Entry.mac[2],
				pMacFdbEntry->l2Entry.mac[3],pMacFdbEntry->l2Entry.mac[4],pMacFdbEntry->l2Entry.mac[5])); 			
            if(pMacFdbEntry->l2Entry.port[0] != 0)
                gSwApiFunction.SwIfNotify((void *)pMacFdbEntry->l2Entry.port[0], SW_IF_MACDEL, &pMacFdbEntry->l2Entry);
			macSynMlagEncode(&(pMacFdbEntry->l2Entry), MACSYN_SYNC_TYPEDEL);/*lisong add 20200119 for mlag*/
        }
        
        pMacFdbEntry = prevEntry;
    }
    semGive(gSysMacSynInfo.semTree);
    
    return OK;
}

 

 

 

 

 

守候初心
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
盛科交换机_MLAG_应用指导
05-18
盛科交换机_MLAG_应用指导,介绍了MLAG如何使用,比较不错,分享出来
M-LAG协议交互原理
2301_76769137的博客
09-24 230
与对端同步成员口信息时，状态由Down先变为Up的M-LAG成员接口成为主M-LAG成员口，对端对应的M-LAG成员口为备，且主备状态默认不回切，即：当M-LAG成员接口状态为主的设备故障恢复后，先前由备状态升级为主状态的接口仍保持主状态，恢复故障的M-LAG成员接口状态为备，此处与DFS Group协商主备状态不一致。在DFS Group协商出主备状态后，M-LAG的两台设备会通过peer-link链路发送M-LAG设备信息报文，报文中携带了M-LAG成员接口的配置信息。介绍M-LAG的实现原理。
M-LAG技术
m0_62621003的博客
03-09 1937
Type1类型配置:影响M-LAG系统转发的配置。如果Type 1类型配置不匹配，则将备设备上M-LAG口置为down状态Type2类型配置:仅影响业务模块的配置。如果Type2类型配置不匹配，备设备上M-LAG口依然为up状态，不影响M-LAG系统正常工作。由Type2类型配置对应的业务模块决定是否关闭该业务功能，其他业务模块不受影响。
一文带你了解多机箱链路聚合组（MLAG）
网络技术联盟站
07-09 1887
你好，这里是网络技术联盟站。今天给大家介绍一下多机箱链路聚合组（MLAG）。
m-lag
weixin_45123715的博客
04-04 3022
m-lag：跨机箱的链路聚合 peer-link作用： 1.m-lag协商 2.表项同步 不同厂商的设备也可以做m-lag，不同型号也可而已，但是配置更多，比较麻烦 拓扑图： m-lag配置： zerotouch cancel 取消设备0配置上线 show interface status 查看接口状态 配置链路聚合口： sw1: interface ethernet 1-2 channel-group 1 mode active 将peer-link接口
mlag 堆叠_S-MLAG解决方案介绍
weixin_33681561的博客
12-24 2510
1摘要本文介绍了互联网接入层可靠性设计的发展和实现。随着互联网业务的快速的扩张和网络架构的发展，接入层可靠性也经历了从分到合，又从合到分的发展历程。本文讲述这一过程的同时也会详细阐述去堆叠技术的原理和实现方式。2服务器接入发展随着互联网的爆发式增长，数据中心的规模也越来越大，数据中心网络架构有传统的二层架构，过渡成为了OSPF和BGP的全三层架构，理论上BGP三层架构组网中可以承载100000+的...
安全MAC和Sticky MAC功能
maxdong2021的博客
10-12 4087
安全MAC和Sticky MAC功能说明
M-LAG技术原理
热门推荐
u011727262的博客
03-01 2万+
M-LAG技术原理、应用场景、技术优势。 简介： M-LAG：就是跨设备链路聚合组，是一种实现跨设备链路聚合的机制。 将两台接入交换机以同一个状态和被接入的设备进行链路聚合协商，从而把链路可靠性从单板级别提升到设备级别，组成双活系统。 名词解释 DFS group：动态交换服务组，用于MLAG之间配对，用于进行MLAG双归设备之间的接口状态，表项等进行同步。 peer-link：是一条直连必须聚合的链路，用于交换协商报文及传输部分流量。 技术原理： MLAG建立过程（画图） DFS Group配对：当两台
利用MLAG实现交换机虚拟堆叠技术指导.docx
09-23
利用MLAG实现交换机虚拟堆叠技术指导.docx
交换机的堆叠与级连的区别
04-17
现在的级连扩展模式综合考虑到不同交换机的转发性能和端口属性，通过一定的拓扑结构设计，可以方便地实现多用户接入。
M-LAG最佳实践3.0
03-06
M-LAG：跨设备链路聚合组，是一种实现跨设备链路聚合的机制，能够实现多台设备间的链路聚合，从而把链路可靠性从单板级提高到了设备级，组成双活系统。
交换机级联与堆叠连接对比分析
12-05
交换机级联与堆叠连接对比分析
mlag 堆叠_华为CE交换机M-LAG配置
weixin_30095833的博客
01-14 9578
场景说明：CE1与CE2组成M-LAG，并且作为VLAN 10的网关CE1&CE2配置：CE1&CE2:vlan 10stp mode rstpstp v-stp enable //开启V-STP，目的是让两台M-LAG的设备虚拟成一个STP设备进行生成树计算stp bridge-address 0000-0000-0001 //由于设备需要参与生成树计算，需要配置一样的桥MA...
华为M-LAG跨设备链路聚合技术理论讲解
m0_49864110的博客
11-17 1万+
M-LAG（Muntichassis Link Aggregation Group）跨设备链路聚合组，将不同设备上的不同端口组成一个聚合组，达到跟普通LAG一样的功能，主要应用场景是“双归接入”场景，即用户侧双归接入到两台设备上对于下游设备来说，认为上游设备是一台设备。
端口隔离和端口安全
weixin_34342992的博客
09-29 1771
采用端口隔离功能，可以实现同一VLAN内端口之间的隔离 端口隔离 可以二层隔离 也可以三层隔离 [Huawei]port-isolate mode ?all Alll2 L2 only 缺省情况下，端口隔离模式为二层隔离三层互通。 如果用户希望同一VLAN不同端口下用户彻底无法通信，则可以将隔离模式配置为二层三层均隔离即可。 S1720GFR、S1720GW-E、S1720GWR-E、...
使用ovs模拟二层mac网段转发
bigsheng2的博客
02-04 2867
openflow流表的mac地址match项支持对mac地址做掩码，如同ip地址的掩码一般，就想着既然ip路由可以只使用一条路由表转发到网段内所有主机的报文，那么利用这个特性，二层也可以做到相同的效果，正好工作中也在用ovs做骨干测的转发，同时也存在流表的性能问题，就想着使用这种方法优化一下。 工作业务上的细节不便描述，这里只简单描述一下思路，总体思路就是模仿ip网段和ip三层路由，将同一ovs设备背后的设备的mac地址配置为同一mac地址网段内且全网唯一的地址，从而利用ovs流表mac地址match项支持
ovs 源mac， 目的src 互换
weixin_30784945的博客
12-05 390
push:NXM_OF_ETH_SRC[],push:NXM_OF_ETH_DST[],pop:NXM_OF_ETH_SRC[],pop:NXM_OF_ETH_DST[] 1：把src mac推到栈顶 push:NXM_OF_ETH_SRC[] 2：把dst mac推到栈顶 push:NXM_OF_ETH_DST[] 3：从栈顶读取mac存到NXM_OF_ETH_...
华为HCIE认证中端口安全sticky方式基本配置ielab
IE-lab网络实验室的博客
07-03 1956
华为HCIE认证中端口安全sticky方式基本配置端口安全经常使用在接入层，通过配置端口安全可以防止仿冒用户从其他端口攻击，或者汇聚层，通过配置端口安全可以控制接入用户的数量。 针对接入用户安全性要求较高的网络中，可以通过使用端口安全机制，将接口学习到的MAC地址转换为安全动态MAC或Sticky MAC。如果接口学习的最大MAC数量超过规定数量，则设备不再学习新的MAC地址，而只允许这些MAC地址和设备通信。这样可以有效阻止非信任的MAC主机通过本接口和其他主机通信，提高网络的安全性。 Sticky
Lan仿朋友圈系统开源，可用于表白墙等微商相册，商品图册等.rar
最新发布
04-30
Lan仿朋友圈系统开源，可用于表白墙等微商相册，商品图册等.rarLan仿朋友圈系统开源，可用于表白墙等微商相册，商品图册等.rar
mlag配置案例
05-28
以下是一个基本的MLAG配置示例： ``` ! 配置 MLAG 基础环境 mlag configuration domain-id MLAG001 ...最后，我们将 VLAN 100 接口与 MLAG 端口组 1 关联，并在每个单独的交换机端口上配置了 VLAN 100 的访问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值