Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3d650141 authored by Martin KaFai Lau's avatar Martin KaFai Lau Committed by Alexei Starovoitov
Browse files

bpf: libbpf: Add btf_line_info support to libbpf 



This patch adds bpf_line_info support to libbpf:
1) Parsing the line_info sec from ".BTF.ext"
2) Relocating the line_info.  If the main prog *_info relocation
   fails, it will ignore the remaining subprog line_info and continue.
   If the subprog *_info relocation fails, it will bail out.
3) BPF_PROG_LOAD a prog with line_info

Signed-off-by: default avatarMartin KaFai Lau <kafai@fb.com>
Acked-by: default avatarYonghong Song <yhs@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent f0187f0b

tools/lib/bpf/bpf.c

+57 −29
Original line number Diff line number Diff line
@@ -173,11 +173,36 @@ int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name, 
					  -1);

}



static void *

alloc_zero_tailing_info(const void *orecord, __u32 cnt,

			__u32 actual_rec_size, __u32 expected_rec_size)

{

	__u64 info_len = actual_rec_size * cnt;

	void *info, *nrecord;

	int i;



	info = malloc(info_len);

	if (!info)

		return NULL;



	/* zero out bytes kernel does not understand */

	nrecord = info;

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

		memcpy(nrecord, orecord, expected_rec_size);

		memset(nrecord + expected_rec_size, 0,

		       actual_rec_size - expected_rec_size);

		orecord += actual_rec_size;

		nrecord += actual_rec_size;

	}



	return info;

}



int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,

			   char *log_buf, size_t log_buf_sz)

{

	void *finfo = NULL, *linfo = NULL;

	union bpf_attr attr;

	void *finfo = NULL;

	__u32 name_len;

	int fd;
@@ -201,6 +226,9 @@ int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr, 
	attr.func_info_rec_size = load_attr->func_info_rec_size;

	attr.func_info_cnt = load_attr->func_info_cnt;

	attr.func_info = ptr_to_u64(load_attr->func_info);

	attr.line_info_rec_size = load_attr->line_info_rec_size;

	attr.line_info_cnt = load_attr->line_info_cnt;

	attr.line_info = ptr_to_u64(load_attr->line_info);

	memcpy(attr.prog_name, load_attr->name,

	       min(name_len, BPF_OBJ_NAME_LEN - 1));
@@ -212,35 +240,34 @@ int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr, 
	 * to give user space a hint how to deal with loading failure.

	 * Check to see whether we can make some changes and load again.

	 */

	if (errno == E2BIG && attr.func_info_cnt &&

	while (errno == E2BIG && (!finfo || !linfo)) {

		if (!finfo && attr.func_info_cnt &&

		    attr.func_info_rec_size < load_attr->func_info_rec_size) {

		__u32 actual_rec_size = load_attr->func_info_rec_size;

		__u32 expected_rec_size = attr.func_info_rec_size;

		__u32 finfo_cnt = load_attr->func_info_cnt;

		__u64 finfo_len = actual_rec_size * finfo_cnt;

		const void *orecord;

		void *nrecord;

		int i;



		finfo = malloc(finfo_len);

			/* try with corrected func info records */

			finfo = alloc_zero_tailing_info(load_attr->func_info,

							load_attr->func_info_cnt,

							load_attr->func_info_rec_size,

							attr.func_info_rec_size);

			if (!finfo)

			/* further try with log buffer won't help */

			return fd;



		/* zero out bytes kernel does not understand */

		orecord = load_attr->func_info;

		nrecord = finfo;

		for (i = 0; i < load_attr->func_info_cnt; i++) {

			memcpy(nrecord, orecord, expected_rec_size);

			memset(nrecord + expected_rec_size, 0,

			       actual_rec_size - expected_rec_size);

			orecord += actual_rec_size;

			nrecord += actual_rec_size;

		}

				goto done;



		/* try with corrected func info records */

			attr.func_info = ptr_to_u64(finfo);

			attr.func_info_rec_size = load_attr->func_info_rec_size;

		} else if (!linfo && attr.line_info_cnt &&

			   attr.line_info_rec_size <

			   load_attr->line_info_rec_size) {

			linfo = alloc_zero_tailing_info(load_attr->line_info,

							load_attr->line_info_cnt,

							load_attr->line_info_rec_size,

							attr.line_info_rec_size);

			if (!linfo)

				goto done;



			attr.line_info = ptr_to_u64(linfo);

			attr.line_info_rec_size = load_attr->line_info_rec_size;

		} else {

			break;

		}



		fd = sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
@@ -259,6 +286,7 @@ int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr, 
	fd = sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));

done:

	free(finfo);

	free(linfo);

	return fd;

}

tools/lib/bpf/bpf.h

+3 −0
Original line number Diff line number Diff line
@@ -82,6 +82,9 @@ struct bpf_load_program_attr { 
	__u32 func_info_rec_size;

	const void *func_info;

	__u32 func_info_cnt;

	__u32 line_info_rec_size;

	const void *line_info;

	__u32 line_info_cnt;

};



/* Flags to direct loading requirements */

tools/lib/bpf/btf.c

+150 −59
Original line number Diff line number Diff line
@@ -37,16 +37,26 @@ struct btf { 
	int fd;

};



struct btf_ext_info {

	/*

	 * info points to a deep copy of the individual info section

	 * (e.g. func_info and line_info) from the .BTF.ext.

	 * It does not include the __u32 rec_size.

	 */

	void *info;

	__u32 rec_size;

	__u32 len;

};



struct btf_ext {

	void *func_info;

	__u32 func_info_rec_size;

	__u32 func_info_len;

	struct btf_ext_info func_info;

	struct btf_ext_info line_info;

};



struct btf_sec_func_info {

struct btf_ext_info_sec {

	__u32	sec_name_off;

	__u32	num_func_info;

	/* Followed by num_func_info number of bpf func_info records */

	__u32	num_info;

	/* Followed by num_info * record_size number of bytes */

	__u8	data[0];

};
@@ -56,6 +66,14 @@ struct bpf_func_info_min { 
	__u32   type_id;

};



/* The minimum bpf_line_info checked by the loader */

struct bpf_line_info_min {

	__u32	insn_off;

	__u32	file_name_off;

	__u32	line_off;

	__u32	line_col;

};



static inline __u64 ptr_to_u64(const void *ptr)

{

	return (__u64) (unsigned long) ptr;
@@ -486,12 +504,22 @@ int btf__get_from_id(__u32 id, struct btf **btf) 
	return err;

}



static int btf_ext_copy_func_info(struct btf_ext *btf_ext,

struct btf_ext_sec_copy_param {

	__u32 off;

	__u32 len;

	__u32 min_rec_size;

	struct btf_ext_info *ext_info;

	const char *desc;

};



static int btf_ext_copy_info(struct btf_ext *btf_ext,

			     __u8 *data, __u32 data_size,

			     struct btf_ext_sec_copy_param *ext_sec,

			     btf_print_fn_t err_log)

{

	const struct btf_ext_header *hdr = (struct btf_ext_header *)data;

	const struct btf_sec_func_info *sinfo;

	const struct btf_ext_info_sec *sinfo;

	struct btf_ext_info *ext_info;

	__u32 info_left, record_size;

	/* The start of the info sec (including the __u32 record_size). */

	const void *info;
@@ -500,66 +528,69 @@ static int btf_ext_copy_func_info(struct btf_ext *btf_ext, 
	data = data + hdr->hdr_len;

	data_size -= hdr->hdr_len;



	if (hdr->func_info_off & 0x03) {

		elog("BTF.ext func_info section is not aligned to 4 bytes\n");

	if (ext_sec->off & 0x03) {

		elog(".BTF.ext %s section is not aligned to 4 bytes\n",

		     ext_sec->desc);

		return -EINVAL;

	}



	if (data_size < hdr->func_info_off ||

	    hdr->func_info_len > data_size - hdr->func_info_off) {

		elog("func_info section (off:%u len:%u) is beyond the end of the ELF section .BTF.ext\n",

		     hdr->func_info_off, hdr->func_info_len);

	if (data_size < ext_sec->off ||

	    ext_sec->len > data_size - ext_sec->off) {

		elog("%s section (off:%u len:%u) is beyond the end of the ELF section .BTF.ext\n",

		     ext_sec->desc, ext_sec->off, ext_sec->len);

		return -EINVAL;

	}



	info = data + hdr->func_info_off;

	info_left = hdr->func_info_len;

	info = data + ext_sec->off;

	info_left = ext_sec->len;



	/* At least a func_info record size */

	/* At least a record size */

	if (info_left < sizeof(__u32)) {

		elog("BTF.ext func_info record size not found");

		elog(".BTF.ext %s record size not found\n", ext_sec->desc);

		return -EINVAL;

	}



	/* The record size needs to meet the minimum standard */

	record_size = *(__u32 *)info;

	if (record_size < sizeof(struct bpf_func_info_min) ||

	if (record_size < ext_sec->min_rec_size ||

	    record_size & 0x03) {

		elog("BTF.ext func_info invalid record size");

		elog("%s section in .BTF.ext has invalid record size %u\n",

		     ext_sec->desc, record_size);

		return -EINVAL;

	}



	sinfo = info + sizeof(__u32);

	info_left -= sizeof(__u32);



	/* If no func_info records, return failure now so .BTF.ext

	 * won't be used.

	 */

	/* If no records, return failure now so .BTF.ext won't be used. */

	if (!info_left) {

		elog("BTF.ext no func info records");

		elog("%s section in .BTF.ext has no records", ext_sec->desc);

		return -EINVAL;

	}



	while (info_left) {

		unsigned int sec_hdrlen = sizeof(struct btf_sec_func_info);

		unsigned int sec_hdrlen = sizeof(struct btf_ext_info_sec);

		__u64 total_record_size;

		__u32 num_records;



		if (info_left < sec_hdrlen) {

			elog("BTF.ext func_info header not found");

			elog("%s section header is not found in .BTF.ext\n",

			     ext_sec->desc);

			return -EINVAL;

		}



		num_records = sinfo->num_func_info;

		num_records = sinfo->num_info;

		if (num_records == 0) {

			elog("incorrect BTF.ext num_func_info");

			elog("%s section has incorrect num_records in .BTF.ext\n",

			     ext_sec->desc);

			return -EINVAL;

		}



		total_record_size = sec_hdrlen +

				    (__u64)num_records * record_size;

		if (info_left < total_record_size) {

			elog("incorrect BTF.ext num_func_info");

			elog("%s section has incorrect num_records in .BTF.ext\n",

			     ext_sec->desc);

			return -EINVAL;

		}
@@ -567,17 +598,49 @@ static int btf_ext_copy_func_info(struct btf_ext *btf_ext, 
		sinfo = (void *)sinfo + total_record_size;

	}



	btf_ext->func_info_len = hdr->func_info_len - sizeof(__u32);

	btf_ext->func_info_rec_size = record_size;

	btf_ext->func_info = malloc(btf_ext->func_info_len);

	if (!btf_ext->func_info)

	ext_info = ext_sec->ext_info;

	ext_info->len = ext_sec->len - sizeof(__u32);

	ext_info->rec_size = record_size;

	ext_info->info = malloc(ext_info->len);

	if (!ext_info->info)

		return -ENOMEM;

	memcpy(btf_ext->func_info, info + sizeof(__u32),

	       btf_ext->func_info_len);

	memcpy(ext_info->info, info + sizeof(__u32), ext_info->len);



	return 0;

}



static int btf_ext_copy_func_info(struct btf_ext *btf_ext,

				  __u8 *data, __u32 data_size,

				  btf_print_fn_t err_log)

{

	const struct btf_ext_header *hdr = (struct btf_ext_header *)data;

	struct btf_ext_sec_copy_param param = {

		.off = hdr->func_info_off,

		.len = hdr->func_info_len,

		.min_rec_size = sizeof(struct bpf_func_info_min),

		.ext_info = &btf_ext->func_info,

		.desc = "func_info"

	};



	return btf_ext_copy_info(btf_ext, data, data_size, &param, err_log);

}



static int btf_ext_copy_line_info(struct btf_ext *btf_ext,

				  __u8 *data, __u32 data_size,

				  btf_print_fn_t err_log)

{

	const struct btf_ext_header *hdr = (struct btf_ext_header *)data;

	struct btf_ext_sec_copy_param param = {

		.off = hdr->line_info_off,

		.len = hdr->line_info_len,

		.min_rec_size = sizeof(struct bpf_line_info_min),

		.ext_info = &btf_ext->line_info,

		.desc = "line_info",

	};



	return btf_ext_copy_info(btf_ext, data, data_size, &param, err_log);

}



static int btf_ext_parse_hdr(__u8 *data, __u32 data_size,

			     btf_print_fn_t err_log)

{
@@ -617,7 +680,8 @@ void btf_ext__free(struct btf_ext *btf_ext) 
	if (!btf_ext)

		return;



	free(btf_ext->func_info);

	free(btf_ext->func_info.info);

	free(btf_ext->line_info.info);

	free(btf_ext);

}
@@ -640,25 +704,32 @@ struct btf_ext *btf_ext__new(__u8 *data, __u32 size, btf_print_fn_t err_log) 
		return ERR_PTR(err);

	}



	err = btf_ext_copy_line_info(btf_ext, data, size, err_log);

	if (err) {

		btf_ext__free(btf_ext);

		return ERR_PTR(err);

	}



	return btf_ext;

}



int btf_ext__reloc_func_info(struct btf *btf, struct btf_ext *btf_ext,

static int btf_ext_reloc_info(const struct btf *btf,

			      const struct btf_ext_info *ext_info,

			      const char *sec_name, __u32 insns_cnt,

			     void **func_info, __u32 *cnt)

			      void **info, __u32 *cnt)

{

	__u32 sec_hdrlen = sizeof(struct btf_sec_func_info);

	__u32 i, record_size, existing_flen, records_len;

	struct btf_sec_func_info *sinfo;

	__u32 sec_hdrlen = sizeof(struct btf_ext_info_sec);

	__u32 i, record_size, existing_len, records_len;

	struct btf_ext_info_sec *sinfo;

	const char *info_sec_name;

	__u64 remain_len;

	void *data;



	record_size = btf_ext->func_info_rec_size;

	sinfo = btf_ext->func_info;

	remain_len = btf_ext->func_info_len;

	record_size = ext_info->rec_size;

	sinfo = ext_info->info;

	remain_len = ext_info->len;

	while (remain_len > 0) {

		records_len = sinfo->num_func_info * record_size;

		records_len = sinfo->num_info * record_size;

		info_sec_name = btf__name_by_offset(btf, sinfo->sec_name_off);

		if (strcmp(info_sec_name, sec_name)) {

			remain_len -= sec_hdrlen + records_len;
@@ -666,32 +737,52 @@ int btf_ext__reloc_func_info(struct btf *btf, struct btf_ext *btf_ext, 
			continue;

		}



		existing_flen = (*cnt) * record_size;

		data = realloc(*func_info, existing_flen + records_len);

		existing_len = (*cnt) * record_size;

		data = realloc(*info, existing_len + records_len);

		if (!data)

			return -ENOMEM;



		memcpy(data + existing_flen, sinfo->data, records_len);

		memcpy(data + existing_len, sinfo->data, records_len);

		/* adjust insn_off only, the rest data will be passed

		 * to the kernel.

		 */

		for (i = 0; i < sinfo->num_func_info; i++) {

			struct bpf_func_info_min *record;

		for (i = 0; i < sinfo->num_info; i++) {

			__u32 *insn_off;



			record = data + existing_flen + i * record_size;

			record->insn_off =

				record->insn_off / sizeof(struct bpf_insn) +

			insn_off = data + existing_len + (i * record_size);

			*insn_off = *insn_off / sizeof(struct bpf_insn) +

				insns_cnt;

		}

		*func_info = data;

		*cnt += sinfo->num_func_info;

		*info = data;

		*cnt += sinfo->num_info;

		return 0;

	}



	return -ENOENT;

}



int btf_ext__reloc_func_info(const struct btf *btf, const struct btf_ext *btf_ext,

			     const char *sec_name, __u32 insns_cnt,

			     void **func_info, __u32 *cnt)

{

	return btf_ext_reloc_info(btf, &btf_ext->func_info, sec_name,

				  insns_cnt, func_info, cnt);

}



int btf_ext__reloc_line_info(const struct btf *btf, const struct btf_ext *btf_ext,

			     const char *sec_name, __u32 insns_cnt,

			     void **line_info, __u32 *cnt)

{

	return btf_ext_reloc_info(btf, &btf_ext->line_info, sec_name,

				  insns_cnt, line_info, cnt);

}



__u32 btf_ext__func_info_rec_size(const struct btf_ext *btf_ext)

{

	return btf_ext->func_info_rec_size;

	return btf_ext->func_info.rec_size;

}



__u32 btf_ext__line_info_rec_size(const struct btf_ext *btf_ext)

{

	return btf_ext->line_info.rec_size;

}

tools/lib/bpf/btf.h

+9 −1
Original line number Diff line number Diff line
@@ -51,6 +51,8 @@ struct btf_ext_header { 
	/* All offsets are in bytes relative to the end of this header */

	__u32	func_info_off;

	__u32	func_info_len;

	__u32	line_info_off;

	__u32	line_info_len;

};



typedef int (*btf_print_fn_t)(const char *, ...)
@@ -70,10 +72,16 @@ LIBBPF_API int btf__get_from_id(__u32 id, struct btf **btf); 


struct btf_ext *btf_ext__new(__u8 *data, __u32 size, btf_print_fn_t err_log);

void btf_ext__free(struct btf_ext *btf_ext);

int btf_ext__reloc_func_info(struct btf *btf, struct btf_ext *btf_ext,

int btf_ext__reloc_func_info(const struct btf *btf,

			     const struct btf_ext *btf_ext,

			     const char *sec_name, __u32 insns_cnt,

			     void **func_info, __u32 *func_info_len);

int btf_ext__reloc_line_info(const struct btf *btf,

			     const struct btf_ext *btf_ext,

			     const char *sec_name, __u32 insns_cnt,

			     void **line_info, __u32 *cnt);

__u32 btf_ext__func_info_rec_size(const struct btf_ext *btf_ext);

__u32 btf_ext__line_info_rec_size(const struct btf_ext *btf_ext);



#ifdef __cplusplus

} /* extern "C" */

tools/lib/bpf/libbpf.c

+20 −0
Original line number Diff line number Diff line
@@ -170,6 +170,10 @@ struct bpf_program { 
	__u32 func_info_cnt;



	struct bpf_capabilities *caps;



	void *line_info;

	__u32 line_info_rec_size;

	__u32 line_info_cnt;

};



struct bpf_map {
@@ -1342,6 +1346,19 @@ bpf_program_reloc_btf_ext(struct bpf_program *prog, struct bpf_object *obj, 
		prog->func_info_rec_size = btf_ext__func_info_rec_size(obj->btf_ext);

	}



	if (!insn_offset || prog->line_info) {

		err = btf_ext__reloc_line_info(obj->btf, obj->btf_ext,

					       section_name, insn_offset,

					       &prog->line_info,

					       &prog->line_info_cnt);

		if (err)

			return check_btf_ext_reloc_err(prog, err,

						       prog->line_info,

						       "bpf_line_info");



		prog->line_info_rec_size = btf_ext__line_info_rec_size(obj->btf_ext);

	}



	if (!insn_offset)

		prog->btf_fd = btf__fd(obj->btf);
@@ -1526,6 +1543,9 @@ load_program(struct bpf_program *prog, struct bpf_insn *insns, int insns_cnt, 
	load_attr.func_info = prog->func_info;

	load_attr.func_info_rec_size = prog->func_info_rec_size;

	load_attr.func_info_cnt = prog->func_info_cnt;

	load_attr.line_info = prog->line_info;

	load_attr.line_info_rec_size = prog->line_info_rec_size;

	load_attr.line_info_cnt = prog->line_info_cnt;

	if (!load_attr.insns || !load_attr.insns_cnt)

		return -EINVAL;