bpf: libbpf: Provide basic API support to specify BPF obj name

This patch extends the libbpf to provide API support to allow specifying BPF object name. In tools/lib/bpf/libbpf, the C symbol of the function and the map is used. Regarding section name, all maps are under the same section named "maps". Hence, section name is not a good choice for map's name. To be consistent with map, bpf_prog also follows and uses its function symbol as the prog's name. This patch adds logic to collect function's symbols in libbpf. There is existing codes to collect the map's symbols and no change is needed. The bpf_load_program_name() and bpf_map_create_name() are added to take the name argument. For the other bpf_map_create_xxx() variants, a name argument is directly added to them. In samples/bpf, bpf_load.c in particular, the symbol is also used as the map's name and the map symbols has already been collected in the existing code. For bpf_prog, bpf_load.c does not collect the function symbol name. We can consider to collect them later if there is a need to continue supporting the bpf_load.c.

Martin KaFai Lau committed 9 years ago

Commit 88cda1c1 parent ad5b1777 files · +157 −47Browse files

Unified · Split

7 files

samples/bpf/bpf_load.c +2 −0
samples/bpf/map_perf_test_user.c +1 −0
tools/include/uapi/linux/bpf.h +10 −0
tools/lib/bpf/bpf.c +44 −13
tools/lib/bpf/bpf.h +16 −7
tools/lib/bpf/libbpf.c +83 −26
tools/testing/selftests/bpf/test_verifier.c +1 −1

samples/bpf/bpf_load.c+2−0

@@ -221,6 +221,7 @@ static int load_maps(struct bpf_map_data *maps, int nr_maps, · 220 unmodified lines
221	221	int inner_map_fd = map_fd[maps[i].def.inner_map_idx];
222	222
223	223	map_fd[i] = bpf_create_map_in_map_node(maps[i].def.type,
	224	+ maps[i].name,
224	225	maps[i].def.key_size,
225	226	inner_map_fd,
226	227	maps[i].def.max_entries,
@@ -228,6 +229,7 @@ static int load_maps(struct bpf_map_data *maps, int nr_maps, · 1 unmodified line
228	229	numa_node);
229	230	} else {
230	231	map_fd[i] = bpf_create_map_node(maps[i].def.type,
	232	+ maps[i].name,
231	233	maps[i].def.key_size,
232	234	maps[i].def.value_size,
233	235	maps[i].def.max_entries,

samples/bpf/map_perf_test_user.c+1−0

@@ -137,6 +137,7 @@ static void do_test_lru(enum test_type test, int cpu) · 136 unmodified lines
137	137
138	138	inner_lru_map_fds[cpu] =
139	139	bpf_create_map_node(BPF_MAP_TYPE_LRU_HASH,
	140	+ test_map_names[INNER_LRU_HASH_PREALLOC],
140	141	sizeof(uint32_t),
141	142	sizeof(long),
142	143	inner_lru_hash_size, 0,

tools/include/uapi/linux/bpf.h+10−0

@@ -175,6 +175,8 @@ enum bpf_attach_type { · 174 unmodified lines
175	175	/* Specify numa node during map creation */
176	176	#define BPF_F_NUMA_NODE (1U << 2)
177	177
	178	+#define BPF_OBJ_NAME_LEN 16U
	179	+
178	180	union bpf_attr {
179	181	struct { /* anonymous struct used by BPF_MAP_CREATE command */
180	182	__u32 map_type; /* one of enum bpf_map_type */
@@ -188,6 +190,7 @@ union bpf_attr { · 7 unmodified lines
188	190	__u32 numa_node; /* numa node (effective only if
189	191	* BPF_F_NUMA_NODE is set).
190	192	*/
	193	+ __u8 map_name[BPF_OBJ_NAME_LEN];
191	194	};
192	195
193	196	struct { /* anonymous struct used by BPF_MAP__ELEM commands /
@@ -210,6 +213,7 @@ union bpf_attr { · 16 unmodified lines
210	213	__aligned_u64 log_buf; /* user supplied buffer */
211	214	__u32 kern_version; /* checked when prog_type=kprobe */
212	215	__u32 prog_flags;
	216	+ __u8 prog_name[BPF_OBJ_NAME_LEN];
213	217	};
214	218
215	219	struct { /* anonymous struct used by BPF_OBJ_* commands */
@@ -812,6 +816,11 @@ struct bpf_prog_info { · 596 unmodified lines
812	816	__u32 xlated_prog_len;
813	817	__aligned_u64 jited_prog_insns;
814	818	__aligned_u64 xlated_prog_insns;
	819	+ __u64 load_time; /* ns since boottime */
	820	+ __u32 created_by_uid;
	821	+ __u32 nr_map_ids;
	822	+ __aligned_u64 map_ids;
	823	+ __u8 name[BPF_OBJ_NAME_LEN];
815	824	} __attribute__((aligned(8)));
816	825
817	826	struct bpf_map_info {
@@ -821,6 +830,7 @@ struct bpf_map_info { · 3 unmodified lines
821	830	__u32 value_size;
822	831	__u32 max_entries;
823	832	__u32 map_flags;
	833	+ __u8 name[BPF_OBJ_NAME_LEN];
824	834	} __attribute__((aligned(8)));
825	835
826	836	/* User bpf_sock_ops struct to access socket values and specify request ops

tools/lib/bpf/bpf.c+44−13

@@ -46,6 +46,8 @@ · 45 unmodified lines
46	46	# endif
47	47	#endif
48	48
	49	+#define min(x, y) ((x) < (y) ? (x) : (y))
	50	+
49	51	static inline __u64 ptr_to_u64(const void *ptr)
50	52	{
51	53	return (__u64) (unsigned long) ptr;
@@ -57,10 +59,11 @@ static inline int sys_bpf(enum bpf_cmd cmd, union bpf_attr *attr, · 5 unmodified lines
57	59	return syscall(__NR_bpf, cmd, attr, size);
58	60	}
59	61
60		−int bpf_create_map_node(enum bpf_map_type map_type, int key_size,
61		− int value_size, int max_entries, __u32 map_flags,
62		− int node)
	62	+int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
	63	+ int key_size, int value_size, int max_entries,
	64	+ __u32 map_flags, int node)
63	65	{
	66	+ __u32 name_len = name ? strlen(name) : 0;
64	67	union bpf_attr attr;
65	68
66	69	memset(&attr, '\0', sizeof(attr));
@@ -70,6 +73,8 @@ int bpf_create_map_node(enum bpf_map_type map_type, int key_size, · 3 unmodified lines
70	73	attr.value_size = value_size;
71	74	attr.max_entries = max_entries;
72	75	attr.map_flags = map_flags;
	76	+ memcpy(attr.map_name, name, min(name_len, BPF_OBJ_NAME_LEN - 1));
	77	+
73	78	if (node >= 0) {
74	79	attr.map_flags \|= BPF_F_NUMA_NODE;
75	80	attr.numa_node = node;
@@ -81,14 +86,23 @@ int bpf_create_map_node(enum bpf_map_type map_type, int key_size, · 5 unmodified lines
81	86	int bpf_create_map(enum bpf_map_type map_type, int key_size,
82	87	int value_size, int max_entries, __u32 map_flags)
83	88	{
84		− return bpf_create_map_node(map_type, key_size, value_size,
	89	+ return bpf_create_map_node(map_type, NULL, key_size, value_size,
85	90	max_entries, map_flags, -1);
86	91	}
87	92
88		−int bpf_create_map_in_map_node(enum bpf_map_type map_type, int key_size,
89		− int inner_map_fd, int max_entries,
	93	+int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
	94	+ int key_size, int value_size, int max_entries,
	95	+ __u32 map_flags)
	96	+{
	97	+ return bpf_create_map_node(map_type, name, key_size, value_size,
	98	+ max_entries, map_flags, -1);
	99	+}
	100	+
	101	+int bpf_create_map_in_map_node(enum bpf_map_type map_type, const char *name,
	102	+ int key_size, int inner_map_fd, int max_entries,
90	103	__u32 map_flags, int node)
91	104	{
	105	+ __u32 name_len = name ? strlen(name) : 0;
92	106	union bpf_attr attr;
93	107
94	108	memset(&attr, '\0', sizeof(attr));
@@ -99,6 +113,8 @@ int bpf_create_map_in_map_node(enum bpf_map_type map_type, int key_size, · 4 unmodified lines
99	113	attr.inner_map_fd = inner_map_fd;
100	114	attr.max_entries = max_entries;
101	115	attr.map_flags = map_flags;
	116	+ memcpy(attr.map_name, name, min(name_len, BPF_OBJ_NAME_LEN - 1));
	117	+
102	118	if (node >= 0) {
103	119	attr.map_flags \|= BPF_F_NUMA_NODE;
104	120	attr.numa_node = node;
@@ -107,19 +123,24 @@ int bpf_create_map_in_map_node(enum bpf_map_type map_type, int key_size, · 2 unmodified lines
107	123	return sys_bpf(BPF_MAP_CREATE, &attr, sizeof(attr));
108	124	}
109	125
110		−int bpf_create_map_in_map(enum bpf_map_type map_type, int key_size,
111		− int inner_map_fd, int max_entries, __u32 map_flags)
	126	+int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name,
	127	+ int key_size, int inner_map_fd, int max_entries,
	128	+ __u32 map_flags)
112	129	{
113		− return bpf_create_map_in_map_node(map_type, key_size, inner_map_fd,
114		− max_entries, map_flags, -1);
	130	+ return bpf_create_map_in_map_node(map_type, name, key_size,
	131	+ inner_map_fd, max_entries, map_flags,
	132	+ -1);
115	133	}
116	134
117		−int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
118		− size_t insns_cnt, const char *license,
119		− __u32 kern_version, char *log_buf, size_t log_buf_sz)
	135	+int bpf_load_program_name(enum bpf_prog_type type, const char *name,
	136	+ const struct bpf_insn *insns,
	137	+ size_t insns_cnt, const char *license,
	138	+ __u32 kern_version, char *log_buf,
	139	+ size_t log_buf_sz)
120	140	{
121	141	int fd;
122	142	union bpf_attr attr;
	143	+ __u32 name_len = name ? strlen(name) : 0;
123	144
124	145	bzero(&attr, sizeof(attr));
125	146	attr.prog_type = type;
@@ -130,6 +151,7 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns, · 4 unmodified lines
130	151	attr.log_size = 0;
131	152	attr.log_level = 0;
132	153	attr.kern_version = kern_version;
	154	+ memcpy(attr.prog_name, name, min(name_len, BPF_OBJ_NAME_LEN - 1));
133	155
134	156	fd = sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
135	157	if (fd >= 0 \|\| !log_buf \|\| !log_buf_sz)
@@ -143,6 +165,15 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns, · 7 unmodified lines
143	165	return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
144	166	}
145	167
	168	+int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
	169	+ size_t insns_cnt, const char *license,
	170	+ __u32 kern_version, char *log_buf,
	171	+ size_t log_buf_sz)
	172	+{
	173	+ return bpf_load_program_name(type, NULL, insns, insns_cnt, license,
	174	+ kern_version, log_buf, log_buf_sz);
	175	+}
	176	+
146	177	int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
147	178	size_t insns_cnt, int strict_alignment,
148	179	const char *license, __u32 kern_version,

tools/lib/bpf/bpf.h+16−7

@@ -24,19 +24,28 @@ · 23 unmodified lines
24	24	#include <linux/bpf.h>
25	25	#include <stddef.h>
26	26
27		−int bpf_create_map_node(enum bpf_map_type map_type, int key_size,
28		− int value_size, int max_entries, __u32 map_flags,
29		− int node);
	27	+int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
	28	+ int key_size, int value_size, int max_entries,
	29	+ __u32 map_flags, int node);
	30	+int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
	31	+ int key_size, int value_size, int max_entries,
	32	+ __u32 map_flags);
30	33	int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
31	34	int max_entries, __u32 map_flags);
32		−int bpf_create_map_in_map_node(enum bpf_map_type map_type, int key_size,
33		− int inner_map_fd, int max_entries,
	35	+int bpf_create_map_in_map_node(enum bpf_map_type map_type, const char *name,
	36	+ int key_size, int inner_map_fd, int max_entries,
34	37	__u32 map_flags, int node);
35		−int bpf_create_map_in_map(enum bpf_map_type map_type, int key_size,
36		− int inner_map_fd, int max_entries, __u32 map_flags);
	38	+int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name,
	39	+ int key_size, int inner_map_fd, int max_entries,
	40	+ __u32 map_flags);
37	41
38	42	/* Recommend log buffer size */
39	43	#define BPF_LOG_BUF_SIZE 65536
	44	+int bpf_load_program_name(enum bpf_prog_type type, const char *name,
	45	+ const struct bpf_insn *insns,
	46	+ size_t insns_cnt, const char *license,
	47	+ __u32 kern_version, char *log_buf,
	48	+ size_t log_buf_sz);
40	49	int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
41	50	size_t insns_cnt, const char *license,
42	51	__u32 kern_version, char *log_buf,

tools/lib/bpf/libbpf.c+83−26

@@ -171,6 +171,7 @@ int libbpf_strerror(int err, char *buf, size_t size) · 170 unmodified lines
171	171	struct bpf_program {
172	172	/* Index in elf obj file, for relocation use. */
173	173	int idx;
	174	+ char *name;
174	175	char *section_name;
175	176	struct bpf_insn *insns;
176	177	size_t insns_cnt;
@@ -283,6 +284,7 @@ static void bpf_program__exit(struct bpf_program *prog) · 106 unmodified lines
283	284	prog->clear_priv = NULL;
284	285
285	286	bpf_program__unload(prog);
	287	+ zfree(&prog->name);
286	288	zfree(&prog->section_name);
287	289	zfree(&prog->insns);
288	290	zfree(&prog->reloc_desc);
@@ -293,26 +295,27 @@ static void bpf_program__exit(struct bpf_program *prog) · 4 unmodified lines
293	295	}
294	296
295	297	static int
296		−bpf_program__init(void data, size_t size, char name, int idx,
297		− struct bpf_program *prog)
	298	+bpf_program__init(void data, size_t size, char section_name, int idx,
	299	+ struct bpf_program *prog)
298	300	{
299	301	if (size < sizeof(struct bpf_insn)) {
300		− pr_warning("corrupted section '%s'\n", name);
	302	+ pr_warning("corrupted section '%s'\n", section_name);
301	303	return -EINVAL;
302	304	}
303	305
304	306	bzero(prog, sizeof(*prog));
305	307
306		− prog->section_name = strdup(name);
	308	+ prog->section_name = strdup(section_name);
307	309	if (!prog->section_name) {
308		− pr_warning("failed to alloc name for prog %s\n",
309		− name);
	310	+ pr_warning("failed to alloc name for prog under section %s\n",
	311	+ section_name);
310	312	goto errout;
311	313	}
312	314
313	315	prog->insns = malloc(size);
314	316	if (!prog->insns) {
315		− pr_warning("failed to alloc insns for %s\n", name);
	317	+ pr_warning("failed to alloc insns for prog under section %s\n",
	318	+ section_name);
316	319	goto errout;
317	320	}
318	321	prog->insns_cnt = size / sizeof(struct bpf_insn);
@@ -331,12 +334,12 @@ errout: · 12 unmodified lines
331	334
332	335	static int
333	336	bpf_object__add_program(struct bpf_object obj, void data, size_t size,
334		− char *name, int idx)
	337	+ char *section_name, int idx)
335	338	{
336	339	struct bpf_program prog, *progs;
337	340	int nr_progs, err;
338	341
339		− err = bpf_program__init(data, size, name, idx, &prog);
	342	+ err = bpf_program__init(data, size, section_name, idx, &prog);
340	343	if (err)
341	344	return err;
342	345
@@ -350,8 +353,8 @@ bpf_object__add_program(struct bpf_object obj, void data, size_t size, · 7 unmodified lines
350	353	* is still valid, so don't need special treat for
351	354	* bpf_close_object().
352	355	*/
353		− pr_warning("failed to alloc a new program '%s'\n",
354		− name);
	356	+ pr_warning("failed to alloc a new program under section '%s'\n",
	357	+ section_name);
355	358	bpf_program__exit(&prog);
356	359	return -ENOMEM;
357	360	}
@@ -364,6 +367,54 @@ bpf_object__add_program(struct bpf_object obj, void data, size_t size, · 6 unmodified lines
364	367	return 0;
365	368	}
366	369
	370	+static int
	371	+bpf_object__init_prog_names(struct bpf_object *obj)
	372	+{
	373	+ Elf_Data *symbols = obj->efile.symbols;
	374	+ struct bpf_program *prog;
	375	+ size_t pi, si;
	376	+
	377	+ for (pi = 0; pi < obj->nr_programs; pi++) {
	378	+ char *name = NULL;
	379	+
	380	+ prog = &obj->programs[pi];
	381	+
	382	+ for (si = 0; si < symbols->d_size / sizeof(GElf_Sym) && !name;
	383	+ si++) {
	384	+ GElf_Sym sym;
	385	+
	386	+ if (!gelf_getsym(symbols, si, &sym))
	387	+ continue;
	388	+ if (sym.st_shndx != prog->idx)
	389	+ continue;
	390	+
	391	+ name = elf_strptr(obj->efile.elf,
	392	+ obj->efile.strtabidx,
	393	+ sym.st_name);
	394	+ if (!name) {
	395	+ pr_warning("failed to get sym name string for prog %s\n",
	396	+ prog->section_name);
	397	+ return -LIBBPF_ERRNO__LIBELF;
	398	+ }
	399	+ }
	400	+
	401	+ if (!name) {
	402	+ pr_warning("failed to find sym for prog %s\n",
	403	+ prog->section_name);
	404	+ return -EINVAL;
	405	+ }
	406	+
	407	+ prog->name = strdup(name);
	408	+ if (!prog->name) {
	409	+ pr_warning("failed to allocate memory for prog sym %s\n",
	410	+ name);
	411	+ return -ENOMEM;
	412	+ }
	413	+ }
	414	+
	415	+ return 0;
	416	+}
	417	+
367	418	static struct bpf_object bpf_object__new(const char path,
368	419	void *obj_buf,
369	420	size_t obj_buf_sz)
@@ -766,8 +817,12 @@ static int bpf_object__elf_collect(struct bpf_object *obj) · 396 unmodified lines
766	817	pr_warning("Corrupted ELF file: index of strtab invalid\n");
767	818	return LIBBPF_ERRNO__FORMAT;
768	819	}
769		− if (obj->efile.maps_shndx >= 0)
	820	+ if (obj->efile.maps_shndx >= 0) {
770	821	err = bpf_object__init_maps(obj);
	822	+ if (err)
	823	+ goto out;
	824	+ }
	825	+ err = bpf_object__init_prog_names(obj);
771	826	out:
772	827	return err;
773	828	}
@@ -870,11 +925,12 @@ bpf_object__create_maps(struct bpf_object *obj) · 96 unmodified lines
870	925	struct bpf_map_def *def = &obj->maps[i].def;
871	926	int *pfd = &obj->maps[i].fd;
872	927
873		− *pfd = bpf_create_map(def->type,
874		− def->key_size,
875		− def->value_size,
876		− def->max_entries,
877		− 0);
	928	+ *pfd = bpf_create_map_name(def->type,
	929	+ obj->maps[i].name,
	930	+ def->key_size,
	931	+ def->value_size,
	932	+ def->max_entries,
	933	+ 0);
878	934	if (*pfd < 0) {
879	935	size_t j;
880	936	int err = *pfd;
@@ -982,7 +1038,7 @@ static int bpf_object__collect_reloc(struct bpf_object *obj) · 101 unmodified lines
982	1038	}
983	1039
984	1040	static int
985		−load_program(enum bpf_prog_type type, struct bpf_insn *insns,
	1041	+load_program(enum bpf_prog_type type, const char name, struct bpf_insn insns,
986	1042	int insns_cnt, char license, u32 kern_version, int pfd)
987	1043	{
988	1044	int ret;
@@ -995,8 +1051,8 @@ load_program(enum bpf_prog_type type, struct bpf_insn *insns, · 6 unmodified lines
995	1051	if (!log_buf)
996	1052	pr_warning("Alloc log buffer for bpf loader error, continue without log\n");
997	1053
998		− ret = bpf_load_program(type, insns, insns_cnt, license,
999		− kern_version, log_buf, BPF_LOG_BUF_SIZE);
	1054	+ ret = bpf_load_program_name(type, name, insns, insns_cnt, license,
	1055	+ kern_version, log_buf, BPF_LOG_BUF_SIZE);
1000	1056
1001	1057	if (ret >= 0) {
1002	1058	*pfd = ret;
@@ -1021,9 +1077,9 @@ load_program(enum bpf_prog_type type, struct bpf_insn *insns, · 18 unmodified lines
1021	1077	if (type != BPF_PROG_TYPE_KPROBE) {
1022	1078	int fd;
1023	1079
1024		− fd = bpf_load_program(BPF_PROG_TYPE_KPROBE, insns,
1025		− insns_cnt, license, kern_version,
1026		− NULL, 0);
	1080	+ fd = bpf_load_program_name(BPF_PROG_TYPE_KPROBE, name,
	1081	+ insns, insns_cnt, license,
	1082	+ kern_version, NULL, 0);
1027	1083	if (fd >= 0) {
1028	1084	close(fd);
1029	1085	ret = -LIBBPF_ERRNO__PROGTYPE;
@@ -1067,8 +1123,8 @@ bpf_program__load(struct bpf_program *prog, · 37 unmodified lines
1067	1123	pr_warning("Program '%s' is inconsistent: nr(%d) != 1\n",
1068	1124	prog->section_name, prog->instances.nr);
1069	1125	}
1070		− err = load_program(prog->type, prog->insns, prog->insns_cnt,
1071		− license, kern_version, &fd);
	1126	+ err = load_program(prog->type, prog->name, prog->insns,
	1127	+ prog->insns_cnt, license, kern_version, &fd);
1072	1128	if (!err)
1073	1129	prog->instances.fds[0] = fd;
1074	1130	goto out;
@@ -1096,7 +1152,8 @@ bpf_program__load(struct bpf_program *prog, · 21 unmodified lines
1096	1152	continue;
1097	1153	}
1098	1154
1099		− err = load_program(prog->type, result.new_insn_ptr,
	1155	+ err = load_program(prog->type, prog->name,
	1156	+ result.new_insn_ptr,
1100	1157	result.new_insn_cnt,
1101	1158	license, kern_version, &fd);
1102	1159

tools/testing/selftests/bpf/test_verifier.c+1−1

@@ -6939,7 +6939,7 @@ static int create_map_in_map(void) · 6938 unmodified lines
6939	6939	return inner_map_fd;
6940	6940	}
6941	6941
6942		− outer_map_fd = bpf_create_map_in_map(BPF_MAP_TYPE_ARRAY_OF_MAPS,
	6942	+ outer_map_fd = bpf_create_map_in_map(BPF_MAP_TYPE_ARRAY_OF_MAPS, NULL,
6943	6943	sizeof(int), inner_map_fd, 1, 0);
6944	6944	if (outer_map_fd < 0)
6945	6945	printf("Failed to create array of maps '%s'!\n",