libbpf: Implement BTFGen

[kernel-patches-bot]

Pull request for series with
subject: libbpf: Implement BTFGen
version: 7
url: https://patchwork.kernel.org/project/netdevbpf/list/?series=614721

[kernel-patches-bot]

Master branch: 8cbf062
series: https://patchwork.kernel.org/project/netdevbpf/list/?series=614721
version: 7

[kernel-patches-bot]

Master branch: 8cbf062
series: https://patchwork.kernel.org/project/netdevbpf/list/?series=614721
version: 7

[kernel-patches-bot]

Master branch: 477bb4c
series: https://patchwork.kernel.org/project/netdevbpf/list/?series=614721
version: 7

Pull request is NOT updated. Failed to apply https://patchwork.kernel.org/project/netdevbpf/list/?series=614721
error message:

Cmd('git') failed due to: exit code(128)
  cmdline: git am -3
  stdout: 'Applying: libbpf: split bpf_core_apply_relo()
Using index info to reconstruct a base tree...
M	kernel/bpf/btf.c
M	tools/lib/bpf/libbpf.c
M	tools/lib/bpf/relo_core.c
M	tools/lib/bpf/relo_core.h
Falling back to patching base and 3-way merge...
Auto-merging tools/lib/bpf/libbpf.c
No changes -- Patch already applied.
Applying: libbpf: Expose bpf_core_{add,free}_cands() to bpftool
Using index info to reconstruct a base tree...
M	tools/lib/bpf/libbpf.c
M	tools/lib/bpf/libbpf_internal.h
Falling back to patching base and 3-way merge...
No changes -- Patch already applied.
Applying: bpftool: Add gen min_core_btf command
Using index info to reconstruct a base tree...
M	tools/bpf/bpftool/bash-completion/bpftool
M	tools/bpf/bpftool/gen.c
Falling back to patching base and 3-way merge...
Auto-merging tools/bpf/bpftool/gen.c
CONFLICT (content): Merge conflict in tools/bpf/bpftool/gen.c
Patch failed at 0003 bpftool: Add gen min_core_btf command
When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".'
  stderr: 'error: Failed to merge in the changes.
hint: Use 'git am --show-current-patch=diff' to see the failed patch'

conflict:

diff --cc tools/bpf/bpftool/gen.c
index e461059a72ee,8e066c747691..000000000000
--- a/tools/bpf/bpftool/gen.c
+++ b/tools/bpf/bpftool/gen.c
@@@ -1120,558 -1119,10 +1120,565 @@@ static int do_help(int argc, char **arg
  	return 0;
  }
  
++<<<<<<< HEAD
 +static int btf_save_raw(const struct btf *btf, const char *path)
 +{
 +	const void *data;
 +	FILE *f = NULL;
 +	__u32 data_sz;
 +	int err = 0;
 +
 +	data = btf__raw_data(btf, &data_sz);
 +	if (!data)
 +		return -ENOMEM;
 +
 +	f = fopen(path, "wb");
 +	if (!f)
 +		return -errno;
 +
 +	if (fwrite(data, 1, data_sz, f) != data_sz)
 +		err = -errno;
 +
 +	fclose(f);
 +	return err;
 +}
 +
 +struct btfgen_info {
 +	struct btf *src_btf;
 +	struct btf *marked_btf; /* btf structure used to mark used types */
 +};
 +
 +static size_t btfgen_hash_fn(const void *key, void *ctx)
 +{
 +	return (size_t)key;
 +}
 +
 +static bool btfgen_equal_fn(const void *k1, const void *k2, void *ctx)
 +{
 +	return k1 == k2;
 +}
 +
 +static void *u32_as_hash_key(__u32 x)
 +{
 +	return (void *)(uintptr_t)x;
 +}
 +
 +static void btfgen_free_info(struct btfgen_info *info)
 +{
 +	if (!info)
 +		return;
 +
 +	btf__free(info->src_btf);
 +	btf__free(info->marked_btf);
 +
 +	free(info);
 +}
 +
 +static struct btfgen_info *
 +btfgen_new_info(const char *targ_btf_path)
 +{
 +	struct btfgen_info *info;
 +	int err;
 +
 +	info = calloc(1, sizeof(*info));
 +	if (!info)
 +		return NULL;
 +
 +	info->src_btf = btf__parse(targ_btf_path, NULL);
 +	if (!info->src_btf) {
 +		err = -errno;
 +		p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno));
 +		goto err_out;
 +	}
 +
 +	info->marked_btf = btf__parse(targ_btf_path, NULL);
 +	if (!info->marked_btf) {
 +		err = -errno;
 +		p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno));
 +		goto err_out;
 +	}
 +
 +	return info;
 +
 +err_out:
 +	btfgen_free_info(info);
 +	errno = -err;
 +	return NULL;
 +}
 +
 +#define MARKED UINT32_MAX
 +
 +static void btfgen_mark_member(struct btfgen_info *info, int type_id, int idx)
 +{
 +	const struct btf_type *t = btf__type_by_id(info->marked_btf, type_id);
 +	struct btf_member *m = btf_members(t) + idx;
 +
 +	m->name_off = MARKED;
 +}
 +
 +static int
 +btfgen_mark_type(struct btfgen_info *info, unsigned int type_id, bool follow_pointers)
 +{
 +	const struct btf_type *btf_type = btf__type_by_id(info->src_btf, type_id);
 +	struct btf_type *cloned_type;
 +	struct btf_param *param;
 +	struct btf_array *array;
 +	int err, i;
 +
 +	if (type_id == 0)
 +		return 0;
 +
 +	/* mark type on cloned BTF as used */
 +	cloned_type = (struct btf_type *) btf__type_by_id(info->marked_btf, type_id);
 +	cloned_type->name_off = MARKED;
 +
 +	/* recursively mark other types needed by it */
 +	switch (btf_kind(btf_type)) {
 +	case BTF_KIND_UNKN:
 +	case BTF_KIND_INT:
 +	case BTF_KIND_FLOAT:
 +	case BTF_KIND_ENUM:
 +	case BTF_KIND_STRUCT:
 +	case BTF_KIND_UNION:
 +		break;
 +	case BTF_KIND_PTR:
 +		if (follow_pointers) {
 +			err = btfgen_mark_type(info, btf_type->type, follow_pointers);
 +			if (err)
 +				return err;
 +		}
 +		break;
 +	case BTF_KIND_CONST:
 +	case BTF_KIND_VOLATILE:
 +	case BTF_KIND_TYPEDEF:
 +		err = btfgen_mark_type(info, btf_type->type, follow_pointers);
 +		if (err)
 +			return err;
 +		break;
 +	case BTF_KIND_ARRAY:
 +		array = btf_array(btf_type);
 +
 +		/* mark array type */
 +		err = btfgen_mark_type(info, array->type, follow_pointers);
 +		/* mark array's index type */
 +		err = err ? : btfgen_mark_type(info, array->index_type, follow_pointers);
 +		if (err)
 +			return err;
 +		break;
 +	case BTF_KIND_FUNC_PROTO:
 +		/* mark ret type */
 +		err = btfgen_mark_type(info, btf_type->type, follow_pointers);
 +		if (err)
 +			return err;
 +
 +		/* mark parameters types */
 +		param = btf_params(btf_type);
 +		for (i = 0; i < btf_vlen(btf_type); i++) {
 +			err = btfgen_mark_type(info, param->type, follow_pointers);
 +			if (err)
 +				return err;
 +			param++;
 +		}
 +		break;
 +	/* tells if some other type needs to be handled */
 +	default:
 +		p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id);
 +		return -EINVAL;
 +	}
 +
 +	return 0;
 +}
 +
 +static int btfgen_record_field_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
 +{
 +	struct btf *btf = info->src_btf;
 +	const struct btf_type *btf_type;
 +	struct btf_member *btf_member;
 +	struct btf_array *array;
 +	unsigned int type_id = targ_spec->root_type_id;
 +	int idx, err;
 +
 +	/* mark root type */
 +	btf_type = btf__type_by_id(btf, type_id);
 +	err = btfgen_mark_type(info, type_id, false);
 +	if (err)
 +		return err;
 +
 +	/* mark types for complex types (arrays, unions, structures) */
 +	for (int i = 1; i < targ_spec->raw_len; i++) {
 +		/* skip typedefs and mods */
 +		while (btf_is_mod(btf_type) || btf_is_typedef(btf_type)) {
 +			type_id = btf_type->type;
 +			btf_type = btf__type_by_id(btf, type_id);
 +		}
 +
 +		switch (btf_kind(btf_type)) {
 +		case BTF_KIND_STRUCT:
 +		case BTF_KIND_UNION:
 +			idx = targ_spec->raw_spec[i];
 +			btf_member = btf_members(btf_type) + idx;
 +
 +			/* mark member */
 +			btfgen_mark_member(info, type_id, idx);
 +
 +			/* mark member's type */
 +			type_id = btf_member->type;
 +			btf_type = btf__type_by_id(btf, type_id);
 +			err = btfgen_mark_type(info, type_id, false);
 +			if (err)
 +				return err;
 +			break;
 +		case BTF_KIND_ARRAY:
 +			array = btf_array(btf_type);
 +			type_id = array->type;
 +			btf_type = btf__type_by_id(btf, type_id);
 +			break;
 +		default:
 +			p_err("unsupported kind: %s (%d)",
 +			      btf_kind_str(btf_type), btf_type->type);
 +			return -EINVAL;
 +		}
 +	}
 +
 +	return 0;
 +}
 +
 +static int btfgen_record_type_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
 +{
 +	return btfgen_mark_type(info, targ_spec->root_type_id, true);
 +}
 +
 +static int btfgen_record_enumval_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
 +{
 +	return btfgen_mark_type(info, targ_spec->root_type_id, false);
 +}
 +
 +static int btfgen_record_reloc(struct btfgen_info *info, struct bpf_core_spec *res)
 +{
 +	switch (res->relo_kind) {
 +	case BPF_CORE_FIELD_BYTE_OFFSET:
 +	case BPF_CORE_FIELD_BYTE_SIZE:
 +	case BPF_CORE_FIELD_EXISTS:
 +	case BPF_CORE_FIELD_SIGNED:
 +	case BPF_CORE_FIELD_LSHIFT_U64:
 +	case BPF_CORE_FIELD_RSHIFT_U64:
 +		return btfgen_record_field_relo(info, res);
 +	case BPF_CORE_TYPE_ID_LOCAL: /* BPF_CORE_TYPE_ID_LOCAL doesn't require kernel BTF */
 +		return 0;
 +	case BPF_CORE_TYPE_ID_TARGET:
 +	case BPF_CORE_TYPE_EXISTS:
 +	case BPF_CORE_TYPE_SIZE:
 +		return btfgen_record_type_relo(info, res);
 +	case BPF_CORE_ENUMVAL_EXISTS:
 +	case BPF_CORE_ENUMVAL_VALUE:
 +		return btfgen_record_enumval_relo(info, res);
 +	default:
 +		return -EINVAL;
 +	}
 +}
 +
 +static struct bpf_core_cand_list *
 +btfgen_find_cands(const struct btf *local_btf, const struct btf *targ_btf, __u32 local_id)
 +{
 +	const struct btf_type *local_type;
 +	struct bpf_core_cand_list *cands = NULL;
 +	struct bpf_core_cand local_cand = {};
 +	size_t local_essent_len;
 +	const char *local_name;
 +	int err;
 +
 +	local_cand.btf = local_btf;
 +	local_cand.id = local_id;
 +
 +	local_type = btf__type_by_id(local_btf, local_id);
 +	if (!local_type) {
 +		err = -EINVAL;
 +		goto err_out;
 +	}
 +
 +	local_name = btf__name_by_offset(local_btf, local_type->name_off);
 +	if (!local_name) {
 +		err = -EINVAL;
 +		goto err_out;
 +	}
 +	local_essent_len = bpf_core_essential_name_len(local_name);
 +
 +	cands = calloc(1, sizeof(*cands));
 +	if (!cands)
 +		return NULL;
 +
 +	err = bpf_core_add_cands(&local_cand, local_essent_len, targ_btf, "vmlinux", 1, cands);
 +	if (err)
 +		goto err_out;
 +
 +	return cands;
 +
 +err_out:
 +	bpf_core_free_cands(cands);
 +	errno = -err;
 +	return NULL;
 +}
 +
 +/* Record relocation information for a single BPF object */
 +static int btfgen_record_obj(struct btfgen_info *info, const char *obj_path)
 +{
 +	const struct btf_ext_info_sec *sec;
 +	const struct bpf_core_relo *relo;
 +	const struct btf_ext_info *seg;
 +	struct hashmap_entry *entry;
 +	struct hashmap *cand_cache = NULL;
 +	struct btf_ext *btf_ext = NULL;
 +	unsigned int relo_idx;
 +	struct btf *btf = NULL;
 +	size_t i;
 +	int err;
 +
 +	btf = btf__parse(obj_path, &btf_ext);
 +	if (!btf) {
 +		err = -errno;
 +		p_err("failed to parse BPF object '%s': %s", obj_path, strerror(errno));
 +		return err;
 +	}
 +
 +	if (!btf_ext) {
 +		p_err("failed to parse BPF object '%s': section %s not found",
 +		      obj_path, BTF_EXT_ELF_SEC);
 +		err = -EINVAL;
 +		goto out;
 +	}
 +
 +	if (btf_ext->core_relo_info.len == 0) {
 +		err = 0;
 +		goto out;
 +	}
 +
 +	cand_cache = hashmap__new(btfgen_hash_fn, btfgen_equal_fn, NULL);
 +	if (IS_ERR(cand_cache)) {
 +		err = PTR_ERR(cand_cache);
 +		goto out;
 +	}
 +
 +	seg = &btf_ext->core_relo_info;
 +	for_each_btf_ext_sec(seg, sec) {
 +		for_each_btf_ext_rec(seg, sec, relo_idx, relo) {
 +			struct bpf_core_spec specs_scratch[3] = {};
 +			struct bpf_core_relo_res targ_res = {};
 +			struct bpf_core_cand_list *cands = NULL;
 +			const void *type_key = u32_as_hash_key(relo->type_id);
 +			const char *sec_name = btf__name_by_offset(btf, sec->sec_name_off);
 +
 +			if (relo->kind != BPF_CORE_TYPE_ID_LOCAL &&
 +			    !hashmap__find(cand_cache, type_key, (void **)&cands)) {
 +				cands = btfgen_find_cands(btf, info->src_btf, relo->type_id);
 +				if (!cands) {
 +					err = -errno;
 +					goto out;
 +				}
 +
 +				err = hashmap__set(cand_cache, type_key, cands, NULL, NULL);
 +				if (err)
 +					goto out;
 +			}
 +
 +			err = bpf_core_calc_relo_insn(sec_name, relo, relo_idx, btf, cands,
 +						      specs_scratch, &targ_res);
 +			if (err)
 +				goto out;
 +
 +			/* specs_scratch[2] is the target spec */
 +			err = btfgen_record_reloc(info, &specs_scratch[2]);
 +			if (err)
 +				goto out;
 +		}
 +	}
 +
 +out:
 +	btf__free(btf);
 +	btf_ext__free(btf_ext);
 +
 +	if (!IS_ERR_OR_NULL(cand_cache)) {
 +		hashmap__for_each_entry(cand_cache, entry, i) {
 +			bpf_core_free_cands(entry->value);
 +		}
 +		hashmap__free(cand_cache);
 +	}
 +
 +	return err;
 +}
 +
 +static int btfgen_remap_id(__u32 *type_id, void *ctx)
 +{
 +	unsigned int *ids = ctx;
 +
 +	*type_id = ids[*type_id];
 +
 +	return 0;
 +}
 +
 +/* Generate BTF from relocation information previously recorded */
 +static struct btf *btfgen_get_btf(struct btfgen_info *info)
 +{
 +	struct btf *btf_new = NULL;
 +	unsigned int *ids = NULL;
 +	unsigned int i, n = btf__type_cnt(info->marked_btf);
 +	int err = 0;
 +
 +	btf_new = btf__new_empty();
 +	if (!btf_new) {
 +		err = -errno;
 +		goto err_out;
 +	}
 +
 +	ids = calloc(n, sizeof(*ids));
 +	if (!ids) {
 +		err = -errno;
 +		goto err_out;
 +	}
 +
 +	/* first pass: add all marked types to btf_new and add their new ids to the ids map */
 +	for (i = 1; i < n; i++) {
 +		const struct btf_type *cloned_type, *type;
 +		const char *name;
 +		int new_id;
 +
 +		cloned_type = btf__type_by_id(info->marked_btf, i);
 +
 +		if (cloned_type->name_off != MARKED)
 +			continue;
 +
 +		type = btf__type_by_id(info->src_btf, i);
 +
 +		/* add members for struct and union */
 +		if (btf_is_composite(type)) {
 +			struct btf_member *cloned_m, *m;
 +			unsigned short vlen;
 +			int idx_src;
 +
 +			name = btf__str_by_offset(info->src_btf, type->name_off);
 +
 +			if (btf_is_struct(type))
 +				err = btf__add_struct(btf_new, name, type->size);
 +			else
 +				err = btf__add_union(btf_new, name, type->size);
 +
 +			if (err < 0)
 +				goto err_out;
 +			new_id = err;
 +
 +			cloned_m = btf_members(cloned_type);
 +			m = btf_members(type);
 +			vlen = btf_vlen(cloned_type);
 +			for (idx_src = 0; idx_src < vlen; idx_src++, cloned_m++, m++) {
 +				/* add only members that are marked as used */
 +				if (cloned_m->name_off != MARKED)
 +					continue;
 +
 +				name = btf__str_by_offset(info->src_btf, m->name_off);
 +				err = btf__add_field(btf_new, name, m->type,
 +						     btf_member_bit_offset(cloned_type, idx_src),
 +						     btf_member_bitfield_size(cloned_type, idx_src));
 +				if (err < 0)
 +					goto err_out;
 +			}
 +		} else {
 +			err = btf__add_type(btf_new, info->src_btf, type);
 +			if (err < 0)
 +				goto err_out;
 +			new_id = err;
 +		}
 +
 +		/* add ID mapping */
 +		ids[i] = new_id;
 +	}
 +
 +	/* second pass: fix up type ids */
 +	for (i = 1; i < btf__type_cnt(btf_new); i++) {
 +		struct btf_type *btf_type = (struct btf_type *) btf__type_by_id(btf_new, i);
 +
 +		err = btf_type_visit_type_ids(btf_type, btfgen_remap_id, ids);
 +		if (err)
 +			goto err_out;
 +	}
 +
 +	free(ids);
 +	return btf_new;
 +
 +err_out:
 +	btf__free(btf_new);
 +	free(ids);
 +	errno = -err;
 +	return NULL;
 +}
 +
 +/* Create minimized BTF file for a set of BPF objects.
 + *
 + * The BTFGen algorithm is divided in two main parts: (1) collect the
 + * BTF types that are involved in relocations and (2) generate the BTF
 + * object using the collected types.
 + *
 + * In order to collect the types involved in the relocations, we parse
 + * the BTF and BTF.ext sections of the BPF objects and use
 + * bpf_core_calc_relo_insn() to get the target specification, this
 + * indicates how the types and fields are used in a relocation.
 + *
 + * Types are recorded in different ways according to the kind of the
 + * relocation. For field-based relocations only the members that are
 + * actually used are saved in order to reduce the size of the generated
 + * BTF file. For type-based relocations empty struct / unions are
 + * generated and for enum-based relocations the whole type is saved.
 + *
 + * The second part of the algorithm generates the BTF object. It creates
 + * an empty BTF object and fills it with the types recorded in the
 + * previous step. This function takes care of only adding the structure
 + * and union members that were marked as used and it also fixes up the
 + * type IDs on the generated BTF object.
 + */
 +static int minimize_btf(const char *src_btf, const char *dst_btf, const char *objspaths[])
 +{
 +	struct btfgen_info *info;
 +	struct btf *btf_new = NULL;
 +	int err, i;
 +
 +	info = btfgen_new_info(src_btf);
 +	if (!info) {
 +		err = -errno;
 +		p_err("failed to allocate info structure: %s", strerror(errno));
 +		goto out;
 +	}
 +
 +	for (i = 0; objspaths[i] != NULL; i++) {
 +		err = btfgen_record_obj(info, objspaths[i]);
 +		if (err) {
 +			p_err("error recording relocations for %s: %s", objspaths[i],
 +			      strerror(errno));
 +			goto out;
 +		}
 +	}
 +
 +	btf_new = btfgen_get_btf(info);
 +	if (!btf_new) {
 +		err = -errno;
 +		p_err("error generating BTF: %s", strerror(errno));
 +		goto out;
 +	}
 +
 +	err = btf_save_raw(btf_new, dst_btf);
 +	if (err) {
 +		p_err("error saving btf file: %s", strerror(errno));
 +		goto out;
 +	}
 +
 +out:
 +	btf__free(btf_new);
 +	btfgen_free_info(info);
 +
 +	return err;
++=======
+ /* Create minimized BTF file for a set of BPF objects */
+ static int minimize_btf(const char *src_btf, const char *dst_btf, const char *objspaths[])
+ {
+ 	return -EOPNOTSUPP;
++>>>>>>> bpftool: Add gen min_core_btf command
  }
  
  static int do_min_core_btf(int argc, char **argv)

[kernel-patches-bot]

At least one diff in series https://patchwork.kernel.org/project/netdevbpf/list/?series=614721 irrelevant now. Closing PR.