Commit 8388092b authored by Andrii Nakryiko's avatar Andrii Nakryiko
Browse files

Merge branch 'libbpf: deprecate bpf_program__get_prog_info_linear' 

Dave Marchevsky says:

====================

bpf_program__get_prog_info_linear is a helper which wraps the
bpf_obj_get_info_by_fd BPF syscall with some niceties that put
all dynamic-length bpf_prog_info in one buffer contiguous with struct
bpf_prog_info, and simplify the selection of which dynamic data to grab.

The resultant combined struct, bpf_prog_info_linear, is persisted to
file by 'perf' to enable later annotation of BPF prog data. libbpf
includes some vaddr <-> offset conversion helpers for
struct bpf_prog_info_linear to simplify this.

This functionality is heavily tailored to perf's usecase, so its use as
a general prog info API should be deemphasized in favor of just calling
bpf_obj_get_info_by_fd, which can be more easily fit to purpose. Some
examples from caller migrations in this series:

  * Some callers weren't requesting or using dynamic-sized prog info and
    are well served by a simple get_info_by_fd call (e.g.
    dump_prog_id_as_func_ptr in bpftool)
  * Some callers were requesting all of a specific dynamic info type but
    only using the first record, so can avoid unnecessary malloc by
    only requesting 1 (e.g. profile_target_name in bpftool)
  * bpftool's do_dump saves some malloc/free by growing and reusing its
    dynamic prog_info buf as it loops over progs to grab info and dump.

Perf does need the full functionality of
bpf_program__get_prog_info_linear and its accompanying structs +
helpers, so copy the code to its codebase, migrate all other uses in the
tree, and deprecate the helper in libbpf.

Since the deprecated symbols continue to be included in perf some
renaming was necessary in perf's copy, otherwise functionality is
unchanged.

This work was previously discussed in libbpf's issue tracker [0].

[0]: https://github.com/libbpf/libbpf/issues/313



v2->v3:
  * Remove v2's patch 1 ("libbpf: Migrate internal use of
    bpf_program__get_prog_info_linear"), which was applied [Andrii]
  * Add new patch 1 migrating error checking of libbpf calls to
    new scheme [Andrii, Quentin]
  * In patch 2, fix != -1 error check of libbpf call, improper realloc
    handling, and get rid of confusing macros [Andrii]
  * In patch 4, deprecate starting from 0.6 instead of 0.7 [Andrii]

v1->v2: fix bpftool do_dump changes to clear bpf_prog_info after use and
correctly pass realloc'd ptr back (patch 2)
====================

Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
parents cc0356d6 f5aafbc2

tools/bpf/bpftool/btf_dumper.c

+25 −17
Original line number Diff line number Diff line
@@ -32,14 +32,16 @@ static int dump_prog_id_as_func_ptr(const struct btf_dumper *d, 
				    const struct btf_type *func_proto,

				    __u32 prog_id)

{

	struct bpf_prog_info_linear *prog_info = NULL;

	const struct btf_type *func_type;

	int prog_fd = -1, func_sig_len;

	struct bpf_prog_info info = {};

	__u32 info_len = sizeof(info);

	const char *prog_name = NULL;

	struct bpf_func_info *finfo;

	struct btf *prog_btf = NULL;

	struct bpf_prog_info *info;

	int prog_fd, func_sig_len;

	struct bpf_func_info finfo;

	__u32 finfo_rec_size;

	char prog_str[1024];

	int err;



	/* Get the ptr's func_proto */

	func_sig_len = btf_dump_func(d->btf, prog_str, func_proto, NULL, 0,
@@ -52,25 +54,30 @@ static int dump_prog_id_as_func_ptr(const struct btf_dumper *d, 


	/* Get the bpf_prog's name.  Obtain from func_info. */

	prog_fd = bpf_prog_get_fd_by_id(prog_id);

	if (prog_fd == -1)

	if (prog_fd < 0)

		goto print;



	prog_info = bpf_program__get_prog_info_linear(prog_fd,

						1UL << BPF_PROG_INFO_FUNC_INFO);

	close(prog_fd);

	if (IS_ERR(prog_info)) {

		prog_info = NULL;

	err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);

	if (err)

		goto print;

	}

	info = &prog_info->info;



	if (!info->btf_id || !info->nr_func_info)

	if (!info.btf_id || !info.nr_func_info)

		goto print;



	finfo_rec_size = info.func_info_rec_size;

	memset(&info, 0, sizeof(info));

	info.nr_func_info = 1;

	info.func_info_rec_size = finfo_rec_size;

	info.func_info = ptr_to_u64(&finfo);



	err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);

	if (err)

		goto print;

	prog_btf = btf__load_from_kernel_by_id(info->btf_id);



	prog_btf = btf__load_from_kernel_by_id(info.btf_id);

	if (libbpf_get_error(prog_btf))

		goto print;

	finfo = u64_to_ptr(info->func_info);

	func_type = btf__type_by_id(prog_btf, finfo->type_id);

	func_type = btf__type_by_id(prog_btf, finfo.type_id);

	if (!func_type || !btf_is_func(func_type))

		goto print;
@@ -92,7 +99,8 @@ static int dump_prog_id_as_func_ptr(const struct btf_dumper *d, 
	prog_str[sizeof(prog_str) - 1] = '\0';

	jsonw_string(d->jw, prog_str);

	btf__free(prog_btf);

	free(prog_info);

	if (prog_fd >= 0)

		close(prog_fd);

	return 0;

}

tools/bpf/bpftool/prog.c

+125 −34
Original line number Diff line number Diff line
@@ -100,6 +100,76 @@ static enum bpf_attach_type parse_attach_type(const char *str) 
	return __MAX_BPF_ATTACH_TYPE;

}



static int prep_prog_info(struct bpf_prog_info *const info, enum dump_mode mode,

			  void **info_data, size_t *const info_data_sz)

{

	struct bpf_prog_info holder = {};

	size_t needed = 0;

	void *ptr;



	if (mode == DUMP_JITED) {

		holder.jited_prog_len = info->jited_prog_len;

		needed += info->jited_prog_len;

	} else {

		holder.xlated_prog_len = info->xlated_prog_len;

		needed += info->xlated_prog_len;

	}



	holder.nr_jited_ksyms = info->nr_jited_ksyms;

	needed += info->nr_jited_ksyms * sizeof(__u64);



	holder.nr_jited_func_lens = info->nr_jited_func_lens;

	needed += info->nr_jited_func_lens * sizeof(__u32);



	holder.nr_func_info = info->nr_func_info;

	holder.func_info_rec_size = info->func_info_rec_size;

	needed += info->nr_func_info * info->func_info_rec_size;



	holder.nr_line_info = info->nr_line_info;

	holder.line_info_rec_size = info->line_info_rec_size;

	needed += info->nr_line_info * info->line_info_rec_size;



	holder.nr_jited_line_info = info->nr_jited_line_info;

	holder.jited_line_info_rec_size = info->jited_line_info_rec_size;

	needed += info->nr_jited_line_info * info->jited_line_info_rec_size;



	if (needed > *info_data_sz) {

		ptr = realloc(*info_data, needed);

		if (!ptr)

			return -1;



		*info_data = ptr;

		*info_data_sz = needed;

	}

	ptr = *info_data;



	if (mode == DUMP_JITED) {

		holder.jited_prog_insns = ptr_to_u64(ptr);

		ptr += holder.jited_prog_len;

	} else {

		holder.xlated_prog_insns = ptr_to_u64(ptr);

		ptr += holder.xlated_prog_len;

	}



	holder.jited_ksyms = ptr_to_u64(ptr);

	ptr += holder.nr_jited_ksyms * sizeof(__u64);



	holder.jited_func_lens = ptr_to_u64(ptr);

	ptr += holder.nr_jited_func_lens * sizeof(__u32);



	holder.func_info = ptr_to_u64(ptr);

	ptr += holder.nr_func_info * holder.func_info_rec_size;



	holder.line_info = ptr_to_u64(ptr);

	ptr += holder.nr_line_info * holder.line_info_rec_size;



	holder.jited_line_info = ptr_to_u64(ptr);

	ptr += holder.nr_jited_line_info * holder.jited_line_info_rec_size;



	*info = holder;

	return 0;

}



static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)

{

	struct timespec real_time_ts, boot_time_ts;
@@ -803,16 +873,18 @@ prog_dump(struct bpf_prog_info *info, enum dump_mode mode, 


static int do_dump(int argc, char **argv)

{

	struct bpf_prog_info_linear *info_linear;

	struct bpf_prog_info info;

	__u32 info_len = sizeof(info);

	size_t info_data_sz = 0;

	void *info_data = NULL;

	char *filepath = NULL;

	bool opcodes = false;

	bool visual = false;

	enum dump_mode mode;

	bool linum = false;

	int *fds = NULL;

	int nb_fds, i = 0;

	int *fds = NULL;

	int err = -1;

	__u64 arrays;



	if (is_prefix(*argv, "jited")) {

		if (disasm_init())
@@ -872,43 +944,44 @@ static int do_dump(int argc, char **argv) 
		goto exit_close;

	}



	if (mode == DUMP_JITED)

		arrays = 1UL << BPF_PROG_INFO_JITED_INSNS;

	else

		arrays = 1UL << BPF_PROG_INFO_XLATED_INSNS;



	arrays |= 1UL << BPF_PROG_INFO_JITED_KSYMS;

	arrays |= 1UL << BPF_PROG_INFO_JITED_FUNC_LENS;

	arrays |= 1UL << BPF_PROG_INFO_FUNC_INFO;

	arrays |= 1UL << BPF_PROG_INFO_LINE_INFO;

	arrays |= 1UL << BPF_PROG_INFO_JITED_LINE_INFO;



	if (json_output && nb_fds > 1)

		jsonw_start_array(json_wtr);	/* root array */

	for (i = 0; i < nb_fds; i++) {

		info_linear = bpf_program__get_prog_info_linear(fds[i], arrays);

		if (IS_ERR_OR_NULL(info_linear)) {

		memset(&info, 0, sizeof(info));



		err = bpf_obj_get_info_by_fd(fds[i], &info, &info_len);

		if (err) {

			p_err("can't get prog info: %s", strerror(errno));

			break;

		}



		err = prep_prog_info(&info, mode, &info_data, &info_data_sz);

		if (err) {

			p_err("can't grow prog info_data");

			break;

		}



		err = bpf_obj_get_info_by_fd(fds[i], &info, &info_len);

		if (err) {

			p_err("can't get prog info: %s", strerror(errno));

			break;

		}



		if (json_output && nb_fds > 1) {

			jsonw_start_object(json_wtr);	/* prog object */

			print_prog_header_json(&info_linear->info);

			print_prog_header_json(&info);

			jsonw_name(json_wtr, "insns");

		} else if (nb_fds > 1) {

			print_prog_header_plain(&info_linear->info);

			print_prog_header_plain(&info);

		}



		err = prog_dump(&info_linear->info, mode, filepath, opcodes,

				visual, linum);

		err = prog_dump(&info, mode, filepath, opcodes, visual, linum);



		if (json_output && nb_fds > 1)

			jsonw_end_object(json_wtr);	/* prog object */

		else if (i != nb_fds - 1 && nb_fds > 1)

			printf("\n");



		free(info_linear);

		if (err)

			break;

		close(fds[i]);
@@ -920,6 +993,7 @@ static int do_dump(int argc, char **argv) 
	for (; i < nb_fds; i++)

		close(fds[i]);

exit_free:

	free(info_data);

	free(fds);

	return err;

}
@@ -2016,41 +2090,58 @@ static void profile_print_readings(void) 


static char *profile_target_name(int tgt_fd)

{

	struct bpf_prog_info_linear *info_linear;

	struct bpf_func_info *func_info;

	struct bpf_func_info func_info;

	struct bpf_prog_info info = {};

	__u32 info_len = sizeof(info);

	const struct btf_type *t;

	__u32 func_info_rec_size;

	struct btf *btf = NULL;

	char *name = NULL;

	int err;



	info_linear = bpf_program__get_prog_info_linear(

		tgt_fd, 1UL << BPF_PROG_INFO_FUNC_INFO);

	if (IS_ERR_OR_NULL(info_linear)) {

		p_err("failed to get info_linear for prog FD %d", tgt_fd);

		return NULL;

	err = bpf_obj_get_info_by_fd(tgt_fd, &info, &info_len);

	if (err) {

		p_err("failed to bpf_obj_get_info_by_fd for prog FD %d", tgt_fd);

		goto out;

	}



	if (info_linear->info.btf_id == 0) {

	if (info.btf_id == 0) {

		p_err("prog FD %d doesn't have valid btf", tgt_fd);

		goto out;

	}



	btf = btf__load_from_kernel_by_id(info_linear->info.btf_id);

	func_info_rec_size = info.func_info_rec_size;

	if (info.nr_func_info == 0) {

		p_err("bpf_obj_get_info_by_fd for prog FD %d found 0 func_info", tgt_fd);

		goto out;

	}



	memset(&info, 0, sizeof(info));

	info.nr_func_info = 1;

	info.func_info_rec_size = func_info_rec_size;

	info.func_info = ptr_to_u64(&func_info);



	err = bpf_obj_get_info_by_fd(tgt_fd, &info, &info_len);

	if (err) {

		p_err("failed to get func_info for prog FD %d", tgt_fd);

		goto out;

	}



	btf = btf__load_from_kernel_by_id(info.btf_id);

	if (libbpf_get_error(btf)) {

		p_err("failed to load btf for prog FD %d", tgt_fd);

		goto out;

	}



	func_info = u64_to_ptr(info_linear->info.func_info);

	t = btf__type_by_id(btf, func_info[0].type_id);

	t = btf__type_by_id(btf, func_info.type_id);

	if (!t) {

		p_err("btf %d doesn't have type %d",

		      info_linear->info.btf_id, func_info[0].type_id);

		      info.btf_id, func_info.type_id);

		goto out;

	}

	name = strdup(btf__name_by_offset(btf, t->name_off));

out:

	btf__free(btf);

	free(info_linear);

	return name;

}

tools/bpf/bpftool/struct_ops.c

+1 −1
Original line number Diff line number Diff line
@@ -252,7 +252,7 @@ static struct res do_one_id(const char *id_str, work_func func, void *data, 
	}



	fd = bpf_map_get_fd_by_id(id);

	if (fd == -1) {

	if (fd < 0) {

		p_err("can't get map by id (%lu): %s", id, strerror(errno));

		res.nr_errs++;

		return res;

tools/lib/bpf/libbpf.h

+3 −0
Original line number Diff line number Diff line
@@ -918,12 +918,15 @@ struct bpf_prog_info_linear { 
	__u8			data[];

};



LIBBPF_DEPRECATED_SINCE(0, 6, "use a custom linear prog_info wrapper")

LIBBPF_API struct bpf_prog_info_linear *

bpf_program__get_prog_info_linear(int fd, __u64 arrays);



LIBBPF_DEPRECATED_SINCE(0, 6, "use a custom linear prog_info wrapper")

LIBBPF_API void

bpf_program__bpil_addr_to_offs(struct bpf_prog_info_linear *info_linear);



LIBBPF_DEPRECATED_SINCE(0, 6, "use a custom linear prog_info wrapper")

LIBBPF_API void

bpf_program__bpil_offs_to_addr(struct bpf_prog_info_linear *info_linear);

tools/perf/Documentation/perf.data-file-format.txt

+1 −1
Original line number Diff line number Diff line
@@ -346,7 +346,7 @@ to special needs. 


        HEADER_BPF_PROG_INFO = 25,



struct bpf_prog_info_linear, which contains detailed information about

struct perf_bpil, which contains detailed information about

a BPF program, including type, id, tag, jited/xlated instructions, etc.



        HEADER_BPF_BTF = 26,