Commit b84fbfe2 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'libbpf-api' 



Andrii Nakryiko says:

====================
Add bpf_object__open_file() and bpf_object__open_mem() APIs that use a new
approach to providing future-proof non-ABI-breaking API changes. It relies on
APIs accepting optional self-describing "opts" struct, containing its own
size, filled out and provided by potentially outdated (as well as
newer-than-libbpf) user application. A set of internal helper macros
(OPTS_VALID, OPTS_HAS, and OPTS_GET) streamline and simplify a graceful
handling forward and backward compatibility for user applications dynamically
linked against different versions of libbpf shared library.

Users of libbpf are provided with convenience macro LIBBPF_OPTS that takes
care of populating correct structure size and zero-initializes options struct,
which helps avoid obscure issues of unitialized padding. Uninitialized padding
in a struct might turn into garbage-populated new fields understood by future
versions of libbpf.

Patch #1 removes enforcement of kern_version in libbpf and always populates
correct one on behalf of users.
Patch #2 defines necessary infrastructure for options and two new open APIs
relying on it.
Patch #3 fixes bug in bpf_object__name().
Patch #4 switches two of test_progs' tests to use new APIs as a validation
that they work as expected.

v2->v3:
- fix LIBBPF_OPTS() to ensure zero-initialization of padded bytes;
- pass through name override and relaxed maps flag for open_file() (Toke);
- fix bpf_object__name() to actually return object name;
- don't bother parsing and verifying version section (John);

v1->v2:
- use better approach for tracking last field in opts struct;
- convert few tests to new APIs for validation;
- fix bug with using offsetof(last_field) instead of offsetofend(last_field).
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents a53ba15d 928ca75e

tools/lib/bpf/libbpf.c

+89 −94
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ 
#include <linux/limits.h>

#include <linux/perf_event.h>

#include <linux/ring_buffer.h>

#include <linux/version.h>

#include <sys/epoll.h>

#include <sys/ioctl.h>

#include <sys/mman.h>
@@ -255,7 +256,7 @@ struct bpf_object { 
	 */

	struct {

		int fd;

		void *obj_buf;

		const void *obj_buf;

		size_t obj_buf_sz;

		Elf *elf;

		GElf_Ehdr ehdr;
@@ -491,9 +492,21 @@ bpf_object__init_prog_names(struct bpf_object *obj) 
	return 0;

}



static __u32 get_kernel_version(void)

{

	__u32 major, minor, patch;

	struct utsname info;



	uname(&info);

	if (sscanf(info.release, "%u.%u.%u", &major, &minor, &patch) != 3)

		return 0;

	return KERNEL_VERSION(major, minor, patch);

}



static struct bpf_object *bpf_object__new(const char *path,

					  void *obj_buf,

					  size_t obj_buf_sz)

					  const void *obj_buf,

					  size_t obj_buf_sz,

					  const char *obj_name)

{

	struct bpf_object *obj;

	char *end;
@@ -505,11 +518,17 @@ static struct bpf_object *bpf_object__new(const char *path, 
	}



	strcpy(obj->path, path);

	if (obj_name) {

		strncpy(obj->name, obj_name, sizeof(obj->name) - 1);

		obj->name[sizeof(obj->name) - 1] = 0;

	} else {

		/* Using basename() GNU version which doesn't modify arg. */

	strncpy(obj->name, basename((void *)path), sizeof(obj->name) - 1);

		strncpy(obj->name, basename((void *)path),

			sizeof(obj->name) - 1);

		end = strchr(obj->name, '.');

		if (end)

			*end = 0;

	}



	obj->efile.fd = -1;

	/*
@@ -526,6 +545,7 @@ static struct bpf_object *bpf_object__new(const char *path, 
	obj->efile.rodata_shndx = -1;

	obj->efile.bss_shndx = -1;



	obj->kern_version = get_kernel_version();

	obj->loaded = false;



	INIT_LIST_HEAD(&obj->list);
@@ -569,7 +589,7 @@ static int bpf_object__elf_init(struct bpf_object *obj) 
		 * obj_buf should have been validated by

		 * bpf_object__open_buffer().

		 */

		obj->efile.elf = elf_memory(obj->efile.obj_buf,

		obj->efile.elf = elf_memory((char *)obj->efile.obj_buf,

					    obj->efile.obj_buf_sz);

	} else {

		obj->efile.fd = open(obj->path, O_RDONLY);
@@ -636,21 +656,6 @@ bpf_object__init_license(struct bpf_object *obj, void *data, size_t size) 
	return 0;

}



static int

bpf_object__init_kversion(struct bpf_object *obj, void *data, size_t size)

{

	__u32 kver;



	if (size != sizeof(kver)) {

		pr_warning("invalid kver section in %s\n", obj->path);

		return -LIBBPF_ERRNO__FORMAT;

	}

	memcpy(&kver, data, sizeof(kver));

	obj->kern_version = kver;

	pr_debug("kernel version of %s is %x\n", obj->path, obj->kern_version);

	return 0;

}



static int compare_bpf_map(const void *_a, const void *_b)

{

	const struct bpf_map *a = _a;
@@ -1568,11 +1573,7 @@ static int bpf_object__elf_collect(struct bpf_object *obj, int flags) 
			if (err)

				return err;

		} else if (strcmp(name, "version") == 0) {

			err = bpf_object__init_kversion(obj,

							data->d_buf,

							data->d_size);

			if (err)

				return err;

			/* skip, we don't need it anymore */

		} else if (strcmp(name, "maps") == 0) {

			obj->efile.maps_shndx = idx;

		} else if (strcmp(name, MAPS_ELF_SEC) == 0) {
@@ -3551,54 +3552,9 @@ bpf_object__load_progs(struct bpf_object *obj, int log_level) 
	return 0;

}



static bool bpf_prog_type__needs_kver(enum bpf_prog_type type)

{

	switch (type) {

	case BPF_PROG_TYPE_SOCKET_FILTER:

	case BPF_PROG_TYPE_SCHED_CLS:

	case BPF_PROG_TYPE_SCHED_ACT:

	case BPF_PROG_TYPE_XDP:

	case BPF_PROG_TYPE_CGROUP_SKB:

	case BPF_PROG_TYPE_CGROUP_SOCK:

	case BPF_PROG_TYPE_LWT_IN:

	case BPF_PROG_TYPE_LWT_OUT:

	case BPF_PROG_TYPE_LWT_XMIT:

	case BPF_PROG_TYPE_LWT_SEG6LOCAL:

	case BPF_PROG_TYPE_SOCK_OPS:

	case BPF_PROG_TYPE_SK_SKB:

	case BPF_PROG_TYPE_CGROUP_DEVICE:

	case BPF_PROG_TYPE_SK_MSG:

	case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:

	case BPF_PROG_TYPE_LIRC_MODE2:

	case BPF_PROG_TYPE_SK_REUSEPORT:

	case BPF_PROG_TYPE_FLOW_DISSECTOR:

	case BPF_PROG_TYPE_UNSPEC:

	case BPF_PROG_TYPE_TRACEPOINT:

	case BPF_PROG_TYPE_RAW_TRACEPOINT:

	case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE:

	case BPF_PROG_TYPE_PERF_EVENT:

	case BPF_PROG_TYPE_CGROUP_SYSCTL:

	case BPF_PROG_TYPE_CGROUP_SOCKOPT:

		return false;

	case BPF_PROG_TYPE_KPROBE:

	default:

		return true;

	}

}



static int bpf_object__validate(struct bpf_object *obj, bool needs_kver)

{

	if (needs_kver && obj->kern_version == 0) {

		pr_warning("%s doesn't provide kernel version\n",

			   obj->path);

		return -LIBBPF_ERRNO__KVERSION;

	}

	return 0;

}



static struct bpf_object *

__bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz,

		   bool needs_kver, int flags)

__bpf_object__open(const char *path, const void *obj_buf, size_t obj_buf_sz,

		   const char *obj_name, int flags)

{

	struct bpf_object *obj;

	int err;
@@ -3608,7 +3564,7 @@ __bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz, 
		return ERR_PTR(-LIBBPF_ERRNO__LIBELF);

	}



	obj = bpf_object__new(path, obj_buf, obj_buf_sz);

	obj = bpf_object__new(path, obj_buf, obj_buf_sz, obj_name);

	if (IS_ERR(obj))

		return obj;
@@ -3617,7 +3573,6 @@ __bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz, 
	CHECK_ERR(bpf_object__probe_caps(obj), err, out);

	CHECK_ERR(bpf_object__elf_collect(obj, flags), err, out);

	CHECK_ERR(bpf_object__collect_reloc(obj), err, out);

	CHECK_ERR(bpf_object__validate(obj, needs_kver), err, out);



	bpf_object__elf_finish(obj);

	return obj;
@@ -3626,8 +3581,8 @@ out: 
	return ERR_PTR(err);

}



struct bpf_object *__bpf_object__open_xattr(struct bpf_object_open_attr *attr,

					    int flags)

static struct bpf_object *

__bpf_object__open_xattr(struct bpf_object_open_attr *attr, int flags)

{

	/* param validation */

	if (!attr->file)
@@ -3635,9 +3590,7 @@ struct bpf_object *__bpf_object__open_xattr(struct bpf_object_open_attr *attr, 


	pr_debug("loading %s\n", attr->file);



	return __bpf_object__open(attr->file, NULL, 0,

				  bpf_prog_type__needs_kver(attr->prog_type),

				  flags);

	return __bpf_object__open(attr->file, NULL, 0, NULL, flags);

}



struct bpf_object *bpf_object__open_xattr(struct bpf_object_open_attr *attr)
@@ -3655,25 +3608,67 @@ struct bpf_object *bpf_object__open(const char *path) 
	return bpf_object__open_xattr(&attr);

}



struct bpf_object *bpf_object__open_buffer(void *obj_buf,

					   size_t obj_buf_sz,

					   const char *name)

struct bpf_object *

bpf_object__open_file(const char *path, struct bpf_object_open_opts *opts)

{

	const char *obj_name;

	bool relaxed_maps;



	if (!OPTS_VALID(opts, bpf_object_open_opts))

		return ERR_PTR(-EINVAL);

	if (!path)

		return ERR_PTR(-EINVAL);



	pr_debug("loading %s\n", path);



	obj_name = OPTS_GET(opts, object_name, path);

	relaxed_maps = OPTS_GET(opts, relaxed_maps, false);

	return __bpf_object__open(path, NULL, 0, obj_name,

				  relaxed_maps ? MAPS_RELAX_COMPAT : 0);

}



struct bpf_object *

bpf_object__open_mem(const void *obj_buf, size_t obj_buf_sz,

		     struct bpf_object_open_opts *opts)

{

	char tmp_name[64];

	const char *obj_name;

	bool relaxed_maps;



	/* param validation */

	if (!obj_buf || obj_buf_sz <= 0)

		return NULL;

	if (!OPTS_VALID(opts, bpf_object_open_opts))

		return ERR_PTR(-EINVAL);

	if (!obj_buf || obj_buf_sz == 0)

		return ERR_PTR(-EINVAL);



	if (!name) {

	obj_name = OPTS_GET(opts, object_name, NULL);

	if (!obj_name) {

		snprintf(tmp_name, sizeof(tmp_name), "%lx-%lx",

			 (unsigned long)obj_buf,

			 (unsigned long)obj_buf_sz);

		name = tmp_name;

		obj_name = tmp_name;

	}

	pr_debug("loading object '%s' from buffer\n", obj_name);



	relaxed_maps = OPTS_GET(opts, relaxed_maps, false);

	return __bpf_object__open(obj_name, obj_buf, obj_buf_sz, obj_name,

				  relaxed_maps ? MAPS_RELAX_COMPAT : 0);

}

	pr_debug("loading object '%s' from buffer\n", name);



	return __bpf_object__open(name, obj_buf, obj_buf_sz, true, true);

struct bpf_object *

bpf_object__open_buffer(const void *obj_buf, size_t obj_buf_sz,

			const char *name)

{

	LIBBPF_OPTS(bpf_object_open_opts, opts,

		.object_name = name,

		/* wrong default, but backwards-compatible */

		.relaxed_maps = true,

	);



	/* returning NULL is wrong, but backwards-compatible */

	if (!obj_buf || obj_buf_sz == 0)

		return NULL;



	return bpf_object__open_mem(obj_buf, obj_buf_sz, &opts);

}



int bpf_object__unload(struct bpf_object *obj)
@@ -4236,7 +4231,7 @@ bpf_object__next(struct bpf_object *prev) 


const char *bpf_object__name(const struct bpf_object *obj)

{

	return obj ? obj->path : ERR_PTR(-EINVAL);

	return obj ? obj->name : ERR_PTR(-EINVAL);

}



unsigned int bpf_object__kversion(const struct bpf_object *obj)

tools/lib/bpf/libbpf.h

+43 −5
Original line number Diff line number Diff line
@@ -67,14 +67,52 @@ struct bpf_object_open_attr { 
	enum bpf_prog_type prog_type;

};



/* Helper macro to declare and initialize libbpf options struct

 *

 * This dance with uninitialized declaration, followed by memset to zero,

 * followed by assignment using compound literal syntax is done to preserve

 * ability to use a nice struct field initialization syntax and **hopefully**

 * have all the padding bytes initialized to zero. It's not guaranteed though,

 * when copying literal, that compiler won't copy garbage in literal's padding

 * bytes, but that's the best way I've found and it seems to work in practice.

 */

#define LIBBPF_OPTS(TYPE, NAME, ...)					    \

	struct TYPE NAME;						    \

	memset(&NAME, 0, sizeof(struct TYPE));				    \

	NAME = (struct TYPE) {						    \

		.sz = sizeof(struct TYPE),				    \

		__VA_ARGS__						    \

	}



struct bpf_object_open_opts {

	/* size of this struct, for forward/backward compatiblity */

	size_t sz;

	/* object name override, if provided:

	 * - for object open from file, this will override setting object

	 *   name from file path's base name;

	 * - for object open from memory buffer, this will specify an object

	 *   name and will override default "<addr>-<buf-size>" name;

	 */

	const char *object_name;

	/* parse map definitions non-strictly, allowing extra attributes/data */

	bool relaxed_maps;

};

#define bpf_object_open_opts__last_field relaxed_maps



LIBBPF_API struct bpf_object *bpf_object__open(const char *path);

LIBBPF_API struct bpf_object *

bpf_object__open_xattr(struct bpf_object_open_attr *attr);

struct bpf_object *__bpf_object__open_xattr(struct bpf_object_open_attr *attr,

					    int flags);

LIBBPF_API struct bpf_object *bpf_object__open_buffer(void *obj_buf,

						      size_t obj_buf_sz,

bpf_object__open_file(const char *path, struct bpf_object_open_opts *opts);

LIBBPF_API struct bpf_object *

bpf_object__open_mem(const void *obj_buf, size_t obj_buf_sz,

		     struct bpf_object_open_opts *opts);



/* deprecated bpf_object__open variants */

LIBBPF_API struct bpf_object *

bpf_object__open_buffer(const void *obj_buf, size_t obj_buf_sz,

			const char *name);

LIBBPF_API struct bpf_object *

bpf_object__open_xattr(struct bpf_object_open_attr *attr);



int bpf_object__section_size(const struct bpf_object *obj, const char *name,

			     __u32 *size);

int bpf_object__variable_offset(const struct bpf_object *obj, const char *name,

tools/lib/bpf/libbpf.map

+3 −0
Original line number Diff line number Diff line
@@ -192,4 +192,7 @@ LIBBPF_0.0.5 { 
} LIBBPF_0.0.4;



LIBBPF_0.0.6 {

	global:

		bpf_object__open_file;

		bpf_object__open_mem;

} LIBBPF_0.0.5;

tools/lib/bpf/libbpf_internal.h

+32 −0
Original line number Diff line number Diff line
@@ -47,6 +47,38 @@ do { \ 
#define pr_info(fmt, ...)	__pr(LIBBPF_INFO, fmt, ##__VA_ARGS__)

#define pr_debug(fmt, ...)	__pr(LIBBPF_DEBUG, fmt, ##__VA_ARGS__)



static inline bool libbpf_validate_opts(const char *opts,

					size_t opts_sz, size_t user_sz,

					const char *type_name)

{

	if (user_sz < sizeof(size_t)) {

		pr_warning("%s size (%zu) is too small\n", type_name, user_sz);

		return false;

	}

	if (user_sz > opts_sz) {

		size_t i;



		for (i = opts_sz; i < user_sz; i++) {

			if (opts[i]) {

				pr_warning("%s has non-zero extra bytes",

					   type_name);

				return false;

			}

		}

	}

	return true;

}



#define OPTS_VALID(opts, type)						      \

	(!(opts) || libbpf_validate_opts((const char *)opts,		      \

					 offsetofend(struct type,	      \

						     type##__last_field),     \

					 (opts)->sz, #type))

#define OPTS_HAS(opts, field) \

	((opts) && opts->sz >= offsetofend(typeof(*(opts)), field))

#define OPTS_GET(opts, field, fallback_value) \

	(OPTS_HAS(opts, field) ? (opts)->field : fallback_value)



int libbpf__load_raw_btf(const char *raw_types, size_t types_len,

			 const char *str_sec, size_t str_len);

tools/testing/selftests/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -160,7 +160,7 @@ $(OUTPUT)/test_queue_map.o: test_queue_stack_map.h 
$(OUTPUT)/test_stack_map.o: test_queue_stack_map.h



$(OUTPUT)/flow_dissector_load.o: flow_dissector_load.h

$(OUTPUT)/test_progs.o: flow_dissector_load.h

$(OUTPUT)/test_progs.o: flow_dissector_load.h $(OUTPUT)/test_attach_probe.o



BTF_LLC_PROBE := $(shell $(LLC) -march=bpf -mattr=help 2>&1 | grep dwarfris)

BTF_PAHOLE_PROBE := $(shell $(BTF_PAHOLE) --help 2>&1 | grep BTF)

CRA Git | Maintained and supported by SUSTech CRA and CCSE