dynptr.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2022 Facebook */
  3
  4#include <test_progs.h>
  5#include <network_helpers.h>
  6#include "dynptr_fail.skel.h"
  7#include "dynptr_success.skel.h"
  8
  9enum test_setup_type {
 10	SETUP_SYSCALL_SLEEP,
 11	SETUP_SKB_PROG,
 12	SETUP_SKB_PROG_TP,
 13	SETUP_XDP_PROG,
 14};
 15
 16static struct {
 17	const char *prog_name;
 18	enum test_setup_type type;
 19} success_tests[] = {
 20	{"test_read_write", SETUP_SYSCALL_SLEEP},
 21	{"test_dynptr_data", SETUP_SYSCALL_SLEEP},
 22	{"test_dynptr_copy", SETUP_SYSCALL_SLEEP},
 23	{"test_dynptr_copy_xdp", SETUP_XDP_PROG},
 24	{"test_dynptr_memset_zero", SETUP_SYSCALL_SLEEP},
 25	{"test_dynptr_memset_notzero", SETUP_SYSCALL_SLEEP},
 26	{"test_dynptr_memset_zero_offset", SETUP_SYSCALL_SLEEP},
 27	{"test_dynptr_memset_zero_adjusted", SETUP_SYSCALL_SLEEP},
 28	{"test_dynptr_memset_overflow", SETUP_SYSCALL_SLEEP},
 29	{"test_dynptr_memset_overflow_offset", SETUP_SYSCALL_SLEEP},
 30	{"test_dynptr_memset_readonly", SETUP_SKB_PROG},
 31	{"test_dynptr_memset_xdp_chunks", SETUP_XDP_PROG},
 32	{"test_ringbuf", SETUP_SYSCALL_SLEEP},
 33	{"test_skb_readonly", SETUP_SKB_PROG},
 34	{"test_dynptr_skb_data", SETUP_SKB_PROG},
 35	{"test_dynptr_skb_meta_data", SETUP_SKB_PROG},
 36	{"test_dynptr_skb_meta_flags", SETUP_SKB_PROG},
 37	{"test_adjust", SETUP_SYSCALL_SLEEP},
 38	{"test_adjust_err", SETUP_SYSCALL_SLEEP},
 39	{"test_zero_size_dynptr", SETUP_SYSCALL_SLEEP},
 40	{"test_dynptr_is_null", SETUP_SYSCALL_SLEEP},
 41	{"test_dynptr_is_rdonly", SETUP_SKB_PROG},
 42	{"test_dynptr_clone", SETUP_SKB_PROG},
 43	{"test_dynptr_skb_no_buff", SETUP_SKB_PROG},
 44	{"test_dynptr_skb_strcmp", SETUP_SKB_PROG},
 45	{"test_dynptr_skb_tp_btf", SETUP_SKB_PROG_TP},
 46	{"test_probe_read_user_dynptr", SETUP_XDP_PROG},
 47	{"test_probe_read_kernel_dynptr", SETUP_XDP_PROG},
 48	{"test_probe_read_user_str_dynptr", SETUP_XDP_PROG},
 49	{"test_probe_read_kernel_str_dynptr", SETUP_XDP_PROG},
 50	{"test_copy_from_user_dynptr", SETUP_SYSCALL_SLEEP},
 51	{"test_copy_from_user_str_dynptr", SETUP_SYSCALL_SLEEP},
 52	{"test_copy_from_user_task_dynptr", SETUP_SYSCALL_SLEEP},
 53	{"test_copy_from_user_task_str_dynptr", SETUP_SYSCALL_SLEEP},
 54};
 55
 56#define PAGE_SIZE_64K 65536
 57
 58static void verify_success(const char *prog_name, enum test_setup_type setup_type)
 59{
 60	char user_data[384] = {[0 ... 382] = 'a', '\0'};
 61	struct dynptr_success *skel;
 62	struct bpf_program *prog;
 63	struct bpf_link *link;
 64	int err;
 65
 66	skel = dynptr_success__open();
 67	if (!ASSERT_OK_PTR(skel, "dynptr_success__open"))
 68		return;
 69
 70	skel->bss->pid = getpid();
 71
 72	prog = bpf_object__find_program_by_name(skel->obj, prog_name);
 73	if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
 74		goto cleanup;
 75
 76	bpf_program__set_autoload(prog, true);
 77
 78	err = dynptr_success__load(skel);
 79	if (!ASSERT_OK(err, "dynptr_success__load"))
 80		goto cleanup;
 81
 82	skel->bss->user_ptr = user_data;
 83	skel->data->test_len[0] = sizeof(user_data);
 84	memcpy(skel->bss->expected_str, user_data, sizeof(user_data));
 85
 86	switch (setup_type) {
 87	case SETUP_SYSCALL_SLEEP:
 88		link = bpf_program__attach(prog);
 89		if (!ASSERT_OK_PTR(link, "bpf_program__attach"))
 90			goto cleanup;
 91
 92		usleep(1);
 93
 94		bpf_link__destroy(link);
 95		break;
 96	case SETUP_SKB_PROG:
 97	{
 98		int prog_fd;
 99		char buf[64];
100
101		LIBBPF_OPTS(bpf_test_run_opts, topts,
102			    .data_in = &pkt_v4,
103			    .data_size_in = sizeof(pkt_v4),
104			    .data_out = buf,
105			    .data_size_out = sizeof(buf),
106			    .repeat = 1,
107		);
108
109		prog_fd = bpf_program__fd(prog);
110		if (!ASSERT_GE(prog_fd, 0, "prog_fd"))
111			goto cleanup;
112
113		err = bpf_prog_test_run_opts(prog_fd, &topts);
114
115		if (!ASSERT_OK(err, "test_run"))
116			goto cleanup;
117
118		break;
119	}
120	case SETUP_SKB_PROG_TP:
121	{
122		struct __sk_buff skb = {};
123		struct bpf_object *obj;
124		int aux_prog_fd;
125
126		/* Just use its test_run to trigger kfree_skb tracepoint */
127		err = bpf_prog_test_load("./test_pkt_access.bpf.o", BPF_PROG_TYPE_SCHED_CLS,
128					 &obj, &aux_prog_fd);
129		if (!ASSERT_OK(err, "prog_load sched cls"))
130			goto cleanup;
131
132		LIBBPF_OPTS(bpf_test_run_opts, topts,
133			    .data_in = &pkt_v4,
134			    .data_size_in = sizeof(pkt_v4),
135			    .ctx_in = &skb,
136			    .ctx_size_in = sizeof(skb),
137		);
138
139		link = bpf_program__attach(prog);
140		if (!ASSERT_OK_PTR(link, "bpf_program__attach"))
141			goto cleanup;
142
143		err = bpf_prog_test_run_opts(aux_prog_fd, &topts);
144		bpf_link__destroy(link);
145
146		if (!ASSERT_OK(err, "test_run"))
147			goto cleanup;
148
149		break;
150	}
151	case SETUP_XDP_PROG:
152	{
153		char data[90000];
154		int err, prog_fd;
155		LIBBPF_OPTS(bpf_test_run_opts, opts,
156			    .data_in = &data,
157			    .repeat = 1,
158		);
159
160		if (getpagesize() == PAGE_SIZE_64K)
161			opts.data_size_in = sizeof(data);
162		else
163			opts.data_size_in = 5000;
164
165		prog_fd = bpf_program__fd(prog);
166		err = bpf_prog_test_run_opts(prog_fd, &opts);
167
168		if (!ASSERT_OK(err, "test_run"))
169			goto cleanup;
170
171		break;
172	}
173	}
174
175	ASSERT_EQ(skel->bss->err, 0, "err");
176
177cleanup:
178	dynptr_success__destroy(skel);
179}
180
181void test_dynptr(void)
182{
183	int i;
184
185	for (i = 0; i < ARRAY_SIZE(success_tests); i++) {
186		if (!test__start_subtest(success_tests[i].prog_name))
187			continue;
188
189		verify_success(success_tests[i].prog_name, success_tests[i].type);
190	}
191
192	RUN_TESTS(dynptr_fail);
193}