Fix new maps example test in new bpftool & libbpf version (#445)

Sy0307 · Officeyutong · web-flow · commit 93bfd9b92493 · 2025-09-08T12:41:07.000+08:00
* update

* [~] Remove def conflict

---------

Co-authored-by: officeyutong &lt;yt.xyxx@gmail.com&gt;
diff --git a/runtime/CMakeLists.txt b/runtime/CMakeLists.txt
@@ -59,7 +59,8 @@ set(sources
   src/handler/perf_event_handler.cpp
   src/handler/prog_handler.cpp
   src/handler/epoll_handler.cpp
-
+  src/handler/memfd_handler.cpp
+  
   src/bpftime_shm.cpp
   src/bpftime_shm_internal.cpp
   src/bpftime_shm_json.cpp
diff --git a/runtime/include/bpftime_shm.hpp b/runtime/include/bpftime_shm.hpp
@@ -410,6 +410,7 @@ int bpftime_add_custom_perf_event(int type, const char *attach_argument);
 int bpftime_poll_gpu_ringbuf_map(int mapfd, void *ctx,
 				 void (*)(const void *, uint64_t, void *));
 #endif
+int bpftime_add_memfd_handler(const char *name, int flags);
 }
 
 #endif // BPFTIME_SHM_CPP_H
diff --git a/runtime/src/bpftime_shm.cpp b/runtime/src/bpftime_shm.cpp
@@ -700,3 +700,9 @@ int bpftime_poll_gpu_ringbuf_map(int mapfd, void *ctx,
 	return 0;
 }
 #endif
+
+int bpftime_add_memfd_handler(const char *name, int flags)
+{
+	auto &shm = shm_holder.global_shared_memory;
+	return shm.add_memfd_handler(name, flags);
+}
diff --git a/runtime/src/bpftime_shm_internal.cpp b/runtime/src/bpftime_shm_internal.cpp
@@ -5,6 +5,7 @@
  */
 #include "bpftime_shm.hpp"
 #include "handler/map_handler.hpp"
+#include "handler/memfd_handler.hpp"
 #include <ebpf-vm.h>
 #include "handler/epoll_handler.hpp"
 #include "handler/handler_manager.hpp"
@@ -777,6 +778,11 @@ int bpftime_shm::add_bpf_map(int fd, const char *name,
 	};
 	verifier::set_map_descriptors(helpers);
 #endif
+	if (!std::holds_alternative<unused_handler>(manager->get_handler(fd))) {
+		SPDLOG_DEBUG(
+			"Creating map handler at {}, which must destroy the existing handler");
+		manager->clear_id_at(fd, segment);
+	}
 	return manager->set_handler(
 		fd, bpftime::bpf_map_handler(fd, name, segment, attr), segment);
 }
@@ -800,6 +806,13 @@ int bpftime_shm::dup_bpf_map(int oldfd, int newfd)
 	auto &handler =
 		std::get<bpftime::bpf_map_handler>(manager->get_handler(oldfd));
 	std::string new_name = std::string("dup_") + handler.name.c_str();
+	// Destroy old handler
+	auto &old_handler = manager->get_handler(newfd);
+	if (!std::holds_alternative<unused_handler>(old_handler)) {
+		SPDLOG_DEBUG("Dup to fd {}, destroying old handler", newfd);
+
+		manager->clear_id_at(newfd, segment);
+	}
 	// Create a new handler with the same parameters
 	return manager->set_handler(
 		newfd,
@@ -963,12 +976,22 @@ int bpftime_shm::poll_gpu_ringbuf_map(
 
 	auto impl_opt = map_handler.try_get_nv_gpu_ringbuf_map_impl();
 	if (!impl_opt) {
-		SPDLOG_ERROR("Failed to get nv_gpu_ringbuf_map_impl for mapfd {}", mapfd);
+		SPDLOG_ERROR(
+			"Failed to get nv_gpu_ringbuf_map_impl for mapfd {}",
+			mapfd);
 		return -1;
 	}
 	auto &impl = *impl_opt;
 	return impl->drain_data(fn);
 }
 #endif
-
+int bpftime_shm::add_memfd_handler(const char *name, int flags)
+{
+	int fd = open_fake_fd();
+	fd = manager->set_handler(fd, memfd_handler(name, flags, segment),
+				  segment);
+	SPDLOG_DEBUG("Created memfd handler at {}, name {}, flags {}", fd, name,
+		     flags);
+	return fd;
+}
 } // namespace bpftime
diff --git a/runtime/src/bpftime_shm_internal.hpp b/runtime/src/bpftime_shm_internal.hpp
@@ -202,6 +202,8 @@ class bpftime_shm {
 	void close_fd(int fd);
 	bool is_exist_fake_fd(int fd) const;
 
+	int add_memfd_handler(const char *name, int flags);
+
 #if BPFTIME_ENABLE_MPK
 	void enable_mpk();
 	void disable_mpk();
diff --git a/runtime/src/handler/handler_manager.hpp b/runtime/src/handler/handler_manager.hpp
@@ -7,6 +7,7 @@
 #define _HANDLER_MANAGER_HPP
 #include "bpftime_config.hpp"
 #include "handler/epoll_handler.hpp"
+#include "handler/memfd_handler.hpp"
 #include "spdlog/spdlog.h"
 #include <boost/interprocess/interprocess_fwd.hpp>
 #include <cstddef>
@@ -51,7 +52,8 @@ constexpr const char *DEFAULT_GLOBAL_SHM_NAME = "bpftime_maps_shm";
 constexpr const char *DEFAULT_GLOBAL_HANDLER_NAME = "bpftime_handler";
 constexpr const char *DEFAULT_SYSCALL_PID_SET_NAME = "bpftime_syscall_pid_set";
 constexpr const char *DEFAULT_AGENT_CONFIG_NAME = "bpftime_agent_config";
-constexpr const char* DEFAULT_ALIVE_AGENT_PIDS_NAME = "bpftime_alive_agent_pids";
+constexpr const char *DEFAULT_ALIVE_AGENT_PIDS_NAME =
+	"bpftime_alive_agent_pids";
 inline const char *get_global_shm_name()
 {
 	const char *name = getenv("BPFTIME_GLOBAL_SHM_NAME");
@@ -81,7 +83,8 @@ struct shm_remove {
 
 using handler_variant =
 	std::variant<unused_handler, bpf_map_handler, bpf_link_handler,
-		     bpf_prog_handler, bpf_perf_event_handler, epoll_handler>;
+		     bpf_prog_handler, bpf_perf_event_handler, epoll_handler,
+		     memfd_handler>;
 
 using handler_variant_allocator =
 	allocator<handler_variant, managed_shared_memory::segment_manager>;
@@ -93,8 +96,7 @@ using handler_variant_vector =
 // This struct will be put on shared memory
 class handler_manager {
     public:
-	handler_manager(managed_shared_memory &mem,
-			size_t max_fd_count);
+	handler_manager(managed_shared_memory &mem, size_t max_fd_count);
 
 	~handler_manager();
 
diff --git a/runtime/src/handler/map_handler.cpp b/runtime/src/handler/map_handler.cpp
@@ -52,7 +52,7 @@ bpftime_map_ops global_map_ops_table[(int)bpf_map_type::BPF_MAP_TYPE_MAX] = {
 	{ 0 }
 };
 
-std::string bpf_map_handler::get_container_name()
+std::string bpf_map_handler::get_container_name() const
 {
 	return "ebpf_map_fd_" + std::string(name.c_str());
 }
@@ -837,7 +837,7 @@ int bpf_map_handler::map_init(managed_shared_memory &memory)
 	return 0;
 }
 
-void bpf_map_handler::map_free(managed_shared_memory &memory)
+void bpf_map_handler::map_free(managed_shared_memory &memory) const
 {
 	auto container_name = get_container_name();
 	switch (type) {
diff --git a/runtime/src/handler/map_handler.hpp b/runtime/src/handler/map_handler.hpp
@@ -191,7 +191,7 @@ class bpf_map_handler {
 	// *
 	int bpf_map_get_next_key(const void *key, void *next_key,
 				 bool from_syscall = false) const;
-	void map_free(boost::interprocess::managed_shared_memory &memory);
+	void map_free(boost::interprocess::managed_shared_memory &memory) const;
 	int map_init(boost::interprocess::managed_shared_memory &memory);
 	uint32_t get_userspace_value_size() const;
 	std::optional<ringbuf_map_impl *> try_get_ringbuf_map_impl() const;
@@ -220,10 +220,10 @@ class bpf_map_handler {
 #endif
     private:
 	int id = 0;
-	std::string get_container_name();
+	std::string get_container_name() const;
 	mutable pthread_spinlock_t map_lock;
 	// The underlying data structure of the map
-	general_map_impl_ptr map_impl_ptr;
+	mutable general_map_impl_ptr map_impl_ptr;
 	uint32_t max_entries = 0;
 	[[maybe_unused]] uint64_t flags = 0;
 	uint32_t key_size = 0;
diff --git a/runtime/src/handler/memfd_handler.cpp b/runtime/src/handler/memfd_handler.cpp
@@ -0,0 +1,11 @@
+#include "memfd_handler.hpp"
+
+using namespace bpftime;
+
+memfd_handler::memfd_handler(const char *name, int flags,
+			     boost::interprocess::managed_shared_memory &memory)
+	: name(char_allocator(memory.get_segment_manager()))
+{
+	this->name = name;
+	this->flags = flags;
+}
diff --git a/runtime/src/handler/memfd_handler.hpp b/runtime/src/handler/memfd_handler.hpp
@@ -0,0 +1,24 @@
+#ifndef _BPFTIME_MEMFD_HANDLER_HPP
+#define _BPFTIME_MEMFD_HANDLER_HPP
+
+#include <boost/interprocess/containers/string.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/managed_shared_memory.hpp>
+namespace bpftime
+{
+
+using char_allocator = boost::interprocess::allocator<
+	char, boost::interprocess::managed_shared_memory::segment_manager>;
+using boost_shm_string =
+	boost::interprocess::basic_string<char, std::char_traits<char>,
+					  char_allocator>;
+
+struct memfd_handler {
+	int flags;
+	boost_shm_string name;
+	memfd_handler(const char *name, int flags,
+		      boost::interprocess::managed_shared_memory &memory);
+};
+} // namespace bpftime
+
+#endif
diff --git a/runtime/syscall-server/syscall_context.cpp b/runtime/syscall-server/syscall_context.cpp
@@ -927,6 +927,17 @@ int syscall_context::handle_dup3(int oldfd, int newfd, int flags)
 	return orig_syscall_fn(__NR_dup3, (long)oldfd, (long)newfd,
 			       (long)flags);
 }
+
+int syscall_context::handle_memfd_create(const char *name, int flags)
+{
+	SPDLOG_DEBUG("Calling mocked memfd_create {}, {}", name, flags);
+	if (!enable_mock || run_with_kernel || initializing_cuda ||
+	    !enable_mock_after_initialized)
+		return orig_syscall_fn(__NR_dup3, (long)name, (long)flags);
+	try_startup();
+	return bpftime_add_memfd_handler(name, flags);
+}
+
 #if defined(BPFTIME_ENABLE_CUDA_ATTACH)
 int syscall_context::poll_gpu_ringbuf_map(int mapfd, void *ctx,
 
diff --git a/runtime/syscall-server/syscall_context.hpp b/runtime/syscall-server/syscall_context.hpp
@@ -199,6 +199,7 @@ class syscall_context {
 	ssize_t handle_read(int fd, void *buf, size_t count);
 	FILE *handle_fopen(const char *pathname, const char *flags);
 	int handle_dup3(int oldfd, int newfd, int flags);
+	int handle_memfd_create(const char *name, int flags);
 
 #if defined(BPFTIME_ENABLE_CUDA_ATTACH)
 	int poll_gpu_ringbuf_map(int mapfd, void *ctx,
diff --git a/runtime/syscall-server/syscall_server_main.cpp b/runtime/syscall-server/syscall_server_main.cpp
@@ -225,6 +225,13 @@ extern "C" long syscall(long sysno, ...)
 			return context->handle_dup3((int)arg1, (int)arg2,
 						    (int)arg3);
 		});
+	} else if (sysno == __NR_memfd_create) {
+		SPDLOG_DEBUG("SYS_MEMFD_CREATE name={} flags={}",
+			     (const char *)arg1, arg2);
+		return handle_exceptions([&]() {
+			return context->handle_memfd_create((const char *)arg1,
+							    (int)arg2);
+		});
 	}
 	return context->orig_syscall_fn(sysno, arg1, arg2, arg3, arg4, arg5,
 					arg6);
diff --git a/runtime/unit-test/maps/test_lpm_trie_map.cpp b/runtime/unit-test/maps/test_lpm_trie_map.cpp
@@ -20,29 +20,29 @@
 #include "linux/bpf.h"
 
 // Helper structures for kernel-style testing
-struct bpf_lpm_trie_key_hdr {
+struct test_bpf_lpm_trie_key_hdr {
 	uint32_t prefixlen;
 };
 
-struct bpf_lpm_trie_key_u8 {
+struct test_bpf_lpm_trie_key_u8 {
 	union {
-		struct bpf_lpm_trie_key_hdr hdr;
+		struct test_bpf_lpm_trie_key_hdr hdr;
 		uint32_t prefixlen;
 	};
 	uint8_t data[8];
 };
 
 struct lpm_trie_int_key {
 	union {
-		struct bpf_lpm_trie_key_hdr hdr;
+		struct test_bpf_lpm_trie_key_hdr hdr;
 		uint32_t prefixlen;
 	};
 	uint32_t data;
 };
 
 struct lpm_trie_bytes_key {
 	union {
-		struct bpf_lpm_trie_key_hdr hdr;
+		struct test_bpf_lpm_trie_key_hdr hdr;
 		uint32_t prefixlen;
 	};
 	uint8_t data[8];
@@ -373,16 +373,16 @@ TEST_CASE("LPM Trie IP Address Operations", "[lpm_trie][kernel_style][ipaddr]")
 		boost::interprocess::create_only, SHARED_MEMORY_NAME,
 		SHARED_MEMORY_SIZE);
 
-	bpf_lpm_trie_key_u8 *key_ipv4;
-	bpf_lpm_trie_key_u8 *key_ipv6;
+	test_bpf_lpm_trie_key_u8 *key_ipv4;
+	test_bpf_lpm_trie_key_u8 *key_ipv6;
 	size_t key_size_ipv4;
 	size_t key_size_ipv6;
 	uint64_t value;
 
 	key_size_ipv4 = sizeof(*key_ipv4) + sizeof(uint32_t);
 	key_size_ipv6 = sizeof(*key_ipv6) + sizeof(uint32_t) * 4;
-	key_ipv4 = (bpf_lpm_trie_key_u8 *)alloca(key_size_ipv4);
-	key_ipv6 = (bpf_lpm_trie_key_u8 *)alloca(key_size_ipv6);
+	key_ipv4 = (test_bpf_lpm_trie_key_u8 *)alloca(key_size_ipv4);
+	key_ipv6 = (test_bpf_lpm_trie_key_u8 *)alloca(key_size_ipv6);
 
 	// Create IPv4 LPM Trie
 	bpftime::lpm_trie_map_impl *trie_ipv4 = nullptr;
@@ -523,12 +523,12 @@ TEST_CASE("LPM Trie Deletion Operations", "[lpm_trie][kernel_style][deletion]")
 		boost::interprocess::create_only, SHARED_MEMORY_NAME,
 		SHARED_MEMORY_SIZE);
 
-	bpf_lpm_trie_key_u8 *key;
+	test_bpf_lpm_trie_key_u8 *key;
 	size_t key_size;
 	uint64_t value;
 
 	key_size = sizeof(*key) + sizeof(uint32_t);
-	key = (bpf_lpm_trie_key_u8 *)alloca(key_size);
+	key = (test_bpf_lpm_trie_key_u8 *)alloca(key_size);
 
 	bpftime::lpm_trie_map_impl *trie = nullptr;
 	try {
@@ -895,10 +895,10 @@ static void *lpm_test_command(void *arg)
 {
 	int i, j, ret, iter, key_size;
 	struct lpm_mt_test_info *info = (lpm_mt_test_info *)arg;
-	bpf_lpm_trie_key_u8 *key_p;
+	test_bpf_lpm_trie_key_u8 *key_p;
 
 	key_size = sizeof(*key_p) + sizeof(uint32_t);
-	key_p = (bpf_lpm_trie_key_u8 *)alloca(key_size);
+	key_p = (test_bpf_lpm_trie_key_u8 *)alloca(key_size);
 	for (iter = 0; iter < info->iter; iter++)
 		for (i = 0; i < MAX_TEST_KEYS; i++) {
 			// first half of iterations in forward order,
@@ -962,7 +962,7 @@ TEST_CASE("LPM Trie Multi-thread", "[lpm_trie][kernel_style][multithread]")
 
 	// create a trie
 	value_size = sizeof(uint32_t);
-	key_size = sizeof(struct bpf_lpm_trie_key_hdr) + value_size;
+	key_size = sizeof(struct test_bpf_lpm_trie_key_hdr) + value_size;
 
 	bpftime::lpm_trie_map_impl *trie = nullptr;
 	try {
diff --git a/third_party/bpftool b/third_party/bpftool
@@ -1 +1 @@
-Subproject commit 784216403e89e9767833be3705bb8be0873eb52a
+Subproject commit 53c1852920c8a8f8ccedb7a64e3d9852949792c7

Original file line number	Diff line number	Diff line change
`@@ -410,6 +410,7 @@ int bpftime_add_custom_perf_event(int type, const char *attach_argument);`
`410`	`410`	`int bpftime_poll_gpu_ringbuf_map(int mapfd, void *ctx,`
`411`	`411`	`void ()(const void , uint64_t, void *));`
`412`	`412`	`#endif`
	`413`	`+int bpftime_add_memfd_handler(const char *name, int flags);`
`413`	`414`	`}`
`414`	`415`
`415`	`416`	`#endif // BPFTIME_SHM_CPP_H`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ bpftime_map_ops global_map_ops_table[(int)bpf_map_type::BPF_MAP_TYPE_MAX] = {`
`52`	`52`	`{ 0 }`
`53`	`53`	`};`
`54`	`54`
`55`		`-std::string bpf_map_handler::get_container_name()`
	`55`	`+std::string bpf_map_handler::get_container_name() const`
`56`	`56`	`{`
`57`	`57`	`return "ebpf_map_fd_" + std::string(name.c_str());`
`58`	`58`	`}`
`@@ -837,7 +837,7 @@ int bpf_map_handler::map_init(managed_shared_memory &memory)`
`837`	`837`	`return 0;`
`838`	`838`	`}`
`839`	`839`
`840`		`-void bpf_map_handler::map_free(managed_shared_memory &memory)`
	`840`	`+void bpf_map_handler::map_free(managed_shared_memory &memory) const`
`841`	`841`	`{`
`842`	`842`	`auto container_name = get_container_name();`
`843`	`843`	`switch (type) {`