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