Add parametr neighbor_resolve_removed

stal76 · stal76 · commit 015d5c7d7dbc · 2025-12-08T18:03:48.000+03:00
diff --git a/common/config.release.h b/common/config.release.h
@@ -74,3 +74,4 @@ static constexpr std::uint32_t YANET_BALANCER_WRR_SERVICE_SIZE = YANET_CONFIG_BA
 #define YANET_CONFIG_BALANCER_STATE_TIMEOUT_DEFAULT (60)
 #define YANET_CONFIG_NEIGHBOR_CHECK_INTERVAL (5)
 #define YANET_CONFIG_NEIGHBOR_REMOVE_TIMEOUT (60)
+#define YANET_CONFIG_RESOLVE_REMOVED (2)
diff --git a/dataplane/config_values.h b/dataplane/config_values.h
@@ -48,6 +48,7 @@ struct ConfigValues
 	uint64_t neighbor_rcvbuf_size = 0;
 	uint64_t neighbor_checks_interval = YANET_CONFIG_NEIGHBOR_CHECK_INTERVAL;
 	uint64_t neighbor_remove_timeout = YANET_CONFIG_NEIGHBOR_REMOVE_TIMEOUT;
+	uint64_t neighbor_resolve_removed = YANET_CONFIG_RESOLVE_REMOVED;
 };
 
 inline uint64_t ReadNeighStaleTime()
@@ -131,4 +132,5 @@ inline void from_json(const nlohmann::json& j, ConfigValues& cfg)
 	}
 	cfg.neighbor_checks_interval = j.value("neighbor_checks_interval", cfg.neighbor_checks_interval);
 	cfg.neighbor_remove_timeout = j.value("neighbor_remove_timeout", cfg.neighbor_remove_timeout);
+	cfg.neighbor_resolve_removed = j.value("neighbor_resolve_removed", cfg.neighbor_resolve_removed);
 }
diff --git a/dataplane/dataplane.cpp b/dataplane/dataplane.cpp
@@ -292,6 +292,7 @@ eResult cDataPlane::init(const std::string& binaryPath,
 	        getConfigValues().neighbor_rcvbuf_size,
 	        getConfigValues().neighbor_checks_interval,
 	        getConfigValues().neighbor_remove_timeout,
+	        getConfigValues().neighbor_resolve_removed,
 	        [this](tSocketId socket_id) {
 		        return memory_manager.create<dataplane::neighbor::hashtable>(
 		                "neighbor.ht",
diff --git a/dataplane/neighbor.cpp b/dataplane/neighbor.cpp
@@ -26,6 +26,7 @@ eResult module::init(
         uint64_t rcvbuf_size,
         uint64_t checks_interval,
         uint64_t remove_timeout,
+        uint64_t resolve_removed,
         std::function<dataplane::neighbor::hashtable*(tSocketId)> ht_allocator,
         std::function<std::uint32_t()> current_time,
         std::function<void()> on_neighbor_flush,
@@ -38,6 +39,7 @@ eResult module::init(
 	rcvbuf_size_ = rcvbuf_size;
 	checks_interval_ = checks_interval;
 	remove_timeout_ = remove_timeout;
+	resolve_removed_ = resolve_removed;
 
 	generation_hashtable.fill([&](neighbor::generation_hashtable& hashtable) {
 		for (const auto socket_id : socket_ids)
@@ -345,7 +347,7 @@ eResult module::DumpOSNeighbors()
 				        hashtable_updater.get_pointer()
 				                ->insert_or_update(
 				                        dataplane::neighbor::key{iface, is_v6 ? flag_is_ipv6 : uint16_t{}, dst},
-				                        dataplane::neighbor::value{mac.value(), 0, now, 0, 0});
+				                        dataplane::neighbor::value{mac.value(), 0, now, 0, 0, 0});
 				        stats.netlink_neighbor_update++;
 			        }
 		        }
@@ -420,7 +422,7 @@ void module::StartResolveJob()
 void module::Upsert(tInterfaceId iface, const ipv6_address_t& dst, bool is_v6, const rte_ether_addr& mac)
 {
 	TransformHashtables([k = key{iface, is_v6 ? flag_is_ipv6 : uint16_t{}, dst},
-	                     v = value{mac, 0, current_time_provider_(), 0, 0},
+	                     v = value{mac, 0, current_time_provider_(), 0, 0, 0},
 	                     this](dataplane::neighbor::hashtable& hashtable) {
 		if (!hashtable.insert_or_update(k, v))
 		{
@@ -444,6 +446,7 @@ void module::UpdateTimestamp(tInterfaceId iface, const ipv6_address_t& dst, bool
 			value->last_update_timestamp = current_time_provider_();
 			value->last_remove_timestamp = 0;
 			value->last_resolve_timestamp = 0;
+			value->number_resolve_after_remove = 0;
 			stats.hashtable_insert_success++;
 		}
 		else
@@ -462,6 +465,7 @@ void module::Remove(tInterfaceId iface, const ipv6_address_t& dst, bool is_v6)
 		if (value)
 		{
 			value->last_remove_timestamp = current_time_provider_();
+			value->number_resolve_after_remove = 0;
 			stats.hashtable_remove_success++;
 		}
 		else
@@ -471,7 +475,7 @@ void module::Remove(tInterfaceId iface, const ipv6_address_t& dst, bool is_v6)
 	});
 }
 
-void module::resolve(const dataplane::neighbor::key& key)
+bool module::resolve(const dataplane::neighbor::key& key)
 {
 	stats.resolve++;
 
@@ -486,7 +490,7 @@ void module::resolve(const dataplane::neighbor::key& key)
 			YANET_LOG_ERROR("unknown interface_id: %u [ipv4_address: %s]\n",
 			                key.interface_id,
 			                ip_address.toString().data());
-			return;
+			return false;
 		}
 
 		const auto& [it_route_name, it_interface_name] = it->second;
@@ -548,7 +552,7 @@ void module::resolve(const dataplane::neighbor::key& key)
 	{
 		YANET_LOG_WARNING("neighbor_resolve: socket(): %s\n",
 		                  strerror(errno));
-		return;
+		return false;
 	}
 
 	int rc = setsockopt(icmp_socket,
@@ -562,7 +566,7 @@ void module::resolve(const dataplane::neighbor::key& key)
 		                  interface_name.data(),
 		                  strerror(errno));
 		close(icmp_socket);
-		return;
+		return false;
 	}
 
 	union
@@ -591,6 +595,7 @@ void module::resolve(const dataplane::neighbor::key& key)
 
 	icmphdr header;
 	memset(&header, 0, sizeof(header));
+	bool result = true;
 	if (sendto(icmp_socket,
 	           &header,
 	           sizeof(header),
@@ -600,10 +605,12 @@ void module::resolve(const dataplane::neighbor::key& key)
 	{
 		YANET_LOG_WARNING("neighbor_resolve: sendto(): %s\n",
 		                  strerror(errno));
+		result = false;
 	}
 
 	close(icmp_socket);
 #endif // CONFIG_YADECAP_AUTOTEST
+	return result;
 }
 
 void module::NeighborThreadAction(uint32_t current_time)
@@ -638,7 +645,7 @@ void module::NeighborThreadAction(uint32_t current_time)
 		{
 			keys_to_remove.push_back(key);
 		}
-		else if (value.last_resolve_timestamp + checks_interval_ <= current_time)
+		else if (value.last_resolve_timestamp + checks_interval_ <= current_time && value.number_resolve_after_remove < resolve_removed_)
 		{
 			keys_to_resolve.push_back(key);
 		}
@@ -662,21 +669,24 @@ void module::NeighborThreadAction(uint32_t current_time)
 	// resolve
 	for (const key& cur_key : keys_to_resolve)
 	{
+		if (!resolve(cur_key))
+		{
+			continue;
+		}
 		TransformHashtables([cur_key, current_time, this](dataplane::neighbor::hashtable& hashtable) {
-			YANET_LOG_INFO("resolve\n");
 			dataplane::neighbor::value* value;
 			hashtable.lookup(cur_key, value);
 			if (value)
 			{
 				value->last_resolve_timestamp = current_time;
+				value->number_resolve_after_remove++;
 				stats.resolve_removed++;
 			}
 			else
 			{
 				stats.hashtable_insert_error++;
 			}
 		});
-		resolve(cur_key);
 	}
 }
 
diff --git a/dataplane/neighbor.h b/dataplane/neighbor.h
@@ -57,6 +57,7 @@ struct value
 	uint32_t last_update_timestamp;
 	uint32_t last_remove_timestamp;
 	uint32_t last_resolve_timestamp;
+	uint32_t number_resolve_after_remove;
 };
 
 //
@@ -89,6 +90,7 @@ class module
 	uint64_t rcvbuf_size_ = 0;
 	uint64_t checks_interval_ = YANET_CONFIG_NEIGHBOR_CHECK_INTERVAL;
 	uint64_t remove_timeout_ = YANET_CONFIG_NEIGHBOR_REMOVE_TIMEOUT;
+	uint64_t resolve_removed_ = YANET_CONFIG_RESOLVE_REMOVED;
 	std::mutex mutex_restart_monitor_;
 
 public:
@@ -100,6 +102,7 @@ class module
 	        uint64_t rcvbuf_size,
 	        uint64_t checks_interval,
 	        uint64_t remove_timeout,
+	        uint64_t resolve_removed,
 	        std::function<dataplane::neighbor::hashtable*(tSocketId)> ht_allocator,
 	        std::function<std::uint32_t()> current_time,
 	        std::function<void()> on_update,
@@ -128,7 +131,7 @@ class module
 	void StopNetlinkMonitor();
 	eResult DumpOSNeighbors();
 
-	void resolve(const dataplane::neighbor::key& key);
+	bool resolve(const dataplane::neighbor::key& key);
 
 protected:
 	generation_manager<dataplane::neighbor::generation_interface> generation_interface;
diff --git a/dataplane/unittest/neighbor.cpp b/dataplane/unittest/neighbor.cpp
@@ -142,6 +142,7 @@ TEST(NeighborTest, Basic)
 	        0,
 	        YANET_CONFIG_NEIGHBOR_CHECK_INTERVAL,
 	        2, // remove_timeout
+	        YANET_CONFIG_RESOLVE_REMOVED,
 	        [](tSocketId) {
 		        auto size = dataplane::neighbor::hashtable::calculate_sizeof(64 * 1024);
 		        void* ptr = new char[size];
@@ -224,6 +225,7 @@ TEST(NeighborTest, Provider)
 	        0,
 	        YANET_CONFIG_NEIGHBOR_CHECK_INTERVAL,
 	        YANET_CONFIG_NEIGHBOR_REMOVE_TIMEOUT,
+	        YANET_CONFIG_RESOLVE_REMOVED,
 	        [](tSocketId) {
 		        auto size = dataplane::neighbor::hashtable::calculate_sizeof(64 * 1024);
 		        void* ptr = new char[size];

Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,7 @@ struct ConfigValues`
`48`	`48`	`uint64_t neighbor_rcvbuf_size = 0;`
`49`	`49`	`uint64_t neighbor_checks_interval = YANET_CONFIG_NEIGHBOR_CHECK_INTERVAL;`
`50`	`50`	`uint64_t neighbor_remove_timeout = YANET_CONFIG_NEIGHBOR_REMOVE_TIMEOUT;`
	`51`	`+ uint64_t neighbor_resolve_removed = YANET_CONFIG_RESOLVE_REMOVED;`
`51`	`52`	`};`
`52`	`53`
`53`	`54`	`inline uint64_t ReadNeighStaleTime()`
`@@ -131,4 +132,5 @@ inline void from_json(const nlohmann::json& j, ConfigValues& cfg)`
`131`	`132`	`}`
`132`	`133`	`cfg.neighbor_checks_interval = j.value("neighbor_checks_interval", cfg.neighbor_checks_interval);`
`133`	`134`	`cfg.neighbor_remove_timeout = j.value("neighbor_remove_timeout", cfg.neighbor_remove_timeout);`
	`135`	`+ cfg.neighbor_resolve_removed = j.value("neighbor_resolve_removed", cfg.neighbor_resolve_removed);`
`134`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ eResult module::init(`
`26`	`26`	`uint64_t rcvbuf_size,`
`27`	`27`	`uint64_t checks_interval,`
`28`	`28`	`uint64_t remove_timeout,`
	`29`	`+ uint64_t resolve_removed,`
`29`	`30`	`std::function<dataplane::neighbor::hashtable*(tSocketId)> ht_allocator,`
`30`	`31`	`std::function<std::uint32_t()> current_time,`
`31`	`32`	`std::function<void()> on_neighbor_flush,`
`@@ -38,6 +39,7 @@ eResult module::init(`
`38`	`39`	`rcvbuf_size_ = rcvbuf_size;`
`39`	`40`	`checks_interval_ = checks_interval;`
`40`	`41`	`remove_timeout_ = remove_timeout;`
	`42`	`+ resolve_removed_ = resolve_removed;`
`41`	`43`
`42`	`44`	`generation_hashtable.fill([&](neighbor::generation_hashtable& hashtable) {`
`43`	`45`	`for (const auto socket_id : socket_ids)`
`@@ -345,7 +347,7 @@ eResult module::DumpOSNeighbors()`
`345`	`347`	`hashtable_updater.get_pointer()`
`346`	`348`	`->insert_or_update(`
`347`	`349`	`dataplane::neighbor::key{iface, is_v6 ? flag_is_ipv6 : uint16_t{}, dst},`
`348`		`- dataplane::neighbor::value{mac.value(), 0, now, 0, 0});`
	`350`	`+ dataplane::neighbor::value{mac.value(), 0, now, 0, 0, 0});`
`349`	`351`	`stats.netlink_neighbor_update++;`
`350`	`352`	`}`
`351`	`353`	`}`
`@@ -420,7 +422,7 @@ void module::StartResolveJob()`
`420`	`422`	`void module::Upsert(tInterfaceId iface, const ipv6_address_t& dst, bool is_v6, const rte_ether_addr& mac)`
`421`	`423`	`{`
`422`	`424`	`TransformHashtables([k = key{iface, is_v6 ? flag_is_ipv6 : uint16_t{}, dst},`
`423`		`- v = value{mac, 0, current_time_provider_(), 0, 0},`
	`425`	`+ v = value{mac, 0, current_time_provider_(), 0, 0, 0},`
`424`	`426`	`this](dataplane::neighbor::hashtable& hashtable) {`
`425`	`427`	`if (!hashtable.insert_or_update(k, v))`
`426`	`428`	`{`
`@@ -444,6 +446,7 @@ void module::UpdateTimestamp(tInterfaceId iface, const ipv6_address_t& dst, bool`
`444`	`446`	`value->last_update_timestamp = current_time_provider_();`
`445`	`447`	`value->last_remove_timestamp = 0;`
`446`	`448`	`value->last_resolve_timestamp = 0;`
	`449`	`+ value->number_resolve_after_remove = 0;`
`447`	`450`	`stats.hashtable_insert_success++;`
`448`	`451`	`}`
`449`	`452`	`else`
`@@ -462,6 +465,7 @@ void module::Remove(tInterfaceId iface, const ipv6_address_t& dst, bool is_v6)`
`462`	`465`	`if (value)`
`463`	`466`	`{`
`464`	`467`	`value->last_remove_timestamp = current_time_provider_();`
	`468`	`+ value->number_resolve_after_remove = 0;`
`465`	`469`	`stats.hashtable_remove_success++;`
`466`	`470`	`}`
`467`	`471`	`else`
`@@ -471,7 +475,7 @@ void module::Remove(tInterfaceId iface, const ipv6_address_t& dst, bool is_v6)`
`471`	`475`	`});`
`472`	`476`	`}`
`473`	`477`
`474`		`-void module::resolve(const dataplane::neighbor::key& key)`
	`478`	`+bool module::resolve(const dataplane::neighbor::key& key)`
`475`	`479`	`{`
`476`	`480`	`stats.resolve++;`
`477`	`481`
`@@ -486,7 +490,7 @@ void module::resolve(const dataplane::neighbor::key& key)`
`486`	`490`	`YANET_LOG_ERROR("unknown interface_id: %u [ipv4_address: %s]\n",`
`487`	`491`	`key.interface_id,`
`488`	`492`	`ip_address.toString().data());`
`489`		`- return;`
	`493`	`+ return false;`
`490`	`494`	`}`
`491`	`495`
`492`	`496`	`const auto& [it_route_name, it_interface_name] = it->second;`
`@@ -548,7 +552,7 @@ void module::resolve(const dataplane::neighbor::key& key)`
`548`	`552`	`{`
`549`	`553`	`YANET_LOG_WARNING("neighbor_resolve: socket(): %s\n",`
`550`	`554`	`strerror(errno));`
`551`		`- return;`
	`555`	`+ return false;`
`552`	`556`	`}`
`553`	`557`
`554`	`558`	`int rc = setsockopt(icmp_socket,`
`@@ -562,7 +566,7 @@ void module::resolve(const dataplane::neighbor::key& key)`
`562`	`566`	`interface_name.data(),`
`563`	`567`	`strerror(errno));`
`564`	`568`	`close(icmp_socket);`
`565`		`- return;`
	`569`	`+ return false;`
`566`	`570`	`}`
`567`	`571`
`568`	`572`	`union`
`@@ -591,6 +595,7 @@ void module::resolve(const dataplane::neighbor::key& key)`
`591`	`595`
`592`	`596`	`icmphdr header;`
`593`	`597`	`memset(&header, 0, sizeof(header));`
	`598`	`+ bool result = true;`
`594`	`599`	`if (sendto(icmp_socket,`
`595`	`600`	`&header,`
`596`	`601`	`sizeof(header),`
`@@ -600,10 +605,12 @@ void module::resolve(const dataplane::neighbor::key& key)`
`600`	`605`	`{`
`601`	`606`	`YANET_LOG_WARNING("neighbor_resolve: sendto(): %s\n",`
`602`	`607`	`strerror(errno));`
	`608`	`+ result = false;`
`603`	`609`	`}`
`604`	`610`
`605`	`611`	`close(icmp_socket);`
`606`	`612`	`#endif // CONFIG_YADECAP_AUTOTEST`
	`613`	`+ return result;`
`607`	`614`	`}`
`608`	`615`
`609`	`616`	`void module::NeighborThreadAction(uint32_t current_time)`
`@@ -638,7 +645,7 @@ void module::NeighborThreadAction(uint32_t current_time)`
`638`	`645`	`{`
`639`	`646`	`keys_to_remove.push_back(key);`
`640`	`647`	`}`
`641`		`- else if (value.last_resolve_timestamp + checks_interval_ <= current_time)`
	`648`	`+ else if (value.last_resolve_timestamp + checks_interval_ <= current_time && value.number_resolve_after_remove < resolve_removed_)`
`642`	`649`	`{`
`643`	`650`	`keys_to_resolve.push_back(key);`
`644`	`651`	`}`
`@@ -662,21 +669,24 @@ void module::NeighborThreadAction(uint32_t current_time)`
`662`	`669`	`// resolve`
`663`	`670`	`for (const key& cur_key : keys_to_resolve)`
`664`	`671`	`{`
	`672`	`+ if (!resolve(cur_key))`
	`673`	`+ {`
	`674`	`+ continue;`
	`675`	`+ }`
`665`	`676`	`TransformHashtables([cur_key, current_time, this](dataplane::neighbor::hashtable& hashtable) {`
`666`		`- YANET_LOG_INFO("resolve\n");`
`667`	`677`	`dataplane::neighbor::value* value;`
`668`	`678`	`hashtable.lookup(cur_key, value);`
`669`	`679`	`if (value)`
`670`	`680`	`{`
`671`	`681`	`value->last_resolve_timestamp = current_time;`
	`682`	`+ value->number_resolve_after_remove++;`
`672`	`683`	`stats.resolve_removed++;`
`673`	`684`	`}`
`674`	`685`	`else`
`675`	`686`	`{`
`676`	`687`	`stats.hashtable_insert_error++;`
`677`	`688`	`}`
`678`	`689`	`});`
`679`		`- resolve(cur_key);`
`680`	`690`	`}`
`681`	`691`	`}`
`682`	`692`