Commit 78e6e5c1 authored by Daniel Borkmann's avatar Daniel Borkmann
Browse files

Merge branch 'bpf-libbpf-attach-by-name' 



Andrey Ignatov says:

====================
This patch set introduces libbpf_attach_type_by_name function in libbpf
to identify attach type by section name.

This is useful to avoid writing same logic over and over again in user
space applications that leverage libbpf.

Patch 1 has more details on the new function and problem being solved.
Patches 2 and 3 add support for new section names.
Patch 4 uses new function in a selftest.
Patch 5 adds selftest for libbpf_{prog,attach}_type_by_name.

As a side note there are a lot of inconsistencies now between names used
by libbpf and bpftool (e.g. cgroup/skb vs cgroup_skb, cgroup_device and
device vs cgroup/dev, sockops vs sock_ops, etc). This patch set does not
address it but it tries not to make it harder to address it in the future.
====================

Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parents 10081193 370920c4

tools/lib/bpf/libbpf.c

+90 −39
Original line number Diff line number Diff line
@@ -2085,22 +2085,31 @@ void bpf_program__set_expected_attach_type(struct bpf_program *prog, 
	prog->expected_attach_type = type;

}



#define BPF_PROG_SEC_FULL(string, ptype, atype) \

	{ string, sizeof(string) - 1, ptype, atype }

#define BPF_PROG_SEC_IMPL(string, ptype, eatype, atype) \

	{ string, sizeof(string) - 1, ptype, eatype, atype }



#define BPF_PROG_SEC(string, ptype) BPF_PROG_SEC_FULL(string, ptype, 0)

/* Programs that can NOT be attached. */

#define BPF_PROG_SEC(string, ptype) BPF_PROG_SEC_IMPL(string, ptype, 0, -EINVAL)



#define BPF_S_PROG_SEC(string, ptype) \

	BPF_PROG_SEC_FULL(string, BPF_PROG_TYPE_CGROUP_SOCK, ptype)

/* Programs that can be attached. */

#define BPF_APROG_SEC(string, ptype, atype) \

	BPF_PROG_SEC_IMPL(string, ptype, 0, atype)



#define BPF_SA_PROG_SEC(string, ptype) \

	BPF_PROG_SEC_FULL(string, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, ptype)

/* Programs that must specify expected attach type at load time. */

#define BPF_EAPROG_SEC(string, ptype, eatype) \

	BPF_PROG_SEC_IMPL(string, ptype, eatype, eatype)



/* Programs that can be attached but attach type can't be identified by section

 * name. Kept for backward compatibility.

 */

#define BPF_APROG_COMPAT(string, ptype) BPF_PROG_SEC(string, ptype)



static const struct {

	const char *sec;

	size_t len;

	enum bpf_prog_type prog_type;

	enum bpf_attach_type expected_attach_type;

	enum bpf_attach_type attach_type;

} section_names[] = {

	BPF_PROG_SEC("socket",			BPF_PROG_TYPE_SOCKET_FILTER),

	BPF_PROG_SEC("kprobe/",			BPF_PROG_TYPE_KPROBE),
@@ -2111,32 +2120,55 @@ static const struct { 
	BPF_PROG_SEC("raw_tracepoint/",		BPF_PROG_TYPE_RAW_TRACEPOINT),

	BPF_PROG_SEC("xdp",			BPF_PROG_TYPE_XDP),

	BPF_PROG_SEC("perf_event",		BPF_PROG_TYPE_PERF_EVENT),

	BPF_PROG_SEC("cgroup/skb",	BPF_PROG_TYPE_CGROUP_SKB),

	BPF_PROG_SEC("cgroup/sock",	BPF_PROG_TYPE_CGROUP_SOCK),

	BPF_PROG_SEC("cgroup/dev",	BPF_PROG_TYPE_CGROUP_DEVICE),

	BPF_PROG_SEC("lwt_in",			BPF_PROG_TYPE_LWT_IN),

	BPF_PROG_SEC("lwt_out",			BPF_PROG_TYPE_LWT_OUT),

	BPF_PROG_SEC("lwt_xmit",		BPF_PROG_TYPE_LWT_XMIT),

	BPF_PROG_SEC("lwt_seg6local",		BPF_PROG_TYPE_LWT_SEG6LOCAL),

	BPF_PROG_SEC("sockops",		BPF_PROG_TYPE_SOCK_OPS),

	BPF_PROG_SEC("sk_skb",		BPF_PROG_TYPE_SK_SKB),

	BPF_PROG_SEC("sk_msg",		BPF_PROG_TYPE_SK_MSG),

	BPF_PROG_SEC("lirc_mode2",	BPF_PROG_TYPE_LIRC_MODE2),

	BPF_PROG_SEC("flow_dissector",	BPF_PROG_TYPE_FLOW_DISSECTOR),

	BPF_SA_PROG_SEC("cgroup/bind4",	BPF_CGROUP_INET4_BIND),

	BPF_SA_PROG_SEC("cgroup/bind6",	BPF_CGROUP_INET6_BIND),

	BPF_SA_PROG_SEC("cgroup/connect4", BPF_CGROUP_INET4_CONNECT),

	BPF_SA_PROG_SEC("cgroup/connect6", BPF_CGROUP_INET6_CONNECT),

	BPF_SA_PROG_SEC("cgroup/sendmsg4", BPF_CGROUP_UDP4_SENDMSG),

	BPF_SA_PROG_SEC("cgroup/sendmsg6", BPF_CGROUP_UDP6_SENDMSG),

	BPF_S_PROG_SEC("cgroup/post_bind4", BPF_CGROUP_INET4_POST_BIND),

	BPF_S_PROG_SEC("cgroup/post_bind6", BPF_CGROUP_INET6_POST_BIND),

	BPF_APROG_SEC("cgroup_skb/ingress",	BPF_PROG_TYPE_CGROUP_SKB,

						BPF_CGROUP_INET_INGRESS),

	BPF_APROG_SEC("cgroup_skb/egress",	BPF_PROG_TYPE_CGROUP_SKB,

						BPF_CGROUP_INET_EGRESS),

	BPF_APROG_COMPAT("cgroup/skb",		BPF_PROG_TYPE_CGROUP_SKB),

	BPF_APROG_SEC("cgroup/sock",		BPF_PROG_TYPE_CGROUP_SOCK,

						BPF_CGROUP_INET_SOCK_CREATE),

	BPF_EAPROG_SEC("cgroup/post_bind4",	BPF_PROG_TYPE_CGROUP_SOCK,

						BPF_CGROUP_INET4_POST_BIND),

	BPF_EAPROG_SEC("cgroup/post_bind6",	BPF_PROG_TYPE_CGROUP_SOCK,

						BPF_CGROUP_INET6_POST_BIND),

	BPF_APROG_SEC("cgroup/dev",		BPF_PROG_TYPE_CGROUP_DEVICE,

						BPF_CGROUP_DEVICE),

	BPF_APROG_SEC("sockops",		BPF_PROG_TYPE_SOCK_OPS,

						BPF_CGROUP_SOCK_OPS),

	BPF_APROG_SEC("sk_skb/stream_parser",	BPF_PROG_TYPE_SK_SKB,

						BPF_SK_SKB_STREAM_PARSER),

	BPF_APROG_SEC("sk_skb/stream_verdict",	BPF_PROG_TYPE_SK_SKB,

						BPF_SK_SKB_STREAM_VERDICT),

	BPF_APROG_COMPAT("sk_skb",		BPF_PROG_TYPE_SK_SKB),

	BPF_APROG_SEC("sk_msg",			BPF_PROG_TYPE_SK_MSG,

						BPF_SK_MSG_VERDICT),

	BPF_APROG_SEC("lirc_mode2",		BPF_PROG_TYPE_LIRC_MODE2,

						BPF_LIRC_MODE2),

	BPF_APROG_SEC("flow_dissector",		BPF_PROG_TYPE_FLOW_DISSECTOR,

						BPF_FLOW_DISSECTOR),

	BPF_EAPROG_SEC("cgroup/bind4",		BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

						BPF_CGROUP_INET4_BIND),

	BPF_EAPROG_SEC("cgroup/bind6",		BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

						BPF_CGROUP_INET6_BIND),

	BPF_EAPROG_SEC("cgroup/connect4",	BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

						BPF_CGROUP_INET4_CONNECT),

	BPF_EAPROG_SEC("cgroup/connect6",	BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

						BPF_CGROUP_INET6_CONNECT),

	BPF_EAPROG_SEC("cgroup/sendmsg4",	BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

						BPF_CGROUP_UDP4_SENDMSG),

	BPF_EAPROG_SEC("cgroup/sendmsg6",	BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

						BPF_CGROUP_UDP6_SENDMSG),

};



#undef BPF_PROG_SEC_IMPL

#undef BPF_PROG_SEC

#undef BPF_PROG_SEC_FULL

#undef BPF_S_PROG_SEC

#undef BPF_SA_PROG_SEC

#undef BPF_APROG_SEC

#undef BPF_EAPROG_SEC

#undef BPF_APROG_COMPAT



int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,

			     enum bpf_attach_type *expected_attach_type)
@@ -2156,6 +2188,25 @@ int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type, 
	return -EINVAL;

}



int libbpf_attach_type_by_name(const char *name,

			       enum bpf_attach_type *attach_type)

{

	int i;



	if (!name)

		return -EINVAL;



	for (i = 0; i < ARRAY_SIZE(section_names); i++) {

		if (strncmp(name, section_names[i].sec, section_names[i].len))

			continue;

		if (section_names[i].attach_type == -EINVAL)

			return -EINVAL;

		*attach_type = section_names[i].attach_type;

		return 0;

	}

	return -EINVAL;

}



static int

bpf_program__identify_section(struct bpf_program *prog,

			      enum bpf_prog_type *prog_type,

tools/lib/bpf/libbpf.h

+2 −0
Original line number Diff line number Diff line
@@ -104,6 +104,8 @@ void *bpf_object__priv(struct bpf_object *prog); 


int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,

			     enum bpf_attach_type *expected_attach_type);

int libbpf_attach_type_by_name(const char *name,

			       enum bpf_attach_type *attach_type);



/* Accessors of bpf_program */

struct bpf_program;

tools/testing/selftests/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ $(TEST_CUSTOM_PROGS): $(OUTPUT)/%: %.c 
TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \

	test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \

	test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \

	test_socket_cookie test_cgroup_storage test_select_reuseport

	test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names



TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test_obj_id.o \

	test_pkt_md_access.o test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o     \

tools/testing/selftests/bpf/test_section_names.c

0 → 100644
+208 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

// Copyright (c) 2018 Facebook



#include <err.h>

#include <bpf/libbpf.h>



#include "bpf_util.h"



struct sec_name_test {

	const char sec_name[32];

	struct {

		int rc;

		enum bpf_prog_type prog_type;

		enum bpf_attach_type expected_attach_type;

	} expected_load;

	struct {

		int rc;

		enum bpf_attach_type attach_type;

	} expected_attach;

};



static struct sec_name_test tests[] = {

	{"InvAliD", {-EINVAL, 0, 0}, {-EINVAL, 0} },

	{"cgroup", {-EINVAL, 0, 0}, {-EINVAL, 0} },

	{"socket", {0, BPF_PROG_TYPE_SOCKET_FILTER, 0}, {-EINVAL, 0} },

	{"kprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} },

	{"kretprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} },

	{"classifier", {0, BPF_PROG_TYPE_SCHED_CLS, 0}, {-EINVAL, 0} },

	{"action", {0, BPF_PROG_TYPE_SCHED_ACT, 0}, {-EINVAL, 0} },

	{"tracepoint/", {0, BPF_PROG_TYPE_TRACEPOINT, 0}, {-EINVAL, 0} },

	{

		"raw_tracepoint/",

		{0, BPF_PROG_TYPE_RAW_TRACEPOINT, 0},

		{-EINVAL, 0},

	},

	{"xdp", {0, BPF_PROG_TYPE_XDP, 0}, {-EINVAL, 0} },

	{"perf_event", {0, BPF_PROG_TYPE_PERF_EVENT, 0}, {-EINVAL, 0} },

	{"lwt_in", {0, BPF_PROG_TYPE_LWT_IN, 0}, {-EINVAL, 0} },

	{"lwt_out", {0, BPF_PROG_TYPE_LWT_OUT, 0}, {-EINVAL, 0} },

	{"lwt_xmit", {0, BPF_PROG_TYPE_LWT_XMIT, 0}, {-EINVAL, 0} },

	{"lwt_seg6local", {0, BPF_PROG_TYPE_LWT_SEG6LOCAL, 0}, {-EINVAL, 0} },

	{

		"cgroup_skb/ingress",

		{0, BPF_PROG_TYPE_CGROUP_SKB, 0},

		{0, BPF_CGROUP_INET_INGRESS},

	},

	{

		"cgroup_skb/egress",

		{0, BPF_PROG_TYPE_CGROUP_SKB, 0},

		{0, BPF_CGROUP_INET_EGRESS},

	},

	{"cgroup/skb", {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, {-EINVAL, 0} },

	{

		"cgroup/sock",

		{0, BPF_PROG_TYPE_CGROUP_SOCK, 0},

		{0, BPF_CGROUP_INET_SOCK_CREATE},

	},

	{

		"cgroup/post_bind4",

		{0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET4_POST_BIND},

		{0, BPF_CGROUP_INET4_POST_BIND},

	},

	{

		"cgroup/post_bind6",

		{0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET6_POST_BIND},

		{0, BPF_CGROUP_INET6_POST_BIND},

	},

	{

		"cgroup/dev",

		{0, BPF_PROG_TYPE_CGROUP_DEVICE, 0},

		{0, BPF_CGROUP_DEVICE},

	},

	{"sockops", {0, BPF_PROG_TYPE_SOCK_OPS, 0}, {0, BPF_CGROUP_SOCK_OPS} },

	{

		"sk_skb/stream_parser",

		{0, BPF_PROG_TYPE_SK_SKB, 0},

		{0, BPF_SK_SKB_STREAM_PARSER},

	},

	{

		"sk_skb/stream_verdict",

		{0, BPF_PROG_TYPE_SK_SKB, 0},

		{0, BPF_SK_SKB_STREAM_VERDICT},

	},

	{"sk_skb", {0, BPF_PROG_TYPE_SK_SKB, 0}, {-EINVAL, 0} },

	{"sk_msg", {0, BPF_PROG_TYPE_SK_MSG, 0}, {0, BPF_SK_MSG_VERDICT} },

	{"lirc_mode2", {0, BPF_PROG_TYPE_LIRC_MODE2, 0}, {0, BPF_LIRC_MODE2} },

	{

		"flow_dissector",

		{0, BPF_PROG_TYPE_FLOW_DISSECTOR, 0},

		{0, BPF_FLOW_DISSECTOR},

	},

	{

		"cgroup/bind4",

		{0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_BIND},

		{0, BPF_CGROUP_INET4_BIND},

	},

	{

		"cgroup/bind6",

		{0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_BIND},

		{0, BPF_CGROUP_INET6_BIND},

	},

	{

		"cgroup/connect4",

		{0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_CONNECT},

		{0, BPF_CGROUP_INET4_CONNECT},

	},

	{

		"cgroup/connect6",

		{0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_CONNECT},

		{0, BPF_CGROUP_INET6_CONNECT},

	},

	{

		"cgroup/sendmsg4",

		{0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_SENDMSG},

		{0, BPF_CGROUP_UDP4_SENDMSG},

	},

	{

		"cgroup/sendmsg6",

		{0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_SENDMSG},

		{0, BPF_CGROUP_UDP6_SENDMSG},

	},

};



static int test_prog_type_by_name(const struct sec_name_test *test)

{

	enum bpf_attach_type expected_attach_type;

	enum bpf_prog_type prog_type;

	int rc;



	rc = libbpf_prog_type_by_name(test->sec_name, &prog_type,

				      &expected_attach_type);



	if (rc != test->expected_load.rc) {

		warnx("prog: unexpected rc=%d for %s", rc, test->sec_name);

		return -1;

	}



	if (rc)

		return 0;



	if (prog_type != test->expected_load.prog_type) {

		warnx("prog: unexpected prog_type=%d for %s", prog_type,

		      test->sec_name);

		return -1;

	}



	if (expected_attach_type != test->expected_load.expected_attach_type) {

		warnx("prog: unexpected expected_attach_type=%d for %s",

		      expected_attach_type, test->sec_name);

		return -1;

	}



	return 0;

}



static int test_attach_type_by_name(const struct sec_name_test *test)

{

	enum bpf_attach_type attach_type;

	int rc;



	rc = libbpf_attach_type_by_name(test->sec_name, &attach_type);



	if (rc != test->expected_attach.rc) {

		warnx("attach: unexpected rc=%d for %s", rc, test->sec_name);

		return -1;

	}



	if (rc)

		return 0;



	if (attach_type != test->expected_attach.attach_type) {

		warnx("attach: unexpected attach_type=%d for %s", attach_type,

		      test->sec_name);

		return -1;

	}



	return 0;

}



static int run_test_case(const struct sec_name_test *test)

{

	if (test_prog_type_by_name(test))

		return -1;

	if (test_attach_type_by_name(test))

		return -1;

	return 0;

}



static int run_tests(void)

{

	int passes = 0;

	int fails = 0;

	int i;



	for (i = 0; i < ARRAY_SIZE(tests); ++i) {

		if (run_test_case(&tests[i]))

			++fails;

		else

			++passes;

	}

	printf("Summary: %d PASSED, %d FAILED\n", passes, fails);

	return fails ? -1 : 0;

}



int main(int argc, char **argv)

{

	return run_tests();

}

tools/testing/selftests/bpf/test_socket_cookie.c

+1 −5
Original line number Diff line number Diff line
@@ -158,11 +158,7 @@ static int run_test(int cgfd) 
	bpf_object__for_each_program(prog, pobj) {

		prog_name = bpf_program__title(prog, /*needs_copy*/ false);



		if (strcmp(prog_name, "cgroup/connect6") == 0) {

			attach_type = BPF_CGROUP_INET6_CONNECT;

		} else if (strcmp(prog_name, "sockops") == 0) {

			attach_type = BPF_CGROUP_SOCK_OPS;

		} else {

		if (libbpf_attach_type_by_name(prog_name, &attach_type)) {

			log_err("Unexpected prog: %s", prog_name);

			goto err;

		}

CRA Git | Maintained and supported by SUSTech CRA and CCSE