Re: [PATCH bpf-next v3 9/9] kbuild, bpf: allow building the vmlinux BTF as a module

[Alan Maguire <alan.maguire@oracle.com>]

[-- Attachment #1: Type: text/plain, Size: 2367 bytes --]

On 28/09/2026 19:04, Wang, Jay wrote:
> Alan and Alexei, I’ll address both of your comments in V4 and provide more detailed responses later as well. ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍
Sounds good. To expand on what I had in mind, as I've tried putting together a generic approach
that will work both for your use case - BTF vmlinux delivered as a module - and mine - inline
vmlinux BTF delivered as a module. They'd need to be separate modules as some folks might want
vmlinux BTF as a module but not want inline BTF.

The idea is close to what you had; we have a .BTF.link / .BTF.inline.link ELF section which consists of:

#define BTF_LINK_SHA256_LEN    32

/*
 * A .BTF.link or .BTF.inline.link section identifies the module which
 * carries a vmlinux BTF section.  The module name is NUL terminated and the
 * field is padded to __MODULE_NAME_LEN.
 */
struct btf_link {
       char module_name[__MODULE_NAME_LEN];
       u8 sha256[BTF_LINK_SHA256_LEN];
       u32 btf_size;
} __packed;

These sections .BTF.link / .BTF.inline.link live in vmlinux and tell it

- the module that delivers the payload
- the SHA; and 
- the size

again similar to what you had.

The link section is populated at the same time resolve_btfids populates the .BTF_ids section;
we add support to resolve_btfids for a --btf_link option of the form

    --btf_link <section>:<module>:<raw-btf-file>

So in your case it will be 

    --btf_link .BTF:btf_vmlinux:vmlinux.BTF

and in mine

    --btf_link .BTF.inline:btf_vmlinux_inline:vmlinux.BTF.inline

The attached patch adds resolve_btfids support for this to give an idea of the approach,
and at the final vmlinux linking where we patch BTF ids, we would add the above options.
resolve_btfids is written to support multiple --btf_link options, so whichever work lands
first could add the support that the other series uses. Hope this helps,

Alan

[-- Attachment #2: 0002-resolve_btfids-add-generic-BTF-link-section-patching.patch --]
[-- Type: text/x-patch, Size: 8262 bytes --]

From 9cb9d0e0bd348a03960e0d7f7fb6ef1a76166d56 Mon Sep 17 00:00:00 2001
From: Alan Maguire <alan.maguire@oracle.com>
Date: Tue, 29 Sep 2026 18:50:14 +0100
Subject: [PATCH v3 bpf-next 2/4] resolve_btfids: Populate BTF link section

Allow the final BTF patch pass to populate one or more BTF link
records.  A link identifies the BTF section to be delivered, its
carrier module, and the raw finalized BTF payload:

    --btf_link <section>:<module>:<raw-btf-file>

Use the raw file size and SHA-256 digest to populate the corresponding
<section>.link record.  This avoids reparsing BTF during final ELF
patching and supports both inline BTF and a future module-delivered
vmlinux BTF.

Signed-off-by: Alan Maguire <alan.maguire@oracle.com>
Assisted-by: OpenAI Codex (GPT 5.6)
---
 tools/bpf/resolve_btfids/main.c | 187 +++++++++++++++++++++++++++++++-
 1 file changed, 183 insertions(+), 4 deletions(-)

diff --git a/tools/bpf/resolve_btfids/main.c b/tools/bpf/resolve_btfids/main.c
index 571f63c4cb82..3baa01f14f33 100644
--- a/tools/bpf/resolve_btfids/main.c
+++ b/tools/bpf/resolve_btfids/main.c
@@ -93,8 +93,13 @@
 #include <subcmd/parse-options.h>
 
 #define BTF_IDS_SECTION	".BTF_ids"
+#define BTF_LINK_MODULE_NAME_MAX	64
+#define LIBBPF_SHA256_DIGEST_LENGTH	32
 #define BTF_ID_PREFIX	"__BTF_ID__"
 
+void libbpf_sha256(const void *data, size_t len,
+		   __u8 out[LIBBPF_SHA256_DIGEST_LENGTH]);
+
 #define BTF_STRUCT	"struct"
 #define BTF_UNION	"union"
 #define BTF_TYPEDEF	"typedef"
@@ -157,6 +162,7 @@ struct object {
 		size_t		 strtabidx;
 		unsigned long	 idlist_addr;
 		int		 encoding;
+		int		 elf_class;
 		const char	**func_symbols;
 		u32		 func_symbols_cnt;
 		u32		 func_symbols_cap;
@@ -179,6 +185,19 @@ struct object {
 	u32 addr_syms_cap;
 };
 
+struct btf_link {
+	char *value;
+	char *section;
+	char *module;
+	char *btf_path;
+};
+
+struct btf_links {
+	struct btf_link *links;
+	u32 cnt;
+	u32 cap;
+};
+
 #define DECL_TAG_FASTCALL "bpf_fastcall"
 #define DECL_TAG_KFUNC "bpf_kfunc"
 
@@ -266,6 +285,49 @@ static int __ensure_mem(void **data, u32 *cap, u32 cnt, size_t elem_sz)
 #define ensure_mem(arr_ptr, cap_ptr, cnt) \
 	__ensure_mem((void **)(arr_ptr), (cap_ptr), (cnt), sizeof(**(arr_ptr)))
 
+static int parse_btf_link(const struct option *opt, const char *arg, int unset)
+{
+	struct btf_links *links = opt->value;
+	struct btf_link *link;
+	char *separator;
+
+	if (unset)
+		return -EINVAL;
+	if (__ensure_mem((void **)&links->links, &links->cap, links->cnt + 1,
+			 sizeof(*links->links)))
+		return -ENOMEM;
+	link = &links->links[links->cnt];
+	memset(link, 0, sizeof(*link));
+	link->value = strdup(arg);
+	if (!link->value)
+		return -ENOMEM;
+	link->section = link->value;
+	separator = strchr(link->section, ':');
+	if (!separator || separator == link->section)
+		goto err_value;
+	*separator++ = '\0';
+	link->module = separator;
+	separator = strchr(link->module, ':');
+	if (!separator || separator == link->module || !separator[1])
+		goto err_value;
+	*separator++ = '\0';
+	link->btf_path = separator;
+	links->cnt++;
+	return 0;
+err_value:
+	free(link->value);
+	return -EINVAL;
+}
+
+static void free_btf_links(struct btf_links *links)
+{
+	u32 i;
+
+	for (i = 0; i < links->cnt; i++)
+		free(links->links[i].value);
+	free(links->links);
+}
+
 static bool is_btf_id(const char *name)
 {
 	return name && !strncmp(name, BTF_ID_PREFIX, sizeof(BTF_ID_PREFIX) - 1);
@@ -487,6 +549,7 @@ static int elf_collect(struct object *obj)
 		return -1;
 	}
 	obj->efile.encoding = ehdr.e_ident[EI_DATA];
+	obj->efile.elf_class = ehdr.e_ident[EI_CLASS];
 
 	/*
 	 * Scan all the elf sections and look for save data
@@ -1036,6 +1099,106 @@ static int dump_raw_btf(struct btf *btf, const char *out_path)
 	return 0;
 }
 
+static int patch_btf_link(struct object *obj, const struct btf_link *link)
+{
+	void *raw_btf_data;
+	Elf_Scn *scn = NULL;
+	Elf_Data *data;
+	GElf_Shdr sh;
+	char section[128];
+	char *name;
+	size_t shdrstrndx, module_name_len;
+	int fd, err = -1;
+	struct stat st;
+	FILE *btf_file;
+	u32 raw_btf_size;
+	Elf *elf;
+	u8 *size;
+
+	if (stat(link->btf_path, &st) || st.st_size > UINT_MAX)
+		return -EINVAL;
+	raw_btf_size = st.st_size;
+	raw_btf_data = malloc(raw_btf_size);
+	if (!raw_btf_data)
+		return -ENOMEM;
+	btf_file = fopen(link->btf_path, "rb");
+	if (!btf_file)
+		goto out_data;
+	if (fread(raw_btf_data, raw_btf_size, 1, btf_file) != 1)
+		goto out_file;
+	fclose(btf_file);
+	if (obj->efile.elf_class == ELFCLASS32)
+		module_name_len = BTF_LINK_MODULE_NAME_MAX - 4;
+	else if (obj->efile.elf_class == ELFCLASS64)
+		module_name_len = BTF_LINK_MODULE_NAME_MAX - 8;
+	else
+		goto out_data;
+	if (strlen(link->module) >= module_name_len)
+		goto out_data;
+
+	snprintf(section, sizeof(section), "%s.link", link->section);
+	fd = open(obj->path, O_RDWR);
+	if (fd < 0)
+		goto out_data;
+	elf = elf_begin(fd, ELF_C_RDWR_MMAP, NULL);
+	if (!elf) {
+		err = -EINVAL;
+		goto out_close;
+	}
+	elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT);
+	if (elf_getshdrstrndx(elf, &shdrstrndx))
+		goto out_elf;
+	while ((scn = elf_nextscn(elf, scn))) {
+		if (gelf_getshdr(scn, &sh) != &sh)
+			goto out_elf;
+		name = elf_strptr(elf, shdrstrndx, sh.sh_name);
+		if (name && !strcmp(name, section))
+			break;
+	}
+	if (!scn) {
+		pr_err("FAILED: section %s not found in %s\n", section, obj->path);
+		goto out_elf;
+	}
+	data = elf_getdata(scn, NULL);
+	if (!data || data->d_size != module_name_len +
+		LIBBPF_SHA256_DIGEST_LENGTH + sizeof(u32)) {
+		pr_err("FAILED: section %s has unexpected size\n", section);
+		goto out_elf;
+	}
+	memset(data->d_buf, 0, data->d_size);
+	memcpy(data->d_buf, link->module, strlen(link->module) + 1);
+	libbpf_sha256(raw_btf_data, raw_btf_size,
+		      (u8 *)data->d_buf + module_name_len);
+	size = (u8 *)data->d_buf + module_name_len + LIBBPF_SHA256_DIGEST_LENGTH;
+	if (obj->efile.encoding == ELFDATA2LSB) {
+		size[0] = raw_btf_size;
+		size[1] = raw_btf_size >> 8;
+		size[2] = raw_btf_size >> 16;
+		size[3] = raw_btf_size >> 24;
+	} else if (obj->efile.encoding == ELFDATA2MSB) {
+		size[0] = raw_btf_size >> 24;
+		size[1] = raw_btf_size >> 16;
+		size[2] = raw_btf_size >> 8;
+		size[3] = raw_btf_size;
+	} else {
+		goto out_elf;
+	}
+	elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY);
+	if (elf_update(elf, ELF_C_WRITE) >= 0)
+		err = 0;
+out_elf:
+	elf_end(elf);
+out_close:
+	close(fd);
+	free(raw_btf_data);
+	return err;
+out_file:
+	fclose(btf_file);
+out_data:
+	free(raw_btf_data);
+	return err;
+}
+
 static const struct btf_type *btf_type_skip_qualifiers(const struct btf *btf, s32 type_id)
 {
 	const struct btf_type *t = btf__type_by_id(btf, type_id);
@@ -1908,6 +2071,7 @@ int main(int argc, const char **argv)
 		.sets     = RB_ROOT,
 	};
 	const char *btfids_path = NULL;
+	struct btf_links btf_links = {};
 	bool fatal_warnings = false;
 	bool resolve_btfids = true;
 	char out_path[PATH_MAX];
@@ -1925,6 +2089,8 @@ int main(int argc, const char **argv)
 			    "distill --btf_base and emit .BTF.base section data"),
 		OPT_BOOLEAN(0, "inline", &obj.extract_inline,
 			    "extract location BTF into a .BTF.inline file"),
+		OPT_CALLBACK(0, "btf_link", &btf_links, "section:module:btf-file",
+			     "patch a BTF link", parse_btf_link),
 		OPT_STRING(0, "patch_btfids", &btfids_path, "file",
 			   "path to .BTF_ids section data blob to patch into ELF file"),
 		OPT_END()
@@ -1938,9 +2104,22 @@ int main(int argc, const char **argv)
 
 	obj.path = argv[0];
 
-	if (btfids_path)
-		return patch_btfids(btfids_path, obj.path);
-
+	if (btfids_path) {
+		err = patch_btfids(btfids_path, obj.path);
+		if (err || !btf_links.cnt)
+			goto out;
+		if (elf_collect(&obj)) {
+			err = -EINVAL;
+			goto out;
+		}
+		for (u32 i = 0; i < btf_links.cnt; i++) {
+			struct btf_link *link = &btf_links.links[i];
+			err = patch_btf_link(&obj, link);
+			if (err)
+				break;
+		}
+		goto out;
+	}
 	if (elf_collect(&obj))
 		goto out;
 	if (obj.extract_inline && collect_func_symbols(&obj))
@@ -2001,10 +2180,10 @@ int main(int argc, const char **argv)
 		if (err)
 			goto out;
 	}
-
 	if (!(fatal_warnings && warnings))
 		err = 0;
 out:
+	free_btf_links(&btf_links);
 	btf__free(obj.inline_btf);
 	btf__free(obj.btf);
 	btf__free(obj.base_btf);
-- 
2.43.5