Commit 5577f24c authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'libbpf: add unified bpf_prog_load() low-level API' 



Andrii Nakryiko says:

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

This patch set adds unified OPTS-based low-level bpf_prog_load() API for
loading BPF programs directly into kernel without utilizing libbpf's
bpf_object abstractions. This OPTS-based interface allows for future
extensions without breaking backwards or forward API and ABI compatibility.
Similar approach will be used for other low-level APIs that require extensive
sets of parameters, like BPF_MAP_CREATE command.

First half of the patch set adds libbpf API, cleans up internal usage of
to-be-deprecated APIs, etc. Second half cleans up and converts selftests away
from using deprecated APIs. See individual patches for more details.

v1->v2:
  - dropped exposing sys_bpf() into public API (Alexei, Daniel);
  - also dropped bpftool/cgroup.c fix for unistd.h include because it's not
    necessary due to sys_bpf() staying as is.

Cc: Hengqi Chen <hengqi.chen@gmail.com>
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents b8b5cb55 f19ddfe0

tools/bpf/bpftool/feature.c

+1 −1
Original line number Diff line number Diff line
@@ -467,7 +467,7 @@ static bool probe_bpf_syscall(const char *define_prefix) 
{

	bool res;



	bpf_load_program(BPF_PROG_TYPE_UNSPEC, NULL, 0, NULL, 0, NULL, 0);

	bpf_prog_load(BPF_PROG_TYPE_UNSPEC, NULL, NULL, NULL, 0, NULL);

	res = (errno != ENOSYS);



	print_bool_feature("have_bpf_syscall",

tools/lib/bpf/bpf.c

+100 −66
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include <asm/unistd.h>

#include <errno.h>

#include <linux/bpf.h>

#include <limits.h>

#include "bpf.h"

#include "libbpf.h"

#include "libbpf_internal.h"
@@ -74,14 +75,15 @@ static inline int sys_bpf_fd(enum bpf_cmd cmd, union bpf_attr *attr, 
	return ensure_good_fd(fd);

}



static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size)

#define PROG_LOAD_ATTEMPTS 5



static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, int attempts)

{

	int retries = 5;

	int fd;



	do {

		fd = sys_bpf_fd(BPF_PROG_LOAD, attr, size);

	} while (fd < 0 && errno == EAGAIN && retries-- > 0);

	} while (fd < 0 && errno == EAGAIN && --attempts > 0);



	return fd;

}
@@ -253,58 +255,91 @@ alloc_zero_tailing_info(const void *orecord, __u32 cnt, 
	return info;

}



int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr)

DEFAULT_VERSION(bpf_prog_load_v0_6_0, bpf_prog_load, LIBBPF_0.6.0)

int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,

		         const char *prog_name, const char *license,

		         const struct bpf_insn *insns, size_t insn_cnt,

		         const struct bpf_prog_load_opts *opts)

{

	void *finfo = NULL, *linfo = NULL;

	const char *func_info, *line_info;

	__u32 log_size, log_level, attach_prog_fd, attach_btf_obj_fd;

	__u32 func_info_rec_size, line_info_rec_size;

	int fd, attempts;

	union bpf_attr attr;

	int fd;

	char *log_buf;



	if (!load_attr->log_buf != !load_attr->log_buf_sz)

	if (!OPTS_VALID(opts, bpf_prog_load_opts))

		return libbpf_err(-EINVAL);



	if (load_attr->log_level > (4 | 2 | 1) || (load_attr->log_level && !load_attr->log_buf))

	attempts = OPTS_GET(opts, attempts, 0);

	if (attempts < 0)

		return libbpf_err(-EINVAL);

	if (attempts == 0)

		attempts = PROG_LOAD_ATTEMPTS;



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

	attr.prog_type = load_attr->prog_type;

	attr.expected_attach_type = load_attr->expected_attach_type;



	if (load_attr->attach_prog_fd)

		attr.attach_prog_fd = load_attr->attach_prog_fd;

	else

		attr.attach_btf_obj_fd = load_attr->attach_btf_obj_fd;

	attr.attach_btf_id = load_attr->attach_btf_id;

	attr.prog_type = prog_type;

	attr.expected_attach_type = OPTS_GET(opts, expected_attach_type, 0);



	attr.prog_ifindex = load_attr->prog_ifindex;

	attr.kern_version = load_attr->kern_version;

	attr.prog_btf_fd = OPTS_GET(opts, prog_btf_fd, 0);

	attr.prog_flags = OPTS_GET(opts, prog_flags, 0);

	attr.prog_ifindex = OPTS_GET(opts, prog_ifindex, 0);

	attr.kern_version = OPTS_GET(opts, kern_version, 0);



	attr.insn_cnt = (__u32)load_attr->insn_cnt;

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

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

	if (prog_name)

		strncat(attr.prog_name, prog_name, sizeof(attr.prog_name) - 1);

	attr.license = ptr_to_u64(license);



	attr.log_level = load_attr->log_level;

	if (attr.log_level) {

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

		attr.log_size = load_attr->log_buf_sz;

	}

	if (insn_cnt > UINT_MAX)

		return libbpf_err(-E2BIG);



	attr.insns = ptr_to_u64(insns);

	attr.insn_cnt = (__u32)insn_cnt;



	attach_prog_fd = OPTS_GET(opts, attach_prog_fd, 0);

	attach_btf_obj_fd = OPTS_GET(opts, attach_btf_obj_fd, 0);



	if (attach_prog_fd && attach_btf_obj_fd)

		return libbpf_err(-EINVAL);



	attr.attach_btf_id = OPTS_GET(opts, attach_btf_id, 0);

	if (attach_prog_fd)

		attr.attach_prog_fd = attach_prog_fd;

	else

		attr.attach_btf_obj_fd = attach_btf_obj_fd;



	attr.prog_btf_fd = load_attr->prog_btf_fd;

	attr.prog_flags = load_attr->prog_flags;

	log_buf = OPTS_GET(opts, log_buf, NULL);

	log_size = OPTS_GET(opts, log_size, 0);

	log_level = OPTS_GET(opts, log_level, 0);



	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);

	if (!!log_buf != !!log_size)

		return libbpf_err(-EINVAL);

	if (log_level > (4 | 2 | 1))

		return libbpf_err(-EINVAL);

	if (log_level && !log_buf)

		return libbpf_err(-EINVAL);



	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);

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

	attr.log_level = log_level;

	attr.log_buf = ptr_to_u64(log_buf);

	attr.log_size = log_size;



	if (load_attr->name)

		memcpy(attr.prog_name, load_attr->name,

		       min(strlen(load_attr->name), (size_t)BPF_OBJ_NAME_LEN - 1));

	func_info_rec_size = OPTS_GET(opts, func_info_rec_size, 0);

	func_info = OPTS_GET(opts, func_info, NULL);

	attr.func_info_rec_size = func_info_rec_size;

	attr.func_info = ptr_to_u64(func_info);

	attr.func_info_cnt = OPTS_GET(opts, func_info_cnt, 0);



	fd = sys_bpf_prog_load(&attr, sizeof(attr));

	line_info_rec_size = OPTS_GET(opts, line_info_rec_size, 0);

	line_info = OPTS_GET(opts, line_info, NULL);

	attr.line_info_rec_size = line_info_rec_size;

	attr.line_info = ptr_to_u64(line_info);

	attr.line_info_cnt = OPTS_GET(opts, line_info_cnt, 0);



	attr.fd_array = ptr_to_u64(OPTS_GET(opts, fd_array, NULL));



	fd = sys_bpf_prog_load(&attr, sizeof(attr), attempts);

	if (fd >= 0)

		return fd;
@@ -314,11 +349,11 @@ int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr) 
	 */

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

		if (!finfo && attr.func_info_cnt &&

		    attr.func_info_rec_size < load_attr->func_info_rec_size) {

		    attr.func_info_rec_size < func_info_rec_size) {

			/* 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,

			finfo = alloc_zero_tailing_info(func_info,

							attr.func_info_cnt,

							func_info_rec_size,

							attr.func_info_rec_size);

			if (!finfo) {

				errno = E2BIG;
@@ -326,13 +361,12 @@ int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr) 
			}



			attr.func_info = ptr_to_u64(finfo);

			attr.func_info_rec_size = load_attr->func_info_rec_size;

			attr.func_info_rec_size = 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 < line_info_rec_size) {

			linfo = alloc_zero_tailing_info(line_info,

							attr.line_info_cnt,

							line_info_rec_size,

							attr.line_info_rec_size);

			if (!linfo) {

				errno = E2BIG;
@@ -340,26 +374,26 @@ int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr) 
			}



			attr.line_info = ptr_to_u64(linfo);

			attr.line_info_rec_size = load_attr->line_info_rec_size;

			attr.line_info_rec_size = line_info_rec_size;

		} else {

			break;

		}



		fd = sys_bpf_prog_load(&attr, sizeof(attr));

		fd = sys_bpf_prog_load(&attr, sizeof(attr), attempts);

		if (fd >= 0)

			goto done;

	}



	if (load_attr->log_level || !load_attr->log_buf)

	if (log_level || !log_buf)

		goto done;



	/* Try again with log */

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

	attr.log_size = load_attr->log_buf_sz;

	log_buf[0] = 0;

	attr.log_buf = ptr_to_u64(log_buf);

	attr.log_size = log_size;

	attr.log_level = 1;

	load_attr->log_buf[0] = 0;



	fd = sys_bpf_prog_load(&attr, sizeof(attr));

	fd = sys_bpf_prog_load(&attr, sizeof(attr), attempts);

done:

	/* free() doesn't affect errno, so we don't need to restore it */

	free(finfo);
@@ -367,17 +401,20 @@ int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr) 
	return libbpf_err_errno(fd);

}



__attribute__((alias("bpf_load_program_xattr2")))

int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,

			   char *log_buf, size_t log_buf_sz);



static int bpf_load_program_xattr2(const struct bpf_load_program_attr *load_attr,

				   char *log_buf, size_t log_buf_sz)

{

	struct bpf_prog_load_params p = {};

	LIBBPF_OPTS(bpf_prog_load_opts, p);



	if (!load_attr || !log_buf != !log_buf_sz)

		return libbpf_err(-EINVAL);



	p.prog_type = load_attr->prog_type;

	p.expected_attach_type = load_attr->expected_attach_type;

	switch (p.prog_type) {

	switch (load_attr->prog_type) {

	case BPF_PROG_TYPE_STRUCT_OPS:

	case BPF_PROG_TYPE_LSM:

		p.attach_btf_id = load_attr->attach_btf_id;
@@ -391,12 +428,9 @@ int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr, 
		p.prog_ifindex = load_attr->prog_ifindex;

		p.kern_version = load_attr->kern_version;

	}

	p.insn_cnt = load_attr->insns_cnt;

	p.insns = load_attr->insns;

	p.license = load_attr->license;

	p.log_level = load_attr->log_level;

	p.log_buf = log_buf;

	p.log_buf_sz = log_buf_sz;

	p.log_size = log_buf_sz;

	p.prog_btf_fd = load_attr->prog_btf_fd;

	p.func_info_rec_size = load_attr->func_info_rec_size;

	p.func_info_cnt = load_attr->func_info_cnt;
@@ -404,10 +438,10 @@ int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr, 
	p.line_info_rec_size = load_attr->line_info_rec_size;

	p.line_info_cnt = load_attr->line_info_cnt;

	p.line_info = load_attr->line_info;

	p.name = load_attr->name;

	p.prog_flags = load_attr->prog_flags;



	return libbpf__bpf_prog_load(&p);

	return bpf_prog_load(load_attr->prog_type, load_attr->name, load_attr->license,

			     load_attr->insns, load_attr->insns_cnt, &p);

}



int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
@@ -426,7 +460,7 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns, 
	load_attr.license = license;

	load_attr.kern_version = kern_version;



	return bpf_load_program_xattr(&load_attr, log_buf, log_buf_sz);

	return bpf_load_program_xattr2(&load_attr, log_buf, log_buf_sz);

}



int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
@@ -449,7 +483,7 @@ int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns, 
	attr.kern_version = kern_version;

	attr.prog_flags = prog_flags;



	fd = sys_bpf_prog_load(&attr, sizeof(attr));

	fd = sys_bpf_prog_load(&attr, sizeof(attr), PROG_LOAD_ATTEMPTS);

	return libbpf_err_errno(fd);

}

tools/lib/bpf/bpf.h

+71 −3
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 
#include <stdint.h>



#include "libbpf_common.h"

#include "libbpf_legacy.h"



#ifdef __cplusplus

extern "C" {
@@ -71,6 +72,71 @@ LIBBPF_API int bpf_create_map_in_map(enum bpf_map_type map_type, 
				     int inner_map_fd, int max_entries,

				     __u32 map_flags);



struct bpf_prog_load_opts {

	size_t sz; /* size of this struct for forward/backward compatibility */



	/* libbpf can retry BPF_PROG_LOAD command if bpf() syscall returns

	 * -EAGAIN. This field determines how many attempts libbpf has to

	 *  make. If not specified, libbpf will use default value of 5.

	 */

	int attempts;



	enum bpf_attach_type expected_attach_type;

	__u32 prog_btf_fd;

	__u32 prog_flags;

	__u32 prog_ifindex;

	__u32 kern_version;



	__u32 attach_btf_id;

	__u32 attach_prog_fd;

	__u32 attach_btf_obj_fd;



	const int *fd_array;



	/* .BTF.ext func info data */

	const void *func_info;

	__u32 func_info_cnt;

	__u32 func_info_rec_size;



	/* .BTF.ext line info data */

	const void *line_info;

	__u32 line_info_cnt;

	__u32 line_info_rec_size;



	/* verifier log options */

	__u32 log_level;

	__u32 log_size;

	char *log_buf;

};

#define bpf_prog_load_opts__last_field log_buf



LIBBPF_API int bpf_prog_load(enum bpf_prog_type prog_type,

			     const char *prog_name, const char *license,

			     const struct bpf_insn *insns, size_t insn_cnt,

			     const struct bpf_prog_load_opts *opts);

/* this "specialization" should go away in libbpf 1.0 */

LIBBPF_API int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,

				    const char *prog_name, const char *license,

				    const struct bpf_insn *insns, size_t insn_cnt,

				    const struct bpf_prog_load_opts *opts);



/* This is an elaborate way to not conflict with deprecated bpf_prog_load()

 * API, defined in libbpf.h. Once we hit libbpf 1.0, all this will be gone.

 * With this approach, if someone is calling bpf_prog_load() with

 * 4 arguments, they will use the deprecated API, which keeps backwards

 * compatibility (both source code and binary). If bpf_prog_load() is called

 * with 6 arguments, though, it gets redirected to __bpf_prog_load.

 * So looking forward to libbpf 1.0 when this hack will be gone and

 * __bpf_prog_load() will be called just bpf_prog_load().

 */

#ifndef bpf_prog_load

#define bpf_prog_load(...) ___libbpf_overload(___bpf_prog_load, __VA_ARGS__)

#define ___bpf_prog_load4(file, type, pobj, prog_fd) \

	bpf_prog_load_deprecated(file, type, pobj, prog_fd)

#define ___bpf_prog_load6(prog_type, prog_name, license, insns, insn_cnt, opts) \

	bpf_prog_load(prog_type, prog_name, license, insns, insn_cnt, opts)

#endif /* bpf_prog_load */



struct bpf_load_program_attr {

	enum bpf_prog_type prog_type;

	enum bpf_attach_type expected_attach_type;
@@ -102,13 +168,15 @@ struct bpf_load_program_attr { 


/* Recommend log buffer size */

#define BPF_LOG_BUF_SIZE (UINT32_MAX >> 8) /* verifier maximum in kernels <= 5.1 */

LIBBPF_API int

bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,

LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_load() instead")

LIBBPF_API int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,

				      char *log_buf, size_t log_buf_sz);

LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_load() instead")

LIBBPF_API int bpf_load_program(enum bpf_prog_type type,

				const struct bpf_insn *insns, size_t insns_cnt,

				const char *license, __u32 kern_version,

				char *log_buf, size_t log_buf_sz);

LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_load() instead")

LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,

				  const struct bpf_insn *insns,

				  size_t insns_cnt, __u32 prog_flags,

tools/lib/bpf/bpf_gen_internal.h

+6 −2
Original line number Diff line number Diff line
@@ -3,6 +3,8 @@ 
#ifndef __BPF_GEN_INTERNAL_H

#define __BPF_GEN_INTERNAL_H



#include "bpf.h"



struct ksym_relo_desc {

	const char *name;

	int kind;
@@ -50,8 +52,10 @@ int bpf_gen__finish(struct bpf_gen *gen); 
void bpf_gen__free(struct bpf_gen *gen);

void bpf_gen__load_btf(struct bpf_gen *gen, const void *raw_data, __u32 raw_size);

void bpf_gen__map_create(struct bpf_gen *gen, struct bpf_create_map_params *map_attr, int map_idx);

struct bpf_prog_load_params;

void bpf_gen__prog_load(struct bpf_gen *gen, struct bpf_prog_load_params *load_attr, int prog_idx);

void bpf_gen__prog_load(struct bpf_gen *gen,

			enum bpf_prog_type prog_type, const char *prog_name,

			const char *license, struct bpf_insn *insns, size_t insn_cnt,

			struct bpf_prog_load_opts *load_attr, int prog_idx);

void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *value, __u32 value_size);

void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx);

void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *name, enum bpf_attach_type type);

tools/lib/bpf/gen_loader.c

+15 −15
Original line number Diff line number Diff line
@@ -901,27 +901,27 @@ static void cleanup_relos(struct bpf_gen *gen, int insns) 
}



void bpf_gen__prog_load(struct bpf_gen *gen,

			struct bpf_prog_load_params *load_attr, int prog_idx)

			enum bpf_prog_type prog_type, const char *prog_name,

			const char *license, struct bpf_insn *insns, size_t insn_cnt,

			struct bpf_prog_load_opts *load_attr, int prog_idx)

{

	int attr_size = offsetofend(union bpf_attr, fd_array);

	int prog_load_attr, license, insns, func_info, line_info;

	int prog_load_attr, license_off, insns_off, func_info, line_info;

	union bpf_attr attr;



	memset(&attr, 0, attr_size);

	pr_debug("gen: prog_load: type %d insns_cnt %zd\n",

		 load_attr->prog_type, load_attr->insn_cnt);

	pr_debug("gen: prog_load: type %d insns_cnt %zd\n", prog_type, insn_cnt);

	/* add license string to blob of bytes */

	license = add_data(gen, load_attr->license, strlen(load_attr->license) + 1);

	license_off = add_data(gen, license, strlen(license) + 1);

	/* add insns to blob of bytes */

	insns = add_data(gen, load_attr->insns,

			 load_attr->insn_cnt * sizeof(struct bpf_insn));

	insns_off = add_data(gen, insns, insn_cnt * sizeof(struct bpf_insn));



	attr.prog_type = load_attr->prog_type;

	attr.prog_type = prog_type;

	attr.expected_attach_type = load_attr->expected_attach_type;

	attr.attach_btf_id = load_attr->attach_btf_id;

	attr.prog_ifindex = load_attr->prog_ifindex;

	attr.kern_version = 0;

	attr.insn_cnt = (__u32)load_attr->insn_cnt;

	attr.insn_cnt = (__u32)insn_cnt;

	attr.prog_flags = load_attr->prog_flags;



	attr.func_info_rec_size = load_attr->func_info_rec_size;
@@ -934,15 +934,15 @@ void bpf_gen__prog_load(struct bpf_gen *gen, 
	line_info = add_data(gen, load_attr->line_info,

			     attr.line_info_cnt * attr.line_info_rec_size);



	memcpy(attr.prog_name, load_attr->name,

	       min((unsigned)strlen(load_attr->name), BPF_OBJ_NAME_LEN - 1));

	memcpy(attr.prog_name, prog_name,

	       min((unsigned)strlen(prog_name), BPF_OBJ_NAME_LEN - 1));

	prog_load_attr = add_data(gen, &attr, attr_size);



	/* populate union bpf_attr with a pointer to license */

	emit_rel_store(gen, attr_field(prog_load_attr, license), license);

	emit_rel_store(gen, attr_field(prog_load_attr, license), license_off);



	/* populate union bpf_attr with a pointer to instructions */

	emit_rel_store(gen, attr_field(prog_load_attr, insns), insns);

	emit_rel_store(gen, attr_field(prog_load_attr, insns), insns_off);



	/* populate union bpf_attr with a pointer to func_info */

	emit_rel_store(gen, attr_field(prog_load_attr, func_info), func_info);
@@ -974,12 +974,12 @@ void bpf_gen__prog_load(struct bpf_gen *gen, 
		emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_7,

				      offsetof(union bpf_attr, attach_btf_obj_fd)));

	}

	emit_relos(gen, insns);

	emit_relos(gen, insns_off);

	/* emit PROG_LOAD command */

	emit_sys_bpf(gen, BPF_PROG_LOAD, prog_load_attr, attr_size);

	debug_ret(gen, "prog_load %s insn_cnt %d", attr.prog_name, attr.insn_cnt);

	/* successful or not, close btf module FDs used in extern ksyms and attach_btf_obj_fd */

	cleanup_relos(gen, insns);

	cleanup_relos(gen, insns_off);

	if (gen->attach_kind)

		emit_sys_close_blob(gen,

				    attr_field(prog_load_attr, attach_btf_obj_fd));