1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2021 Facebook */
  3#include <test_progs.h>
  4#include <network_helpers.h>
  5#include "kfunc_call_fail.skel.h"
  6#include "kfunc_call_test.skel.h"
  7#include "kfunc_call_test.lskel.h"
  8#include "kfunc_call_test_subprog.skel.h"
  9#include "kfunc_call_test_subprog.lskel.h"
 10#include "kfunc_call_destructive.skel.h"
 11
 12#include "cap_helpers.h"
 13
 14static size_t log_buf_sz = 1048576; /* 1 MB */
 15static char obj_log_buf[1048576];
 16
 17enum kfunc_test_type {
 18	tc_test = 0,
 19	syscall_test,
 20	syscall_null_ctx_test,
 21};
 22
 23struct kfunc_test_params {
 24	const char *prog_name;
 25	unsigned long lskel_prog_desc_offset;
 26	int retval;
 27	enum kfunc_test_type test_type;
 28	const char *expected_err_msg;
 29};
 30
 31#define __BPF_TEST_SUCCESS(name, __retval, type) \
 32	{ \
 33	  .prog_name = #name, \
 34	  .lskel_prog_desc_offset = offsetof(struct kfunc_call_test_lskel, progs.name), \
 35	  .retval = __retval, \
 36	  .test_type = type, \
 37	  .expected_err_msg = NULL, \
 38	}
 39
 40#define __BPF_TEST_FAIL(name, __retval, type, error_msg) \
 41	{ \
 42	  .prog_name = #name, \
 43	  .lskel_prog_desc_offset = 0 /* unused when test is failing */, \
 44	  .retval = __retval, \
 45	  .test_type = type, \
 46	  .expected_err_msg = error_msg, \
 47	}
 48
 49#define TC_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, tc_test)
 50#define SYSCALL_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, syscall_test)
 51#define SYSCALL_NULL_CTX_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, syscall_null_ctx_test)
 52
 53#define TC_FAIL(name, retval, error_msg) __BPF_TEST_FAIL(name, retval, tc_test, error_msg)
 54#define SYSCALL_NULL_CTX_FAIL(name, retval, error_msg) \
 55	__BPF_TEST_FAIL(name, retval, syscall_null_ctx_test, error_msg)
 56
 57static struct kfunc_test_params kfunc_tests[] = {
 58	/* failure cases:
 59	 * if retval is 0 -> the program will fail to load and the error message is an error
 60	 * if retval is not 0 -> the program can be loaded but running it will gives the
 61	 *                       provided return value. The error message is thus the one
 62	 *                       from a successful load
 63	 */
 64	SYSCALL_NULL_CTX_FAIL(kfunc_syscall_test_fail, -EINVAL, "processed 4 insns"),
 65	SYSCALL_NULL_CTX_FAIL(kfunc_syscall_test_null_fail, -EINVAL, "processed 4 insns"),
 66	TC_FAIL(kfunc_call_test_get_mem_fail_rdonly, 0, "R0 cannot write into rdonly_mem"),
 67	TC_FAIL(kfunc_call_test_get_mem_fail_use_after_free, 0, "invalid mem access 'scalar'"),
 68	TC_FAIL(kfunc_call_test_get_mem_fail_oob, 0, "min value is outside of the allowed memory range"),
 69	TC_FAIL(kfunc_call_test_get_mem_fail_not_const, 0, "is not a const"),
 70	TC_FAIL(kfunc_call_test_mem_acquire_fail, 0, "acquire kernel function does not return PTR_TO_BTF_ID"),
 71
 72	/* success cases */
 73	TC_TEST(kfunc_call_test1, 12),
 74	TC_TEST(kfunc_call_test2, 3),
 75	TC_TEST(kfunc_call_test4, -1234),
 76	TC_TEST(kfunc_call_test_ref_btf_id, 0),
 77	TC_TEST(kfunc_call_test_get_mem, 42),
 78	SYSCALL_TEST(kfunc_syscall_test, 0),
 79	SYSCALL_NULL_CTX_TEST(kfunc_syscall_test_null, 0),
 80	TC_TEST(kfunc_call_test_static_unused_arg, 0),
 81};
 82
 83struct syscall_test_args {
 84	__u8 data[16];
 85	size_t size;
 86};
 87
 88static void verify_success(struct kfunc_test_params *param)
 89{
 90	struct kfunc_call_test_lskel *lskel = NULL;
 91	LIBBPF_OPTS(bpf_test_run_opts, topts);
 92	struct bpf_prog_desc *lskel_prog;
 93	struct kfunc_call_test *skel;
 94	struct bpf_program *prog;
 95	int prog_fd, err;
 96	struct syscall_test_args args = {
 97		.size = 10,
 98	};
 99
100	switch (param->test_type) {
101	case syscall_test:
102		topts.ctx_in = &args;
103		topts.ctx_size_in = sizeof(args);
104		/* fallthrough */
105	case syscall_null_ctx_test:
106		break;
107	case tc_test:
108		topts.data_in = &pkt_v4;
109		topts.data_size_in = sizeof(pkt_v4);
110		topts.repeat = 1;
111		break;
112	}
113
114	/* first test with normal libbpf */
115	skel = kfunc_call_test__open_and_load();
116	if (!ASSERT_OK_PTR(skel, "skel"))
117		return;
118
119	prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);
120	if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
121		goto cleanup;
122
123	prog_fd = bpf_program__fd(prog);
124	err = bpf_prog_test_run_opts(prog_fd, &topts);
125	if (!ASSERT_OK(err, param->prog_name))
126		goto cleanup;
127
128	if (!ASSERT_EQ(topts.retval, param->retval, "retval"))
129		goto cleanup;
130
131	/* second test with light skeletons */
132	lskel = kfunc_call_test_lskel__open_and_load();
133	if (!ASSERT_OK_PTR(lskel, "lskel"))
134		goto cleanup;
135
136	lskel_prog = (struct bpf_prog_desc *)((char *)lskel + param->lskel_prog_desc_offset);
137
138	prog_fd = lskel_prog->prog_fd;
139	err = bpf_prog_test_run_opts(prog_fd, &topts);
140	if (!ASSERT_OK(err, param->prog_name))
141		goto cleanup;
142
143	ASSERT_EQ(topts.retval, param->retval, "retval");
144
145cleanup:
146	kfunc_call_test__destroy(skel);
147	if (lskel)
148		kfunc_call_test_lskel__destroy(lskel);
149}
150
151static void verify_fail(struct kfunc_test_params *param)
152{
153	LIBBPF_OPTS(bpf_object_open_opts, opts);
154	LIBBPF_OPTS(bpf_test_run_opts, topts);
155	struct bpf_program *prog;
156	struct kfunc_call_fail *skel;
157	int prog_fd, err;
158	struct syscall_test_args args = {
159		.size = 10,
160	};
161
162	opts.kernel_log_buf = obj_log_buf;
163	opts.kernel_log_size = log_buf_sz;
164	opts.kernel_log_level = 1;
165
166	switch (param->test_type) {
167	case syscall_test:
168		topts.ctx_in = &args;
169		topts.ctx_size_in = sizeof(args);
170		/* fallthrough */
171	case syscall_null_ctx_test:
172		break;
173	case tc_test:
174		topts.data_in = &pkt_v4;
175		topts.data_size_in = sizeof(pkt_v4);
176		topts.repeat = 1;
177		break;
178	}
179
180	skel = kfunc_call_fail__open_opts(&opts);
181	if (!ASSERT_OK_PTR(skel, "kfunc_call_fail__open_opts"))
182		goto cleanup;
183
184	prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);
185	if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
186		goto cleanup;
187
188	bpf_program__set_autoload(prog, true);
189
190	err = kfunc_call_fail__load(skel);
191	if (!param->retval) {
192		/* the verifier is supposed to complain and refuses to load */
193		if (!ASSERT_ERR(err, "unexpected load success"))
194			goto out_err;
195
196	} else {
197		/* the program is loaded but must dynamically fail */
198		if (!ASSERT_OK(err, "unexpected load error"))
199			goto out_err;
200
201		prog_fd = bpf_program__fd(prog);
202		err = bpf_prog_test_run_opts(prog_fd, &topts);
203		if (!ASSERT_EQ(err, param->retval, param->prog_name))
204			goto out_err;
205	}
206
207out_err:
208	if (!ASSERT_OK_PTR(strstr(obj_log_buf, param->expected_err_msg), "expected_err_msg")) {
209		fprintf(stderr, "Expected err_msg: %s\n", param->expected_err_msg);
210		fprintf(stderr, "Verifier output: %s\n", obj_log_buf);
211	}
212
213cleanup:
214	kfunc_call_fail__destroy(skel);
215}
216
217static void test_main(void)
218{
219	int i;
220
221	for (i = 0; i < ARRAY_SIZE(kfunc_tests); i++) {
222		if (!test__start_subtest(kfunc_tests[i].prog_name))
223			continue;
224
225		if (!kfunc_tests[i].expected_err_msg)
226			verify_success(&kfunc_tests[i]);
227		else
228			verify_fail(&kfunc_tests[i]);
229	}
230}
231
232static void test_subprog(void)
233{
234	struct kfunc_call_test_subprog *skel;
235	int prog_fd, err;
236	LIBBPF_OPTS(bpf_test_run_opts, topts,
237		.data_in = &pkt_v4,
238		.data_size_in = sizeof(pkt_v4),
239		.repeat = 1,
240	);
241
242	skel = kfunc_call_test_subprog__open_and_load();
243	if (!ASSERT_OK_PTR(skel, "skel"))
244		return;
245
246	prog_fd = bpf_program__fd(skel->progs.kfunc_call_test1);
247	err = bpf_prog_test_run_opts(prog_fd, &topts);
248	ASSERT_OK(err, "bpf_prog_test_run(test1)");
249	ASSERT_EQ(topts.retval, 10, "test1-retval");
250	ASSERT_NEQ(skel->data->active_res, -1, "active_res");
251	ASSERT_EQ(skel->data->sk_state_res, BPF_TCP_CLOSE, "sk_state_res");
252
253	kfunc_call_test_subprog__destroy(skel);
254}
255
256static void test_subprog_lskel(void)
257{
258	struct kfunc_call_test_subprog_lskel *skel;
259	int prog_fd, err;
260	LIBBPF_OPTS(bpf_test_run_opts, topts,
261		.data_in = &pkt_v4,
262		.data_size_in = sizeof(pkt_v4),
263		.repeat = 1,
264	);
265
266	skel = kfunc_call_test_subprog_lskel__open_and_load();
267	if (!ASSERT_OK_PTR(skel, "skel"))
268		return;
269
270	prog_fd = skel->progs.kfunc_call_test1.prog_fd;
271	err = bpf_prog_test_run_opts(prog_fd, &topts);
272	ASSERT_OK(err, "bpf_prog_test_run(test1)");
273	ASSERT_EQ(topts.retval, 10, "test1-retval");
274	ASSERT_NEQ(skel->data->active_res, -1, "active_res");
275	ASSERT_EQ(skel->data->sk_state_res, BPF_TCP_CLOSE, "sk_state_res");
276
277	kfunc_call_test_subprog_lskel__destroy(skel);
278}
279
280static int test_destructive_open_and_load(void)
281{
282	struct kfunc_call_destructive *skel;
283	int err;
284
285	skel = kfunc_call_destructive__open();
286	if (!ASSERT_OK_PTR(skel, "prog_open"))
287		return -1;
288
289	err = kfunc_call_destructive__load(skel);
290
291	kfunc_call_destructive__destroy(skel);
292
293	return err;
294}
295
296static void test_destructive(void)
297{
298	__u64 save_caps = 0;
299
300	ASSERT_OK(test_destructive_open_and_load(), "successful_load");
301
302	if (!ASSERT_OK(cap_disable_effective(1ULL << CAP_SYS_BOOT, &save_caps), "drop_caps"))
303		return;
304
305	ASSERT_EQ(test_destructive_open_and_load(), -13, "no_caps_failure");
306
307	cap_enable_effective(save_caps, NULL);
308}
309
310void test_kfunc_call(void)
311{
312	test_main();
313
314	if (test__start_subtest("subprog"))
315		test_subprog();
316
317	if (test__start_subtest("subprog_lskel"))
318		test_subprog_lskel();
319
320	if (test__start_subtest("destructive"))
321		test_destructive();
322}