Use Vlan MAC as src MAC for link prober by default (#93)

What is the motivation for this PR?
In active-standby, scenario ICMP request is replied by server host and duplicated by smart cable. In active-active scenario, ICMP is replied by FPGA, and it will simply reverse src MAC and dest MAC. If we continue to use device MAC address as src MAC in active-active scenarios, heartbeats won't be duplicated to both sides.

How did you do it?
Get Vlan MAC address when initializing, and use it for link prober by default.
Add handlers to support switching between using Vlan MAC and ToR MAC.
To use ToR MAC, set src_mac field in MUX_LINKMGR|LINK_PROBER table in CONFIG DB to value ToRMac.
How did you verify/test it?
Tested on dualToR testbeds, captured the ICMP requests and replies:

Able to see src MAC as Vlan MAC by default
Able to see src MAC switch to Device MAC after updating CONFIG DB entry
Able to see replies flood back to both sides.

sign-off: Jing Zhang [email protected]

Author: zjswhhh

src/DbInterface.cpp

@@ -541,6 +541,69 @@ void DbInterface::getTorMacAddress(std::shared_ptr<swss::DBConnector> configDbCo
     }
 }
 
+//
+// ---> getVlanNames(std::shared_ptr<swss::DBConnector> configDbConnector);
+// 
+// get vlan names
+//
+void DbInterface::getVlanNames(std::shared_ptr<swss::DBConnector> configDbConnector)
+{
+    MUXLOGINFO("Reading Vlan MAC Address");
+    swss::Table configDbVlanTable(configDbConnector.get(), CFG_VLAN_TABLE_NAME);
+    std::vector<std::string> vlanNames;
+
+    configDbVlanTable.getKeys(vlanNames);
+    getVlanMacAddress(vlanNames);
+}
+
+//
+// ---> getVlanMacAddress(std::vector<std::string> &vlanNames);
+//
+// retrieve Vlan MAC address informtaion
+//
+void DbInterface::getVlanMacAddress(std::vector<std::string> &vlanNames)
+{
+    MUXLOGINFO("Reading Vlan MAC Address");
+
+    if (vlanNames.size() > 0) {
+        std::shared_ptr<swss::DBConnector> configDbPtr = std::make_shared<swss::DBConnector> ("CONFIG_DB", 0);
+        swss::Table configDbVlanTable(configDbPtr.get(), CFG_VLAN_TABLE_NAME);
+        const std::string vlanName = vlanNames[0];
+        const std::string field = "mac";
+        std::string mac;
+        
+        if (configDbVlanTable.hget(vlanName, field, mac)) {
+            processVlanMacAddress(mac);
+        } else {
+            MUXLOGWARNING(boost::format("MAC address is not found for %s, fall back to use device MAC for link prober.") % vlanName);
+            mMuxManagerPtr->setIfUseTorMacAsSrcMac(true);
+        }
+    } else {
+        MUXLOGWARNING("VLAN table is not found in CONFIG DB, fall back to use device MAC for link prober.");
+        mMuxManagerPtr->setIfUseTorMacAsSrcMac(true);
+    }
+}
+
+//
+// ---> processVlanMacAddress(std::string& mac);
+//
+// process Vlan Mac Address 
+//
+void DbInterface::processVlanMacAddress(std::string& mac)
+{
+    try {
+        swss::MacAddress swssMacAddress(mac);
+        std::array<uint8_t, ETHER_ADDR_LEN> macAddress;
+
+        memcpy(macAddress.data(), swssMacAddress.getMac(), macAddress.size());
+        mMuxManagerPtr->setVlanMacAddress(macAddress);
+    }
+    catch (const std::invalid_argument &invalidArgument) {
+        MUXLOGWARNING("Invalid Vlan MAC address " + mac);
+        mMuxManagerPtr->setIfUseTorMacAsSrcMac(true);
+    }
+}
+
 //
 // ---> processLoopback2InterfaceInfo(std::vector<std::string> &loopbackIntfs)
 //
@@ -848,6 +911,8 @@ void DbInterface::processMuxLinkmgrConfigNotifiction(std::deque<swss::KeyOpField
                         mMuxManagerPtr->setSuspendTimeout_msec(boost::lexical_cast<uint32_t> (v));
                     } else if (f == "use_well_known_mac") {
                         mMuxManagerPtr->setUseWellKnownMacActiveActive(v == "enable");
+                    } else if (f == "src_mac") {
+                        mMuxManagerPtr->processSrcMac(v == "ToRMac");
                     }
 
                     MUXLOGINFO(boost::format("key: %s, Operation: %s, f: %s, v: %s") %
@@ -1272,6 +1337,7 @@ void DbInterface::handleSwssNotification()
     swss::SubscriberStateTable stateDbPeerMuxTable(stateDbPtr.get(), STATE_PEER_HW_FORWARDING_STATE_TABLE_NAME);
 
     getTorMacAddress(configDbPtr);
+    getVlanNames(configDbPtr);
     getLoopback2InterfaceInfo(configDbPtr);
     getPortCableType(configDbPtr);
     getServerIpAddress(configDbPtr);

src/DbInterface.h

@@ -421,6 +421,37 @@ class DbInterface
     */
     void getTorMacAddress(std::shared_ptr<swss::DBConnector> configDbConnector);
 
+    /**
+     * @method getVlanNames
+     * 
+     * @brief  get vlan names
+     * 
+     * @param configDbConnector   config db connector
+     * 
+     * @return none
+     */
+    void getVlanNames(std::shared_ptr<swss::DBConnector> configDbConnector);
+
+    /**
+     * @method getVlanMacAddress
+     * 
+     * @brief retrieve Vlan MAC address information
+     * 
+     * @param vlanNames (in) vlan names 
+     * 
+     * @return none
+     */
+    void getVlanMacAddress(std::vector<std::string> &vlanNames);
+
+    /**
+     * @method processVlanMacAddress
+     * 
+     * @brief process Vlan Mac Address
+     * 
+     * @return none 
+     */
+    void processVlanMacAddress(std::string& mac);
+
     /**
     *@method processLoopback2InterfaceInfo
     *

src/MuxManager.cpp

@@ -302,6 +302,25 @@ void MuxManager::processGetServerMacAddress(
     }
 }
 
+//
+// ---> processSrcMac(bool useTorMac);
+//
+// processs src mac config 
+//
+void MuxManager::processSrcMac(bool useTorMac)
+{
+    if (mMuxConfig.getIfEnableUseTorMac() != useTorMac) {
+        setIfUseTorMacAsSrcMac(useTorMac);
+
+        PortMapIterator portMapIterator = mPortMap.begin();
+        while (portMapIterator != mPortMap.end()) {
+            portMapIterator->second->handleSrcMacAddressUpdate();
+            portMapIterator ++;
+        }
+    }
+}
+
+
 //
 // ---> processGetMuxState(const std::string &portName, const std::string &muxState);
 //

src/MuxManager.h

@@ -170,6 +170,39 @@ class MuxManager
     */
     inline void setTorMacAddress(std::array<uint8_t, ETHER_ADDR_LEN> &address) {mMuxConfig.setTorMacAddress(address);};
 
+    /**
+     * @method setVlanMacAddress
+     * 
+     * @brief setter for Vlan Mac Address
+     * 
+     * @param address (in) Vlan mac address 
+     * 
+     * @return none
+     */
+    inline void setVlanMacAddress(std::array<uint8_t, ETHER_ADDR_LEN> &address) {mMuxConfig.setVlanMacAddress(address);};
+
+    /**
+     * @method setIfUseTorMacAsSrcMac
+     * 
+     * @brief setter for flag whether use ToR MAC address as link prober src MAC 
+     * 
+     * @param useTorMac (in) bool
+     * 
+     * @return none
+     */
+    void setIfUseTorMacAsSrcMac(bool useTorMac) {mMuxConfig.setIfUseTorMacAsSrcMac(useTorMac);};
+
+    /**
+     * @method processSrcMac
+     * 
+     * @brief processs src mac config 
+     * 
+     * @param enable (in) bool 
+     * 
+     * @return none
+     */
+    void processSrcMac(bool useTorMac);
+
     /**
     *@method setSuspendTimeout_msec
     *

src/MuxPort.cpp

@@ -198,6 +198,22 @@ void MuxPort::handleUseWellKnownMacAddress()
     )));
 }
 
+//
+// ---> handleSrcMacAddressUpdate();
+// 
+// handles src mac address config update 
+//
+void MuxPort::handleSrcMacAddressUpdate()
+{
+    MUXLOGDEBUG(mMuxPortConfig.getPortName());
+
+    boost::asio::io_service &ioService = mStrand.context();
+    ioService.post(mStrand.wrap(boost::bind(
+        &link_manager::LinkManagerStateMachineBase::handleSrcMacConfigNotification,
+        mLinkManagerStateMachinePtr.get()
+    )));
+}
+
 //
 // ---> handleGetMuxState(const std::string &muxState);
 //

src/MuxPort.h

@@ -301,6 +301,15 @@ class MuxPort: public std::enable_shared_from_this<MuxPort>
     */
     void handleUseWellKnownMacAddress();
 
+    /**
+     * @method handleSrcMacAddressUpdate
+     * 
+     * @brief handles src mac address config update
+     * 
+     * @return none
+     */
+    void handleSrcMacAddressUpdate();
+
     /**
     *@method handleGetMuxState
     *

src/common/MuxConfig.h

@@ -166,6 +166,28 @@ class MuxConfig
     */
     inline void setTorMacAddress(const std::array<uint8_t, ETHER_ADDR_LEN> &address) {mTorMacAddress = address;};
 
+    /**
+     * @method setVlanMacAddress
+     * 
+     * @brief setter for Vlan MAC address
+     * 
+     * @param address (in) Vlan MAC address
+     * 
+     * @return none
+     */
+    inline void setVlanMacAddress(const std::array<uint8_t, ETHER_ADDR_LEN> &address) {mVlanMacAddress = address;};
+
+    /**
+     * @method setIfUseTorMacAsSrcMac
+     * 
+     * @brief setter for flag whether use ToR MAC address as link prober src MAC 
+     * 
+     * @param enable (in) bool 
+     * 
+     * @return none
+     */
+    inline void setIfUseTorMacAsSrcMac(bool enable) {mEnableUseTorMac = enable;};
+
     /**
     *@method setLoopbackIpv4Address
     *
@@ -258,6 +280,15 @@ class MuxConfig
     */
     inline const std::array<uint8_t, ETHER_ADDR_LEN>& getTorMacAddress() const {return mTorMacAddress;};
 
+    /**
+     * @method getVlanMacAddress
+     * 
+     * @brief getter for Vlan MAC address
+     * 
+     * @return Vlan MAC address
+     */
+    inline const std::array<uint8_t, ETHER_ADDR_LEN>& getVlanMacAddress() const {return mVlanMacAddress;};
+
     /**
     *@method getLoopbackIpv4Address
     *
@@ -334,6 +365,15 @@ class MuxConfig
      */
     inline void setUseWellKnownMacActiveActive(bool useWellKnownMacActiveActive) { mUseWellKnownMacActiveActive = useWellKnownMacActiveActive; };
 
+    /**
+     * @method getIfEnableUseTorMac
+     * 
+     * @brief check if use ToR MAC address as src MAC for link prober 
+     * 
+     * @return if use ToR MAC 
+     */
+    inline bool getIfEnableUseTorMac() {return mEnableUseTorMac;};
+
 private:
     uint8_t mNumberOfThreads = 5;
     uint32_t mTimeoutIpv4_msec = 100;
@@ -350,7 +390,10 @@ class MuxConfig
     bool mEnableDefaultRouteFeature = false;
     bool mUseWellKnownMacActiveActive = true;
 
+    bool mEnableUseTorMac = false;
+
     std::array<uint8_t, ETHER_ADDR_LEN> mTorMacAddress;
+    std::array<uint8_t, ETHER_ADDR_LEN> mVlanMacAddress;
     boost::asio::ip::address mLoopbackIpv4Address = boost::asio::ip::make_address("10.212.64.0");
 };
 

src/common/MuxPortConfig.h

@@ -210,6 +210,15 @@ class MuxPortConfig
     */
     inline const std::array<uint8_t, ETHER_ADDR_LEN>& getTorMacAddress() const {return mMuxConfig.getTorMacAddress();};
 
+    /**
+     * @method getVlanMacAddress
+     * 
+     * @brief getter for Vlan MAC address
+     * 
+     * @return Vlan MAC address
+     */
+    inline const std::array<uint8_t, ETHER_ADDR_LEN>& getVlanMacAddress() const {return mMuxConfig.getVlanMacAddress();};
+
     /**
     *@method getLoopbackIpv4Address
     *
@@ -360,6 +369,15 @@ class MuxPortConfig
     */
     inline void setLastUpdatedMacAddress(const std::array<uint8_t, ETHER_ADDR_LEN> &address) {mLastUpdatedMacAddress = address;};
 
+    /**
+     * @method ifEnableUseTorMac
+     * 
+     * @brief check if use ToR MAC address as src MAC for link prober 
+     * 
+     * @reutrn if use ToR MAC
+     */
+    inline bool ifEnableUseTorMac() {return mMuxConfig.getIfEnableUseTorMac();};
+
 private:
     MuxConfig &mMuxConfig;
     std::string mPortName;

src/link_manager/LinkManagerStateMachineActiveActive.h

@@ -570,7 +570,6 @@ class ActiveActiveStateMachine : public LinkManagerStateMachineBase,
 
     boost::function<void()> mInitializeProberFnPtr;
     boost::function<void()> mStartProbingFnPtr;
-    boost::function<void()> mUpdateEthernetFrameFnPtr;
     boost::function<void()> mProbePeerTorFnPtr;
     boost::function<void(uint32_t suspendTime_msec)> mSuspendTxFnPtr;
     boost::function<void()> mResumeTxFnPtr;

src/link_manager/LinkManagerStateMachineActiveStandby.h

@@ -835,7 +835,6 @@ class ActiveStandbyStateMachine: public LinkManagerStateMachineBase,
 
     boost::function<void ()> mInitializeProberFnPtr;
     boost::function<void ()> mStartProbingFnPtr;
-    boost::function<void ()> mUpdateEthernetFrameFnPtr;
     boost::function<void ()> mProbePeerTorFnPtr;
     boost::function<void (uint32_t suspendTime_msec)> mSuspendTxFnPtr;
     boost::function<void ()> mResumeTxFnPtr;

src/link_manager/LinkManagerStateMachineBase.cpp

@@ -139,6 +139,33 @@ void LinkManagerStateMachineBase::handleGetServerMacAddressNotification(std::arr
     MUXLOGINFO(mMuxPortConfig.getPortName());
 }
 
+//
+// ---> handleSrcMacConfigNotification();
+//
+// handle src mac config notification 
+// 
+void LinkManagerStateMachineBase::handleSrcMacConfigNotification()
+{
+    MUXLOGDEBUG(mMuxPortConfig.getPortName());
+
+    if (mUpdateEthernetFrameFnPtr) {
+        mUpdateEthernetFrameFnPtr();
+    } else {
+        std::array<uint8_t, ETHER_ADDR_LEN> address = (mMuxPortConfig.ifEnableUseTorMac())? mMuxPortConfig.getTorMacAddress() : mMuxPortConfig.getVlanMacAddress() ;
+        std::array<char, 3 * ETHER_ADDR_LEN> addressStr = {0};
+        snprintf(
+            addressStr.data(), addressStr.size(), "%02x:%02x:%02x:%02x:%02x:%02x",
+            address[0], address[1], address[2], address[3], address[4], address[5]
+        );
+
+        MUXLOGERROR(boost::format("%s: failed to update Ethernet frame with src mac '%s', link prober init state: %d") %
+            mMuxPortConfig.getPortName() %
+            addressStr.data() %
+            mComponentInitState.test(LinkProberComponent)
+        );
+    }
+}
+
 //
 // ---> handleUseWellKnownMacAddressNotification();
 //