[[RFC xdp-hints] 14/16] libbpf: Helpers to access XDP hints based on BTF definitions

[Ederson de Souza <ederson.desouza@intel.com>]

A new set of functions to help get the BTF definition of XDP hints
structure and get the information based on it.

`xsk_umem__btf_id` helps retrieve the BTF id of XDP metadata.
`xsk_btf__init` sets up a context based on the BTF, including a hashmap,
so that subsequent queries are faster.
`xsk_btf__read` returns a pointer to the position in the XDP metadata
containing a given field.
`xsk_btf__has_field` checks the presence of a field in the BTF.
`xsk_btf__free` frees up the context.

Besides those, a macro `XSK_BTF_READ_INTO` acts as a convenient helper
to read the field contents into a given variable.

Note that currently, the hashmap used to speed-up offset location into
the BTF doesn't use the field name as a string as key to the hashmap. It
directly uses the pointer value instead, as it is expected that most of
time, field names will be addressed by a shared constant string residing
on read-only memory, thus saving some time. If this assumption is not
entirely true, this optimisation needs to be rethought (or discarded
altogether).

Signed-off-by: Ederson de Souza <ederson.desouza@intel.com>
---
 tools/lib/bpf/libbpf.map |   5 ++
 tools/lib/bpf/xsk.c      | 177 +++++++++++++++++++++++++++++++++++++++
 tools/lib/bpf/xsk.h      |  15 ++++
 3 files changed, 197 insertions(+)

diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map
index 663585f7f186..04ffee0dc005 100644
--- a/tools/lib/bpf/libbpf.map
+++ b/tools/lib/bpf/libbpf.map
@@ -375,8 +375,13 @@ LIBBPF_0.5.0 {
 		bpf_map_lookup_and_delete_elem_flags;
 		bpf_object__gen_loader;
 		libbpf_set_strict_mode;
+		xsk_btf__init;
+		xsk_btf__read;
+		xsk_btf__has_field;
+		xsk_btf__free;
 		xsk_umem__adjust_cons_data;
 		xsk_umem__adjust_cons_data_meta;
 		xsk_umem__adjust_prod_data;
 		xsk_umem__adjust_prod_data_meta;
+		xsk_umem__btf_id;
 } LIBBPF_0.4.0;
diff --git a/tools/lib/bpf/xsk.c b/tools/lib/bpf/xsk.c
index 17e8045eac0e..0455ddaa1734 100644
--- a/tools/lib/bpf/xsk.c
+++ b/tools/lib/bpf/xsk.c
@@ -31,6 +31,7 @@
 #include <linux/if_link.h>
 
 #include "bpf.h"
+#include "hashmap.h"
 #include "libbpf.h"
 #include "libbpf_internal.h"
 #include "xsk.h"
@@ -143,6 +144,14 @@ void *xsk_umem__adjust_cons_data_meta(void *umem_data, const struct xsk_umem *um
 	return umem_data;
 }
 
+int xsk_umem__btf_id(void *umem_data, const struct xsk_umem *umem)
+{
+	if (umem->config.xdp_headroom < sizeof(int))
+		return -EINVAL;
+
+	return *(int *)(umem_data - sizeof(int));
+}
+
 static bool xsk_page_aligned(void *buffer)
 {
 	unsigned long addr = (unsigned long)buffer;
@@ -1290,3 +1299,171 @@ void xsk_socket__delete(struct xsk_socket *xsk)
 		close(xsk->fd);
 	free(xsk);
 }
+
+struct xsk_btf_info {
+	struct hashmap map;
+	struct btf *btf;
+	const struct btf_type *type;
+};
+
+struct xsk_btf_entry {
+	__u32 offset;
+	__u32 size;
+};
+
+static void __xsk_btf_free_hash(struct xsk_btf_info *xbi)
+{
+	struct hashmap_entry *entry;
+	int i;
+
+	hashmap__for_each_entry((&(xbi->map)), entry, i) {
+		free(entry->value);
+	}
+	hashmap__clear(&(xbi->map));
+}
+
+static size_t __xsk_hash_fn(const void *key, void *ctx)
+{
+	return (size_t)key;
+}
+
+static bool __xsk_equal_fn(const void *k1, const void *k2, void *ctx)
+{
+	return k1 == k2;
+}
+
+int xsk_btf__init(__u32 btf_id, struct xsk_btf_info **xbi)
+{
+	const struct btf_member *m;
+	const struct btf_type *t;
+	unsigned short vlen;
+	struct btf *btf;
+	int i, id, ret = 0;
+
+	if (!xbi)
+		return -EINVAL;
+
+	ret = btf__get_from_id(btf_id, &btf);
+	if (ret < 0)
+		return ret;
+
+	id = btf__find_by_name(btf, "xdp_hints");
+	if (id < 0) {
+		ret = id;
+		goto error_btf;
+	}
+
+	t = btf__type_by_id(btf, id);
+
+	if (!BTF_INFO_KFLAG(t->info)) {
+		ret = -EINVAL;
+		goto error_btf;
+	}
+
+	*xbi = malloc(sizeof(**xbi));
+	if (!*xbi) {
+		ret = -ENOMEM;
+		goto error_btf;
+	}
+
+	hashmap__init(&(*xbi)->map, __xsk_hash_fn, __xsk_equal_fn, NULL);
+
+	/* Validate no BTF field is a bitfield */
+	m = btf_members(t);
+	vlen = BTF_INFO_VLEN(t->info);
+	for (i = 0; i < vlen; i++, m++) {
+		if (BTF_MEMBER_BITFIELD_SIZE(m->offset)) {
+			ret = -ENOTSUP;
+			goto error_entry;
+		}
+	}
+
+	(*xbi)->btf = btf;
+	(*xbi)->type = t;
+
+	return ret;
+
+error_entry:
+	__xsk_btf_free_hash(*xbi);
+	free(*xbi);
+
+error_btf:
+	btf__free(btf);
+	return ret;
+}
+
+static int __xsk_btf_field_entry(struct xsk_btf_info *xbi, const char *field,
+			  struct xsk_btf_entry **entry)
+{
+	const struct btf_member *m;
+	unsigned short vlen;
+	int i;
+
+	m = btf_members(xbi->type);
+	vlen = BTF_INFO_VLEN(xbi->type->info);
+	for (i = 0; i < vlen; i++, m++) {
+		const struct btf_type *member_type;
+		const char *name = btf__name_by_offset(xbi->btf, m->name_off);
+
+		if (strcmp(name, field))
+			continue;
+
+		if (entry) {
+			member_type = btf__type_by_id(xbi->btf, m->type);
+			*entry = malloc(sizeof(*entry));
+			if (!entry) {
+				return -ENOMEM;
+			}
+
+			/* As we bail out at init for bit fields, there should
+			 * be no entries whose offset is not a multiple of byte */
+			(*entry)->offset = BTF_MEMBER_BIT_OFFSET(m->offset) / 8;
+			(*entry)->size = member_type->size;
+		}
+		return 0;
+	}
+
+	return -ENOENT;
+}
+
+bool xsk_btf__has_field(const char *field, struct xsk_btf_info *xbi)
+{
+	if (!xbi)
+		return false;
+
+	return __xsk_btf_field_entry(xbi, field, NULL);
+}
+
+void xsk_btf__free(struct xsk_btf_info *xbi)
+{
+	if (!xbi)
+		return;
+
+	__xsk_btf_free_hash(xbi);
+	btf__free(xbi->btf);
+	free(xbi);
+}
+
+int xsk_btf__read(void **dest, size_t size, const char *field, struct xsk_btf_info *xbi,
+		  const void *addr)
+{
+	struct xsk_btf_entry *entry;
+	int err;
+
+	if (!field || !xbi || !dest || !addr)
+		return -EINVAL;
+
+	if (!hashmap__find(&(xbi->map), field, (void **)&entry)) {
+		err = __xsk_btf_field_entry(xbi, field, &entry);
+		if (err)
+			return err;
+
+		hashmap__add(&(xbi->map), field, entry);
+	}
+
+	if (entry->size != size)
+		return -EINVAL;
+
+	*dest = (void *)((char *)addr - xbi->type->size + entry->offset);
+	return 0;
+}
diff --git a/tools/lib/bpf/xsk.h b/tools/lib/bpf/xsk.h
index 7f4143150746..b0bddc70c5a6 100644
--- a/tools/lib/bpf/xsk.h
+++ b/tools/lib/bpf/xsk.h
@@ -253,6 +253,8 @@ LIBBPF_API void *xsk_umem__adjust_prod_data_meta(void *umem_data, const struct x
 LIBBPF_API void *xsk_umem__adjust_cons_data(void *umem_data, const struct xsk_umem *umem);
 LIBBPF_API void *xsk_umem__adjust_cons_data_meta(void *umem_data, const struct xsk_umem *umem);
 
+LIBBPF_API int xsk_umem__btf_id(void *umem_data, const struct xsk_umem *umem);
+
 #define XSK_RING_CONS__DEFAULT_NUM_DESCS      2048
 #define XSK_RING_PROD__DEFAULT_NUM_DESCS      2048
 #define XSK_UMEM__DEFAULT_FRAME_SHIFT    12 /* 4096 bytes */
@@ -322,6 +324,19 @@ xsk_socket__create_shared(struct xsk_socket **xsk_ptr,
 LIBBPF_API int xsk_umem__delete(struct xsk_umem *umem);
 LIBBPF_API void xsk_socket__delete(struct xsk_socket *xsk);
 
+struct xsk_btf_info;
+
+LIBBPF_API int xsk_btf__init(__u32 btf_id, struct xsk_btf_info **xbi);
+LIBBPF_API int xsk_btf__read(void **dest, size_t size, const char *field, struct xsk_btf_info *xbi,
+			     const void *addr);
+LIBBPF_API bool xsk_btf__has_field(const char *field, struct xsk_btf_info *xbi);
+LIBBPF_API void xsk_btf__free(struct xsk_btf_info *xbi);
+
+#define XSK_BTF_READ_INTO(dest, field, xbi, addr) ({ \
+	typeof(dest) *_d; \
+	xsk_btf__read((void **)&_d, sizeof(dest), #field, xbi, addr); \
+	dest = *_d; })
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
-- 
2.32.0