wip: bisect the table-cleanup PR

test/libsinsp_e2e/thread_state.cpp

@@ -36,7 +36,7 @@ class thread_state_test : public ::testing::Test {
 		// Each entry in the vector has a parent of the previous
 		// entry. The first entry has a parent of 1.
 		for(int64_t pid = 100, i = 0; i < m_max; pid++, i++) {
-			int64_t ppid = (i == 0 ? 1 : m_threads[i - 1]->m_tid);
+			int64_t ppid = (i == 0 ? 1 : m_threads[i - 1]->m_tid.load());
 			std::unique_ptr<sinsp_threadinfo> thr = threadinfo_factory.create();
 			thr->init();
 			thr->m_tid = pid;
@@ -54,7 +54,7 @@ class thread_state_test : public ::testing::Test {
 	void reset() {
 		// Reset the state
 		for(uint32_t i = 0; i < m_max; i++) {
-			int64_t ppid = (i == 0 ? 1 : m_threads[i - 1]->m_tid);
+			int64_t ppid = (i == 0 ? 1 : m_threads[i - 1]->m_tid.load());
 			sinsp_threadinfo* tinfo = m_threads[i];
 			tinfo->m_lastevent_fd = 0;
 			tinfo->set_parent_loop_detected(false);

userspace/libsinsp/examples/test.cpp

@@ -115,7 +115,8 @@ void print_all_tables(sinsp& inspector) {
 	std::cout << "Available tables (" << tables.size() << "):\n\n";
 	for(const auto& [table_name, table] : tables) {
 		std::cout << "Table: " << table_name << "\n";
-		std::cout << "  Key type: " << table->key_info().name() << std::endl;
+		std::string name = libsinsp::state::type_name(table->key_type());
+		std::cout << "  Key type: " << name << std::endl;
 
 		// Create a temporary owner to call list_fields
 		libsinsp::state::sinsp_table_owner owner;

userspace/libsinsp/fdinfo.cpp

@@ -24,6 +24,55 @@ limitations under the License.
 #include <libsinsp/sinsp_int.h>
 #include <libscap/scap-int.h>
 
+template<auto Member, size_t Offset>
+struct ipv6_client_field {
+	static_assert(Offset == 0 || Offset == 2,
+	              "Offset must be either 0 (for low bits) or 2 (for high bits)");
+
+	static constexpr ss_plugin_state_type type_id() { return SS_PLUGIN_ST_UINT64; }
+
+	static uint64_t read(const sinsp_fdinfo* c) {
+		uint64_t addr;
+		const ipv6addr& a = (c->m_sockinfo.m_ipv6info.m_fields.*Member);
+		memcpy(&addr, &a.m_b[Offset], sizeof(uint64_t));
+		return addr;
+	}
+
+	static void write(sinsp_fdinfo* c, const libsinsp::state::borrowed_state_data& in_data) {
+		ipv6addr& a = (c->m_sockinfo.m_ipv6info.m_fields.*Member);
+		memcpy(&a.m_b[Offset], &in_data.data().u64, sizeof(uint64_t));
+	}
+};
+
+template<size_t Offset>
+struct ipv6_server_field {
+	static_assert(Offset == 0 || Offset == 2,
+	              "Offset must be either 0 (for low bits) or 2 (for high bits)");
+
+	static constexpr ss_plugin_state_type type_id() { return SS_PLUGIN_ST_UINT64; }
+
+	static uint64_t read(const sinsp_fdinfo* c) {
+		uint64_t addr;
+		const ipv6addr& a = (c->m_sockinfo.m_ipv6serverinfo.m_ip);
+		memcpy(&addr, &a.m_b[Offset], sizeof(uint64_t));
+		return addr;
+	}
+
+	static void write(sinsp_fdinfo* c, const libsinsp::state::borrowed_state_data& in_data) {
+		ipv6addr& a = (c->m_sockinfo.m_ipv6serverinfo.m_ip);
+		memcpy(&a.m_b[Offset], &in_data.data().u64, sizeof(uint64_t));
+	}
+};
+
+struct fd_type {
+	static constexpr ss_plugin_state_type type_id() { return SS_PLUGIN_ST_UINT8; }
+
+	static uint8_t read(const sinsp_fdinfo* c) { return c->m_type; }
+	static void write(sinsp_fdinfo* c, const libsinsp::state::borrowed_state_data& in_data) {
+		c->m_type = static_cast<scap_fd_type>(in_data.data().u8);
+	}
+};
+
 char sinsp_fdinfo::get_typechar() const {
 	switch(m_type) {
 	case SCAP_FD_FILE_V2:
@@ -119,96 +168,113 @@ const char* sinsp_fdinfo::get_typestring() const {
 	}
 }
 
-sinsp_fdinfo::sinsp_fdinfo(
-        const std::shared_ptr<libsinsp::state::dynamic_struct::field_infos>& dyn_fields):
-        table_entry(dyn_fields) {}
-
-libsinsp::state::static_struct::field_infos sinsp_fdinfo::static_fields() const {
-	return get_static_fields();
-}
+sinsp_fdinfo::sinsp_fdinfo(const std::shared_ptr<libsinsp::state::dynamic_field_infos>& dyn_fields):
+        extensible_struct(dyn_fields) {}
 
-#if defined(__clang__)
-__attribute__((no_sanitize("undefined")))
-#endif
-libsinsp::state::static_struct::field_infos
-sinsp_fdinfo::get_static_fields() {
+libsinsp::state::static_field_infos sinsp_fdinfo::get_static_fields() {
 	using self = sinsp_fdinfo;
+	using namespace libsinsp::state;
 
-	libsinsp::state::static_struct::field_infos ret;
+	static_field_infos ret;
 
-	// the m_type is weird because it's a C-defined non-scoped enum, meaning that it
-	// should be represented by default as an integer of word-size (e.g. uint32_t in
-	// most cases). However, the state and plugin API only supports integers, and so
-	// we need to do some smart casting. Our enemy is the platform/compiler dependent
-	// integer size with which the enum could be represented, plus the endianess
-	// of the targeted architecture
-	auto is_big_endian = htonl(12) == 12;  // the chosen number does not matter
-	size_t type_byte_offset = is_big_endian ? (sizeof(scap_fd_type) - 1) : 0;
-	define_static_field<uint8_t>(ret,
-	                             OFFSETOF_STATIC_FIELD(self, m_type) + type_byte_offset,
-	                             "type");
+	define_custom_static_field<fd_type>(ret, "type");
 
 	// the rest fo the fields are more trivial to expose
-	DEFINE_STATIC_FIELD(ret, self, m_openflags, "open_flags");
-	DEFINE_STATIC_FIELD(ret, self, m_name, "name");
-	DEFINE_STATIC_FIELD(ret, self, m_name_raw, "name_raw");
-	DEFINE_STATIC_FIELD(ret, self, m_oldname, "old_name");
-	DEFINE_STATIC_FIELD(ret, self, m_flags, "flags");
-	DEFINE_STATIC_FIELD(ret, self, m_dev, "dev");
-	DEFINE_STATIC_FIELD(ret, self, m_mount_id, "mount_id");
-	DEFINE_STATIC_FIELD(ret, self, m_ino, "ino");
-	DEFINE_STATIC_FIELD(ret, self, m_pid, "pid");
-	DEFINE_STATIC_FIELD(ret, self, m_fd, "fd");
+	define_static_member_field<&self::m_openflags>(ret, "open_flags");
+	define_static_member_field<&self::m_name>(ret, "name");
+	define_static_member_field<&self::m_name_raw>(ret, "name_raw");
+	define_static_member_field<&self::m_oldname>(ret, "old_name");
+	define_static_member_field<&self::m_flags>(ret, "flags");
+	define_static_member_field<&self::m_dev>(ret, "dev");
+	define_static_member_field<&self::m_mount_id>(ret, "mount_id");
+	define_static_member_field<&self::m_ino>(ret, "ino");
+	define_static_member_field<&self::m_pid>(ret, "pid");
+	define_static_member_field<&self::m_fd>(ret, "fd");
 
 	// in this case we have a union, so many of the following exposed fields
 	// will point to the same memory areas, but this should not be an issue
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv4info.m_fields.m_sip, "socket_ipv4_src_ip");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv4info.m_fields.m_dip, "socket_ipv4_dest_dip");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv4info.m_fields.m_sport, "socket_ipv4_src_port");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv4info.m_fields.m_dport, "socket_ipv4_dst_port");
-	DEFINE_STATIC_FIELD(ret,
-	                    self,
-	                    m_sockinfo.m_ipv4info.m_fields.m_l4proto,
-	                    "socket_ipv4_l4_proto");
-	define_static_field<uint64_t>(ret,
-	                              OFFSETOF_STATIC_FIELD(self, m_sockinfo.m_ipv6info.m_fields.m_sip),
-	                              "socket_ipv6_src_ip_low");
-	define_static_field<uint64_t>(
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4info,
+	                           &ipv4tuple::m_fields,
+	                           &decltype(ipv4tuple::m_fields)::m_sip>(ret, "socket_ipv4_src_ip");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4info,
+	                           &ipv4tuple::m_fields,
+	                           &decltype(ipv4tuple::m_fields)::m_dip>(ret, "socket_ipv4_dest_dip");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4info,
+	                           &ipv4tuple::m_fields,
+	                           &decltype(ipv4tuple::m_fields)::m_sport>(ret,
+	                                                                    "socket_ipv4_src_port");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4info,
+	                           &ipv4tuple::m_fields,
+	                           &decltype(ipv4tuple::m_fields)::m_dport>(ret,
+	                                                                    "socket_ipv4_dst_port");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4info,
+	                           &ipv4tuple::m_fields,
+	                           &decltype(ipv4tuple::m_fields)::m_l4proto>(ret,
+	                                                                      "socket_ipv4_l4_proto");
+
+	define_custom_static_field<ipv6_client_field<&decltype(ipv6tuple::m_fields)::m_sip, 0>>(
+	        ret,
+	        "socket_ipv6_src_ip_low");
+	define_custom_static_field<ipv6_client_field<&decltype(ipv6tuple::m_fields)::m_sip, 2>>(
 	        ret,
-	        OFFSETOF_STATIC_FIELD(self, m_sockinfo.m_ipv6info.m_fields.m_sip) + 8,
 	        "socket_ipv6_src_ip_high");
-	define_static_field<uint64_t>(ret,
-	                              OFFSETOF_STATIC_FIELD(self, m_sockinfo.m_ipv6info.m_fields.m_dip),
-	                              "socket_ipv6_dest_ip_low");
-	define_static_field<uint64_t>(
+
+	define_custom_static_field<ipv6_client_field<&decltype(ipv6tuple::m_fields)::m_dip, 0>>(
+	        ret,
+	        "socket_ipv6_dest_ip_low");
+	define_custom_static_field<ipv6_client_field<&decltype(ipv6tuple::m_fields)::m_dip, 2>>(
 	        ret,
-	        OFFSETOF_STATIC_FIELD(self, m_sockinfo.m_ipv6info.m_fields.m_dip) + 8,
 	        "socket_ipv6_dest_ip_high");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv6info.m_fields.m_sport, "socket_ipv6_src_port");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv6info.m_fields.m_dport, "socket_ipv6_dst_port");
-	DEFINE_STATIC_FIELD(ret,
-	                    self,
-	                    m_sockinfo.m_ipv6info.m_fields.m_l4proto,
-	                    "socket_ipv6_l4_proto");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv4serverinfo.m_ip, "socket_ipv4_server_ip");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv4serverinfo.m_port, "socket_ipv4_server_port");
-	DEFINE_STATIC_FIELD(ret,
-	                    self,
-	                    m_sockinfo.m_ipv4serverinfo.m_l4proto,
-	                    "socket_ipv4_server_l4_proto");
-	define_static_field<uint64_t>(ret,
-	                              OFFSETOF_STATIC_FIELD(self, m_sockinfo.m_ipv6serverinfo.m_ip),
-	                              "socket_ipv6_server_ip_low");
-	define_static_field<uint64_t>(ret,
-	                              OFFSETOF_STATIC_FIELD(self, m_sockinfo.m_ipv6serverinfo.m_ip) + 8,
-	                              "socket_ipv6_server_ip_high");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_ipv6serverinfo.m_port, "socket_ipv6_server_port");
-	DEFINE_STATIC_FIELD(ret,
-	                    self,
-	                    m_sockinfo.m_ipv6serverinfo.m_l4proto,
-	                    "socket_ipv6_server_l4_proto");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_unixinfo.m_fields.m_source, "socket_unix_src");
-	DEFINE_STATIC_FIELD(ret, self, m_sockinfo.m_unixinfo.m_fields.m_dest, "socket_unix_dest");
+
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv6info,
+	                           &ipv6tuple::m_fields,
+	                           &decltype(ipv6tuple::m_fields)::m_sport>(ret,
+	                                                                    "socket_ipv6_src_port");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv6info,
+	                           &ipv6tuple::m_fields,
+	                           &decltype(ipv6tuple::m_fields)::m_dport>(ret,
+	                                                                    "socket_ipv6_dst_port");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv6info,
+	                           &ipv6tuple::m_fields,
+	                           &decltype(ipv6tuple::m_fields)::m_l4proto>(ret,
+	                                                                      "socket_ipv6_l4_proto");
+
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4serverinfo,
+	                           &ipv4serverinfo::m_ip>(ret, "socket_ipv4_server_ip");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4serverinfo,
+	                           &ipv4serverinfo::m_port>(ret, "socket_ipv4_server_port");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv4serverinfo,
+	                           &ipv4serverinfo::m_l4proto>(ret, "socket_ipv4_server_l4_proto");
+
+	define_custom_static_field<ipv6_server_field<0>>(ret, "socket_ipv6_server_ip_low");
+	define_custom_static_field<ipv6_server_field<2>>(ret, "socket_ipv6_server_ip_high");
+
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv6serverinfo,
+	                           &ipv6serverinfo::m_port>(ret, "socket_ipv6_server_port");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_ipv6serverinfo,
+	                           &ipv6serverinfo::m_l4proto>(ret, "socket_ipv6_server_l4_proto");
+
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_unixinfo,
+	                           &unix_tuple::m_fields,
+	                           &decltype(unix_tuple::m_fields)::m_source>(ret, "socket_unix_src");
+	define_static_member_field<&self::m_sockinfo,
+	                           &sinsp_sockinfo::m_unixinfo,
+	                           &unix_tuple::m_fields,
+	                           &decltype(unix_tuple::m_fields)::m_dest>(ret, "socket_unix_dest");
 
 	return ret;
 }

userspace/libsinsp/fdinfo.h

@@ -74,7 +74,7 @@ union sinsp_sockinfo {
    you get them by calling \ref sinsp_evt::get_fd_info or
    \ref sinsp_threadinfo::get_fd.
 */
-class SINSP_PUBLIC sinsp_fdinfo : public libsinsp::state::table_entry {
+class SINSP_PUBLIC sinsp_fdinfo : public libsinsp::state::extensible_struct {
 public:
 	/*!
 	  \brief FD flags.
@@ -102,17 +102,14 @@ class SINSP_PUBLIC sinsp_fdinfo : public libsinsp::state::table_entry {
 		FLAGS_OVERLAY_LOWER = (1 << 18),
 	};
 
-	sinsp_fdinfo(const std::shared_ptr<libsinsp::state::dynamic_struct::field_infos>& dyn_fields =
-	                     nullptr);
+	sinsp_fdinfo(const std::shared_ptr<libsinsp::state::dynamic_field_infos>& dyn_fields = nullptr);
 	sinsp_fdinfo(sinsp_fdinfo&& o) = default;
 	sinsp_fdinfo& operator=(sinsp_fdinfo&& o) = default;
 	sinsp_fdinfo(const sinsp_fdinfo& o) = default;
 	sinsp_fdinfo& operator=(const sinsp_fdinfo& o) = default;
 
 	virtual ~sinsp_fdinfo() = default;
 
-	libsinsp::state::static_struct::field_infos static_fields() const override;
-
 	virtual std::unique_ptr<sinsp_fdinfo> clone() const {
 		return std::make_unique<sinsp_fdinfo>(*this);
 	}
@@ -339,7 +336,7 @@ class SINSP_PUBLIC sinsp_fdinfo : public libsinsp::state::table_entry {
 	  \brief A static version of static_fields()
 	  \return The group of field infos available.
 	 */
-	static static_struct::field_infos get_static_fields();
+	static libsinsp::state::static_field_infos get_static_fields();
 
 	scap_fd_type m_type =
 	        SCAP_FD_UNINITIALIZED;  ///< The fd type, e.g. file, directory, IPv4 socket...

userspace/libsinsp/fdtable.cpp

@@ -28,7 +28,7 @@ limitations under the License.
 static const auto s_fdtable_static_fields = sinsp_fdinfo::get_static_fields();
 
 sinsp_fdtable::sinsp_fdtable(const std::shared_ptr<ctor_params>& params):
-        built_in_table{"file_descriptors", &s_fdtable_static_fields},
+        extensible_table{type_tag<sinsp_fdinfo>{}, "file_descriptors", &s_fdtable_static_fields},
         m_params{params},
         m_tid{0} {
 	reset_cache();
@@ -70,10 +70,6 @@ inline const std::shared_ptr<sinsp_fdinfo>& sinsp_fdtable::find_ref(int64_t fd)
 inline const std::shared_ptr<sinsp_fdinfo>& sinsp_fdtable::add_ref(
         int64_t fd,
         std::shared_ptr<sinsp_fdinfo>&& fdinfo) {
-	if(fdinfo->dynamic_fields() != dynamic_fields()) {
-		throw sinsp_exception("adding entry with incompatible dynamic defs to fd table");
-	}
-
 	fdinfo->m_fd = fd;
 
 	const auto it = m_table.find(fd);

userspace/libsinsp/fdtable.h

@@ -30,7 +30,7 @@ struct sinsp_stats_v2;
 ///////////////////////////////////////////////////////////////////////////////
 // fd info table
 ///////////////////////////////////////////////////////////////////////////////
-class sinsp_fdtable : public libsinsp::state::built_in_table<int64_t> {
+class sinsp_fdtable : public libsinsp::state::extensible_table<int64_t> {
 public:
 	typedef std::function<bool(int64_t, sinsp_fdinfo&)> fdtable_visitor_t;
 

userspace/libsinsp/plugin.h

@@ -507,18 +507,19 @@ class sinsp_table {
 	sinsp_table(libsinsp::state::sinsp_table_owner* p, libsinsp::state::base_table* t):
 	        m_owner_plugin(p),
 	        m_table(t) {
-		if(m_table->key_info().type_id() != libsinsp::state::typeinfo::of<KeyType>().type_id()) {
-			throw sinsp_exception("table key type mismatch, requested='" +
-			                      std::string(libsinsp::state::typeinfo::of<KeyType>().name()) +
-			                      "', actual='" + std::string(m_table->key_info().name()) + "'");
+		if(m_table->key_type() != libsinsp::state::type_id_of<KeyType>()) {
+			std::string req_type = libsinsp::state::type_name<KeyType>();
+			std::string key_type = libsinsp::state::type_name(m_table->key_type());
+			throw sinsp_exception("table key type mismatch, requested='" + req_type +
+			                      "', actual='" + key_type + "'");
 		}
 	}
 
 	std::string_view name() const { return m_table->name(); }
 
 	size_t entries_count() const { return m_table->get_size(m_owner_plugin); }
 
-	const libsinsp::state::typeinfo& key_info() const { return m_table->key_info(); }
+	ss_plugin_state_type key_type() const { return m_table->key_type(); }
 
 	span<const ss_plugin_table_fieldinfo> fields() const {
 		uint32_t nfields;
@@ -538,14 +539,12 @@ class sinsp_table {
 
 	template<typename FieldType>
 	ss_plugin_table_field_t* get_field(const char* name) {
-		auto typeinfo = libsinsp::state::typeinfo::of<FieldType>();
-		return m_table->get_field(m_owner_plugin, name, typeinfo.type_id());
+		return m_table->get_field(m_owner_plugin, name, libsinsp::state::type_id_of<FieldType>());
 	}
 
 	template<typename FieldType>
 	ss_plugin_table_field_t* add_field(const char* name) {
-		auto typeinfo = libsinsp::state::typeinfo::of<FieldType>();
-		return m_table->add_field(m_owner_plugin, name, typeinfo.type_id());
+		return m_table->add_field(m_owner_plugin, name, libsinsp::state::type_id_of<FieldType>());
 	}
 
 	sinsp_table_entry get_entry(const KeyType& key) {