Commit fb66223a authored by Benjamin Tissoires's avatar Benjamin Tissoires Committed by Alexei Starovoitov
Browse files

selftests/bpf: add test for accessing ctx from syscall program type 



We need to also export the kfunc set to the syscall program type,
and then add a couple of eBPF programs that are testing those calls.

The first one checks for valid access, and the second one is OK
from a static analysis point of view but fails at run time because
we are trying to access outside of the allocated memory.

Signed-off-by: default avatarBenjamin Tissoires <benjamin.tissoires@redhat.com>
Link: https://lore.kernel.org/r/20220906151303.2780789-5-benjamin.tissoires@redhat.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 15baa55f

net/bpf/test_run.c

+1 −0
Original line number Diff line number Diff line
@@ -1634,6 +1634,7 @@ static int __init bpf_prog_test_run_init(void) 


	ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_SCHED_CLS, &bpf_prog_test_kfunc_set);

	ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_TRACING, &bpf_prog_test_kfunc_set);

	ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_SYSCALL, &bpf_prog_test_kfunc_set);

	return ret ?: register_btf_id_dtor_kfuncs(bpf_prog_test_dtor_kfunc,

						  ARRAY_SIZE(bpf_prog_test_dtor_kfunc),

						  THIS_MODULE);

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

+136 −7
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
/* Copyright (c) 2021 Facebook */

#include <test_progs.h>

#include <network_helpers.h>

#include "kfunc_call_fail.skel.h"

#include "kfunc_call_test.skel.h"

#include "kfunc_call_test.lskel.h"

#include "kfunc_call_test_subprog.skel.h"
@@ -10,37 +11,96 @@ 


#include "cap_helpers.h"



static size_t log_buf_sz = 1048576; /* 1 MB */

static char obj_log_buf[1048576];



enum kfunc_test_type {

	tc_test = 0,

	syscall_test,

	syscall_null_ctx_test,

};



struct kfunc_test_params {

	const char *prog_name;

	unsigned long lskel_prog_desc_offset;

	int retval;

	enum kfunc_test_type test_type;

	const char *expected_err_msg;

};



#define TC_TEST(name, __retval) \

#define __BPF_TEST_SUCCESS(name, __retval, type) \

	{ \

	  .prog_name = #name, \

	  .lskel_prog_desc_offset = offsetof(struct kfunc_call_test_lskel, progs.name), \

	  .retval = __retval, \

	  .test_type = type, \

	  .expected_err_msg = NULL, \

	}



#define __BPF_TEST_FAIL(name, __retval, type, error_msg) \

	{ \

	  .prog_name = #name, \

	  .lskel_prog_desc_offset = 0 /* unused when test is failing */, \

	  .retval = __retval, \

	  .test_type = type, \

	  .expected_err_msg = error_msg, \

	}



#define TC_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, tc_test)

#define SYSCALL_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, syscall_test)

#define SYSCALL_NULL_CTX_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, syscall_null_ctx_test)



#define SYSCALL_NULL_CTX_FAIL(name, retval, error_msg) \

	__BPF_TEST_FAIL(name, retval, syscall_null_ctx_test, error_msg)



static struct kfunc_test_params kfunc_tests[] = {

	/* failure cases:

	 * if retval is 0 -> the program will fail to load and the error message is an error

	 * if retval is not 0 -> the program can be loaded but running it will gives the

	 *                       provided return value. The error message is thus the one

	 *                       from a successful load

	 */

	SYSCALL_NULL_CTX_FAIL(kfunc_syscall_test_fail, -EINVAL, "processed 4 insns"),

	SYSCALL_NULL_CTX_FAIL(kfunc_syscall_test_null_fail, -EINVAL, "processed 4 insns"),



	/* success cases */

	TC_TEST(kfunc_call_test1, 12),

	TC_TEST(kfunc_call_test2, 3),

	TC_TEST(kfunc_call_test_ref_btf_id, 0),

	SYSCALL_TEST(kfunc_syscall_test, 0),

	SYSCALL_NULL_CTX_TEST(kfunc_syscall_test_null, 0),

};



struct syscall_test_args {

	__u8 data[16];

	size_t size;

};



static void verify_success(struct kfunc_test_params *param)

{

	struct kfunc_call_test_lskel *lskel = NULL;

	LIBBPF_OPTS(bpf_test_run_opts, topts);

	struct bpf_prog_desc *lskel_prog;

	struct kfunc_call_test *skel;

	struct bpf_program *prog;

	int prog_fd, err;

	LIBBPF_OPTS(bpf_test_run_opts, topts,

		.data_in = &pkt_v4,

		.data_size_in = sizeof(pkt_v4),

		.repeat = 1,

	);

	struct syscall_test_args args = {

		.size = 10,

	};



	switch (param->test_type) {

	case syscall_test:

		topts.ctx_in = &args;

		topts.ctx_size_in = sizeof(args);

		/* fallthrough */

	case syscall_null_ctx_test:

		break;

	case tc_test:

		topts.data_in = &pkt_v4;

		topts.data_size_in = sizeof(pkt_v4);

		topts.repeat = 1;

		break;

	}



	/* first test with normal libbpf */

	skel = kfunc_call_test__open_and_load();
@@ -79,6 +139,72 @@ static void verify_success(struct kfunc_test_params *param) 
		kfunc_call_test_lskel__destroy(lskel);

}



static void verify_fail(struct kfunc_test_params *param)

{

	LIBBPF_OPTS(bpf_object_open_opts, opts);

	LIBBPF_OPTS(bpf_test_run_opts, topts);

	struct bpf_program *prog;

	struct kfunc_call_fail *skel;

	int prog_fd, err;

	struct syscall_test_args args = {

		.size = 10,

	};



	opts.kernel_log_buf = obj_log_buf;

	opts.kernel_log_size = log_buf_sz;

	opts.kernel_log_level = 1;



	switch (param->test_type) {

	case syscall_test:

		topts.ctx_in = &args;

		topts.ctx_size_in = sizeof(args);

		/* fallthrough */

	case syscall_null_ctx_test:

		break;

	case tc_test:

		topts.data_in = &pkt_v4;

		topts.data_size_in = sizeof(pkt_v4);

		break;

		topts.repeat = 1;

	}



	skel = kfunc_call_fail__open_opts(&opts);

	if (!ASSERT_OK_PTR(skel, "kfunc_call_fail__open_opts"))

		goto cleanup;



	prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);

	if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

		goto cleanup;



	bpf_program__set_autoload(prog, true);



	err = kfunc_call_fail__load(skel);

	if (!param->retval) {

		/* the verifier is supposed to complain and refuses to load */

		if (!ASSERT_ERR(err, "unexpected load success"))

			goto out_err;



	} else {

		/* the program is loaded but must dynamically fail */

		if (!ASSERT_OK(err, "unexpected load error"))

			goto out_err;



		prog_fd = bpf_program__fd(prog);

		err = bpf_prog_test_run_opts(prog_fd, &topts);

		if (!ASSERT_EQ(err, param->retval, param->prog_name))

			goto out_err;

	}



out_err:

	if (!ASSERT_OK_PTR(strstr(obj_log_buf, param->expected_err_msg), "expected_err_msg")) {

		fprintf(stderr, "Expected err_msg: %s\n", param->expected_err_msg);

		fprintf(stderr, "Verifier output: %s\n", obj_log_buf);

	}



cleanup:

	kfunc_call_fail__destroy(skel);

}



static void test_main(void)

{

	int i;
@@ -87,7 +213,10 @@ static void test_main(void) 
		if (!test__start_subtest(kfunc_tests[i].prog_name))

			continue;



		if (!kfunc_tests[i].expected_err_msg)

			verify_success(&kfunc_tests[i]);

		else

			verify_fail(&kfunc_tests[i]);

	}

}

tools/testing/selftests/bpf/progs/kfunc_call_fail.c

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

/* Copyright (c) 2021 Facebook */

#include <vmlinux.h>

#include <bpf/bpf_helpers.h>



extern void bpf_kfunc_call_test_mem_len_pass1(void *mem, int len) __ksym;



struct syscall_test_args {

	__u8 data[16];

	size_t size;

};



SEC("?syscall")

int kfunc_syscall_test_fail(struct syscall_test_args *args)

{

	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(*args) + 1);



	return 0;

}



SEC("?syscall")

int kfunc_syscall_test_null_fail(struct syscall_test_args *args)

{

	/* Must be called with args as a NULL pointer

	 * we do not check for it to have the verifier consider that

	 * the pointer might not be null, and so we can load it.

	 *

	 * So the following can not be added:

	 *

	 * if (args)

	 *      return -22;

	 */



	bpf_kfunc_call_test_mem_len_pass1(args, sizeof(*args));



	return 0;

}



char _license[] SEC("license") = "GPL";

tools/testing/selftests/bpf/progs/kfunc_call_test.c

+38 −0
Original line number Diff line number Diff line
@@ -92,4 +92,42 @@ int kfunc_call_test_pass(struct __sk_buff *skb) 
	return 0;

}



struct syscall_test_args {

	__u8 data[16];

	size_t size;

};



SEC("syscall")

int kfunc_syscall_test(struct syscall_test_args *args)

{

	const long size = args->size;



	if (size > sizeof(args->data))

		return -7; /* -E2BIG */



	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(args->data));

	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(*args));

	bpf_kfunc_call_test_mem_len_pass1(&args->data, size);



	return 0;

}



SEC("syscall")

int kfunc_syscall_test_null(struct syscall_test_args *args)

{

	/* Must be called with args as a NULL pointer

	 * we do not check for it to have the verifier consider that

	 * the pointer might not be null, and so we can load it.

	 *

	 * So the following can not be added:

	 *

	 * if (args)

	 *      return -22;

	 */



	bpf_kfunc_call_test_mem_len_pass1(args, 0);



	return 0;

}



char _license[] SEC("license") = "GPL";