linux/tools/testing/selftests/bpf/prog_tests/atomic_bounds.c

// SPDX-License-Identifier: GPL-2.0

#include <test_progs.h>

#include "atomic_bounds.skel.h"

void test_atomic_bounds(void)
{
	struct atomic_bounds *skel;
	__u32 duration = 0;

	skel = atomic_bounds__open_and_load();
	if (CHECK(!skel, "skel_load", "couldn't load program\n"))
		return;

	atomic_bounds__destroy(skel);
}
bpf: Propagate stack bounds to registers in atomics w/ BPF_FETCH When BPF_FETCH is set, atomic instructions load a value from memory into a register. The current verifier code first checks via check_mem_access whether we can access the memory, and then checks via check_reg_arg whether we can write into the register. For loads, check_reg_arg has the side-effect of marking the register's value as unkonwn, and check_mem_access has the side effect of propagating bounds from memory to the register. This currently only takes effect for stack memory. Therefore with the current order, bounds information is thrown away, but by simply reversing the order of check_reg_arg vs. check_mem_access, we can instead propagate bounds smartly. A simple test is added with an infinite loop that can only be proved unreachable if this propagation is present. This is implemented both with C and directly in test_verifier using assembly. Suggested-by: John Fastabend <john.fastabend@gmail.com> Signed-off-by: Brendan Jackman <jackmanb@google.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://lore.kernel.org/bpf/20210202135002.4024825-1-jackmanb@google.com 2021-02-02 13:50:02 +00:00			`// SPDX-License-Identifier: GPL-2.0`

			`#include <test_progs.h>`

			`#include "atomic_bounds.skel.h"`

			`void test_atomic_bounds(void)`
			`{`
			`struct atomic_bounds *skel;`
			`__u32 duration = 0;`

			`skel = atomic_bounds__open_and_load();`
			`if (CHECK(!skel, "skel_load", "couldn't load program\n"))`
			`return;`
selftests/bpf: Add missing cleanup in atomic_bounds test Add missing skeleton destroy call. Fixes: 37086bfdc737 ("bpf: Propagate stack bounds to registers in atomics w/ BPF_FETCH") Reported-by: Yonghong Song <yhs@fb.com> Signed-off-by: Brendan Jackman <jackmanb@google.com> Signed-off-by: Andrii Nakryiko <andrii@kernel.org> Link: https://lore.kernel.org/bpf/20210208123737.963172-1-jackmanb@google.com 2021-02-08 12:37:37 +00:00
			`atomic_bounds__destroy(skel);`
bpf: Propagate stack bounds to registers in atomics w/ BPF_FETCH When BPF_FETCH is set, atomic instructions load a value from memory into a register. The current verifier code first checks via check_mem_access whether we can access the memory, and then checks via check_reg_arg whether we can write into the register. For loads, check_reg_arg has the side-effect of marking the register's value as unkonwn, and check_mem_access has the side effect of propagating bounds from memory to the register. This currently only takes effect for stack memory. Therefore with the current order, bounds information is thrown away, but by simply reversing the order of check_reg_arg vs. check_mem_access, we can instead propagate bounds smartly. A simple test is added with an infinite loop that can only be proved unreachable if this propagation is present. This is implemented both with C and directly in test_verifier using assembly. Suggested-by: John Fastabend <john.fastabend@gmail.com> Signed-off-by: Brendan Jackman <jackmanb@google.com> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://lore.kernel.org/bpf/20210202135002.4024825-1-jackmanb@google.com 2021-02-02 13:50:02 +00:00			`}`