1// SPDX-License-Identifier: GPL-2.0-or-later 2 3#include <kunit/test.h> 4 5/* GSO */ 6 7#include <linux/skbuff.h> 8 9static const char hdr[] = "abcdefgh"; 10#define GSO_TEST_SIZE 1000 11 12static void __init_skb(struct sk_buff *skb) 13{ 14 skb_reset_mac_header(skb); 15 memcpy(skb_mac_header(skb), hdr, sizeof(hdr)); 16 17 /* skb_segment expects skb->data at start of payload */ 18 skb_pull(skb, sizeof(hdr)); 19 skb_reset_network_header(skb); 20 skb_reset_transport_header(skb); 21 22 /* proto is arbitrary, as long as not ETH_P_TEB or vlan */ 23 skb->protocol = htons(ETH_P_ATALK); 24 skb_shinfo(skb)->gso_size = GSO_TEST_SIZE; 25} 26 27enum gso_test_nr { 28 GSO_TEST_LINEAR, 29 GSO_TEST_NO_GSO, 30 GSO_TEST_FRAGS, 31 GSO_TEST_FRAGS_PURE, 32 GSO_TEST_GSO_PARTIAL, 33 GSO_TEST_FRAG_LIST, 34 GSO_TEST_FRAG_LIST_PURE, 35 GSO_TEST_FRAG_LIST_NON_UNIFORM, 36 GSO_TEST_GSO_BY_FRAGS, 37}; 38 39struct gso_test_case { 40 enum gso_test_nr id; 41 const char *name; 42 43 /* input */ 44 unsigned int linear_len; 45 unsigned int nr_frags; 46 const unsigned int *frags; 47 unsigned int nr_frag_skbs; 48 const unsigned int *frag_skbs; 49 50 /* output as expected */ 51 unsigned int nr_segs; 52 const unsigned int *segs; 53}; 54 55static struct gso_test_case cases[] = { 56 { 57 .id = GSO_TEST_NO_GSO, 58 .name = "no_gso", 59 .linear_len = GSO_TEST_SIZE, 60 .nr_segs = 1, 61 .segs = (const unsigned int[]) { GSO_TEST_SIZE }, 62 }, 63 { 64 .id = GSO_TEST_LINEAR, 65 .name = "linear", 66 .linear_len = GSO_TEST_SIZE + GSO_TEST_SIZE + 1, 67 .nr_segs = 3, 68 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 }, 69 }, 70 { 71 .id = GSO_TEST_FRAGS, 72 .name = "frags", 73 .linear_len = GSO_TEST_SIZE, 74 .nr_frags = 2, 75 .frags = (const unsigned int[]) { GSO_TEST_SIZE, 1 }, 76 .nr_segs = 3, 77 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 }, 78 }, 79 { 80 .id = GSO_TEST_FRAGS_PURE, 81 .name = "frags_pure", 82 .nr_frags = 3, 83 .frags = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 }, 84 .nr_segs = 3, 85 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 }, 86 }, 87 { 88 .id = GSO_TEST_GSO_PARTIAL, 89 .name = "gso_partial", 90 .linear_len = GSO_TEST_SIZE, 91 .nr_frags = 2, 92 .frags = (const unsigned int[]) { GSO_TEST_SIZE, 3 }, 93 .nr_segs = 2, 94 .segs = (const unsigned int[]) { 2 * GSO_TEST_SIZE, 3 }, 95 }, 96 { 97 /* commit 89319d3801d1: frag_list on mss boundaries */ 98 .id = GSO_TEST_FRAG_LIST, 99 .name = "frag_list", 100 .linear_len = GSO_TEST_SIZE, 101 .nr_frag_skbs = 2, 102 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE }, 103 .nr_segs = 3, 104 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE }, 105 }, 106 { 107 .id = GSO_TEST_FRAG_LIST_PURE, 108 .name = "frag_list_pure", 109 .nr_frag_skbs = 2, 110 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE }, 111 .nr_segs = 2, 112 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE }, 113 }, 114 { 115 /* commit 43170c4e0ba7: GRO of frag_list trains */ 116 .id = GSO_TEST_FRAG_LIST_NON_UNIFORM, 117 .name = "frag_list_non_uniform", 118 .linear_len = GSO_TEST_SIZE, 119 .nr_frag_skbs = 4, 120 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, 1, GSO_TEST_SIZE, 2 }, 121 .nr_segs = 4, 122 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE, 3 }, 123 }, 124 { 125 /* commit 3953c46c3ac7 ("sk_buff: allow segmenting based on frag sizes") and 126 * commit 90017accff61 ("sctp: Add GSO support") 127 * 128 * "there will be a cover skb with protocol headers and 129 * children ones containing the actual segments" 130 */ 131 .id = GSO_TEST_GSO_BY_FRAGS, 132 .name = "gso_by_frags", 133 .nr_frag_skbs = 4, 134 .frag_skbs = (const unsigned int[]) { 100, 200, 300, 400 }, 135 .nr_segs = 4, 136 .segs = (const unsigned int[]) { 100, 200, 300, 400 }, 137 }, 138}; 139 140static void gso_test_case_to_desc(struct gso_test_case *t, char *desc) 141{ 142 sprintf(desc, "%s", t->name); 143} 144 145KUNIT_ARRAY_PARAM(gso_test, cases, gso_test_case_to_desc); 146 147static void gso_test_func(struct kunit *test) 148{ 149 const int shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); 150 struct sk_buff *skb, *segs, *cur, *next, *last; 151 const struct gso_test_case *tcase; 152 netdev_features_t features; 153 struct page *page; 154 int i; 155 156 tcase = test->param_value; 157 158 page = alloc_page(GFP_KERNEL); 159 KUNIT_ASSERT_NOT_NULL(test, page); 160 skb = build_skb(page_address(page), sizeof(hdr) + tcase->linear_len + shinfo_size); 161 KUNIT_ASSERT_NOT_NULL(test, skb); 162 __skb_put(skb, sizeof(hdr) + tcase->linear_len); 163 164 __init_skb(skb); 165 166 if (tcase->nr_frags) { 167 unsigned int pg_off = 0; 168 169 page = alloc_page(GFP_KERNEL); 170 KUNIT_ASSERT_NOT_NULL(test, page); 171 page_ref_add(page, tcase->nr_frags - 1); 172 173 for (i = 0; i < tcase->nr_frags; i++) { 174 skb_fill_page_desc(skb, i, page, pg_off, tcase->frags[i]); 175 pg_off += tcase->frags[i]; 176 } 177 178 KUNIT_ASSERT_LE(test, pg_off, PAGE_SIZE); 179 180 skb->data_len = pg_off; 181 skb->len += skb->data_len; 182 skb->truesize += skb->data_len; 183 } 184 185 if (tcase->frag_skbs) { 186 unsigned int total_size = 0, total_true_size = 0; 187 struct sk_buff *frag_skb, *prev = NULL; 188 189 for (i = 0; i < tcase->nr_frag_skbs; i++) { 190 unsigned int frag_size; 191 192 page = alloc_page(GFP_KERNEL); 193 KUNIT_ASSERT_NOT_NULL(test, page); 194 195 frag_size = tcase->frag_skbs[i]; 196 frag_skb = build_skb(page_address(page), 197 frag_size + shinfo_size); 198 KUNIT_ASSERT_NOT_NULL(test, frag_skb); 199 __skb_put(frag_skb, frag_size); 200 201 if (prev) 202 prev->next = frag_skb; 203 else 204 skb_shinfo(skb)->frag_list = frag_skb; 205 prev = frag_skb; 206 207 total_size += frag_size; 208 total_true_size += frag_skb->truesize; 209 } 210 211 skb->len += total_size; 212 skb->data_len += total_size; 213 skb->truesize += total_true_size; 214 215 if (tcase->id == GSO_TEST_GSO_BY_FRAGS) 216 skb_shinfo(skb)->gso_size = GSO_BY_FRAGS; 217 } 218 219 features = NETIF_F_SG | NETIF_F_HW_CSUM; 220 if (tcase->id == GSO_TEST_GSO_PARTIAL) 221 features |= NETIF_F_GSO_PARTIAL; 222 223 /* TODO: this should also work with SG, 224 * rather than hit BUG_ON(i >= nfrags) 225 */ 226 if (tcase->id == GSO_TEST_FRAG_LIST_NON_UNIFORM) 227 features &= ~NETIF_F_SG; 228 229 segs = skb_segment(skb, features); 230 if (IS_ERR(segs)) { 231 KUNIT_FAIL(test, "segs error %pe", segs); 232 goto free_gso_skb; 233 } else if (!segs) { 234 KUNIT_FAIL(test, "no segments"); 235 goto free_gso_skb; 236 } 237 238 last = segs->prev; 239 for (cur = segs, i = 0; cur; cur = next, i++) { 240 next = cur->next; 241 242 KUNIT_ASSERT_EQ(test, cur->len, sizeof(hdr) + tcase->segs[i]); 243 244 /* segs have skb->data pointing to the mac header */ 245 KUNIT_ASSERT_PTR_EQ(test, skb_mac_header(cur), cur->data); 246 KUNIT_ASSERT_PTR_EQ(test, skb_network_header(cur), cur->data + sizeof(hdr)); 247 248 /* header was copied to all segs */ 249 KUNIT_ASSERT_EQ(test, memcmp(skb_mac_header(cur), hdr, sizeof(hdr)), 0); 250 251 /* last seg can be found through segs->prev pointer */ 252 if (!next) 253 KUNIT_ASSERT_PTR_EQ(test, cur, last); 254 255 consume_skb(cur); 256 } 257 258 KUNIT_ASSERT_EQ(test, i, tcase->nr_segs); 259 260free_gso_skb: 261 consume_skb(skb); 262} 263 264/* IP tunnel flags */ 265 266#include <net/ip_tunnels.h> 267 268struct ip_tunnel_flags_test { 269 const char *name; 270 271 const u16 *src_bits; 272 const u16 *exp_bits; 273 u8 src_num; 274 u8 exp_num; 275 276 __be16 exp_val; 277 bool exp_comp; 278}; 279 280#define IP_TUNNEL_FLAGS_TEST(n, src, comp, eval, exp) { \ 281 .name = (n), \ 282 .src_bits = (src), \ 283 .src_num = ARRAY_SIZE(src), \ 284 .exp_comp = (comp), \ 285 .exp_val = (eval), \ 286 .exp_bits = (exp), \ 287 .exp_num = ARRAY_SIZE(exp), \ 288} 289 290/* These are __be16-compatible and can be compared as is */ 291static const u16 ip_tunnel_flags_1[] = { 292 IP_TUNNEL_KEY_BIT, 293 IP_TUNNEL_STRICT_BIT, 294 IP_TUNNEL_ERSPAN_OPT_BIT, 295}; 296 297/* Due to the previous flags design limitation, setting either 298 * ``IP_TUNNEL_CSUM_BIT`` (on Big Endian) or ``IP_TUNNEL_DONT_FRAGMENT_BIT`` 299 * (on Little) also sets VTI/ISATAP bit. In the bitmap implementation, they 300 * correspond to ``BIT(16)``, which is bigger than ``U16_MAX``, but still is 301 * backward-compatible. 302 */ 303#ifdef __LITTLE_ENDIAN 304#define IP_TUNNEL_CONFLICT_BIT IP_TUNNEL_DONT_FRAGMENT_BIT 305#else 306#define IP_TUNNEL_CONFLICT_BIT IP_TUNNEL_CSUM_BIT 307#endif 308 309static const u16 ip_tunnel_flags_2_src[] = { 310 IP_TUNNEL_CONFLICT_BIT, 311}; 312 313static const u16 ip_tunnel_flags_2_exp[] = { 314 IP_TUNNEL_CONFLICT_BIT, 315 IP_TUNNEL_SIT_ISATAP_BIT, 316}; 317 318/* Bits 17 and higher are not compatible with __be16 flags */ 319static const u16 ip_tunnel_flags_3_src[] = { 320 IP_TUNNEL_VXLAN_OPT_BIT, 321 17, 322 18, 323 20, 324}; 325 326static const u16 ip_tunnel_flags_3_exp[] = { 327 IP_TUNNEL_VXLAN_OPT_BIT, 328}; 329 330static const struct ip_tunnel_flags_test ip_tunnel_flags_test[] = { 331 IP_TUNNEL_FLAGS_TEST("compat", ip_tunnel_flags_1, true, 332 cpu_to_be16(BIT(IP_TUNNEL_KEY_BIT) | 333 BIT(IP_TUNNEL_STRICT_BIT) | 334 BIT(IP_TUNNEL_ERSPAN_OPT_BIT)), 335 ip_tunnel_flags_1), 336 IP_TUNNEL_FLAGS_TEST("conflict", ip_tunnel_flags_2_src, true, 337 VTI_ISVTI, ip_tunnel_flags_2_exp), 338 IP_TUNNEL_FLAGS_TEST("new", ip_tunnel_flags_3_src, false, 339 cpu_to_be16(BIT(IP_TUNNEL_VXLAN_OPT_BIT)), 340 ip_tunnel_flags_3_exp), 341}; 342 343static void 344ip_tunnel_flags_test_case_to_desc(const struct ip_tunnel_flags_test *t, 345 char *desc) 346{ 347 strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE); 348} 349KUNIT_ARRAY_PARAM(ip_tunnel_flags_test, ip_tunnel_flags_test, 350 ip_tunnel_flags_test_case_to_desc); 351 352static void ip_tunnel_flags_test_run(struct kunit *test) 353{ 354 const struct ip_tunnel_flags_test *t = test->param_value; 355 IP_TUNNEL_DECLARE_FLAGS(src) = { }; 356 IP_TUNNEL_DECLARE_FLAGS(exp) = { }; 357 IP_TUNNEL_DECLARE_FLAGS(out); 358 359 for (u32 j = 0; j < t->src_num; j++) 360 __set_bit(t->src_bits[j], src); 361 for (u32 j = 0; j < t->exp_num; j++) 362 __set_bit(t->exp_bits[j], exp); 363 364 KUNIT_ASSERT_EQ(test, t->exp_comp, 365 ip_tunnel_flags_is_be16_compat(src)); 366 KUNIT_ASSERT_EQ(test, (__force u16)t->exp_val, 367 (__force u16)ip_tunnel_flags_to_be16(src)); 368 369 ip_tunnel_flags_from_be16(out, t->exp_val); 370 KUNIT_ASSERT_TRUE(test, __ipt_flag_op(bitmap_equal, exp, out)); 371} 372 373static struct kunit_case net_test_cases[] = { 374 KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params), 375 KUNIT_CASE_PARAM(ip_tunnel_flags_test_run, 376 ip_tunnel_flags_test_gen_params), 377 { }, 378}; 379 380static struct kunit_suite net_test_suite = { 381 .name = "net_core", 382 .test_cases = net_test_cases, 383}; 384kunit_test_suite(net_test_suite); 385 386MODULE_DESCRIPTION("KUnit tests for networking core"); 387MODULE_LICENSE("GPL"); 388