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, 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(desc, "%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), sizeof(hdr) + tcase->linear_len + shinfo_size); 158 KUNIT_ASSERT_NOT_NULL(test, skb); 159 __skb_put(skb, 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, tcase->nr_frags - 1); 169 170 for (i = 0; i < tcase->nr_frags; i++) { 171 skb_fill_page_desc(skb, i, page, pg_off, 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 + shinfo_size); 195 KUNIT_ASSERT_NOT_NULL(test, frag_skb); 196 __skb_put(frag_skb, 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(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(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