xref: /linux/tools/bpf/resolve_btfids/main.c (revision a8471eb0747f083ae5bde949e667d3d799d65cf7)

// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)

/*
 * resolve_btfids scans ELF object for .BTF_ids section and resolves
 * its symbols with BTF ID values.
 *
 * Each symbol points to 4 bytes data and is expected to have
 * following name syntax:
 *
 * __BTF_ID__<type>__<symbol>[__<id>]
 *
 * type is:
 *
 *   func    - lookup BTF_KIND_FUNC symbol with <symbol> name
 *             and store its ID into the data:
 *
 *             __BTF_ID__func__vfs_close__1:
 *             .zero 4
 *
 *   struct  - lookup BTF_KIND_STRUCT symbol with <symbol> name
 *             and store its ID into the data:
 *
 *             __BTF_ID__struct__sk_buff__1:
 *             .zero 4
 *
 *   union   - lookup BTF_KIND_UNION symbol with <symbol> name
 *             and store its ID into the data:
 *
 *             __BTF_ID__union__thread_union__1:
 *             .zero 4
 *
 *   typedef - lookup BTF_KIND_TYPEDEF symbol with <symbol> name
 *             and store its ID into the data:
 *
 *             __BTF_ID__typedef__pid_t__1:
 *             .zero 4
 *
 *   set     - store symbol size into first 4 bytes and sort following
 *             ID list
 *
 *             __BTF_ID__set__list:
 *             .zero 4
 *             list:
 *             __BTF_ID__func__vfs_getattr__3:
 *             .zero 4
 *             __BTF_ID__func__vfs_fallocate__4:
 *             .zero 4
 *
 *   set8    - store symbol size into first 4 bytes and sort following
 *             ID list
 *
 *             __BTF_ID__set8__list:
 *             .zero 8
 *             list:
 *             __BTF_ID__func__vfs_getattr__3:
 *             .zero 4
 *	       .word (1 << 0) | (1 << 2)
 *             __BTF_ID__func__vfs_fallocate__5:
 *             .zero 4
 *	       .word (1 << 3) | (1 << 1) | (1 << 2)
 *
 * In addition to resolving BTF IDs, resolve_btfids performs kernel-specific
 * BTF-to-BTF transformations for kfuncs found in BTF_SET8_KFUNCS sets. For
 * each such kfunc it:
 *
 *   - emits a "bpf_kfunc" decl tag, and "bpf_fastcall" when KF_FASTCALL is set;
 *   - wraps the return value and/or arguments that use arena pointers
 *     with the "address_space(1)" type attribute;
 *   - rewrites the prototype of KF_IMPLICIT_ARGS kfuncs.
 *
 * These kfunc annotations were historically produced by pahole.
 */

#define  _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <libelf.h>
#include <gelf.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <linux/btf_ids.h>
#include <linux/kallsyms.h>
#include <linux/rbtree.h>
#include <linux/zalloc.h>
#include <linux/err.h>
#include <linux/limits.h>
#include <bpf/btf.h>
#include <bpf/libbpf.h>
#include "btf_colors.h"
#include <subcmd/parse-options.h>

#define BTF_IDS_SECTION	".BTF_ids"
#define BTF_LINK_MODULE_NAME_MAX	64
#define BTF_ID_PREFIX	"__BTF_ID__"

#define BTF_STRUCT	"struct"
#define BTF_UNION	"union"
#define BTF_TYPEDEF	"typedef"
#define BTF_FUNC	"func"
#define BTF_SET		"set"
#define BTF_SET8	"set8"

#define ADDR_CNT	100

#if __BYTE_ORDER == __LITTLE_ENDIAN
# define ELFDATANATIVE	ELFDATA2LSB
#elif __BYTE_ORDER == __BIG_ENDIAN
# define ELFDATANATIVE	ELFDATA2MSB
#else
# error "Unknown machine endianness!"
#endif

enum btf_id_kind {
	BTF_ID_KIND_NONE,
	BTF_ID_KIND_SYM,
	BTF_ID_KIND_SET,
	BTF_ID_KIND_SET8
};

struct btf_id {
	struct rb_node	 rb_node;
	char		*name;
	union {
		int	 id;
		int	 cnt;
	};
	enum btf_id_kind kind;
	int		 addr_cnt;
	Elf64_Addr	 addr[ADDR_CNT];
};

struct addr_sym {
	Elf64_Addr	 addr;
	const char	*name;
};

struct object {
	const char *path;
	const char *btf_path;
	const char *base_btf_path;

	struct btf *btf;
	struct btf *base_btf;
	struct btf *inline_btf;
	struct btf *orig_btf;
	bool distill_base;
	bool extract_inline;

	struct {
		int		 fd;
		Elf		*elf;
		Elf_Data	*symbols;
		Elf_Data	*idlist;
		int		 symbols_shndx;
		int		 idlist_shndx;
		size_t		 strtabidx;
		unsigned long	 idlist_addr;
		int		 encoding;
		int		 elf_class;
		const char	**func_symbols;
		u32		 func_symbols_cnt;
		u32		 func_symbols_cap;
		bool		 func_symbols_collected;
	} efile;

	struct rb_root	sets;
	struct rb_root	structs;
	struct rb_root	unions;
	struct rb_root	typedefs;
	struct rb_root	funcs;

	int nr_funcs;
	int nr_structs;
	int nr_unions;
	int nr_typedefs;

	struct addr_sym *addr_syms;
	u32 addr_syms_cnt;
	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"

#define KF_FASTCALL	(1 << 12)
#define KF_ARENA_RET	(1 << 13)
#define KF_ARENA_ARG1	(1 << 14)
#define KF_ARENA_ARG2	(1 << 15)
#define KF_IMPLICIT_ARGS (1 << 16)
#define KF_IMPL_SUFFIX "_impl"
#define TYPE_ATTR_ARENA "address_space(1)"
#define PARAM_SUFFIX_ARENA "__arena"
#define PARAM_SUFFIX_ARENA_NULLABLE "__arena__nullable"

struct kfunc {
	struct rb_node rb_node;
	const char *name;
	u32 btf_id;
	u32 flags;
};

struct btf2btf_context {
	struct btf *btf;
	u32 *decl_tags;
	u32 nr_decl_tags;
	u32 max_decl_tags;
	struct rb_root kfuncs;
};

static int verbose;
static int warnings;

static int eprintf(int level, int var, const char *fmt, ...)
{
	va_list args;
	int ret = 0;

	if (var >= level) {
		va_start(args, fmt);
		ret = vfprintf(stderr, fmt, args);
		va_end(args);
	}
	return ret;
}

#ifndef pr_fmt
#define pr_fmt(fmt) fmt
#endif

#define pr_debug(fmt, ...) \
	eprintf(1, verbose, pr_fmt(fmt), ##__VA_ARGS__)
#define pr_debugN(n, fmt, ...) \
	eprintf(n, verbose, pr_fmt(fmt), ##__VA_ARGS__)
#define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__)
#define pr_err(fmt, ...) \
	eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__)
#define pr_info(fmt, ...) \
	eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__)

/*
 * Grow *data so it can hold at least cnt elements of elem_sz bytes each.
 * *cap is the capacity in elements and is updated on growth.
 */
static int __ensure_mem(void **data, u32 *cap, u32 cnt, size_t elem_sz)
{
	u32 new_cap, old_cap = *cap;
	void *arr;

	if (cnt <= old_cap)
		return 0;

	new_cap = max(old_cap + 256, old_cap * 2);
	if (new_cap < cnt)
		new_cap = cnt;

	arr = realloc(*data, elem_sz * new_cap);
	if (!arr)
		return -ENOMEM;

	*data = arr;
	*cap = new_cap;

	return 0;
}

#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);
}

static struct btf_id *btf_id__find(struct rb_root *root, const char *name)
{
	struct rb_node *p = root->rb_node;
	struct btf_id *id;
	int cmp;

	while (p) {
		id = rb_entry(p, struct btf_id, rb_node);
		cmp = strcmp(id->name, name);
		if (cmp < 0)
			p = p->rb_left;
		else if (cmp > 0)
			p = p->rb_right;
		else
			return id;
	}
	return NULL;
}

static struct btf_id *__btf_id__add(struct rb_root *root,
				    const char *name,
				    enum btf_id_kind kind,
				    bool unique)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct btf_id *id;
	int cmp;

	while (*p != NULL) {
		parent = *p;
		id = rb_entry(parent, struct btf_id, rb_node);
		cmp = strcmp(id->name, name);
		if (cmp < 0)
			p = &(*p)->rb_left;
		else if (cmp > 0)
			p = &(*p)->rb_right;
		else
			return unique ? NULL : id;
	}

	id = zalloc(sizeof(*id));
	if (id) {
		pr_debug("adding symbol %s\n", name);
		id->name = strdup(name);
		if (!id->name) {
			free(id);
			return NULL;
		}
		id->kind = kind;
		rb_link_node(&id->rb_node, parent, p);
		rb_insert_color(&id->rb_node, root);
	}
	return id;
}

static inline struct btf_id *btf_id__add(struct rb_root *root,
					 const char *name,
					 enum btf_id_kind kind)
{
	return __btf_id__add(root, name, kind, false);
}

static inline struct btf_id *btf_id__add_unique(struct rb_root *root,
						const char *name,
						enum btf_id_kind kind)
{
	return __btf_id__add(root, name, kind, true);
}

static int get_id(const char *prefix_end, char *buf, size_t buf_sz)
{
	/*
	 * __BTF_ID__func__vfs_truncate__0
	 * prefix_end =  ^
	 * pos        =    ^
	 */
	int len = strlen(prefix_end);
	int pos = sizeof("__") - 1;
	char *p;

	if (pos >= len)
		return -1;

	if (len - pos >= buf_sz)
		return -1;

	strcpy(buf, prefix_end + pos);
	/*
	 * __BTF_ID__func__vfs_truncate__0
	 * buf =           ^
	 *
	 * cut the unique id part
	 */
	p = strrchr(buf, '_');
	p--;
	if (*p != '_')
		return -1;
	*p = '\0';

	return 0;
}

static struct btf_id *add_set(struct object *obj, char *name, enum btf_id_kind kind)
{
	int len = strlen(name);
	int prefixlen;
	char *id;

	/*
	 * __BTF_ID__set__name
	 * name =    ^
	 * id   =         ^
	 */
	switch (kind) {
	case BTF_ID_KIND_SET:
		prefixlen = sizeof(BTF_SET "__") - 1;
		break;
	case BTF_ID_KIND_SET8:
		prefixlen = sizeof(BTF_SET8 "__") - 1;
		break;
	default:
		pr_err("Unexpected kind %d passed to %s() for symbol %s\n", kind, __func__, name);
		return NULL;
	}

	id = name + prefixlen;
	if (id >= name + len) {
		pr_err("FAILED to parse set name: %s\n", name);
		return NULL;
	}

	return btf_id__add_unique(&obj->sets, id, kind);
}

static struct btf_id *add_symbol(struct rb_root *root, char *name, size_t size)
{
	char id[KSYM_NAME_LEN];

	if (get_id(name + size, id, sizeof(id))) {
		pr_err("FAILED to parse symbol name: %s\n", name);
		return NULL;
	}

	return btf_id__add(root, id, BTF_ID_KIND_SYM);
}

static void btf_id__free_all(struct rb_root *root)
{
	struct rb_node *next;
	struct btf_id *id;

	next = rb_first(root);
	while (next) {
		id = rb_entry(next, struct btf_id, rb_node);
		next = rb_next(&id->rb_node);
		rb_erase(&id->rb_node, root);
		free(id->name);
		free(id);
	}
}

static void bswap_32_data(void *data, u32 nr_bytes)
{
	u32 cnt, i;
	u32 *ptr;

	cnt = nr_bytes / sizeof(u32);
	ptr = data;

	for (i = 0; i < cnt; i++)
		ptr[i] = bswap_32(ptr[i]);
}

static int elf_collect(struct object *obj)
{
	Elf_Scn *scn = NULL;
	size_t shdrstrndx;
	GElf_Ehdr ehdr;
	int idx = 0;
	Elf *elf;
	int fd;

	fd = open(obj->path, O_RDWR, 0666);
	if (fd == -1) {
		pr_err("FAILED cannot open %s: %s\n",
			obj->path, strerror(errno));
		return -1;
	}

	elf_version(EV_CURRENT);

	elf = elf_begin(fd, ELF_C_READ_MMAP_PRIVATE, NULL);
	if (!elf) {
		close(fd);
		pr_err("FAILED cannot create ELF descriptor: %s\n",
			elf_errmsg(-1));
		return -1;
	}

	obj->efile.fd  = fd;
	obj->efile.elf = elf;

	elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT);

	if (elf_getshdrstrndx(elf, &shdrstrndx) != 0) {
		pr_err("FAILED cannot get shdr str ndx\n");
		return -1;
	}

	if (gelf_getehdr(obj->efile.elf, &ehdr) == NULL) {
		pr_err("FAILED cannot get ELF header: %s\n",
			elf_errmsg(-1));
		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
	 * from .BTF_ids section and symbols.
	 */
	while ((scn = elf_nextscn(elf, scn)) != NULL) {
		Elf_Data *data;
		GElf_Shdr sh;
		char *name;

		idx++;
		if (gelf_getshdr(scn, &sh) != &sh) {
			pr_err("FAILED get section(%d) header\n", idx);
			return -1;
		}

		name = elf_strptr(elf, shdrstrndx, sh.sh_name);
		if (!name) {
			pr_err("FAILED get section(%d) name\n", idx);
			return -1;
		}

		data = elf_getdata(scn, 0);
		if (!data) {
			pr_err("FAILED to get section(%d) data from %s\n",
				idx, name);
			return -1;
		}

		pr_debug2("section(%d) %s, size %ld, link %d, flags %lx, type=%d\n",
			  idx, name, (unsigned long) data->d_size,
			  (int) sh.sh_link, (unsigned long) sh.sh_flags,
			  (int) sh.sh_type);

		if (sh.sh_type == SHT_SYMTAB) {
			obj->efile.symbols       = data;
			obj->efile.symbols_shndx = idx;
			obj->efile.strtabidx     = sh.sh_link;
		} else if (!strcmp(name, BTF_IDS_SECTION)) {
			/*
			 * If target endianness differs from host, we need to bswap32
			 * the .BTF_ids section data on load, because .BTF_ids has
			 * Elf_Type = ELF_T_BYTE, and so libelf returns data buffer in
			 * the target endianness. We repeat this on dump.
			 */
			if (obj->efile.encoding != ELFDATANATIVE) {
				pr_debug("bswap_32 .BTF_ids data from target to host endianness\n");
				bswap_32_data(data->d_buf, data->d_size);
			}
			obj->efile.idlist       = data;
			obj->efile.idlist_shndx = idx;
			obj->efile.idlist_addr  = sh.sh_addr;
		}
	}

	return 0;
}

static int push_addr_sym(struct object *obj, Elf64_Addr addr, const char *name)
{
	if (ensure_mem(&obj->addr_syms, &obj->addr_syms_cap, obj->addr_syms_cnt + 1))
		return -ENOMEM;

	obj->addr_syms[obj->addr_syms_cnt++] = (struct addr_sym){
		.addr = addr,
		.name = name,
	};

	return 0;
}

static int cmp_addr_sym(const void *a, const void *b)
{
	Elf64_Addr aa = ((const struct addr_sym *)a)->addr;
	Elf64_Addr ab = ((const struct addr_sym *)b)->addr;

	return (aa > ab) - (aa < ab);
}

static const char *find_name_by_addr(struct object *obj, Elf64_Addr addr)
{
	struct addr_sym key = { .addr = addr };
	struct addr_sym *res;

	if (!obj->addr_syms_cnt)
		return NULL;

	res = bsearch(&key, obj->addr_syms, obj->addr_syms_cnt,
		      sizeof(*obj->addr_syms), cmp_addr_sym);
	return res ? res->name : NULL;
}

static int cmp_func_symbol(const void *a, const void *b)
{
	const char * const *name = a;
	const char * const *other = b;

	return strcmp(*name, *other);
}

static int collect_func_symbols(struct object *obj)
{
	Elf_Scn *scn;
	GElf_Shdr sh;
	int n, i;

	if (obj->efile.symbols_shndx == -1)
		return 0;

	scn = elf_getscn(obj->efile.elf, obj->efile.symbols_shndx);
	if (!scn || gelf_getshdr(scn, &sh) != &sh || !sh.sh_entsize)
		return -EINVAL;
	n = sh.sh_size / sh.sh_entsize;

	for (i = 0; i < n; i++) {
		GElf_Sym sym;
		const char *name;

		if (!gelf_getsym(obj->efile.symbols, i, &sym))
			return -EINVAL;
		if (GELF_ST_TYPE(sym.st_info) != STT_FUNC ||
		    sym.st_shndx == SHN_UNDEF || !sym.st_name)
			continue;
		name = elf_strptr(obj->efile.elf, obj->efile.strtabidx, sym.st_name);
		if (!name)
			return -EINVAL;
		if (ensure_mem(&obj->efile.func_symbols, &obj->efile.func_symbols_cap,
			       obj->efile.func_symbols_cnt + 1))
			return -ENOMEM;
		obj->efile.func_symbols[obj->efile.func_symbols_cnt++] = name;
	}

	qsort(obj->efile.func_symbols, obj->efile.func_symbols_cnt,
	      sizeof(*obj->efile.func_symbols), cmp_func_symbol);
	obj->efile.func_symbols_collected = true;
	return 0;
}

static bool has_func_symbol(const struct object *obj, const char *name)
{
	return bsearch(&name, obj->efile.func_symbols, obj->efile.func_symbols_cnt,
		       sizeof(*obj->efile.func_symbols), cmp_func_symbol) != NULL;
}

static int symbols_collect(struct object *obj)
{
	Elf_Scn *scn = NULL;
	int n, i;
	GElf_Shdr sh;
	char *name;

	scn = elf_getscn(obj->efile.elf, obj->efile.symbols_shndx);
	if (!scn)
		return -1;

	if (gelf_getshdr(scn, &sh) != &sh)
		return -1;

	n = sh.sh_size / sh.sh_entsize;

	/*
	 * Scan symbols and look for the ones starting with
	 * __BTF_ID__* over .BTF_ids section.
	 */
	for (i = 0; i < n; i++) {
		char *prefix;
		struct btf_id *id;
		GElf_Sym sym;

		if (!gelf_getsym(obj->efile.symbols, i, &sym))
			return -1;

		if (sym.st_shndx != obj->efile.idlist_shndx)
			continue;

		name = elf_strptr(obj->efile.elf, obj->efile.strtabidx,
				  sym.st_name);

		if (!is_btf_id(name))
			continue;

		/*
		 * __BTF_ID__TYPE__vfs_truncate__0
		 * prefix =  ^
		 */
		prefix = name + sizeof(BTF_ID_PREFIX) - 1;

		/* struct */
		if (!strncmp(prefix, BTF_STRUCT, sizeof(BTF_STRUCT) - 1)) {
			obj->nr_structs++;
			id = add_symbol(&obj->structs, prefix, sizeof(BTF_STRUCT) - 1);
		/* union  */
		} else if (!strncmp(prefix, BTF_UNION, sizeof(BTF_UNION) - 1)) {
			obj->nr_unions++;
			id = add_symbol(&obj->unions, prefix, sizeof(BTF_UNION) - 1);
		/* typedef */
		} else if (!strncmp(prefix, BTF_TYPEDEF, sizeof(BTF_TYPEDEF) - 1)) {
			obj->nr_typedefs++;
			id = add_symbol(&obj->typedefs, prefix, sizeof(BTF_TYPEDEF) - 1);
		/* func */
		} else if (!strncmp(prefix, BTF_FUNC, sizeof(BTF_FUNC) - 1)) {
			obj->nr_funcs++;
			id = add_symbol(&obj->funcs, prefix, sizeof(BTF_FUNC) - 1);
		/* set8 */
		} else if (!strncmp(prefix, BTF_SET8, sizeof(BTF_SET8) - 1)) {
			id = add_set(obj, prefix, BTF_ID_KIND_SET8);
			/*
			 * SET8 objects store list's count, which is encoded
			 * in symbol's size, together with 'cnt' field hence
			 * that - 1.
			 */
			if (id)
				id->cnt = sym.st_size / sizeof(uint64_t) - 1;
		/* set */
		} else if (!strncmp(prefix, BTF_SET, sizeof(BTF_SET) - 1)) {
			id = add_set(obj, prefix, BTF_ID_KIND_SET);
			/*
			 * SET objects store list's count, which is encoded
			 * in symbol's size, together with 'cnt' field hence
			 * that - 1.
			 */
			if (id)
				id->cnt = sym.st_size / sizeof(int) - 1;
		} else {
			pr_err("FAILED unsupported prefix %s\n", prefix);
			return -1;
		}

		if (!id)
			return -EINVAL;

		if (id->addr_cnt >= ADDR_CNT) {
			pr_err("FAILED symbol %s crossed the number of allowed lists\n",
				id->name);
			return -1;
		}
		id->addr[id->addr_cnt++] = sym.st_value;

		if (push_addr_sym(obj, sym.st_value, id->name))
			return -1;
	}

	if (obj->addr_syms_cnt)
		qsort(obj->addr_syms, obj->addr_syms_cnt,
		      sizeof(*obj->addr_syms), cmp_addr_sym);

	return 0;
}

static int load_btf(struct object *obj)
{
	struct btf *base_btf = NULL, *btf = NULL;
	int err;

	if (obj->base_btf_path) {
		base_btf = btf__parse(obj->base_btf_path, NULL);
		err = libbpf_get_error(base_btf);
		if (err) {
			pr_err("FAILED: load base BTF from %s: %s\n",
			       obj->base_btf_path, strerror(-err));
			return err;
		}
		obj->base_btf = base_btf;
	}

	btf = btf__parse_split(obj->btf_path ?: obj->path, base_btf);
	err = libbpf_get_error(btf);
	if (err) {
		pr_err("FAILED: load BTF from %s: %s\n",
			obj->btf_path ?: obj->path, strerror(-err));
		return err;
	}

	obj->btf = btf;

	return 0;
}

static int symbols_resolve(struct object *obj)
{
	int nr_typedefs = obj->nr_typedefs;
	int nr_structs  = obj->nr_structs;
	int nr_unions   = obj->nr_unions;
	int nr_funcs    = obj->nr_funcs;
	struct btf *btf = obj->btf;
	int err, type_id;
	__u32 nr_types;

	err = -1;
	nr_types = btf__type_cnt(btf);

	/*
	 * Iterate all the BTF types and search for collected symbol IDs.
	 */
	for (type_id = 1; type_id < nr_types; type_id++) {
		const struct btf_type *type;
		struct rb_root *root;
		struct btf_id *id;
		const char *str;
		int *nr;

		type = btf__type_by_id(btf, type_id);
		if (!type) {
			pr_err("FAILED: malformed BTF, can't resolve type for ID %d\n",
				type_id);
			goto out;
		}

		if (btf_is_func(type) && nr_funcs) {
			nr   = &nr_funcs;
			root = &obj->funcs;
		} else if (btf_is_struct(type) && nr_structs) {
			nr   = &nr_structs;
			root = &obj->structs;
		} else if (btf_is_union(type) && nr_unions) {
			nr   = &nr_unions;
			root = &obj->unions;
		} else if (btf_is_typedef(type) && nr_typedefs) {
			nr   = &nr_typedefs;
			root = &obj->typedefs;
		} else
			continue;

		str = btf__name_by_offset(btf, type->name_off);
		if (!str) {
			pr_err("FAILED: malformed BTF, can't resolve name for ID %d\n",
				type_id);
			goto out;
		}

		id = btf_id__find(root, str);
		if (id) {
			if (id->id) {
				pr_info("WARN: multiple IDs found for '%s': %d, %d - using %d\n",
					str, id->id, type_id, id->id);
				warnings++;
			} else {
				id->id = type_id;
				(*nr)--;
			}
		}
	}

	err = 0;
out:
	return err;
}

static int id_patch(struct object *obj, struct btf_id *id)
{
	Elf_Data *data = obj->efile.idlist;
	int *ptr = data->d_buf;
	int i;

	/* For set, set8, id->id may be 0 */
	if (!id->id && id->kind != BTF_ID_KIND_SET && id->kind != BTF_ID_KIND_SET8) {
		pr_err("WARN: resolve_btfids: unresolved symbol %s\n", id->name);
		warnings++;
	}

	for (i = 0; i < id->addr_cnt; i++) {
		unsigned long addr = id->addr[i];
		unsigned long idx = addr - obj->efile.idlist_addr;

		pr_debug("patching addr %5lu: ID %7d [%s]\n",
			 idx, id->id, id->name);

		if (idx >= data->d_size) {
			pr_err("FAILED patching index %lu out of bounds %lu\n",
				idx, data->d_size);
			return -1;
		}

		idx = idx / sizeof(int);
		ptr[idx] = id->id;
	}

	return 0;
}

static int __symbols_patch(struct object *obj, struct rb_root *root)
{
	struct rb_node *next;
	struct btf_id *id;

	next = rb_first(root);
	while (next) {
		id = rb_entry(next, struct btf_id, rb_node);

		if (id_patch(obj, id))
			return -1;

		next = rb_next(next);
	}
	return 0;
}

static int cmp_id(const void *pa, const void *pb)
{
	const int *a = pa, *b = pb;

	return *a - *b;
}

static int sets_patch(struct object *obj)
{
	Elf_Data *data = obj->efile.idlist;
	struct rb_node *next;
	int cnt;

	next = rb_first(&obj->sets);
	while (next) {
		struct btf_id_set8 *set8 = NULL;
		struct btf_id_set *set = NULL;
		unsigned long addr, off;
		struct btf_id *id;

		id   = rb_entry(next, struct btf_id, rb_node);
		addr = id->addr[0];
		off = addr - obj->efile.idlist_addr;

		/* sets are unique */
		if (id->addr_cnt != 1) {
			pr_err("FAILED malformed data for set '%s'\n",
				id->name);
			return -1;
		}

		switch (id->kind) {
		case BTF_ID_KIND_SET:
			set = data->d_buf + off;
			cnt = set->cnt;
			qsort(set->ids, set->cnt, sizeof(set->ids[0]), cmp_id);
			break;
		case BTF_ID_KIND_SET8:
			set8 = data->d_buf + off;
			cnt = set8->cnt;
			/*
			 * Make sure id is at the beginning of the pairs
			 * struct, otherwise the below qsort would not work.
			 */
			BUILD_BUG_ON((u32 *)set8->pairs != &set8->pairs[0].id);
			qsort(set8->pairs, set8->cnt, sizeof(set8->pairs[0]), cmp_id);
			break;
		default:
			pr_err("Unexpected btf_id_kind %d for set '%s'\n", id->kind, id->name);
			return -1;
		}

		pr_debug("sorting  addr %5lu: cnt %6d [%s]\n", off, cnt, id->name);

		next = rb_next(next);
	}
	return 0;
}

static int symbols_patch(struct object *obj)
{
	if (__symbols_patch(obj, &obj->structs)  ||
	    __symbols_patch(obj, &obj->unions)   ||
	    __symbols_patch(obj, &obj->typedefs) ||
	    __symbols_patch(obj, &obj->funcs)    ||
	    __symbols_patch(obj, &obj->sets))
		return -1;

	if (sets_patch(obj))
		return -1;

	return 0;
}

static int dump_raw_data(const char *out_path, const void *data, u32 size)
{
	size_t written;
	FILE *file;

	file = fopen(out_path, "wb");
	if (!file) {
		pr_err("Couldn't open %s for writing\n", out_path);
		return -1;
	}

	written = fwrite(data, 1, size, file);
	if (written != size) {
		pr_err("Failed to write data to %s\n", out_path);
		fclose(file);
		unlink(out_path);
		return -1;
	}

	fclose(file);
	pr_debug("Dumped %lu bytes of data to %s\n", size, out_path);

	return 0;
}

static int dump_raw_btf_ids(struct object *obj, const char *out_path)
{
	Elf_Data *data = obj->efile.idlist;
	int err;

	if (!data || !data->d_buf) {
		pr_debug("%s has no BTF_ids data to dump\n", obj->path);
		return 0;
	}

	/*
	 * If target endianness differs from host, we need to bswap32 the
	 * .BTF_ids section data before dumping so that the output is in
	 * target endianness.
	 */
	if (obj->efile.encoding != ELFDATANATIVE) {
		pr_debug("bswap_32 .BTF_ids data from host to target endianness\n");
		bswap_32_data(data->d_buf, data->d_size);
	}

	err = dump_raw_data(out_path, data->d_buf, data->d_size);
	if (err)
		return -1;

	return 0;
}

static int dump_raw_btf(struct btf *btf, const char *out_path)
{
	const void *raw_btf_data;
	u32 raw_btf_size;
	int err;

	raw_btf_data = btf__raw_data(btf, &raw_btf_size);
	if (!raw_btf_data) {
		pr_err("btf__raw_data() failed\n");
		return -1;
	}

	err = dump_raw_data(out_path, raw_btf_data, raw_btf_size);
	if (err)
		return -1;

	return 0;
}

static int patch_btf_link(struct object *obj, const struct btf_link *link)
{
	char section[128];
	void *raw_btf_data = NULL;
	size_t shdrstrndx, module_name_len;
	int fd = -1, len, err = -1;
	FILE *btf_file = NULL;
	Elf_Scn *scn = NULL;
	u32 raw_btf_size;
	struct stat st;
	Elf_Data *data;
	GElf_Shdr sh;
	char *name;
	Elf *elf = NULL;
	u8 *size;

	if (stat(link->btf_path, &st)) {
		err = -errno;
		pr_err("FAILED to stat BTF file %s: %s\n",
		       link->btf_path, strerror(errno));
		return err;
	}
	if (!S_ISREG(st.st_mode) || st.st_size <= 0 || st.st_size > UINT_MAX) {
		pr_err("FAILED: invalid BTF file size or type: %s\n", link->btf_path);
		return -EINVAL;
	}
	raw_btf_size = st.st_size;
	raw_btf_data = malloc(raw_btf_size);
	if (!raw_btf_data) {
		pr_err("FAILED to allocate %u bytes for BTF file %s\n",
		       raw_btf_size, link->btf_path);
		return -ENOMEM;
	}
	btf_file = fopen(link->btf_path, "rb");
	if (!btf_file) {
		err = -errno;
		pr_err("FAILED to open BTF file %s: %s\n",
		       link->btf_path, strerror(errno));
		goto out;
	}
	if (fread(raw_btf_data, raw_btf_size, 1, btf_file) != 1) {
		err = -EIO;
		pr_err("FAILED to read BTF file %s\n", link->btf_path);
		goto out;
	}
	fclose(btf_file);
	btf_file = NULL;
	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 {
		err = -EINVAL;
		pr_err("FAILED: unsupported ELF class %u in %s\n",
		       obj->efile.elf_class, obj->path);
		goto out;
	}
	if (strlen(link->module) >= module_name_len) {
		err = -EINVAL;
		pr_err("FAILED: module name too long for BTF link: %s\n", link->module);
		goto out;
	}
	len = snprintf(section, sizeof(section), "%s.link", link->section);
	if (len < 0 || len >= sizeof(section)) {
		err = -ENAMETOOLONG;
		pr_err("FAILED: BTF link section name too long: %s.link\n", link->section);
		goto out;
	}

	fd = open(obj->path, O_RDWR);
	if (fd < 0) {
		err = -errno;
		pr_err("FAILED to open %s: %s\n", obj->path, strerror(errno));
		goto out;
	}
	elf = elf_begin(fd, ELF_C_RDWR_MMAP, NULL);
	if (!elf) {
		err = -EINVAL;
		pr_err("FAILED to create ELF descriptor for %s: %s\n",
		       obj->path, elf_errmsg(-1));
		goto out;
	}
	elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT);
	if (elf_getshdrstrndx(elf, &shdrstrndx)) {
		pr_err("FAILED to get section name index from %s: %s\n",
		       obj->path, elf_errmsg(-1));
		goto out;
	}
	while ((scn = elf_nextscn(elf, scn))) {
		if (gelf_getshdr(scn, &sh) != &sh) {
			pr_err("FAILED to get section header from %s: %s\n",
			       obj->path, elf_errmsg(-1));
			goto out;
		}
		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;
	}
	data = elf_getdata(scn, NULL);
	if (sh.sh_type != SHT_PROGBITS || !data || !data->d_buf ||
	    data->d_size != module_name_len +
		BTF_SHA256_DIGEST_LENGTH + sizeof(u32)) {
		pr_err("FAILED: section %s is not a writable BTF link\n", section);
		goto out;
	}
	memset(data->d_buf, 0, data->d_size);
	memcpy(data->d_buf, link->module, strlen(link->module) + 1);
	btf_sha256(raw_btf_data, raw_btf_size,
		   (u8 *)data->d_buf + module_name_len);
	size = (u8 *)data->d_buf + module_name_len + BTF_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 {
		pr_err("FAILED: unsupported ELF data encoding %u in %s\n",
		       obj->efile.encoding, obj->path);
		goto out;
	}
	elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY);
	if (elf_update(elf, ELF_C_WRITE) < 0) {
		pr_err("FAILED to update ELF file %s: %s\n",
		       obj->path, elf_errmsg(-1));
		goto out;
	}
	err = 0;
out:
	if (elf)
		elf_end(elf);
	if (fd >= 0)
		close(fd);
	if (btf_file)
		fclose(btf_file);
	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);

	while (btf_is_mod(t))
		t = btf__type_by_id(btf, t->type);

	return t;
}

static int push_decl_tag_id(struct btf2btf_context *ctx, u32 decl_tag_id)
{
	if (ensure_mem(&ctx->decl_tags, &ctx->max_decl_tags, ctx->nr_decl_tags + 1))
		return -ENOMEM;

	ctx->decl_tags[ctx->nr_decl_tags++] = decl_tag_id;

	return 0;
}

static int push_kfunc(struct btf2btf_context *ctx, struct kfunc *kfunc)
{
	struct rb_node **p = &ctx->kfuncs.rb_node;
	struct rb_node *parent = NULL;
	struct kfunc *k;

	/*
	 * Dedup by BTF ID: collecting the same kfunc twice is a no-op,
	 * UNLESS the kfunc flags are inconsistent, in which case we
	 * fail hard because it indicates a bug in a kfunc set declaration.
	 */
	while (*p) {
		parent = *p;
		k = rb_entry(parent, struct kfunc, rb_node);

		if (kfunc->btf_id < k->btf_id) {
			p = &(*p)->rb_left;
		} else if (kfunc->btf_id > k->btf_id) {
			p = &(*p)->rb_right;
		} else if (k->flags == kfunc->flags) {
			return 0;
		} else {
			pr_err("ERROR: resolve_btfids: kfunc %s has inconsistent flags across BTF ID sets: 0x%x != 0x%x\n",
			       kfunc->name, k->flags, kfunc->flags);
			return -EINVAL;
		}
	}

	k = zalloc(sizeof(*k));
	if (!k)
		return -ENOMEM;

	*k = *kfunc;
	rb_link_node(&k->rb_node, parent, p);
	rb_insert_color(&k->rb_node, &ctx->kfuncs);

	return 0;
}

static void free_kfuncs(struct rb_root *root)
{
	struct rb_node *next;
	struct kfunc *kfunc;

	next = rb_first(root);
	while (next) {
		kfunc = rb_entry(next, struct kfunc, rb_node);
		next = rb_next(&kfunc->rb_node);
		rb_erase(&kfunc->rb_node, root);
		free(kfunc);
	}
}

static int collect_decl_tags(struct btf2btf_context *ctx)
{
	const u32 type_cnt = btf__type_cnt(ctx->btf);
	struct btf *btf = ctx->btf;
	const struct btf_type *t;
	int err;

	for (u32 id = 1; id < type_cnt; id++) {
		t = btf__type_by_id(btf, id);
		if (!btf_is_decl_tag(t))
			continue;
		err = push_decl_tag_id(ctx, id);
		if (err)
			return err;
	}

	return 0;
}

static bool param_name_has_suffix(const char *name, const char *suffix)
{
	size_t name_len = strlen(name);
	size_t suffix_len = strlen(suffix);

	return name_len >= suffix_len && !strcmp(name + name_len - suffix_len, suffix);
}

static bool is_arena_param(const struct btf *btf, const struct btf_param *param)
{
	const char *name = btf__name_by_offset(btf, param->name_off);

	return param_name_has_suffix(name, PARAM_SUFFIX_ARENA) ||
	       param_name_has_suffix(name, PARAM_SUFFIX_ARENA_NULLABLE);
}

static int collect_kfuncs(struct object *obj, struct btf2btf_context *ctx)
{
	Elf_Data *idlist = obj->efile.idlist;
	struct btf *btf = ctx->btf;
	struct rb_node *next;

	if (!idlist || !idlist->d_buf)
		return 0;

	for (next = rb_first(&obj->sets); next; next = rb_next(next)) {
		struct btf_id_set8 *set8;
		struct btf_id *set_id;
		u64 set_addr;

		set_id = rb_entry(next, struct btf_id, rb_node);
		if (set_id->kind != BTF_ID_KIND_SET8 || set_id->addr_cnt != 1)
			continue;

		set_addr = set_id->addr[0];
		set8 = idlist->d_buf + (set_addr - obj->efile.idlist_addr);
		if (!(set8->flags & BTF_SET8_KFUNCS))
			continue;

		for (u32 i = 0; i < set_id->cnt; i++) {
			size_t off = (char *)&set8->pairs[i] - (char *)set8;
			const char *name = find_name_by_addr(obj, set_addr + off);
			struct kfunc kfunc;
			s32 func_id;
			int err;

			if (!name) {
				pr_err("WARN: resolve_btfids: no BTF ID symbol for %s entry %u\n",
				       set_id->name, i);
				warnings++;
				continue;
			}

			func_id = btf__find_by_name_kind_own(btf, name, BTF_KIND_FUNC);
			if (func_id < 0) {
				pr_err("WARN: resolve_btfids: no BTF func for kfunc %s in %s\n",
				       name, set_id->name);
				warnings++;
				continue;
			}

			pr_debug("found kfunc %s in %s\n", name, set_id->name);

			kfunc.name = name;
			kfunc.btf_id = func_id;
			kfunc.flags = set8->pairs[i].flags;
			err = push_kfunc(ctx, &kfunc);
			if (err)
				return err;
		}
	}

	return 0;
}

static int build_btf2btf_context(struct object *obj, struct btf2btf_context *ctx)
{
	int err;

	ctx->btf = obj->btf;

	err = collect_decl_tags(ctx);
	if (err) {
		pr_err("ERROR: resolve_btfids: failed to collect decl tags from BTF\n");
		return err;
	}

	err = collect_kfuncs(obj, ctx);
	if (err) {
		pr_err("ERROR: resolve_btfids: failed to collect kfuncs from BTF\n");
		return err;
	}

	return 0;
}


/* Implicit BPF kfunc arguments can only be of particular types */
static bool is_kf_implicit_arg(const struct btf *btf, const struct btf_param *p)
{
	static const char *const kf_implicit_arg_types[] = {
		"bpf_prog_aux",
		"btf_struct_meta",
	};
	const struct btf_type *t;
	const char *name;

	t = btf_type_skip_qualifiers(btf, p->type);
	if (!btf_is_ptr(t))
		return false;

	t = btf_type_skip_qualifiers(btf, t->type);
	if (!btf_is_struct(t))
		return false;

	name = btf__name_by_offset(btf, t->name_off);
	if (!name)
		return false;

	for (int i = 0; i < ARRAY_SIZE(kf_implicit_arg_types); i++)
		if (strcmp(name, kf_implicit_arg_types[i]) == 0)
			return true;

	return false;
}

/*
 * For a kfunc with KF_IMPLICIT_ARGS we do the following:
 *   1. Add a new function with _impl suffix in the name, with the prototype
 *      of the original kfunc.
 *   2. Add all decl tags except "bpf_kfunc" for the _impl func.
 *   3. Add a new function prototype with modified list of arguments:
 *      omitting implicit args.
 *   4. Change the prototype of the original kfunc to the new one.
 *
 * This way we transform the BTF associated with the kfunc from
 *	__bpf_kfunc bpf_foo(int arg1, void *implicit_arg);
 * into
 *	bpf_foo_impl(int arg1, void *implicit_arg);
 *	__bpf_kfunc bpf_foo(int arg1);
 *
 * If a kfunc with KF_IMPLICIT_ARGS already has an _impl counterpart
 * in BTF, then it's a legacy case: an _impl function is declared in the
 * source code. In this case, we can skip adding an _impl function, but we
 * still have to add a func prototype that omits implicit args.
 */
static int process_kfunc_with_implicit_args(struct btf2btf_context *ctx, struct kfunc *kfunc)
{
	s32 idx, new_proto_id, new_func_id, proto_id;
	const char *param_name, *tag_name;
	const struct btf_param *params;
	enum btf_func_linkage linkage;
	char tmp_name[KSYM_NAME_LEN];
	struct btf *btf = ctx->btf;
	int err, len, nr_params;
	struct btf_type *t;

	t = (struct btf_type *)btf__type_by_id(btf, kfunc->btf_id);
	if (!t || !btf_is_func(t)) {
		pr_err("ERROR: resolve_btfids: btf id %d is not a function\n", kfunc->btf_id);
		return -EINVAL;
	}

	linkage = btf_vlen(t);

	proto_id = t->type;
	t = (struct btf_type *)btf__type_by_id(btf, proto_id);
	if (!t || !btf_is_func_proto(t)) {
		pr_err("ERROR: resolve_btfids: btf id %d is not a function prototype\n", proto_id);
		return -EINVAL;
	}

	len = snprintf(tmp_name, sizeof(tmp_name), "%s%s", kfunc->name, KF_IMPL_SUFFIX);
	if (len < 0 || len >= sizeof(tmp_name)) {
		pr_err("ERROR: function name is too long: %s%s\n", kfunc->name, KF_IMPL_SUFFIX);
		return -E2BIG;
	}

	if (btf__find_by_name_kind_own(btf, tmp_name, BTF_KIND_FUNC) > 0) {
		pr_debug("resolve_btfids: function %s already exists in BTF\n", tmp_name);
		goto add_new_proto;
	}

	/* Add a new function with _impl suffix and original prototype */
	new_func_id = btf__add_func(btf, tmp_name, linkage, proto_id);
	if (new_func_id < 0) {
		pr_err("ERROR: resolve_btfids: failed to add func %s to BTF\n", tmp_name);
		return new_func_id;
	}

	/* Copy all decl tags except "bpf_kfunc" from the original kfunc to the new one */
	for (int i = 0; i < ctx->nr_decl_tags; i++) {
		t = (struct btf_type *)btf__type_by_id(btf, ctx->decl_tags[i]);
		if (t->type != kfunc->btf_id)
			continue;

		tag_name = btf__name_by_offset(btf, t->name_off);
		if (strcmp(tag_name, DECL_TAG_KFUNC) == 0)
			continue;

		idx = btf_decl_tag(t)->component_idx;

		if (btf_kflag(t))
			err = btf__add_decl_attr(btf, tag_name, new_func_id, idx);
		else
			err = btf__add_decl_tag(btf, tag_name, new_func_id, idx);

		if (err < 0) {
			pr_err("ERROR: resolve_btfids: failed to add decl tag %s for %s\n",
			       tag_name, tmp_name);
			return -EINVAL;
		}
	}

add_new_proto:
	t = (struct btf_type *)btf__type_by_id(btf, proto_id);
	new_proto_id = btf__add_func_proto(btf, t->type);
	if (new_proto_id < 0) {
		pr_err("ERROR: resolve_btfids: failed to add func proto for %s\n", kfunc->name);
		return new_proto_id;
	}

	/* Add non-implicit args to the new prototype */
	t = (struct btf_type *)btf__type_by_id(btf, proto_id);
	nr_params = btf_vlen(t);
	for (int i = 0; i < nr_params; i++) {
		params = btf_params(t);
		if (is_kf_implicit_arg(btf, &params[i]))
			break;
		param_name = btf__name_by_offset(btf, params[i].name_off);
		err = btf__add_func_param(btf, param_name, params[i].type);
		if (err < 0) {
			pr_err("ERROR: resolve_btfids: failed to add param %s for %s\n",
			       param_name, kfunc->name);
			return err;
		}
		t = (struct btf_type *)btf__type_by_id(btf, proto_id);
	}

	/* Finally change the prototype of the original kfunc to the new one */
	t = (struct btf_type *)btf__type_by_id(btf, kfunc->btf_id);
	t->type = new_proto_id;

	pr_debug("resolve_btfids: updated BTF for kfunc with implicit args %s\n", kfunc->name);

	return 0;
}

static bool is_arena_arg(const struct btf *btf, const struct kfunc *kfunc,
			 const struct btf_param *param, u32 idx)
{
	if (is_arena_param(btf, param))
		return true;

	switch (idx) {
	case 0:
		return kfunc->flags & KF_ARENA_ARG1;
	case 1:
		return kfunc->flags & KF_ARENA_ARG2;
	default:
		return false;
	}
}

static s32 arena_tag_ptr(struct btf *btf, u32 ptr_id, struct kfunc *kfunc)
{
	const struct btf_type *ptr = btf__type_by_id(btf, ptr_id);
	s32 tag_id, new_ptr_id;

	if (!btf_is_ptr(ptr)) {
		pr_err("ERROR: resolve_btfids: kfunc %s: arena type is not a pointer\n",
		       kfunc->name);
		return -EINVAL;
	}

	tag_id = btf__add_type_attr(btf, TYPE_ATTR_ARENA, ptr->type);
	if (tag_id < 0) {
		pr_err("ERROR: resolve_btfids: kfunc %s: failed to add a type attr to BTF: %d\n",
		       kfunc->name, tag_id);
		return tag_id;
	}

	new_ptr_id = btf__add_ptr(btf, tag_id);
	if (new_ptr_id < 0) {
		pr_err("ERROR: resolve_btfids: kfunc %s: failed to add a pointer to BTF: %d\n",
		       kfunc->name, new_ptr_id);
	}

	return new_ptr_id;
}

/*
 * Add a FUNC_PROTO for @kfunc with each arena pointer tagged with an
 * "address_space(1)" attribute. The original proto may be shared with
 * other FUNCs, so it is never modified in place. Returns the original
 * proto id when @kfunc has no arena return value or arguments.
 */
static s32 add_arena_tagged_proto(struct btf *btf, struct kfunc *kfunc)
{
	const struct btf_type *func = btf__type_by_id(btf, kfunc->btf_id);
	u32 proto_id = func->type;
	const struct btf_type *proto = btf__type_by_id(btf, proto_id);
	const struct btf_param *params = btf_params(proto);
	u32 nr_params = btf_vlen(proto);
	s32 ret_type_id = proto->type;
	const struct btf_type *t;
	struct btf_param *tag_params;
	s32 new_proto_id, id;
	const char *name;
	bool has_arena_arg = false;
	int err, i;

	for (i = 0; i < nr_params; i++) {
		if (is_arena_arg(btf, kfunc, &params[i], i)) {
			has_arena_arg = true;
			break;
		}
	}

	if (!(kfunc->flags & KF_ARENA_RET) && !has_arena_arg)
		return proto_id;

	if (kfunc->flags & KF_ARENA_RET) {
		ret_type_id = arena_tag_ptr(btf, ret_type_id, kfunc);
		if (ret_type_id < 0)
			return ret_type_id;
	}

	new_proto_id = btf__add_func_proto(btf, ret_type_id);
	if (new_proto_id < 0) {
		pr_err("ERROR: resolve_btfids: kfunc %s: failed to add a func proto to BTF: %d\n",
		       kfunc->name, new_proto_id);
		return new_proto_id;
	}

	for (i = 0; i < nr_params; i++) {
		/* btf__add_func_param() below may move the proto, re-fetch */
		proto = btf__type_by_id(btf, proto_id);
		name = btf__name_by_offset(btf, btf_params(proto)[i].name_off);

		err = btf__add_func_param(btf, name ?: "", btf_params(proto)[i].type);
		if (err < 0) {
			pr_err("ERROR: resolve_btfids: kfunc %s: failed to add a proto param to BTF: %d\n",
			       kfunc->name, err);
			return err;
		}
	}

	for (i = 0; i < nr_params; i++) {
		t = btf__type_by_id(btf, new_proto_id);
		tag_params = btf_params(t);
		if (!is_arena_arg(btf, kfunc, &tag_params[i], i))
			continue;

		id = arena_tag_ptr(btf, tag_params[i].type, kfunc);
		if (id < 0)
			return id;

		t = btf__type_by_id(btf, new_proto_id);
		tag_params = btf_params(t);
		tag_params[i].type = id;
	}

	pr_debug("added arena-tagged proto for kfunc %s: %d\n", kfunc->name, new_proto_id);

	return new_proto_id;
}

static int process_kfunc_with_arena_attrs(struct btf2btf_context *ctx,
					  struct kfunc *kfunc)
{
	struct btf_type *t;
	s32 proto_id;

	proto_id = add_arena_tagged_proto(ctx->btf, kfunc);
	if (proto_id < 0)
		return proto_id;

	t = (struct btf_type *)btf__type_by_id(ctx->btf, kfunc->btf_id);
	t->type = proto_id;

	return 0;
}

static int add_decl_tag(struct btf2btf_context *ctx, const char *tag_name,
			u32 target_btf_id, int component_idx)
{
	s32 new_id;

	new_id = btf__add_decl_tag(ctx->btf, tag_name, target_btf_id, component_idx);
	if (new_id < 0) {
		pr_err("ERROR: resolve_btfids: failed to add '%s' decl tag for BTF id %u: %d\n",
		       tag_name, target_btf_id, new_id);
		return new_id;
	}

	return push_decl_tag_id(ctx, new_id);
}

static int btf2btf(struct object *obj)
{
	struct btf2btf_context ctx = {};
	struct rb_node *next;
	int err;

	err = build_btf2btf_context(obj, &ctx);
	if (err)
		goto out;

	for (next = rb_first(&ctx.kfuncs); next; next = rb_next(next)) {
		struct kfunc *kfunc = rb_entry(next, struct kfunc, rb_node);

		err = add_decl_tag(&ctx, DECL_TAG_KFUNC, kfunc->btf_id, -1);
		if (err)
			goto out;

		if (kfunc->flags & KF_FASTCALL) {
			err = add_decl_tag(&ctx, DECL_TAG_FASTCALL, kfunc->btf_id, -1);
			if (err)
				goto out;
		}

		if (kfunc->flags & KF_IMPLICIT_ARGS) {
			err = process_kfunc_with_implicit_args(&ctx, kfunc);
			if (err)
				goto out;
		}

		err = process_kfunc_with_arena_attrs(&ctx, kfunc);
		if (err)
			goto out;
	}

	err = 0;
out:
	free(ctx.decl_tags);
	free_kfuncs(&ctx.kfuncs);

	return err;
}

static bool keep_in_base_btf(struct object *obj, const struct btf_type *t)
{
	const char *name;

	switch (btf_kind(t)) {
	case BTF_KIND_FUNC:
		name = btf__name_by_offset(obj->btf, t->name_off);
		return !obj->efile.func_symbols_collected || has_func_symbol(obj, name) ||
		       btf_id__find(&obj->funcs, name);
	case BTF_KIND_FUNC_PROTO:
	case BTF_KIND_LOC_PARAM:
	case BTF_KIND_LOC_PROTO:
	case BTF_KIND_LOCSEC:
		return false;
	default:
		/*
		 * Ordinary types stay in base btf even if only inline records use them.
		 * Should we relax this?
		 */
		return true;
	}
}

/* Mark which types should go to .BTF.inline */
static int color_btf(struct object *obj, __u8 *colors)
{
	struct btf *btf = obj->btf;
	const struct btf *base = btf__base_btf(btf);
	__u32 start_id = base ? btf__type_cnt(base) : 1;
	__u32 type_cnt = btf__type_cnt(btf), i;
	__u32 *worklist;

	worklist = malloc((type_cnt - start_id ?: 1) * sizeof(*worklist));
	if (!worklist)
		return -ENOMEM;
	/* First, mark all types reachable from LOC BTF entries. */
	for (i = start_id; i < type_cnt; i++) {
		const struct btf_type *t = btf__type_by_id(btf, i);

		if (!btf_is_locsec(t) && !btf_is_loc_proto(t) && !btf_is_loc_param(t))
			continue;
		btf_mark_reachable(btf, i, BTF_COLOR_LOC, colors, worklist);
	}
	/* Next, traverse non-marked types converting some LOC markings to SHARED. */
	for (i = start_id; i < type_cnt; i++) {
		const struct btf_type *t = btf__type_by_id(btf, i);

		if (colors[i] == BTF_COLOR_LOC && !keep_in_base_btf(obj, t))
			continue;
		btf_mark_reachable(btf, i, BTF_COLOR_MAIN, colors, worklist);
	}
	free(worklist);
	return 0;
}

static int extract_inline_btf(struct object *obj)
{
	struct btf *btf = obj->btf, *main_btf, *inline_btf;
	__u8 *colors;
	int err;

	colors = calloc(btf__type_cnt(btf), sizeof(*colors));
	if (!colors)
		return -ENOMEM;
	err = color_btf(obj, colors);
	if (err)
		goto out;
	err = btf_split_by_color(btf, colors, &main_btf, &inline_btf);
	if (!err) {
		obj->orig_btf = btf;
		obj->btf = main_btf;
		obj->inline_btf = inline_btf;
	}
out:
	free(colors);
	return err;
}

/*
 * Sort types by name in ascending order resulting in all
 * anonymous types being placed before named types.
 */
static int cmp_type_names(const void *a, const void *b, void *priv)
{
	struct btf *btf = (struct btf *)priv;
	const struct btf_type *ta = btf__type_by_id(btf, *(__u32 *)a);
	const struct btf_type *tb = btf__type_by_id(btf, *(__u32 *)b);
	const char *na, *nb;
	int r;

	na = btf__str_by_offset(btf, ta->name_off);
	nb = btf__str_by_offset(btf, tb->name_off);
	r = strcmp(na, nb);
	if (r != 0)
		return r;

	/* preserve original relative order of anonymous or same-named types */
	return *(__u32 *)a < *(__u32 *)b ? -1 : 1;
}

static int sort_btf_by_name(struct btf *btf)
{
	__u32 *permute_ids = NULL, *id_map = NULL;
	int nr_types, i, err = 0;
	__u32 start_id = 0, id;

	if (btf__base_btf(btf))
		start_id = btf__type_cnt(btf__base_btf(btf));
	nr_types = btf__type_cnt(btf) - start_id;

	permute_ids = calloc(nr_types, sizeof(*permute_ids));
	if (!permute_ids) {
		err = -ENOMEM;
		goto out;
	}

	id_map = calloc(nr_types, sizeof(*id_map));
	if (!id_map) {
		err = -ENOMEM;
		goto out;
	}

	for (i = 0, id = start_id; i < nr_types; i++, id++)
		permute_ids[i] = id;

	qsort_r(permute_ids, nr_types, sizeof(*permute_ids), cmp_type_names,
		btf);

	for (i = 0; i < nr_types; i++) {
		id = permute_ids[i] - start_id;
		id_map[id] = i + start_id;
	}

	err = btf__permute(btf, id_map, nr_types, NULL);
	if (err)
		pr_err("FAILED: btf permute: %s\n", strerror(-err));

out:
	free(permute_ids);
	free(id_map);
	return err;
}

static int finalize_btf(struct object *obj)
{
	struct btf *base_btf = obj->base_btf, *btf = obj->btf;
	int err;

	err = btf__dedup(obj->btf, NULL);
	if (err) {
		pr_err("FAILED to dedup BTF: %s\n", strerror(errno));
		return err;
	}

	if (obj->base_btf && obj->distill_base) {
		err = btf__distill_base(obj->btf, &base_btf, &btf);
		if (err) {
			pr_err("FAILED to distill base BTF: %s\n", strerror(errno));
			return err;
		}

		btf__free(obj->base_btf);
		btf__free(obj->btf);
		obj->base_btf = base_btf;
		obj->btf = btf;
	}

	err = sort_btf_by_name(obj->btf);
	if (err) {
		pr_err("FAILED to sort BTF: %s\n", strerror(errno));
		return err;
	}

	if (obj->extract_inline) {
		err = extract_inline_btf(obj);
		if (err) {
			pr_err("FAILED to extract inline BTF: %s\n", strerror(-err));
			return err;
		}
	}

	return 0;
}

static inline int make_out_path(char *buf, u32 buf_sz, const char *in_path, const char *suffix)
{
	int len = snprintf(buf, buf_sz, "%s%s", in_path, suffix);

	if (len < 0 || len >= buf_sz) {
		pr_err("Output path is too long: %s%s\n", in_path, suffix);
		return -E2BIG;
	}

	return 0;
}

/*
 * Patch the .BTF_ids section of an ELF file with data from provided file.
 * Equivalent to: objcopy --update-section .BTF_ids=<btfids> <elf>
 *
 * 1. Find .BTF_ids section in the ELF
 * 2. Verify that blob file size matches section size
 * 3. Update section data buffer with blob data
 * 4. Write the ELF file
 */
static int patch_btfids(const char *btfids_path, const char *elf_path)
{
	Elf_Scn *scn = NULL;
	FILE *btfids_file;
	size_t shdrstrndx;
	int fd, err = -1;
	Elf_Data *data;
	struct stat st;
	GElf_Shdr sh;
	char *name;
	Elf *elf;

	elf_version(EV_CURRENT);

	fd = open(elf_path, O_RDWR, 0666);
	if (fd < 0) {
		pr_err("FAILED to open %s: %s\n", elf_path, strerror(errno));
		return -1;
	}

	elf = elf_begin(fd, ELF_C_RDWR_MMAP, NULL);
	if (!elf) {
		close(fd);
		pr_err("FAILED cannot create ELF descriptor: %s\n", elf_errmsg(-1));
		return -1;
	}

	elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT);

	if (elf_getshdrstrndx(elf, &shdrstrndx) != 0) {
		pr_err("FAILED cannot get shdr str ndx\n");
		goto out;
	}

	while ((scn = elf_nextscn(elf, scn)) != NULL) {

		if (gelf_getshdr(scn, &sh) != &sh) {
			pr_err("FAILED to get section header\n");
			goto out;
		}

		name = elf_strptr(elf, shdrstrndx, sh.sh_name);
		if (!name)
			continue;

		if (strcmp(name, BTF_IDS_SECTION) == 0)
			break;
	}

	if (!scn) {
		pr_err("FAILED: section %s not found in %s\n", BTF_IDS_SECTION, elf_path);
		goto out;
	}

	data = elf_getdata(scn, NULL);
	if (!data) {
		pr_err("FAILED to get %s section data from %s\n", BTF_IDS_SECTION, elf_path);
		goto out;
	}

	if (stat(btfids_path, &st) < 0) {
		pr_err("FAILED to stat %s: %s\n", btfids_path, strerror(errno));
		goto out;
	}

	if ((size_t)st.st_size != data->d_size) {
		pr_err("FAILED: size mismatch - %s section in %s is %zu bytes, %s is %zu bytes\n",
		       BTF_IDS_SECTION, elf_path, data->d_size, btfids_path, (size_t)st.st_size);
		goto out;
	}

	btfids_file = fopen(btfids_path, "rb");
	if (!btfids_file) {
		pr_err("FAILED to open %s: %s\n", btfids_path, strerror(errno));
		goto out;
	}

	pr_debug("Copying data from %s to %s section of %s (%zu bytes)\n",
		 btfids_path, BTF_IDS_SECTION, elf_path, data->d_size);

	if (fread(data->d_buf, data->d_size, 1, btfids_file) != 1) {
		pr_err("FAILED to read %s\n", btfids_path);
		fclose(btfids_file);
		goto out;
	}
	fclose(btfids_file);

	elf_flagdata(data, ELF_C_SET, ELF_F_DIRTY);
	if (elf_update(elf, ELF_C_WRITE) < 0) {
		pr_err("FAILED to update ELF file %s\n", elf_path);
		goto out;
	}

	err = 0;
out:
	elf_end(elf);
	close(fd);

	return err;
}

static const char * const resolve_btfids_usage[] = {
	"resolve_btfids [<options>] <ELF object>",
	"resolve_btfids --patch_btfids <.BTF_ids file> [--btf_link <section:module:btf-file>] <ELF object>",
	NULL
};

int main(int argc, const char **argv)
{
	struct object obj = {
		.efile = {
			.idlist_shndx  = -1,
			.symbols_shndx = -1,
		},
		.structs  = RB_ROOT,
		.unions   = RB_ROOT,
		.typedefs = RB_ROOT,
		.funcs    = RB_ROOT,
		.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];

	struct option btfid_options[] = {
		OPT_INCR('v', "verbose", &verbose,
			 "be more verbose (show errors, etc)"),
		OPT_STRING(0, "btf", &obj.btf_path, "file",
			   "path to a file with input BTF data"),
		OPT_STRING('b', "btf_base", &obj.base_btf_path, "file",
			   "path of file providing base BTF"),
		OPT_BOOLEAN(0, "fatal_warnings", &fatal_warnings,
			    "turn warnings into errors"),
		OPT_BOOLEAN(0, "distill_base", &obj.distill_base,
			    "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 with --patch_btfids", 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()
	};
	int err = -1;

	argc = parse_options(argc, argv, btfid_options, resolve_btfids_usage,
			     PARSE_OPT_STOP_AT_NON_OPTION);
	if (argc != 1)
		usage_with_options(resolve_btfids_usage, btfid_options);
	if (btf_links.cnt && !btfids_path) {
		pr_err("--btf_link requires --patch_btfids\n");
		goto out;
	}

	obj.path = argv[0];

	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))
		goto out;

	/*
	 * We did not find .BTF_ids section or symbols section,
	 * nothing to do..
	 */
	if (obj.efile.idlist_shndx == -1 ||
	    obj.efile.symbols_shndx == -1) {
		pr_debug("Cannot find .BTF_ids or symbols sections, skip symbols resolution\n");
		resolve_btfids = false;
	}

	if (resolve_btfids)
		if (symbols_collect(&obj))
			goto out;

	if (load_btf(&obj))
		goto out;

	if (btf2btf(&obj))
		goto out;

	if (finalize_btf(&obj))
		goto out;

	if (!resolve_btfids)
		goto dump_btf;

	if (symbols_resolve(&obj))
		goto out;

	if (symbols_patch(&obj))
		goto out;

	err = make_out_path(out_path, sizeof(out_path), obj.path, BTF_IDS_SECTION);
	err = err ?: dump_raw_btf_ids(&obj, out_path);
	if (err)
		goto out;

dump_btf:
	err = make_out_path(out_path, sizeof(out_path), obj.path, BTF_ELF_SEC);
	err = err ?: dump_raw_btf(obj.btf, out_path);
	if (err)
		goto out;

	if (obj.base_btf && obj.distill_base) {
		err = make_out_path(out_path, sizeof(out_path), obj.path, BTF_BASE_ELF_SEC);
		err = err ?: dump_raw_btf(obj.base_btf, out_path);
		if (err)
			goto out;
	}
	if (obj.inline_btf) {
		err = make_out_path(out_path, sizeof(out_path), obj.path, BTF_ELF_SEC ".inline");
		err = err ?: dump_raw_btf(obj.inline_btf, out_path);
		if (err)
			goto out;
	}

	err = fatal_warnings && warnings ? -1 : 0;
out:
	free_btf_links(&btf_links);
	/*
	 * Free BTFs in reverse dependency order.  inline_btf borrows obj.btf;
	 * obj.btf can borrow a base owned by orig_btf or obj.base_btf, and
	 * orig_btf can also borrow obj.base_btf.
	 */
	btf__free(obj.inline_btf);
	btf__free(obj.btf);
	btf__free(obj.orig_btf);
	btf__free(obj.base_btf);
	btf_id__free_all(&obj.structs);
	btf_id__free_all(&obj.unions);
	btf_id__free_all(&obj.typedefs);
	btf_id__free_all(&obj.funcs);
	btf_id__free_all(&obj.sets);
	free(obj.addr_syms);
	free(obj.efile.func_symbols);
	if (obj.efile.elf) {
		elf_end(obj.efile.elf);
		close(obj.efile.fd);
	}
	return err;
}