Commit d2a93715 authored by Kumar Kartikeya Dwivedi's avatar Kumar Kartikeya Dwivedi Committed by Alexei Starovoitov
Browse files

selftests/bpf: Add tests for BPF exceptions 



Add selftests to cover success and failure cases of API usage, runtime
behavior and invariants that need to be maintained for implementation
correctness.

Signed-off-by: default avatarKumar Kartikeya Dwivedi <memxor@gmail.com>
Link: https://lore.kernel.org/r/20230912233214.1518551-18-memxor@gmail.com


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

tools/testing/selftests/bpf/DENYLIST.aarch64

+1 −0
Original line number Diff line number Diff line 
bpf_cookie/multi_kprobe_attach_api               # kprobe_multi_link_api_subtest:FAIL:fentry_raw_skel_load unexpected error: -3

bpf_cookie/multi_kprobe_link_api                 # kprobe_multi_link_api_subtest:FAIL:fentry_raw_skel_load unexpected error: -3

exceptions					 # JIT does not support calling kfunc bpf_throw: -524

fexit_sleep                                      # The test never returns. The remaining tests cannot start.

kprobe_multi_bench_attach                        # bpf_program__attach_kprobe_multi_opts unexpected error: -95

kprobe_multi_test/attach_api_addrs               # bpf_program__attach_kprobe_multi_opts unexpected error: -95

tools/testing/selftests/bpf/DENYLIST.s390x

+1 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ bpf_loop # attaches to __x64_sys_nanosleep 
cgrp_local_storage                       # prog_attach unexpected error: -524                                          (trampoline)

dynptr/test_dynptr_skb_data

dynptr/test_skb_readonly

exceptions				 # JIT does not support calling kfunc bpf_throw				       (exceptions)

fexit_sleep                              # fexit_skel_load fexit skeleton failed                                       (trampoline)

get_stack_raw_tp                         # user_stack corrupted user stack                                             (no backchain userspace)

iters/testmod_seq*                       # s390x doesn't support kfuncs in modules yet

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

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

#include <test_progs.h>

#include <network_helpers.h>



#include "exceptions.skel.h"

#include "exceptions_ext.skel.h"

#include "exceptions_fail.skel.h"

#include "exceptions_assert.skel.h"



static char log_buf[1024 * 1024];



static void test_exceptions_failure(void)

{

	RUN_TESTS(exceptions_fail);

}



static void test_exceptions_success(void)

{

	LIBBPF_OPTS(bpf_test_run_opts, ropts,

		.data_in = &pkt_v4,

		.data_size_in = sizeof(pkt_v4),

		.repeat = 1,

	);

	struct exceptions_ext *eskel = NULL;

	struct exceptions *skel;

	int ret;



	skel = exceptions__open();

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

		return;



	ret = exceptions__load(skel);

	if (!ASSERT_OK(ret, "exceptions__load"))

		goto done;



	if (!ASSERT_OK(bpf_map_update_elem(bpf_map__fd(skel->maps.jmp_table), &(int){0},

					   &(int){bpf_program__fd(skel->progs.exception_tail_call_target)}, BPF_ANY),

		       "bpf_map_update_elem jmp_table"))

		goto done;



#define RUN_SUCCESS(_prog, return_val)						  \

	if (!test__start_subtest(#_prog)) goto _prog##_##return_val;		  \

	ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs._prog), &ropts); \

	ASSERT_OK(ret, #_prog " prog run ret");					  \

	ASSERT_EQ(ropts.retval, return_val, #_prog " prog run retval");		  \

	_prog##_##return_val:



	RUN_SUCCESS(exception_throw_always_1, 64);

	RUN_SUCCESS(exception_throw_always_2, 32);

	RUN_SUCCESS(exception_throw_unwind_1, 16);

	RUN_SUCCESS(exception_throw_unwind_2, 32);

	RUN_SUCCESS(exception_throw_default, 0);

	RUN_SUCCESS(exception_throw_default_value, 5);

	RUN_SUCCESS(exception_tail_call, 24);

	RUN_SUCCESS(exception_ext, 0);

	RUN_SUCCESS(exception_ext_mod_cb_runtime, 35);

	RUN_SUCCESS(exception_throw_subprog, 1);

	RUN_SUCCESS(exception_assert_nz_gfunc, 1);

	RUN_SUCCESS(exception_assert_zero_gfunc, 1);

	RUN_SUCCESS(exception_assert_neg_gfunc, 1);

	RUN_SUCCESS(exception_assert_pos_gfunc, 1);

	RUN_SUCCESS(exception_assert_negeq_gfunc, 1);

	RUN_SUCCESS(exception_assert_poseq_gfunc, 1);

	RUN_SUCCESS(exception_assert_nz_gfunc_with, 1);

	RUN_SUCCESS(exception_assert_zero_gfunc_with, 1);

	RUN_SUCCESS(exception_assert_neg_gfunc_with, 1);

	RUN_SUCCESS(exception_assert_pos_gfunc_with, 1);

	RUN_SUCCESS(exception_assert_negeq_gfunc_with, 1);

	RUN_SUCCESS(exception_assert_poseq_gfunc_with, 1);

	RUN_SUCCESS(exception_bad_assert_nz_gfunc, 0);

	RUN_SUCCESS(exception_bad_assert_zero_gfunc, 0);

	RUN_SUCCESS(exception_bad_assert_neg_gfunc, 0);

	RUN_SUCCESS(exception_bad_assert_pos_gfunc, 0);

	RUN_SUCCESS(exception_bad_assert_negeq_gfunc, 0);

	RUN_SUCCESS(exception_bad_assert_poseq_gfunc, 0);

	RUN_SUCCESS(exception_bad_assert_nz_gfunc_with, 100);

	RUN_SUCCESS(exception_bad_assert_zero_gfunc_with, 105);

	RUN_SUCCESS(exception_bad_assert_neg_gfunc_with, 200);

	RUN_SUCCESS(exception_bad_assert_pos_gfunc_with, 0);

	RUN_SUCCESS(exception_bad_assert_negeq_gfunc_with, 101);

	RUN_SUCCESS(exception_bad_assert_poseq_gfunc_with, 99);

	RUN_SUCCESS(exception_assert_range, 1);

	RUN_SUCCESS(exception_assert_range_with, 1);

	RUN_SUCCESS(exception_bad_assert_range, 0);

	RUN_SUCCESS(exception_bad_assert_range_with, 10);



#define RUN_EXT(load_ret, attach_err, expr, msg, after_link)			  \

	{									  \

		LIBBPF_OPTS(bpf_object_open_opts, o, .kernel_log_buf = log_buf,		 \

						     .kernel_log_size = sizeof(log_buf), \

						     .kernel_log_level = 2);		 \

		exceptions_ext__destroy(eskel);					  \

		eskel = exceptions_ext__open_opts(&o);				  \

		struct bpf_program *prog = NULL;				  \

		struct bpf_link *link = NULL;					  \

		if (!ASSERT_OK_PTR(eskel, "exceptions_ext__open"))		  \

			goto done;						  \

		(expr);								  \

		ASSERT_OK_PTR(bpf_program__name(prog), bpf_program__name(prog));  \

		if (!ASSERT_EQ(exceptions_ext__load(eskel), load_ret,		  \

			       "exceptions_ext__load"))	{			  \

			printf("%s\n", log_buf);				  \

			goto done;						  \

		}								  \

		if (load_ret != 0) {						  \

			printf("%s\n", log_buf);				  \

			if (!ASSERT_OK_PTR(strstr(log_buf, msg), "strstr"))	  \

				goto done;					  \

		}								  \

		if (!load_ret && attach_err) {					  \

			if (!ASSERT_ERR_PTR(link = bpf_program__attach(prog), "attach err")) \

				goto done;					  \

		} else if (!load_ret) {						  \

			if (!ASSERT_OK_PTR(link = bpf_program__attach(prog), "attach ok"))  \

				goto done;					  \

			(void)(after_link);					  \

			bpf_link__destroy(link);				  \

		}								  \

	}



	if (test__start_subtest("non-throwing fentry -> exception_cb"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.pfentry;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext_mod_cb_runtime),

				       "exception_cb_mod"), "set_attach_target"))

				goto done;

		}), "FENTRY/FEXIT programs cannot attach to exception callback", 0);



	if (test__start_subtest("throwing fentry -> exception_cb"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.throwing_fentry;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext_mod_cb_runtime),

				       "exception_cb_mod"), "set_attach_target"))

				goto done;

		}), "FENTRY/FEXIT programs cannot attach to exception callback", 0);



	if (test__start_subtest("non-throwing fexit -> exception_cb"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.pfexit;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext_mod_cb_runtime),

				       "exception_cb_mod"), "set_attach_target"))

				goto done;

		}), "FENTRY/FEXIT programs cannot attach to exception callback", 0);



	if (test__start_subtest("throwing fexit -> exception_cb"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.throwing_fexit;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext_mod_cb_runtime),

				       "exception_cb_mod"), "set_attach_target"))

				goto done;

		}), "FENTRY/FEXIT programs cannot attach to exception callback", 0);



	if (test__start_subtest("throwing extension (with custom cb) -> exception_cb"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.throwing_exception_cb_extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext_mod_cb_runtime),

				       "exception_cb_mod"), "set_attach_target"))

				goto done;

		}), "Extension programs cannot attach to exception callback", 0);



	if (test__start_subtest("throwing extension -> global func in exception_cb"))

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_exception_cb_extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext_mod_cb_runtime),

				       "exception_cb_mod_global"), "set_attach_target"))

				goto done;

		}), "", ({ RUN_SUCCESS(exception_ext_mod_cb_runtime, 131); }));



	if (test__start_subtest("throwing extension (with custom cb) -> global func in exception_cb"))

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_ext),

				       "exception_ext_global"), "set_attach_target"))

				goto done;

		}), "", ({ RUN_SUCCESS(exception_ext, 128); }));



	if (test__start_subtest("non-throwing fentry -> non-throwing subprog"))

		/* non-throwing fentry -> non-throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.pfentry;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing fentry -> non-throwing subprog"))

		/* throwing fentry -> non-throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_fentry;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("non-throwing fentry -> throwing subprog"))

		/* non-throwing fentry -> throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.pfentry;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing fentry -> throwing subprog"))

		/* throwing fentry -> throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_fentry;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("non-throwing fexit -> non-throwing subprog"))

		/* non-throwing fexit -> non-throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.pfexit;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing fexit -> non-throwing subprog"))

		/* throwing fexit -> non-throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_fexit;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("non-throwing fexit -> throwing subprog"))

		/* non-throwing fexit -> throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.pfexit;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing fexit -> throwing subprog"))

		/* throwing fexit -> throwing subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_fexit;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	/* fmod_ret not allowed for subprog - Check so we remember to handle its

	 * throwing specification compatibility with target when supported.

	 */

	if (test__start_subtest("non-throwing fmod_ret -> non-throwing subprog"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.pfmod_ret;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "subprog"), "set_attach_target"))

				goto done;

		}), "can't modify return codes of BPF program", 0);



	/* fmod_ret not allowed for subprog - Check so we remember to handle its

	 * throwing specification compatibility with target when supported.

	 */

	if (test__start_subtest("non-throwing fmod_ret -> non-throwing global subprog"))

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.pfmod_ret;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "global_subprog"), "set_attach_target"))

				goto done;

		}), "can't modify return codes of BPF program", 0);



	if (test__start_subtest("non-throwing extension -> non-throwing subprog"))

		/* non-throwing extension -> non-throwing subprog : BAD (!global) */

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "subprog"), "set_attach_target"))

				goto done;

		}), "subprog() is not a global function", 0);



	if (test__start_subtest("non-throwing extension -> throwing subprog"))

		/* non-throwing extension -> throwing subprog : BAD (!global) */

		RUN_EXT(-EINVAL, true, ({

			prog = eskel->progs.extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_subprog"), "set_attach_target"))

				goto done;

		}), "throwing_subprog() is not a global function", 0);



	if (test__start_subtest("non-throwing extension -> non-throwing subprog"))

		/* non-throwing extension -> non-throwing global subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "global_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("non-throwing extension -> throwing global subprog"))

		/* non-throwing extension -> throwing global subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_global_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing extension -> throwing global subprog"))

		/* throwing extension -> throwing global subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "throwing_global_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing extension -> non-throwing global subprog"))

		/* throwing extension -> non-throwing global subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "global_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("non-throwing extension -> main subprog"))

		/* non-throwing extension -> main subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "exception_throw_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



	if (test__start_subtest("throwing extension -> main subprog"))

		/* throwing extension -> main subprog : OK */

		RUN_EXT(0, false, ({

			prog = eskel->progs.throwing_extension;

			bpf_program__set_autoload(prog, true);

			if (!ASSERT_OK(bpf_program__set_attach_target(prog,

				       bpf_program__fd(skel->progs.exception_throw_subprog),

				       "exception_throw_subprog"), "set_attach_target"))

				goto done;

		}), "", 0);



done:

	exceptions_ext__destroy(eskel);

	exceptions__destroy(skel);

}



static void test_exceptions_assertions(void)

{

	RUN_TESTS(exceptions_assert);

}



void test_exceptions(void)

{

	test_exceptions_success();

	test_exceptions_failure();

	test_exceptions_assertions();

}

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

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

#include <vmlinux.h>

#include <bpf/bpf_tracing.h>

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_core_read.h>

#include <bpf/bpf_endian.h>

#include "bpf_misc.h"

#include "bpf_experimental.h"



#ifndef ETH_P_IP

#define ETH_P_IP 0x0800

#endif



struct {

	__uint(type, BPF_MAP_TYPE_PROG_ARRAY);

	__uint(max_entries, 4);

	__uint(key_size, sizeof(__u32));

	__uint(value_size, sizeof(__u32));

} jmp_table SEC(".maps");



static __noinline int static_func(u64 i)

{

	bpf_throw(32);

	return i;

}



__noinline int global2static_simple(u64 i)

{

	static_func(i + 2);

	return i - 1;

}



__noinline int global2static(u64 i)

{

	if (i == ETH_P_IP)

		bpf_throw(16);

	return static_func(i);

}



static __noinline int static2global(u64 i)

{

	return global2static(i) + i;

}



SEC("tc")

int exception_throw_always_1(struct __sk_buff *ctx)

{

	bpf_throw(64);

	return 0;

}



/* In this case, the global func will never be seen executing after call to

 * static subprog, hence verifier will DCE the remaining instructions. Ensure we

 * are resilient to that.

 */

SEC("tc")

int exception_throw_always_2(struct __sk_buff *ctx)

{

	return global2static_simple(ctx->protocol);

}



SEC("tc")

int exception_throw_unwind_1(struct __sk_buff *ctx)

{

	return static2global(bpf_ntohs(ctx->protocol));

}



SEC("tc")

int exception_throw_unwind_2(struct __sk_buff *ctx)

{

	return static2global(bpf_ntohs(ctx->protocol) - 1);

}



SEC("tc")

int exception_throw_default(struct __sk_buff *ctx)

{

	bpf_throw(0);

	return 1;

}



SEC("tc")

int exception_throw_default_value(struct __sk_buff *ctx)

{

	bpf_throw(5);

	return 1;

}



SEC("tc")

int exception_tail_call_target(struct __sk_buff *ctx)

{

	bpf_throw(16);

	return 0;

}



static __noinline

int exception_tail_call_subprog(struct __sk_buff *ctx)

{

	volatile int ret = 10;



	bpf_tail_call_static(ctx, &jmp_table, 0);

	return ret;

}



SEC("tc")

int exception_tail_call(struct __sk_buff *ctx) {

	volatile int ret = 0;



	ret = exception_tail_call_subprog(ctx);

	return ret + 8;

}



__noinline int exception_ext_global(struct __sk_buff *ctx)

{

	volatile int ret = 0;



	return ret;

}



static __noinline int exception_ext_static(struct __sk_buff *ctx)

{

	return exception_ext_global(ctx);

}



SEC("tc")

int exception_ext(struct __sk_buff *ctx)

{

	return exception_ext_static(ctx);

}



__noinline int exception_cb_mod_global(u64 cookie)

{

	volatile int ret = 0;



	return ret;

}



/* Example of how the exception callback supplied during verification can still

 * introduce extensions by calling to dummy global functions, and alter runtime

 * behavior.

 *

 * Right now we don't allow freplace attachment to exception callback itself,

 * but if the need arises this restriction is technically feasible to relax in

 * the future.

 */

__noinline int exception_cb_mod(u64 cookie)

{

	return exception_cb_mod_global(cookie) + cookie + 10;

}



SEC("tc")

__exception_cb(exception_cb_mod)

int exception_ext_mod_cb_runtime(struct __sk_buff *ctx)

{

	bpf_throw(25);

	return 0;

}



__noinline static int subprog(struct __sk_buff *ctx)

{

	return bpf_ktime_get_ns();

}



__noinline static int throwing_subprog(struct __sk_buff *ctx)

{

	if (ctx->tstamp)

		bpf_throw(0);

	return bpf_ktime_get_ns();

}



__noinline int global_subprog(struct __sk_buff *ctx)

{

	return bpf_ktime_get_ns();

}



__noinline int throwing_global_subprog(struct __sk_buff *ctx)

{

	if (ctx->tstamp)

		bpf_throw(0);

	return bpf_ktime_get_ns();

}



SEC("tc")

int exception_throw_subprog(struct __sk_buff *ctx)

{

	switch (ctx->protocol) {

	case 1:

		return subprog(ctx);

	case 2:

		return global_subprog(ctx);

	case 3:

		return throwing_subprog(ctx);

	case 4:

		return throwing_global_subprog(ctx);

	default:

		break;

	}

	bpf_throw(1);

	return 0;

}



__noinline int assert_nz_gfunc(u64 c)

{

	volatile u64 cookie = c;



	bpf_assert(cookie != 0);

	return 0;

}



__noinline int assert_zero_gfunc(u64 c)

{

	volatile u64 cookie = c;



	bpf_assert_eq(cookie, 0);

	return 0;

}



__noinline int assert_neg_gfunc(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_lt(cookie, 0);

	return 0;

}



__noinline int assert_pos_gfunc(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_gt(cookie, 0);

	return 0;

}



__noinline int assert_negeq_gfunc(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_le(cookie, -1);

	return 0;

}



__noinline int assert_poseq_gfunc(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_ge(cookie, 1);

	return 0;

}



__noinline int assert_nz_gfunc_with(u64 c)

{

	volatile u64 cookie = c;



	bpf_assert_with(cookie != 0, cookie + 100);

	return 0;

}



__noinline int assert_zero_gfunc_with(u64 c)

{

	volatile u64 cookie = c;



	bpf_assert_eq_with(cookie, 0, cookie + 100);

	return 0;

}



__noinline int assert_neg_gfunc_with(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_lt_with(cookie, 0, cookie + 100);

	return 0;

}



__noinline int assert_pos_gfunc_with(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_gt_with(cookie, 0, cookie + 100);

	return 0;

}



__noinline int assert_negeq_gfunc_with(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_le_with(cookie, -1, cookie + 100);

	return 0;

}



__noinline int assert_poseq_gfunc_with(s64 c)

{

	volatile s64 cookie = c;



	bpf_assert_ge_with(cookie, 1, cookie + 100);

	return 0;

}



#define check_assert(name, cookie, tag)				\

SEC("tc")							\

int exception##tag##name(struct __sk_buff *ctx)			\

{								\

	return name(cookie) + 1;				\

}



check_assert(assert_nz_gfunc, 5, _);

check_assert(assert_zero_gfunc, 0, _);

check_assert(assert_neg_gfunc, -100, _);

check_assert(assert_pos_gfunc, 100, _);

check_assert(assert_negeq_gfunc, -1, _);

check_assert(assert_poseq_gfunc, 1, _);



check_assert(assert_nz_gfunc_with, 5, _);

check_assert(assert_zero_gfunc_with, 0, _);

check_assert(assert_neg_gfunc_with, -100, _);

check_assert(assert_pos_gfunc_with, 100, _);

check_assert(assert_negeq_gfunc_with, -1, _);

check_assert(assert_poseq_gfunc_with, 1, _);



check_assert(assert_nz_gfunc, 0, _bad_);

check_assert(assert_zero_gfunc, 5, _bad_);

check_assert(assert_neg_gfunc, 100, _bad_);

check_assert(assert_pos_gfunc, -100, _bad_);

check_assert(assert_negeq_gfunc, 1, _bad_);

check_assert(assert_poseq_gfunc, -1, _bad_);



check_assert(assert_nz_gfunc_with, 0, _bad_);

check_assert(assert_zero_gfunc_with, 5, _bad_);

check_assert(assert_neg_gfunc_with, 100, _bad_);

check_assert(assert_pos_gfunc_with, -100, _bad_);

check_assert(assert_negeq_gfunc_with, 1, _bad_);

check_assert(assert_poseq_gfunc_with, -1, _bad_);



SEC("tc")

int exception_assert_range(struct __sk_buff *ctx)

{

	u64 time = bpf_ktime_get_ns();



	bpf_assert_range(time, 0, ~0ULL);

	return 1;

}



SEC("tc")

int exception_assert_range_with(struct __sk_buff *ctx)

{

	u64 time = bpf_ktime_get_ns();



	bpf_assert_range_with(time, 0, ~0ULL, 10);

	return 1;

}



SEC("tc")

int exception_bad_assert_range(struct __sk_buff *ctx)

{

	u64 time = bpf_ktime_get_ns();



	bpf_assert_range(time, -100, 100);

	return 1;

}



SEC("tc")

int exception_bad_assert_range_with(struct __sk_buff *ctx)

{

	u64 time = bpf_ktime_get_ns();



	bpf_assert_range_with(time, -1000, 1000, 10);

	return 1;

}



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

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

0 → 100644
+135 −0

File added.

Preview size limit exceeded, changes collapsed.