1// SPDX-License-Identifier: GPL-2.0-or-later
2
3#include <kunit/test.h>
4#include <linux/skbuff.h>
5
6static const char hdr[] = "abcdefgh";
7#define GSO_TEST_SIZE 1000
8
9static void __init_skb(struct sk_buff *skb)
10{
11 skb_reset_mac_header(skb);
12 memcpy(skb_mac_header(skb), hdr, sizeof(hdr));
13
14 /* skb_segment expects skb->data at start of payload */
15 skb_pull(skb, len: sizeof(hdr));
16 skb_reset_network_header(skb);
17 skb_reset_transport_header(skb);
18
19 /* proto is arbitrary, as long as not ETH_P_TEB or vlan */
20 skb->protocol = htons(ETH_P_ATALK);
21 skb_shinfo(skb)->gso_size = GSO_TEST_SIZE;
22}
23
24enum gso_test_nr {
25 GSO_TEST_LINEAR,
26 GSO_TEST_NO_GSO,
27 GSO_TEST_FRAGS,
28 GSO_TEST_FRAGS_PURE,
29 GSO_TEST_GSO_PARTIAL,
30 GSO_TEST_FRAG_LIST,
31 GSO_TEST_FRAG_LIST_PURE,
32 GSO_TEST_FRAG_LIST_NON_UNIFORM,
33 GSO_TEST_GSO_BY_FRAGS,
34};
35
36struct gso_test_case {
37 enum gso_test_nr id;
38 const char *name;
39
40 /* input */
41 unsigned int linear_len;
42 unsigned int nr_frags;
43 const unsigned int *frags;
44 unsigned int nr_frag_skbs;
45 const unsigned int *frag_skbs;
46
47 /* output as expected */
48 unsigned int nr_segs;
49 const unsigned int *segs;
50};
51
52static struct gso_test_case cases[] = {
53 {
54 .id = GSO_TEST_NO_GSO,
55 .name = "no_gso",
56 .linear_len = GSO_TEST_SIZE,
57 .nr_segs = 1,
58 .segs = (const unsigned int[]) { GSO_TEST_SIZE },
59 },
60 {
61 .id = GSO_TEST_LINEAR,
62 .name = "linear",
63 .linear_len = GSO_TEST_SIZE + GSO_TEST_SIZE + 1,
64 .nr_segs = 3,
65 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 },
66 },
67 {
68 .id = GSO_TEST_FRAGS,
69 .name = "frags",
70 .linear_len = GSO_TEST_SIZE,
71 .nr_frags = 2,
72 .frags = (const unsigned int[]) { GSO_TEST_SIZE, 1 },
73 .nr_segs = 3,
74 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 },
75 },
76 {
77 .id = GSO_TEST_FRAGS_PURE,
78 .name = "frags_pure",
79 .nr_frags = 3,
80 .frags = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 },
81 .nr_segs = 3,
82 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 },
83 },
84 {
85 .id = GSO_TEST_GSO_PARTIAL,
86 .name = "gso_partial",
87 .linear_len = GSO_TEST_SIZE,
88 .nr_frags = 2,
89 .frags = (const unsigned int[]) { GSO_TEST_SIZE, 3 },
90 .nr_segs = 2,
91 .segs = (const unsigned int[]) { 2 * GSO_TEST_SIZE, 3 },
92 },
93 {
94 /* commit 89319d3801d1: frag_list on mss boundaries */
95 .id = GSO_TEST_FRAG_LIST,
96 .name = "frag_list",
97 .linear_len = GSO_TEST_SIZE,
98 .nr_frag_skbs = 2,
99 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },
100 .nr_segs = 3,
101 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE },
102 },
103 {
104 .id = GSO_TEST_FRAG_LIST_PURE,
105 .name = "frag_list_pure",
106 .nr_frag_skbs = 2,
107 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },
108 .nr_segs = 2,
109 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },
110 },
111 {
112 /* commit 43170c4e0ba7: GRO of frag_list trains */
113 .id = GSO_TEST_FRAG_LIST_NON_UNIFORM,
114 .name = "frag_list_non_uniform",
115 .linear_len = GSO_TEST_SIZE,
116 .nr_frag_skbs = 4,
117 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, 1, GSO_TEST_SIZE, 2 },
118 .nr_segs = 4,
119 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE, 3 },
120 },
121 {
122 /* commit 3953c46c3ac7 ("sk_buff: allow segmenting based on frag sizes") and
123 * commit 90017accff61 ("sctp: Add GSO support")
124 *
125 * "there will be a cover skb with protocol headers and
126 * children ones containing the actual segments"
127 */
128 .id = GSO_TEST_GSO_BY_FRAGS,
129 .name = "gso_by_frags",
130 .nr_frag_skbs = 4,
131 .frag_skbs = (const unsigned int[]) { 100, 200, 300, 400 },
132 .nr_segs = 4,
133 .segs = (const unsigned int[]) { 100, 200, 300, 400 },
134 },
135};
136
137static void gso_test_case_to_desc(struct gso_test_case *t, char *desc)
138{
139 sprintf(buf: desc, fmt: "%s", t->name);
140}
141
142KUNIT_ARRAY_PARAM(gso_test, cases, gso_test_case_to_desc);
143
144static void gso_test_func(struct kunit *test)
145{
146 const int shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
147 struct sk_buff *skb, *segs, *cur, *next, *last;
148 const struct gso_test_case *tcase;
149 netdev_features_t features;
150 struct page *page;
151 int i;
152
153 tcase = test->param_value;
154
155 page = alloc_page(GFP_KERNEL);
156 KUNIT_ASSERT_NOT_NULL(test, page);
157 skb = build_skb(page_address(page), frag_size: sizeof(hdr) + tcase->linear_len + shinfo_size);
158 KUNIT_ASSERT_NOT_NULL(test, skb);
159 __skb_put(skb, len: sizeof(hdr) + tcase->linear_len);
160
161 __init_skb(skb);
162
163 if (tcase->nr_frags) {
164 unsigned int pg_off = 0;
165
166 page = alloc_page(GFP_KERNEL);
167 KUNIT_ASSERT_NOT_NULL(test, page);
168 page_ref_add(page, nr: tcase->nr_frags - 1);
169
170 for (i = 0; i < tcase->nr_frags; i++) {
171 skb_fill_page_desc(skb, i, page, off: pg_off, size: tcase->frags[i]);
172 pg_off += tcase->frags[i];
173 }
174
175 KUNIT_ASSERT_LE(test, pg_off, PAGE_SIZE);
176
177 skb->data_len = pg_off;
178 skb->len += skb->data_len;
179 skb->truesize += skb->data_len;
180 }
181
182 if (tcase->frag_skbs) {
183 unsigned int total_size = 0, total_true_size = 0;
184 struct sk_buff *frag_skb, *prev = NULL;
185
186 for (i = 0; i < tcase->nr_frag_skbs; i++) {
187 unsigned int frag_size;
188
189 page = alloc_page(GFP_KERNEL);
190 KUNIT_ASSERT_NOT_NULL(test, page);
191
192 frag_size = tcase->frag_skbs[i];
193 frag_skb = build_skb(page_address(page),
194 frag_size: frag_size + shinfo_size);
195 KUNIT_ASSERT_NOT_NULL(test, frag_skb);
196 __skb_put(skb: frag_skb, len: frag_size);
197
198 if (prev)
199 prev->next = frag_skb;
200 else
201 skb_shinfo(skb)->frag_list = frag_skb;
202 prev = frag_skb;
203
204 total_size += frag_size;
205 total_true_size += frag_skb->truesize;
206 }
207
208 skb->len += total_size;
209 skb->data_len += total_size;
210 skb->truesize += total_true_size;
211
212 if (tcase->id == GSO_TEST_GSO_BY_FRAGS)
213 skb_shinfo(skb)->gso_size = GSO_BY_FRAGS;
214 }
215
216 features = NETIF_F_SG | NETIF_F_HW_CSUM;
217 if (tcase->id == GSO_TEST_GSO_PARTIAL)
218 features |= NETIF_F_GSO_PARTIAL;
219
220 /* TODO: this should also work with SG,
221 * rather than hit BUG_ON(i >= nfrags)
222 */
223 if (tcase->id == GSO_TEST_FRAG_LIST_NON_UNIFORM)
224 features &= ~NETIF_F_SG;
225
226 segs = skb_segment(skb, features);
227 if (IS_ERR(ptr: segs)) {
228 KUNIT_FAIL(test, "segs error %pe", segs);
229 goto free_gso_skb;
230 } else if (!segs) {
231 KUNIT_FAIL(test, "no segments");
232 goto free_gso_skb;
233 }
234
235 last = segs->prev;
236 for (cur = segs, i = 0; cur; cur = next, i++) {
237 next = cur->next;
238
239 KUNIT_ASSERT_EQ(test, cur->len, sizeof(hdr) + tcase->segs[i]);
240
241 /* segs have skb->data pointing to the mac header */
242 KUNIT_ASSERT_PTR_EQ(test, skb_mac_header(cur), cur->data);
243 KUNIT_ASSERT_PTR_EQ(test, skb_network_header(cur), cur->data + sizeof(hdr));
244
245 /* header was copied to all segs */
246 KUNIT_ASSERT_EQ(test, memcmp(skb_mac_header(cur), hdr, sizeof(hdr)), 0);
247
248 /* last seg can be found through segs->prev pointer */
249 if (!next)
250 KUNIT_ASSERT_PTR_EQ(test, cur, last);
251
252 consume_skb(skb: cur);
253 }
254
255 KUNIT_ASSERT_EQ(test, i, tcase->nr_segs);
256
257free_gso_skb:
258 consume_skb(skb);
259}
260
261static struct kunit_case gso_test_cases[] = {
262 KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params),
263 {}
264};
265
266static struct kunit_suite gso_test_suite = {
267 .name = "net_core_gso",
268 .test_cases = gso_test_cases,
269};
270
271kunit_test_suite(gso_test_suite);
272
273MODULE_LICENSE("GPL");
274MODULE_DESCRIPTION("KUnit tests for segmentation offload");
275

source code of linux/net/core/gso_test.c