[vnetorch] missing handling of rx and tx interval of monitoring session (sonic-net#3878)

zjswhhh · web-flow · commit 85412005a1b7 · 2025-11-24T09:50:51.000-08:00
What I did Adding rx_monitor_timer and tx_monitor_timer handling per HLD: https://github.com/sonic-net/SONiC/blob/master/doc/vxlan/Overlay%20ECMP%20ehancements.md sign-off: Jing Zhang zhangjing@microsoft.com Why I did it It's needed for SSW HA scenario as DPU side bfd is a software solution, interval must be set to a reasonable value.
diff --git a/orchagent/vnetorch.cpp b/orchagent/vnetorch.cpp
@@ -1015,6 +1015,8 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,
                                        NextHopGroupKey& nexthops_primary,
                                        NextHopGroupKey& nexthops_secondary,
                                        const string& monitoring,
+                                       const int32_t rx_monitor_timer,
+                                       const int32_t tx_monitor_timer,
                                        IpPrefix& ipPrefix,
                                        VNetVrfObject *vrf_obj,
                                        NextHopGroupKey& nexthops_selected,
@@ -1033,18 +1035,18 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,
         auto it_route =  syncd_tunnel_routes_[vnet].find(ipPrefix);
         if (it_route == syncd_tunnel_routes_[vnet].end())
         {
-            setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, ipPrefix);
-            setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, ipPrefix);
+            setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);
+            setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);
         }
         else
         {
             if (it_route->second.primary != nexthops_primary)
             {
-                setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, ipPrefix);
+                setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);
             }
             if (it_route->second.secondary != nexthops_secondary)
             {
-                setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, ipPrefix);
+                setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);
             }
             nexthops_selected = it_route->second.nhg_key;
             return true;
@@ -1103,7 +1105,7 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,
     else if (!hasNextHopGroup(vnet, nexthops_primary))
     {
         SWSS_LOG_INFO("Creating next hop group  %s", nexthops_primary.to_string().c_str());
-        setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, ipPrefix);
+        setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);
         if (!createNextHopGroup(vnet, nexthops_primary, vrf_obj, monitoring))
         {
             delEndpointMonitor(vnet, nexthops_primary, ipPrefix);
@@ -1117,7 +1119,10 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,
 template<>
 bool VNetRouteOrch::doRouteTask<VNetVrfObject>(const string& vnet, IpPrefix& ipPrefix,
                                                NextHopGroupKey& nexthops, string& op, string& profile,
-                                               const string& monitoring, NextHopGroupKey& nexthops_secondary,
+                                               const string& monitoring,
+                                               const int32_t rx_monitor_timer,
+                                               const int32_t tx_monitor_timer,
+                                               NextHopGroupKey& nexthops_secondary,
                                                const IpPrefix& adv_prefix,
                                                const map<NextHopKey, IpAddress>& monitors)
 {
@@ -1158,7 +1163,7 @@ bool VNetRouteOrch::doRouteTask<VNetVrfObject>(const string& vnet, IpPrefix& ipP
     {
         sai_object_id_t nh_id = SAI_NULL_OBJECT_ID;
         NextHopGroupKey active_nhg("", true);
-        if (!selectNextHopGroup(vnet, nexthops, nexthops_secondary, monitoring, ipPrefix, vrf_obj, active_nhg, monitors))
+        if (!selectNextHopGroup(vnet, nexthops, nexthops_secondary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix, vrf_obj, active_nhg, monitors))
         {
             return true;
         }
@@ -1981,7 +1986,7 @@ void VNetRouteOrch::delRoute(const IpPrefix& ipPrefix)
     syncd_routes_.erase(route_itr);
 }
 
-void VNetRouteOrch::createBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& monitor_addr)
+void VNetRouteOrch::createBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& monitor_addr, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer)
 {
     SWSS_LOG_ENTER();
 
@@ -2012,6 +2017,19 @@ void VNetRouteOrch::createBfdSession(const string& vnet, const NextHopKey& endpo
         // when the device goes into TSA.  The following parameter ensures that these session are
         // brought down while transitioning to TSA and brought back up when transitioning to TSB.
         data.emplace_back("shutdown_bfd_during_tsa", "true");
+
+        if (rx_monitor_timer >= 0)
+        {
+            FieldValueTuple fv_rx("rx_interval", to_string(rx_monitor_timer));
+            data.push_back(fv_rx);
+        }
+
+        if (tx_monitor_timer >= 0)
+        {
+            FieldValueTuple fv_tx("tx_interval", to_string(tx_monitor_timer));
+            data.push_back(fv_tx);
+        }
+
         bfd_session_producer_.set(key, data);
         bfd_sessions_[monitor_addr].bfd_state = SAI_BFD_SESSION_STATE_DOWN;
     }
@@ -2116,7 +2134,7 @@ void VNetRouteOrch::removeMonitoringSession(const string& vnet, const NextHopKey
     monitor_info_[vnet][ipPrefix].erase(monitor_addr);
 }
 
-void VNetRouteOrch::setEndpointMonitor(const string& vnet, const map<NextHopKey, IpAddress>& monitors, NextHopGroupKey& nexthops, const string& monitoring, IpPrefix& ipPrefix)
+void VNetRouteOrch::setEndpointMonitor(const string& vnet, const map<NextHopKey, IpAddress>& monitors, NextHopGroupKey& nexthops, const string& monitoring, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer, IpPrefix& ipPrefix)
 {
     SWSS_LOG_ENTER();
 
@@ -2145,7 +2163,7 @@ void VNetRouteOrch::setEndpointMonitor(const string& vnet, const map<NextHopKey,
             {
                 if (nexthop_info_[vnet].find(nh.ip_address) == nexthop_info_[vnet].end())
                 {
-                    createBfdSession(vnet, nh, monitor_ip);
+                    createBfdSession(vnet, nh, monitor_ip, rx_monitor_timer, tx_monitor_timer);
                 }
                 nexthop_info_[vnet][nh.ip_address].ref_count++;
             }
@@ -2863,6 +2881,8 @@ bool VNetRouteOrch::handleTunnel(const Request& request)
     vector<IpAddress> primary_list;
     vector<IpAddress> secondary_list;
     string monitoring;
+    int32_t rx_monitor_timer = -1;
+    int32_t tx_monitor_timer = -1;
     swss::IpPrefix adv_prefix;
     bool has_priority_ep = false;
     bool has_adv_pfx = false;
@@ -2908,6 +2928,14 @@ bool VNetRouteOrch::handleTunnel(const Request& request)
         {
             check_directly_connected = request.getAttrBool(name);
         }
+        else if (name == "rx_monitor_timer")
+        {
+            rx_monitor_timer = static_cast<int32_t>(request.getAttrUint(name));
+        }
+        else if (name == "tx_monitor_timer")
+        {
+            tx_monitor_timer = static_cast<int32_t>(request.getAttrUint(name));
+        }
         else
         {
             SWSS_LOG_INFO("Unknown attribute: %s", name.c_str());
@@ -3043,7 +3071,7 @@ bool VNetRouteOrch::handleTunnel(const Request& request)
     }
     if (vnet_orch_->isVnetExecVrf())
     {
-        return doRouteTask<VNetVrfObject>(vnet_name, ip_pfx, (has_priority_ep == true) ? nhg_primary : nhg, op, profile, monitoring, nhg_secondary, adv_prefix, monitors);
+        return doRouteTask<VNetVrfObject>(vnet_name, ip_pfx, (has_priority_ep == true) ? nhg_primary : nhg, op, profile, monitoring, rx_monitor_timer, tx_monitor_timer, nhg_secondary, adv_prefix, monitors);
     }
 
     return true;
diff --git a/orchagent/vnetorch.h b/orchagent/vnetorch.h
@@ -311,6 +311,8 @@ const request_description_t vnet_route_description = {
         { "monitoring",             REQ_T_STRING },
         { "adv_prefix",             REQ_T_IP_PREFIX },
         { "check_directly_connected", REQ_T_BOOL },
+        { "rx_monitor_timer",       REQ_T_UINT },
+        { "tx_monitor_timer",       REQ_T_UINT },
     },
     { }
 };
@@ -479,16 +481,17 @@ class VNetRouteOrch : public Orch2, public Subject, public Observer
                             const string& monitoring);
     NextHopGroupKey getActiveNHSet(const string&, NextHopGroupKey&, const IpPrefix& );
 
-    bool selectNextHopGroup(const string&, NextHopGroupKey&, NextHopGroupKey&, const string&, IpPrefix&,
+    bool selectNextHopGroup(const string&, NextHopGroupKey&, NextHopGroupKey&, const string&, const int32_t, const int32_t, IpPrefix&,
                             VNetVrfObject *vrf_obj, NextHopGroupKey&,
                             const std::map<NextHopKey,IpAddress>& monitors=std::map<NextHopKey, IpAddress>());
 
-    void createBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& ipAddr);
+    void createBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& ipAddr, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer);
     void removeBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& ipAddr);
     void createMonitoringSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& ipAddr, IpPrefix& ipPrefix);
     void removeMonitoringSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& ipAddr, IpPrefix& ipPrefix);
     void setEndpointMonitor(const string& vnet, const map<NextHopKey, IpAddress>& monitors, NextHopGroupKey& nexthops,
-                            const string& monitoring, IpPrefix& ipPrefix);
+                            const string& monitoring, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer,
+                            IpPrefix& ipPrefix);
     void delEndpointMonitor(const string& vnet, NextHopGroupKey& nexthops, IpPrefix& ipPrefix);
     void postRouteState(const string& vnet, IpPrefix& ipPrefix, NextHopGroupKey& nexthops, string& profile);
     void removeRouteState(const string& vnet, IpPrefix& ipPrefix);
@@ -506,7 +509,8 @@ class VNetRouteOrch : public Orch2, public Subject, public Observer
 
     template<typename T>
     bool doRouteTask(const string& vnet, IpPrefix& ipPrefix, NextHopGroupKey& nexthops, string& op, string& profile,
-                    const string& monitoring, NextHopGroupKey& nexthops_secondary, const IpPrefix& adv_prefix,
+                    const string& monitoring, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer,
+                    NextHopGroupKey& nexthops_secondary, const IpPrefix& adv_prefix,
                     const std::map<NextHopKey, IpAddress>& monitors=std::map<NextHopKey, IpAddress>());
 
     template<typename T>
diff --git a/tests/test_vnet.py b/tests/test_vnet.py
@@ -3112,7 +3112,58 @@ def test_vnet_local_route_ecmp(self, dvs, testlog):
         delete_vxlan_tunnel(dvs, tunnel_name)
         vnet_obj.check_del_vxlan_tunnel(dvs)
 
+    '''
+    Test 32 - Test for priority vnet tunnel routes with local endpoint + bfd monitoring + rx and tx timer.
+    '''
+    def test_vnet_orch_30(self, dvs, dvs_acl, testlog):
+        self.setup_db(dvs)
+        self.clear_srv_config(dvs)
+
+        vnet_obj = self.get_vnet_obj()
+        tunnel_name = 'tunnel_32'
+        vnet_name = 'Vnet32'
+        asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
+
+        vnet_obj.fetch_exist_entries(dvs)
+
+        create_vxlan_tunnel(dvs, tunnel_name, '9.9.9.9')
+        create_vnet_entry(dvs, vnet_name, tunnel_name, '10028', "", advertise_prefix=True, overlay_dmac="22:33:33:44:44:66")
+
+        vnet_obj.check_vnet_entry(dvs, vnet_name)
+        vnet_obj.check_vxlan_tunnel_entry(dvs, tunnel_name, vnet_name, '10028')
+        vnet_obj.check_vxlan_tunnel(dvs, tunnel_name, '9.9.9.9')
+
+        # create l3 interface
+        self.create_l3_intf("Ethernet8", "")
+
+        # set ip address
+        self.add_ip_address("Ethernet8", "9.1.0.1/32")
+
+        # bring up interface
+        self.set_admin_status("Ethernet8", "up")
+
+        # add neighbor for directly connected endpoint
+        self.add_neighbor("Ethernet8", "9.1.0.1", "00:01:02:03:04:05")
+
+        vnet_obj.fetch_exist_entries(dvs)
+        create_vnet_routes(dvs, "100.100.1.1/32", vnet_name, '9.1.0.1,9.1.0.2', ep_monitor='9.1.0.1,9.1.0.2', primary ='9.1.0.1', profile="Test_profile", monitoring='', rx_monitor_timer=100, tx_monitor_timer=100, adv_prefix='100.100.1.0/24', check_directly_connected=True)
+
+        # Remove tunnel route 1
+        delete_vnet_routes(dvs, "100.100.1.1/32", vnet_name)
+
+        vnet_obj.check_del_vnet_routes(dvs, vnet_name, ["100.100.1.1/32"])
+        check_remove_state_db_routes(dvs, vnet_name, "100.100.1.1/32")
+        check_remove_routes_advertisement(dvs, "100.100.1.0/24")
+
+        delete_vnet_entry(dvs, vnet_name)
+        vnet_obj.check_del_vnet_entry(dvs, vnet_name)
+        delete_vxlan_tunnel(dvs, tunnel_name)
+
+        self.remove_neighbor("Ethernet8", "9.1.0.1")
+        self.remove_ip_address("Ethernet8", "9.1.0.1/32")
+        self.set_admin_status("Ethernet8", "down")
+
 # Add Dummy always-pass test at end as workaroud
 # for issue when Flaky fail on final test it invokes module tear-down before retrying
 def test_nonflaky_dummy():
-    pass
+    pass
diff --git a/tests/vnet_lib.py b/tests/vnet_lib.py
@@ -140,11 +140,11 @@ def delete_vnet_local_routes(dvs, prefix, vnet_name):
     time.sleep(2)
 
 
-def create_vnet_routes(dvs, prefix, vnet_name, endpoint, mac="", vni=0, ep_monitor="", profile="", primary="", monitoring="", adv_prefix="", check_directly_connected=False):
-    set_vnet_routes(dvs, prefix, vnet_name, endpoint, mac=mac, vni=vni, ep_monitor=ep_monitor, profile=profile, primary=primary, monitoring=monitoring, adv_prefix=adv_prefix, check_directly_connected=check_directly_connected)
+def create_vnet_routes(dvs, prefix, vnet_name, endpoint, mac="", vni=0, ep_monitor="", profile="", primary="", monitoring="", rx_monitor_timer=-1, tx_monitor_timer=-1, adv_prefix="", check_directly_connected=False):
+    set_vnet_routes(dvs, prefix, vnet_name, endpoint, mac=mac, vni=vni, ep_monitor=ep_monitor, profile=profile, primary=primary, monitoring=monitoring, rx_monitor_timer=rx_monitor_timer, tx_monitor_timer=tx_monitor_timer, adv_prefix=adv_prefix, check_directly_connected=check_directly_connected)
 
 
-def set_vnet_routes(dvs, prefix, vnet_name, endpoint, mac="", vni=0, ep_monitor="", profile="", primary="", monitoring="", adv_prefix="", check_directly_connected=False):
+def set_vnet_routes(dvs, prefix, vnet_name, endpoint, mac="", vni=0, ep_monitor="", profile="", primary="", monitoring="", rx_monitor_timer=-1, tx_monitor_timer=-1, adv_prefix="", check_directly_connected=False):
     conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0)
 
     attrs = [
@@ -175,6 +175,12 @@ def set_vnet_routes(dvs, prefix, vnet_name, endpoint, mac="", vni=0, ep_monitor=
     if check_directly_connected:
         attrs.append(('check_directly_connected', 'true'))
 
+    if rx_monitor_timer != -1:
+        attrs.append(('rx_monitor_timer', str(rx_monitor_timer)))
+
+    if tx_monitor_timer != -1:
+        attrs.append(('tx_monitor_timer', str(tx_monitor_timer)))
+
     tbl = swsscommon.Table(conf_db, "VNET_ROUTE_TUNNEL")
     fvs = swsscommon.FieldValuePairs(attrs)
     tbl.set("%s|%s" % (vnet_name, prefix), fvs)

Original file line number	Diff line number	Diff line change
`@@ -1015,6 +1015,8 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,`
`1015`	`1015`	`NextHopGroupKey& nexthops_primary,`
`1016`	`1016`	`NextHopGroupKey& nexthops_secondary,`
`1017`	`1017`	`const string& monitoring,`
	`1018`	`+ const int32_t rx_monitor_timer,`
	`1019`	`+ const int32_t tx_monitor_timer,`
`1018`	`1020`	`IpPrefix& ipPrefix,`
`1019`	`1021`	`VNetVrfObject *vrf_obj,`
`1020`	`1022`	`NextHopGroupKey& nexthops_selected,`
`@@ -1033,18 +1035,18 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,`
`1033`	`1035`	`auto it_route = syncd_tunnel_routes_[vnet].find(ipPrefix);`
`1034`	`1036`	`if (it_route == syncd_tunnel_routes_[vnet].end())`
`1035`	`1037`	`{`
`1036`		`- setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, ipPrefix);`
`1037`		`- setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, ipPrefix);`
	`1038`	`+ setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);`
	`1039`	`+ setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);`
`1038`	`1040`	`}`
`1039`	`1041`	`else`
`1040`	`1042`	`{`
`1041`	`1043`	`if (it_route->second.primary != nexthops_primary)`
`1042`	`1044`	`{`
`1043`		`- setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, ipPrefix);`
	`1045`	`+ setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);`
`1044`	`1046`	`}`
`1045`	`1047`	`if (it_route->second.secondary != nexthops_secondary)`
`1046`	`1048`	`{`
`1047`		`- setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, ipPrefix);`
	`1049`	`+ setEndpointMonitor(vnet, monitors, nexthops_secondary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);`
`1048`	`1050`	`}`
`1049`	`1051`	`nexthops_selected = it_route->second.nhg_key;`
`1050`	`1052`	`return true;`
`@@ -1103,7 +1105,7 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,`
`1103`	`1105`	`else if (!hasNextHopGroup(vnet, nexthops_primary))`
`1104`	`1106`	`{`
`1105`	`1107`	`SWSS_LOG_INFO("Creating next hop group %s", nexthops_primary.to_string().c_str());`
`1106`		`- setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, ipPrefix);`
	`1108`	`+ setEndpointMonitor(vnet, monitors, nexthops_primary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix);`
`1107`	`1109`	`if (!createNextHopGroup(vnet, nexthops_primary, vrf_obj, monitoring))`
`1108`	`1110`	`{`
`1109`	`1111`	`delEndpointMonitor(vnet, nexthops_primary, ipPrefix);`
`@@ -1117,7 +1119,10 @@ bool VNetRouteOrch::selectNextHopGroup(const string& vnet,`
`1117`	`1119`	`template<>`
`1118`	`1120`	`bool VNetRouteOrch::doRouteTask<VNetVrfObject>(const string& vnet, IpPrefix& ipPrefix,`
`1119`	`1121`	`NextHopGroupKey& nexthops, string& op, string& profile,`
`1120`		`- const string& monitoring, NextHopGroupKey& nexthops_secondary,`
	`1122`	`+ const string& monitoring,`
	`1123`	`+ const int32_t rx_monitor_timer,`
	`1124`	`+ const int32_t tx_monitor_timer,`
	`1125`	`+ NextHopGroupKey& nexthops_secondary,`
`1121`	`1126`	`const IpPrefix& adv_prefix,`
`1122`	`1127`	`const map<NextHopKey, IpAddress>& monitors)`
`1123`	`1128`	`{`
`@@ -1158,7 +1163,7 @@ bool VNetRouteOrch::doRouteTask<VNetVrfObject>(const string& vnet, IpPrefix& ipP`
`1158`	`1163`	`{`
`1159`	`1164`	`sai_object_id_t nh_id = SAI_NULL_OBJECT_ID;`
`1160`	`1165`	`NextHopGroupKey active_nhg("", true);`
`1161`		`- if (!selectNextHopGroup(vnet, nexthops, nexthops_secondary, monitoring, ipPrefix, vrf_obj, active_nhg, monitors))`
	`1166`	`+ if (!selectNextHopGroup(vnet, nexthops, nexthops_secondary, monitoring, rx_monitor_timer, tx_monitor_timer, ipPrefix, vrf_obj, active_nhg, monitors))`
`1162`	`1167`	`{`
`1163`	`1168`	`return true;`
`1164`	`1169`	`}`
`@@ -1981,7 +1986,7 @@ void VNetRouteOrch::delRoute(const IpPrefix& ipPrefix)`
`1981`	`1986`	`syncd_routes_.erase(route_itr);`
`1982`	`1987`	`}`
`1983`	`1988`
`1984`		`-void VNetRouteOrch::createBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& monitor_addr)`
	`1989`	`+void VNetRouteOrch::createBfdSession(const string& vnet, const NextHopKey& endpoint, const IpAddress& monitor_addr, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer)`
`1985`	`1990`	`{`
`1986`	`1991`	`SWSS_LOG_ENTER();`
`1987`	`1992`
`@@ -2012,6 +2017,19 @@ void VNetRouteOrch::createBfdSession(const string& vnet, const NextHopKey& endpo`
`2012`	`2017`	`// when the device goes into TSA. The following parameter ensures that these session are`
`2013`	`2018`	`// brought down while transitioning to TSA and brought back up when transitioning to TSB.`
`2014`	`2019`	`data.emplace_back("shutdown_bfd_during_tsa", "true");`
	`2020`	`+`
	`2021`	`+ if (rx_monitor_timer >= 0)`
	`2022`	`+ {`
	`2023`	`+ FieldValueTuple fv_rx("rx_interval", to_string(rx_monitor_timer));`
	`2024`	`+ data.push_back(fv_rx);`
	`2025`	`+ }`
	`2026`	`+`
	`2027`	`+ if (tx_monitor_timer >= 0)`
	`2028`	`+ {`
	`2029`	`+ FieldValueTuple fv_tx("tx_interval", to_string(tx_monitor_timer));`
	`2030`	`+ data.push_back(fv_tx);`
	`2031`	`+ }`
	`2032`	`+`
`2015`	`2033`	`bfd_session_producer_.set(key, data);`
`2016`	`2034`	`bfd_sessions_[monitor_addr].bfd_state = SAI_BFD_SESSION_STATE_DOWN;`
`2017`	`2035`	`}`
`@@ -2116,7 +2134,7 @@ void VNetRouteOrch::removeMonitoringSession(const string& vnet, const NextHopKey`
`2116`	`2134`	`monitor_info_[vnet][ipPrefix].erase(monitor_addr);`
`2117`	`2135`	`}`
`2118`	`2136`
`2119`		`-void VNetRouteOrch::setEndpointMonitor(const string& vnet, const map<NextHopKey, IpAddress>& monitors, NextHopGroupKey& nexthops, const string& monitoring, IpPrefix& ipPrefix)`
	`2137`	`+void VNetRouteOrch::setEndpointMonitor(const string& vnet, const map<NextHopKey, IpAddress>& monitors, NextHopGroupKey& nexthops, const string& monitoring, const int32_t rx_monitor_timer, const int32_t tx_monitor_timer, IpPrefix& ipPrefix)`
`2120`	`2138`	`{`
`2121`	`2139`	`SWSS_LOG_ENTER();`
`2122`	`2140`
`@@ -2145,7 +2163,7 @@ void VNetRouteOrch::setEndpointMonitor(const string& vnet, const map<NextHopKey,`
`2145`	`2163`	`{`
`2146`	`2164`	`if (nexthop_info_[vnet].find(nh.ip_address) == nexthop_info_[vnet].end())`
`2147`	`2165`	`{`
`2148`		`- createBfdSession(vnet, nh, monitor_ip);`
	`2166`	`+ createBfdSession(vnet, nh, monitor_ip, rx_monitor_timer, tx_monitor_timer);`
`2149`	`2167`	`}`
`2150`	`2168`	`nexthop_info_[vnet][nh.ip_address].ref_count++;`
`2151`	`2169`	`}`
`@@ -2863,6 +2881,8 @@ bool VNetRouteOrch::handleTunnel(const Request& request)`
`2863`	`2881`	`vector<IpAddress> primary_list;`
`2864`	`2882`	`vector<IpAddress> secondary_list;`
`2865`	`2883`	`string monitoring;`
	`2884`	`+ int32_t rx_monitor_timer = -1;`
	`2885`	`+ int32_t tx_monitor_timer = -1;`
`2866`	`2886`	`swss::IpPrefix adv_prefix;`
`2867`	`2887`	`bool has_priority_ep = false;`
`2868`	`2888`	`bool has_adv_pfx = false;`
`@@ -2908,6 +2928,14 @@ bool VNetRouteOrch::handleTunnel(const Request& request)`
`2908`	`2928`	`{`
`2909`	`2929`	`check_directly_connected = request.getAttrBool(name);`
`2910`	`2930`	`}`
	`2931`	`+ else if (name == "rx_monitor_timer")`
	`2932`	`+ {`
	`2933`	`+ rx_monitor_timer = static_cast<int32_t>(request.getAttrUint(name));`
	`2934`	`+ }`
	`2935`	`+ else if (name == "tx_monitor_timer")`
	`2936`	`+ {`
	`2937`	`+ tx_monitor_timer = static_cast<int32_t>(request.getAttrUint(name));`
	`2938`	`+ }`
`2911`	`2939`	`else`
`2912`	`2940`	`{`
`2913`	`2941`	`SWSS_LOG_INFO("Unknown attribute: %s", name.c_str());`
`@@ -3043,7 +3071,7 @@ bool VNetRouteOrch::handleTunnel(const Request& request)`
`3043`	`3071`	`}`
`3044`	`3072`	`if (vnet_orch_->isVnetExecVrf())`
`3045`	`3073`	`{`
`3046`		`- return doRouteTask<VNetVrfObject>(vnet_name, ip_pfx, (has_priority_ep == true) ? nhg_primary : nhg, op, profile, monitoring, nhg_secondary, adv_prefix, monitors);`
	`3074`	`+ return doRouteTask<VNetVrfObject>(vnet_name, ip_pfx, (has_priority_ep == true) ? nhg_primary : nhg, op, profile, monitoring, rx_monitor_timer, tx_monitor_timer, nhg_secondary, adv_prefix, monitors);`
`3047`	`3075`	`}`
`3048`	`3076`
`3049`	`3077`	`return true;`