1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | |
3 | #include <kunit/test.h> |
4 | #include <linux/skbuff.h> |
5 | |
6 | static const char hdr[] = "abcdefgh" ; |
7 | #define GSO_TEST_SIZE 1000 |
8 | |
9 | static 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 | |
24 | enum 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 | |
36 | struct 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 | |
52 | static 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 | |
137 | static void gso_test_case_to_desc(struct gso_test_case *t, char *desc) |
138 | { |
139 | sprintf(buf: desc, fmt: "%s" , t->name); |
140 | } |
141 | |
142 | KUNIT_ARRAY_PARAM(gso_test, cases, gso_test_case_to_desc); |
143 | |
144 | static 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 | |
257 | free_gso_skb: |
258 | consume_skb(skb); |
259 | } |
260 | |
261 | static struct kunit_case gso_test_cases[] = { |
262 | KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params), |
263 | {} |
264 | }; |
265 | |
266 | static struct kunit_suite gso_test_suite = { |
267 | .name = "net_core_gso" , |
268 | .test_cases = gso_test_cases, |
269 | }; |
270 | |
271 | kunit_test_suite(gso_test_suite); |
272 | |
273 | MODULE_LICENSE("GPL" ); |
274 | MODULE_DESCRIPTION("KUnit tests for segmentation offload" ); |
275 | |