// SPDX-License-Identifier: GPL-2.0-or-later #include <kunit/test.h> /* GSO */ #include <linux/skbuff.h> static const char hdr[] = "abcdefgh";#define GSO_TEST_SIZE 1000 static void __init_skb(struct sk_buff *skb){	skb_reset_mac_header(skb);	memcpy(skb_mac_header(skb), hdr, sizeof(hdr)); 	/* skb_segment expects skb->data at start of payload */	skb_pull(skb, sizeof(hdr));	skb_reset_network_header(skb);	skb_reset_transport_header(skb); 	/* proto is arbitrary, as long as not ETH_P_TEB or vlan */	skb->protocol = htons(ETH_P_ATALK);	skb_shinfo(skb)->gso_size = GSO_TEST_SIZE;} enum gso_test_nr {	GSO_TEST_LINEAR,	GSO_TEST_NO_GSO,	GSO_TEST_FRAGS,	GSO_TEST_FRAGS_PURE,	GSO_TEST_GSO_PARTIAL,	GSO_TEST_FRAG_LIST,	GSO_TEST_FRAG_LIST_PURE,	GSO_TEST_FRAG_LIST_NON_UNIFORM,	GSO_TEST_GSO_BY_FRAGS,}; struct gso_test_case {	enum gso_test_nr id;	const char *name; 	/* input */	unsigned int linear_len;	unsigned int nr_frags;	const unsigned int *frags;	unsigned int nr_frag_skbs;	const unsigned int *frag_skbs; 	/* output as expected */	unsigned int nr_segs;	const unsigned int *segs;}; static struct gso_test_case cases[] = {	{		.id = GSO_TEST_NO_GSO,		.name = "no_gso",		.linear_len = GSO_TEST_SIZE,		.nr_segs = 1,		.segs = (const unsigned int[]) { GSO_TEST_SIZE },	},	{		.id = GSO_TEST_LINEAR,		.name = "linear",		.linear_len = GSO_TEST_SIZE + GSO_TEST_SIZE + 1,		.nr_segs = 3,		.segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 },	},	{		.id = GSO_TEST_FRAGS,		.name = "frags",		.linear_len = GSO_TEST_SIZE,		.nr_frags = 2,		.frags = (const unsigned int[]) { GSO_TEST_SIZE, 1 },		.nr_segs = 3,		.segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 },	},	{		.id = GSO_TEST_FRAGS_PURE,		.name = "frags_pure",		.nr_frags = 3,		.frags = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 },		.nr_segs = 3,		.segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 },	},	{		.id = GSO_TEST_GSO_PARTIAL,		.name = "gso_partial",		.linear_len = GSO_TEST_SIZE,		.nr_frags = 2,		.frags = (const unsigned int[]) { GSO_TEST_SIZE, 3 },		.nr_segs = 2,		.segs = (const unsigned int[]) { 2 * GSO_TEST_SIZE, 3 },	},	{		/* commit 89319d3801d1: frag_list on mss boundaries */		.id = GSO_TEST_FRAG_LIST,		.name = "frag_list",		.linear_len = GSO_TEST_SIZE,		.nr_frag_skbs = 2,		.frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },		.nr_segs = 3,		.segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE },	},	{		.id = GSO_TEST_FRAG_LIST_PURE,		.name = "frag_list_pure",		.nr_frag_skbs = 2,		.frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },		.nr_segs = 2,		.segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },	},	{		/* commit 43170c4e0ba7: GRO of frag_list trains */		.id = GSO_TEST_FRAG_LIST_NON_UNIFORM,		.name = "frag_list_non_uniform",		.linear_len = GSO_TEST_SIZE,		.nr_frag_skbs = 4,		.frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, 1, GSO_TEST_SIZE, 2 },		.nr_segs = 4,		.segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE, 3 },	},	{		/* commit 3953c46c3ac7 ("sk_buff: allow segmenting based on frag sizes") and		 * commit 90017accff61 ("sctp: Add GSO support")		 *		 * "there will be a cover skb with protocol headers and		 *  children ones containing the actual segments"		 */		.id = GSO_TEST_GSO_BY_FRAGS,		.name = "gso_by_frags",		.nr_frag_skbs = 4,		.frag_skbs = (const unsigned int[]) { 100, 200, 300, 400 },		.nr_segs = 4,		.segs = (const unsigned int[]) { 100, 200, 300, 400 },	},}; static void gso_test_case_to_desc(struct gso_test_case *t, char *desc){	sprintf(desc, "%s", t->name);} KUNIT_ARRAY_PARAM(gso_test, cases, gso_test_case_to_desc); static void gso_test_func(struct kunit *test){	const int shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));	struct sk_buff *skb, *segs, *cur, *next, *last;	const struct gso_test_case *tcase;	netdev_features_t features;	struct page *page;	int i; 	tcase = test->param_value; 	page = alloc_page(GFP_KERNEL);	KUNIT_ASSERT_NOT_NULL(test, page);	skb = build_skb(page_address(page), sizeof(hdr) + tcase->linear_len + shinfo_size);	KUNIT_ASSERT_NOT_NULL(test, skb);	__skb_put(skb, sizeof(hdr) + tcase->linear_len); 	__init_skb(skb); 	if (tcase->nr_frags) {		unsigned int pg_off = 0; 		page = alloc_page(GFP_KERNEL);		KUNIT_ASSERT_NOT_NULL(test, page);		page_ref_add(page, tcase->nr_frags - 1); 		for (i = 0; i < tcase->nr_frags; i++) {			skb_fill_page_desc(skb, i, page, pg_off, tcase->frags[i]);			pg_off += tcase->frags[i];		} 		KUNIT_ASSERT_LE(test, pg_off, PAGE_SIZE); 		skb->data_len = pg_off;		skb->len += skb->data_len;		skb->truesize += skb->data_len;	} 	if (tcase->frag_skbs) {		unsigned int total_size = 0, total_true_size = 0;		struct sk_buff *frag_skb, *prev = NULL; 		for (i = 0; i < tcase->nr_frag_skbs; i++) {			unsigned int frag_size; 			page = alloc_page(GFP_KERNEL);			KUNIT_ASSERT_NOT_NULL(test, page); 			frag_size = tcase->frag_skbs[i];			frag_skb = build_skb(page_address(page),					     frag_size + shinfo_size);			KUNIT_ASSERT_NOT_NULL(test, frag_skb);			__skb_put(frag_skb, frag_size); 			if (prev)				prev->next = frag_skb;			else				skb_shinfo(skb)->frag_list = frag_skb;			prev = frag_skb; 			total_size += frag_size;			total_true_size += frag_skb->truesize;		} 		skb->len += total_size;		skb->data_len += total_size;		skb->truesize += total_true_size; 		if (tcase->id == GSO_TEST_GSO_BY_FRAGS)			skb_shinfo(skb)->gso_size = GSO_BY_FRAGS;	} 	features = NETIF_F_SG | NETIF_F_HW_CSUM;	if (tcase->id == GSO_TEST_GSO_PARTIAL)		features |= NETIF_F_GSO_PARTIAL; 	/* TODO: this should also work with SG,	 * rather than hit BUG_ON(i >= nfrags)	 */	if (tcase->id == GSO_TEST_FRAG_LIST_NON_UNIFORM)		features &= ~NETIF_F_SG; 	segs = skb_segment(skb, features);	if (IS_ERR(segs)) {		KUNIT_FAIL(test, "segs error %pe", segs);		goto free_gso_skb;	} else if (!segs) {		KUNIT_FAIL(test, "no segments");		goto free_gso_skb;	} 	last = segs->prev;	for (cur = segs, i = 0; cur; cur = next, i++) {		next = cur->next; 		KUNIT_ASSERT_EQ(test, cur->len, sizeof(hdr) + tcase->segs[i]); 		/* segs have skb->data pointing to the mac header */		KUNIT_ASSERT_PTR_EQ(test, skb_mac_header(cur), cur->data);		KUNIT_ASSERT_PTR_EQ(test, skb_network_header(cur), cur->data + sizeof(hdr)); 		/* header was copied to all segs */		KUNIT_ASSERT_EQ(test, memcmp(skb_mac_header(cur), hdr, sizeof(hdr)), 0); 		/* last seg can be found through segs->prev pointer */		if (!next)			KUNIT_ASSERT_PTR_EQ(test, cur, last); 		consume_skb(cur);	} 	KUNIT_ASSERT_EQ(test, i, tcase->nr_segs); free_gso_skb:	consume_skb(skb);} /* IP tunnel flags */ #include <net/ip_tunnels.h> struct ip_tunnel_flags_test {	const char	*name; 	const u16	*src_bits;	const u16	*exp_bits;	u8		src_num;	u8		exp_num; 	__be16		exp_val;	bool		exp_comp;}; #define IP_TUNNEL_FLAGS_TEST(n, src, comp, eval, exp) {	\	.name		= (n),				\	.src_bits	= (src),			\	.src_num	= ARRAY_SIZE(src),		\	.exp_comp	= (comp),			\	.exp_val	= (eval),			\	.exp_bits	= (exp),			\	.exp_num	= ARRAY_SIZE(exp),		\} /* These are __be16-compatible and can be compared as is */static const u16 ip_tunnel_flags_1[] = {	IP_TUNNEL_KEY_BIT,	IP_TUNNEL_STRICT_BIT,	IP_TUNNEL_ERSPAN_OPT_BIT,}; /* Due to the previous flags design limitation, setting either * ``IP_TUNNEL_CSUM_BIT`` (on Big Endian) or ``IP_TUNNEL_DONT_FRAGMENT_BIT`` * (on Little) also sets VTI/ISATAP bit. In the bitmap implementation, they * correspond to ``BIT(16)``, which is bigger than ``U16_MAX``, but still is * backward-compatible. */#ifdef __LITTLE_ENDIAN#define IP_TUNNEL_CONFLICT_BIT	IP_TUNNEL_DONT_FRAGMENT_BIT#else#define IP_TUNNEL_CONFLICT_BIT	IP_TUNNEL_CSUM_BIT#endif static const u16 ip_tunnel_flags_2_src[] = {	IP_TUNNEL_CONFLICT_BIT,}; static const u16 ip_tunnel_flags_2_exp[] = {	IP_TUNNEL_CONFLICT_BIT,	IP_TUNNEL_SIT_ISATAP_BIT,}; /* Bits 17 and higher are not compatible with __be16 flags */static const u16 ip_tunnel_flags_3_src[] = {	IP_TUNNEL_VXLAN_OPT_BIT,	17,	18,	20,}; static const u16 ip_tunnel_flags_3_exp[] = {	IP_TUNNEL_VXLAN_OPT_BIT,}; static const struct ip_tunnel_flags_test ip_tunnel_flags_test[] = {	IP_TUNNEL_FLAGS_TEST("compat", ip_tunnel_flags_1, true,			     cpu_to_be16(BIT(IP_TUNNEL_KEY_BIT) |					 BIT(IP_TUNNEL_STRICT_BIT) |					 BIT(IP_TUNNEL_ERSPAN_OPT_BIT)),			     ip_tunnel_flags_1),	IP_TUNNEL_FLAGS_TEST("conflict", ip_tunnel_flags_2_src, true,			     VTI_ISVTI, ip_tunnel_flags_2_exp),	IP_TUNNEL_FLAGS_TEST("new", ip_tunnel_flags_3_src, false,			     cpu_to_be16(BIT(IP_TUNNEL_VXLAN_OPT_BIT)),			     ip_tunnel_flags_3_exp),}; static voidip_tunnel_flags_test_case_to_desc(const struct ip_tunnel_flags_test *t,				  char *desc){	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);}KUNIT_ARRAY_PARAM(ip_tunnel_flags_test, ip_tunnel_flags_test,		  ip_tunnel_flags_test_case_to_desc); static void ip_tunnel_flags_test_run(struct kunit *test){	const struct ip_tunnel_flags_test *t = test->param_value;	IP_TUNNEL_DECLARE_FLAGS(src) = { };	IP_TUNNEL_DECLARE_FLAGS(exp) = { };	IP_TUNNEL_DECLARE_FLAGS(out); 	for (u32 j = 0; j < t->src_num; j++)		__set_bit(t->src_bits[j], src);	for (u32 j = 0; j < t->exp_num; j++)		__set_bit(t->exp_bits[j], exp); 	KUNIT_ASSERT_EQ(test, t->exp_comp,			ip_tunnel_flags_is_be16_compat(src));	KUNIT_ASSERT_EQ(test, (__force u16)t->exp_val,			(__force u16)ip_tunnel_flags_to_be16(src)); 	ip_tunnel_flags_from_be16(out, t->exp_val);	KUNIT_ASSERT_TRUE(test, __ipt_flag_op(bitmap_equal, exp, out));} static struct kunit_case net_test_cases[] = {	KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params),	KUNIT_CASE_PARAM(ip_tunnel_flags_test_run,			 ip_tunnel_flags_test_gen_params),	{ },}; static struct kunit_suite net_test_suite = {	.name		= "net_core",	.test_cases	= net_test_cases,};kunit_test_suite(net_test_suite); MODULE_DESCRIPTION("KUnit tests for networking core");MODULE_LICENSE("GPL");