Commit d8e86407 authored by Andrii Nakryiko's avatar Andrii Nakryiko Committed by Alexei Starovoitov
Browse files

selftests/bpf: Convert legacy prog load APIs to bpf_prog_load() 



Convert all the uses of legacy low-level BPF program loading APIs
(mostly bpf_load_program_xattr(), but also some bpf_verify_program()) to
bpf_prog_load() uses.

Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20211103220845.2676888-10-andrii@kernel.org
parent 3d1d6239

tools/testing/selftests/bpf/prog_tests/align.c

+8 −3
Original line number Diff line number Diff line
@@ -594,6 +594,12 @@ static int do_test_single(struct bpf_align_test *test) 
	struct bpf_insn *prog = test->insns;

	int prog_type = test->prog_type;

	char bpf_vlog_copy[32768];

	LIBBPF_OPTS(bpf_prog_load_opts, opts,

		.prog_flags = BPF_F_STRICT_ALIGNMENT,

		.log_buf = bpf_vlog,

		.log_size = sizeof(bpf_vlog),

		.log_level = 2,

	);

	const char *line_ptr;

	int cur_line = -1;

	int prog_len, i;
@@ -601,9 +607,8 @@ static int do_test_single(struct bpf_align_test *test) 
	int ret;



	prog_len = probe_filter_length(prog);

	fd_prog = bpf_verify_program(prog_type ? : BPF_PROG_TYPE_SOCKET_FILTER,

				     prog, prog_len, BPF_F_STRICT_ALIGNMENT,

				     "GPL", 0, bpf_vlog, sizeof(bpf_vlog), 2);

	fd_prog = bpf_prog_load(prog_type ? : BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL",

				prog, prog_len, &opts);

	if (fd_prog < 0 && test->result != REJECT) {

		printf("Failed to load program.\n");

		printf("%s", bpf_vlog);

tools/testing/selftests/bpf/prog_tests/fexit_stress.c

+17 −16
Original line number Diff line number Diff line
@@ -20,34 +20,33 @@ void test_fexit_stress(void) 
		BPF_EXIT_INSN(),

	};



	struct bpf_load_program_attr load_attr = {

		.prog_type = BPF_PROG_TYPE_TRACING,

		.license = "GPL",

		.insns = trace_program,

		.insns_cnt = sizeof(trace_program) / sizeof(struct bpf_insn),

	LIBBPF_OPTS(bpf_prog_load_opts, trace_opts,

		.expected_attach_type = BPF_TRACE_FEXIT,

	};

		.log_buf = error,

		.log_size = sizeof(error),

	);



	const struct bpf_insn skb_program[] = {

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_EXIT_INSN(),

	};



	struct bpf_load_program_attr skb_load_attr = {

		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,

		.license = "GPL",

		.insns = skb_program,

		.insns_cnt = sizeof(skb_program) / sizeof(struct bpf_insn),

	};

	LIBBPF_OPTS(bpf_prog_load_opts, skb_opts,

		.log_buf = error,

		.log_size = sizeof(error),

	);



	err = libbpf_find_vmlinux_btf_id("bpf_fentry_test1",

					 load_attr.expected_attach_type);

					 trace_opts.expected_attach_type);

	if (CHECK(err <= 0, "find_vmlinux_btf_id", "failed: %d\n", err))

		goto out;

	load_attr.attach_btf_id = err;

	trace_opts.attach_btf_id = err;



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

		fexit_fd[i] = bpf_load_program_xattr(&load_attr, error, sizeof(error));

		fexit_fd[i] = bpf_prog_load(BPF_PROG_TYPE_TRACING, NULL, "GPL",

					    trace_program,

					    sizeof(trace_program) / sizeof(struct bpf_insn),

					    &trace_opts);

		if (CHECK(fexit_fd[i] < 0, "fexit loaded",

			  "failed: %d errno %d\n", fexit_fd[i], errno))

			goto out;
@@ -57,7 +56,9 @@ void test_fexit_stress(void) 
			goto out;

	}



	filter_fd = bpf_load_program_xattr(&skb_load_attr, error, sizeof(error));

	filter_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL",

				  skb_program, sizeof(skb_program) / sizeof(struct bpf_insn),

				  &skb_opts);

	if (CHECK(filter_fd < 0, "test_program_loaded", "failed: %d errno %d\n",

		  filter_fd, errno))

		goto out;

tools/testing/selftests/bpf/prog_tests/raw_tp_writable_reject_nbd_invalid.c

+7 −7
Original line number Diff line number Diff line
@@ -18,15 +18,15 @@ void test_raw_tp_writable_reject_nbd_invalid(void) 
		BPF_EXIT_INSN(),

	};



	struct bpf_load_program_attr load_attr = {

		.prog_type = BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE,

		.license = "GPL v2",

		.insns = program,

		.insns_cnt = sizeof(program) / sizeof(struct bpf_insn),

	LIBBPF_OPTS(bpf_prog_load_opts, opts,

		.log_level = 2,

	};

		.log_buf = error,

		.log_size = sizeof(error),

	);



	bpf_fd = bpf_load_program_xattr(&load_attr, error, sizeof(error));

	bpf_fd = bpf_prog_load(BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, NULL, "GPL v2",

			       program, sizeof(program) / sizeof(struct bpf_insn),

			       &opts);

	if (CHECK(bpf_fd < 0, "bpf_raw_tracepoint_writable load",

		  "failed: %d errno %d\n", bpf_fd, errno))

		return;

tools/testing/selftests/bpf/prog_tests/raw_tp_writable_test_run.c

+14 −15
Original line number Diff line number Diff line
@@ -17,15 +17,15 @@ void serial_test_raw_tp_writable_test_run(void) 
		BPF_EXIT_INSN(),

	};



	struct bpf_load_program_attr load_attr = {

		.prog_type = BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE,

		.license = "GPL v2",

		.insns = trace_program,

		.insns_cnt = sizeof(trace_program) / sizeof(struct bpf_insn),

	LIBBPF_OPTS(bpf_prog_load_opts, trace_opts,

		.log_level = 2,

	};

		.log_buf = error,

		.log_size = sizeof(error),

	);



	int bpf_fd = bpf_load_program_xattr(&load_attr, error, sizeof(error));

	int bpf_fd = bpf_prog_load(BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, NULL, "GPL v2",

				   trace_program, sizeof(trace_program) / sizeof(struct bpf_insn),

				   &trace_opts);

	if (CHECK(bpf_fd < 0, "bpf_raw_tracepoint_writable loaded",

		  "failed: %d errno %d\n", bpf_fd, errno))

		return;
@@ -35,15 +35,14 @@ void serial_test_raw_tp_writable_test_run(void) 
		BPF_EXIT_INSN(),

	};



	struct bpf_load_program_attr skb_load_attr = {

		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,

		.license = "GPL v2",

		.insns = skb_program,

		.insns_cnt = sizeof(skb_program) / sizeof(struct bpf_insn),

	};

	LIBBPF_OPTS(bpf_prog_load_opts, skb_opts,

		.log_buf = error,

		.log_size = sizeof(error),

	);



	int filter_fd =

		bpf_load_program_xattr(&skb_load_attr, error, sizeof(error));

	int filter_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL v2",

				      skb_program, sizeof(skb_program) / sizeof(struct bpf_insn),

				      &skb_opts);

	if (CHECK(filter_fd < 0, "test_program_loaded", "failed: %d errno %d\n",

		  filter_fd, errno))

		goto out_bpffd;

tools/testing/selftests/bpf/prog_tests/sockopt.c

+9 −10
Original line number Diff line number Diff line
@@ -852,22 +852,21 @@ static struct sockopt_test { 
static int load_prog(const struct bpf_insn *insns,

		     enum bpf_attach_type expected_attach_type)

{

	struct bpf_load_program_attr attr = {

		.prog_type = BPF_PROG_TYPE_CGROUP_SOCKOPT,

	LIBBPF_OPTS(bpf_prog_load_opts, opts,

		.expected_attach_type = expected_attach_type,

		.insns = insns,

		.license = "GPL",

		.log_level = 2,

	};

	int fd;

		.log_buf = bpf_log_buf,

		.log_size = sizeof(bpf_log_buf),

	);

	int fd, insns_cnt = 0;



	for (;

	     insns[attr.insns_cnt].code != (BPF_JMP | BPF_EXIT);

	     attr.insns_cnt++) {

	     insns[insns_cnt].code != (BPF_JMP | BPF_EXIT);

	     insns_cnt++) {

	}

	attr.insns_cnt++;

	insns_cnt++;



	fd = bpf_load_program_xattr(&attr, bpf_log_buf, sizeof(bpf_log_buf));

	fd = bpf_prog_load(BPF_PROG_TYPE_CGROUP_SOCKOPT, NULL, "GPL", insns, insns_cnt, &opts);

	if (verbose && fd < 0)

		fprintf(stderr, "%s\n", bpf_log_buf);