Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 */
17static 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 */
54static 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]");
109out:
110 free(buf);
111}
112
113static 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
173out:
174 test_xdp_pull_data__destroy(skel);
175}
176
177void test_xdp_pull_data(void)
178{
179 if (test__start_subtest("xdp_pull_data"))
180 test_xdp_pull_data_basic();
181}