1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <test_progs.h> 4 #include <network_helpers.h> 5 #include "test_xdp_pull_data.skel.h" 6 7 #define PULL_MAX (1 << 31) 8 #define PULL_PLUS_ONE (1 << 30) 9 10 #define XDP_PACKET_HEADROOM 256 11 12 /* Find headroom and tailroom occupied by struct xdp_frame and struct 13 * skb_shared_info so that we can calculate the maximum pull lengths for 14 * test cases. They might not be the real size of the structures due to 15 * cache alignment. 16 */ 17 static int find_xdp_sizes(struct test_xdp_pull_data *skel, int frame_sz) 18 { 19 LIBBPF_OPTS(bpf_test_run_opts, topts); 20 struct xdp_md ctx = {}; 21 int prog_fd, err; 22 __u8 *buf; 23 24 buf = calloc(frame_sz, sizeof(__u8)); 25 if (!ASSERT_OK_PTR(buf, "calloc buf")) 26 return -ENOMEM; 27 28 topts.data_in = buf; 29 topts.data_out = buf; 30 topts.data_size_in = frame_sz; 31 topts.data_size_out = frame_sz; 32 /* Pass a data_end larger than the linear space available to make sure 33 * bpf_prog_test_run_xdp() will fill the linear data area so that 34 * xdp_find_sizes can infer the size of struct skb_shared_info 35 */ 36 ctx.data_end = frame_sz; 37 topts.ctx_in = &ctx; 38 topts.ctx_out = &ctx; 39 topts.ctx_size_in = sizeof(ctx); 40 topts.ctx_size_out = sizeof(ctx); 41 42 prog_fd = bpf_program__fd(skel->progs.xdp_find_sizes); 43 err = bpf_prog_test_run_opts(prog_fd, &topts); 44 ASSERT_OK(err, "bpf_prog_test_run_opts"); 45 46 free(buf); 47 48 return err; 49 } 50 51 /* xdp_pull_data_prog will directly read a marker 0xbb stored at buf[1024] 52 * so caller expecting XDP_PASS should always pass pull_len no less than 1024 53 */ 54 static void run_test(struct test_xdp_pull_data *skel, int retval, 55 int frame_sz, int buff_len, int meta_len, int data_len, 56 int pull_len) 57 { 58 LIBBPF_OPTS(bpf_test_run_opts, topts); 59 struct xdp_md ctx = {}; 60 int prog_fd, err; 61 __u8 *buf; 62 63 buf = calloc(buff_len, sizeof(__u8)); 64 if (!ASSERT_OK_PTR(buf, "calloc buf")) 65 return; 66 67 buf[meta_len + 1023] = 0xaa; 68 buf[meta_len + 1024] = 0xbb; 69 buf[meta_len + 1025] = 0xcc; 70 71 topts.data_in = buf; 72 topts.data_out = buf; 73 topts.data_size_in = buff_len; 74 topts.data_size_out = buff_len; 75 ctx.data = meta_len; 76 ctx.data_end = meta_len + data_len; 77 topts.ctx_in = &ctx; 78 topts.ctx_out = &ctx; 79 topts.ctx_size_in = sizeof(ctx); 80 topts.ctx_size_out = sizeof(ctx); 81 82 skel->bss->data_len = data_len; 83 if (pull_len & PULL_MAX) { 84 int headroom = XDP_PACKET_HEADROOM - meta_len - skel->bss->xdpf_sz; 85 int tailroom = frame_sz - XDP_PACKET_HEADROOM - 86 data_len - skel->bss->sinfo_sz; 87 88 pull_len = pull_len & PULL_PLUS_ONE ? 1 : 0; 89 pull_len += headroom + tailroom + data_len; 90 } 91 skel->bss->pull_len = pull_len; 92 93 prog_fd = bpf_program__fd(skel->progs.xdp_pull_data_prog); 94 err = bpf_prog_test_run_opts(prog_fd, &topts); 95 ASSERT_OK(err, "bpf_prog_test_run_opts"); 96 ASSERT_EQ(topts.retval, retval, "xdp_pull_data_prog retval"); 97 98 if (retval == XDP_DROP) 99 goto out; 100 101 ASSERT_EQ(ctx.data_end, meta_len + pull_len, "linear data size"); 102 ASSERT_EQ(topts.data_size_out, buff_len, "linear + non-linear data size"); 103 /* Make sure data around xdp->data_end was not messed up by 104 * bpf_xdp_pull_data() 105 */ 106 ASSERT_EQ(buf[meta_len + 1023], 0xaa, "data[1023]"); 107 ASSERT_EQ(buf[meta_len + 1024], 0xbb, "data[1024]"); 108 ASSERT_EQ(buf[meta_len + 1025], 0xcc, "data[1025]"); 109 out: 110 free(buf); 111 } 112 113 static void test_xdp_pull_data_basic(void) 114 { 115 u32 pg_sz, max_meta_len, max_data_len; 116 struct test_xdp_pull_data *skel; 117 int buff_len; 118 119 skel = test_xdp_pull_data__open_and_load(); 120 if (!ASSERT_OK_PTR(skel, "test_xdp_pull_data__open_and_load")) 121 return; 122 123 pg_sz = sysconf(_SC_PAGE_SIZE); 124 buff_len = pg_sz + pg_sz / 2; 125 126 if (find_xdp_sizes(skel, pg_sz)) 127 goto out; 128 129 max_meta_len = XDP_PACKET_HEADROOM - skel->bss->xdpf_sz; 130 max_data_len = pg_sz - XDP_PACKET_HEADROOM - skel->bss->sinfo_sz; 131 132 /* linear xdp pkt, pull 0 byte */ 133 run_test(skel, XDP_PASS, pg_sz, 2048, 0, 2048, 2048); 134 135 /* multi-buf pkt, pull results in linear xdp pkt */ 136 run_test(skel, XDP_PASS, pg_sz, 2048, 0, 1024, 2048); 137 138 /* multi-buf pkt, pull 1 byte to linear data area */ 139 run_test(skel, XDP_PASS, pg_sz, 9000, 0, 1024, 1025); 140 141 /* multi-buf pkt, pull 0 byte to linear data area */ 142 run_test(skel, XDP_PASS, pg_sz, 9000, 0, 1025, 1025); 143 144 /* multi-buf pkt, empty linear data area, pull requires memmove */ 145 run_test(skel, XDP_PASS, pg_sz, buff_len, 0, 0, PULL_MAX); 146 147 /* multi-buf pkt, no headroom */ 148 run_test(skel, XDP_PASS, pg_sz, buff_len, max_meta_len, 1024, PULL_MAX); 149 150 /* multi-buf pkt, no tailroom, pull requires memmove */ 151 run_test(skel, XDP_PASS, pg_sz, buff_len, 0, max_data_len, PULL_MAX); 152 153 /* Test cases with invalid pull length */ 154 155 /* linear xdp pkt, pull more than total data len */ 156 run_test(skel, XDP_DROP, pg_sz, 2048, 0, 2048, 2049); 157 158 /* multi-buf pkt with no space left in linear data area */ 159 run_test(skel, XDP_DROP, pg_sz, buff_len, max_meta_len, max_data_len, 160 PULL_MAX | PULL_PLUS_ONE); 161 162 /* multi-buf pkt, empty linear data area */ 163 run_test(skel, XDP_DROP, pg_sz, buff_len, 0, 0, PULL_MAX | PULL_PLUS_ONE); 164 165 /* multi-buf pkt, no headroom */ 166 run_test(skel, XDP_DROP, pg_sz, buff_len, max_meta_len, 1024, 167 PULL_MAX | PULL_PLUS_ONE); 168 169 /* multi-buf pkt, no tailroom */ 170 run_test(skel, XDP_DROP, pg_sz, buff_len, 0, max_data_len, 171 PULL_MAX | PULL_PLUS_ONE); 172 173 out: 174 test_xdp_pull_data__destroy(skel); 175 } 176 177 void test_xdp_pull_data(void) 178 { 179 if (test__start_subtest("xdp_pull_data")) 180 test_xdp_pull_data_basic(); 181 } 182