route-test.c

   1// SPDX-License-Identifier: GPL-2.0
   2
   3#include <kunit/test.h>
   4
   5/* keep clangd happy when compiled outside of the route.c include */
   6#include <net/mctp.h>
   7#include <net/mctpdevice.h>
   8
   9#include "utils.h"
  10
  11#define mctp_test_create_skb_data(h, d) \
  12	__mctp_test_create_skb_data(h, d, sizeof(*d))
  13
  14struct mctp_frag_test {
  15	unsigned int mtu;
  16	unsigned int msgsize;
  17	unsigned int n_frags;
  18};
  19
  20static void mctp_test_fragment(struct kunit *test)
  21{
  22	const struct mctp_frag_test *params;
  23	int rc, i, n, mtu, msgsize;
  24	struct mctp_test_dev *dev;
  25	struct mctp_dst dst;
  26	struct sk_buff *skb;
  27	struct mctp_hdr hdr;
  28	u8 seq;
  29
  30	params = test->param_value;
  31	mtu = params->mtu;
  32	msgsize = params->msgsize;
  33
  34	hdr.ver = 1;
  35	hdr.src = 8;
  36	hdr.dest = 10;
  37	hdr.flags_seq_tag = MCTP_HDR_FLAG_TO;
  38
  39	skb = mctp_test_create_skb(&hdr, msgsize);
  40	KUNIT_ASSERT_TRUE(test, skb);
  41
  42	dev = mctp_test_create_dev();
  43	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
  44
  45	mctp_test_dst_setup(test, &dst, dev, mtu);
  46
  47	rc = mctp_do_fragment_route(&dst, skb, mtu, MCTP_TAG_OWNER);
  48	KUNIT_EXPECT_FALSE(test, rc);
  49
  50	n = dev->pkts.qlen;
  51	KUNIT_EXPECT_EQ(test, n, params->n_frags);
  52
  53	for (i = 0;; i++) {
  54		struct mctp_hdr *hdr2;
  55		struct sk_buff *skb2;
  56		u8 tag_mask, seq2;
  57		bool first, last;
  58
  59		first = i == 0;
  60		last = i == (n - 1);
  61
  62		skb2 = skb_dequeue(&dev->pkts);
  63		if (!skb2)
  64			break;
  65
  66		hdr2 = mctp_hdr(skb2);
  67
  68		tag_mask = MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO;
  69
  70		KUNIT_EXPECT_EQ(test, hdr2->ver, hdr.ver);
  71		KUNIT_EXPECT_EQ(test, hdr2->src, hdr.src);
  72		KUNIT_EXPECT_EQ(test, hdr2->dest, hdr.dest);
  73		KUNIT_EXPECT_EQ(test, hdr2->flags_seq_tag & tag_mask,
  74				hdr.flags_seq_tag & tag_mask);
  75
  76		KUNIT_EXPECT_EQ(test,
  77				!!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_SOM), first);
  78		KUNIT_EXPECT_EQ(test,
  79				!!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_EOM), last);
  80
  81		seq2 = (hdr2->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) &
  82			MCTP_HDR_SEQ_MASK;
  83
  84		if (first) {
  85			seq = seq2;
  86		} else {
  87			seq++;
  88			KUNIT_EXPECT_EQ(test, seq2, seq & MCTP_HDR_SEQ_MASK);
  89		}
  90
  91		if (!last)
  92			KUNIT_EXPECT_EQ(test, skb2->len, mtu);
  93		else
  94			KUNIT_EXPECT_LE(test, skb2->len, mtu);
  95
  96		kfree_skb(skb2);
  97	}
  98
  99	mctp_dst_release(&dst);
 100	mctp_test_destroy_dev(dev);
 101}
 102
 103static const struct mctp_frag_test mctp_frag_tests[] = {
 104	{.mtu = 68, .msgsize = 63, .n_frags = 1},
 105	{.mtu = 68, .msgsize = 64, .n_frags = 1},
 106	{.mtu = 68, .msgsize = 65, .n_frags = 2},
 107	{.mtu = 68, .msgsize = 66, .n_frags = 2},
 108	{.mtu = 68, .msgsize = 127, .n_frags = 2},
 109	{.mtu = 68, .msgsize = 128, .n_frags = 2},
 110	{.mtu = 68, .msgsize = 129, .n_frags = 3},
 111	{.mtu = 68, .msgsize = 130, .n_frags = 3},
 112};
 113
 114static void mctp_frag_test_to_desc(const struct mctp_frag_test *t, char *desc)
 115{
 116	sprintf(desc, "mtu %d len %d -> %d frags",
 117		t->msgsize, t->mtu, t->n_frags);
 118}
 119
 120KUNIT_ARRAY_PARAM(mctp_frag, mctp_frag_tests, mctp_frag_test_to_desc);
 121
 122struct mctp_rx_input_test {
 123	struct mctp_hdr hdr;
 124	bool input;
 125};
 126
 127static void mctp_test_rx_input(struct kunit *test)
 128{
 129	const struct mctp_rx_input_test *params;
 130	struct mctp_test_route *rt;
 131	struct mctp_test_dev *dev;
 132	struct sk_buff *skb;
 133
 134	params = test->param_value;
 135
 136	dev = mctp_test_create_dev();
 137	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 138
 139	rt = mctp_test_create_route_direct(&init_net, dev->mdev, 8, 68);
 140	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
 141
 142	skb = mctp_test_create_skb(&params->hdr, 1);
 143	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
 144
 145	mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL);
 146
 147	KUNIT_EXPECT_EQ(test, !!dev->pkts.qlen, params->input);
 148
 149	mctp_test_route_destroy(test, rt);
 150	mctp_test_destroy_dev(dev);
 151}
 152
 153#define RX_HDR(_ver, _src, _dest, _fst) \
 154	{ .ver = _ver, .src = _src, .dest = _dest, .flags_seq_tag = _fst }
 155
 156/* we have a route for EID 8 only */
 157static const struct mctp_rx_input_test mctp_rx_input_tests[] = {
 158	{ .hdr = RX_HDR(1, 10, 8, 0), .input = true },
 159	{ .hdr = RX_HDR(1, 10, 9, 0), .input = false }, /* no input route */
 160	{ .hdr = RX_HDR(2, 10, 8, 0), .input = false }, /* invalid version */
 161};
 162
 163static void mctp_rx_input_test_to_desc(const struct mctp_rx_input_test *t,
 164				       char *desc)
 165{
 166	sprintf(desc, "{%x,%x,%x,%x}", t->hdr.ver, t->hdr.src, t->hdr.dest,
 167		t->hdr.flags_seq_tag);
 168}
 169
 170KUNIT_ARRAY_PARAM(mctp_rx_input, mctp_rx_input_tests,
 171		  mctp_rx_input_test_to_desc);
 172
 173/* set up a local dev, route on EID 8, and a socket listening on type 0 */
 174static void __mctp_route_test_init(struct kunit *test,
 175				   struct mctp_test_dev **devp,
 176				   struct mctp_dst *dst,
 177				   struct socket **sockp,
 178				   unsigned int netid)
 179{
 180	struct sockaddr_mctp addr = {0};
 181	struct mctp_test_dev *dev;
 182	struct socket *sock;
 183	int rc;
 184
 185	dev = mctp_test_create_dev();
 186	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 187	if (netid != MCTP_NET_ANY)
 188		WRITE_ONCE(dev->mdev->net, netid);
 189
 190	mctp_test_dst_setup(test, dst, dev, 68);
 191
 192	rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
 193	KUNIT_ASSERT_EQ(test, rc, 0);
 194
 195	addr.smctp_family = AF_MCTP;
 196	addr.smctp_network = netid;
 197	addr.smctp_addr.s_addr = 8;
 198	addr.smctp_type = 0;
 199	rc = kernel_bind(sock, (struct sockaddr_unsized *)&addr, sizeof(addr));
 200	KUNIT_ASSERT_EQ(test, rc, 0);
 201
 202	*devp = dev;
 203	*sockp = sock;
 204}
 205
 206static void __mctp_route_test_fini(struct kunit *test,
 207				   struct mctp_test_dev *dev,
 208				   struct mctp_dst *dst,
 209				   struct socket *sock)
 210{
 211	sock_release(sock);
 212	mctp_dst_release(dst);
 213	mctp_test_destroy_dev(dev);
 214}
 215
 216struct mctp_route_input_sk_test {
 217	struct mctp_hdr hdr;
 218	u8 type;
 219	bool deliver;
 220};
 221
 222static void mctp_test_route_input_sk(struct kunit *test)
 223{
 224	const struct mctp_route_input_sk_test *params;
 225	struct sk_buff *skb, *skb2;
 226	struct mctp_test_dev *dev;
 227	struct mctp_dst dst;
 228	struct socket *sock;
 229	int rc;
 230
 231	params = test->param_value;
 232
 233	__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);
 234
 235	skb = mctp_test_create_skb_data(&params->hdr, &params->type);
 236	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
 237
 238	mctp_test_skb_set_dev(skb, dev);
 239
 240	rc = mctp_dst_input(&dst, skb);
 241
 242	if (params->deliver) {
 243		KUNIT_EXPECT_EQ(test, rc, 0);
 244
 245		skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
 246		KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
 247		KUNIT_EXPECT_EQ(test, skb2->len, 1);
 248
 249		skb_free_datagram(sock->sk, skb2);
 250
 251	} else {
 252		KUNIT_EXPECT_NE(test, rc, 0);
 253		skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
 254		KUNIT_EXPECT_NULL(test, skb2);
 255	}
 256
 257	__mctp_route_test_fini(test, dev, &dst, sock);
 258}
 259
 260#define FL_S	(MCTP_HDR_FLAG_SOM)
 261#define FL_E	(MCTP_HDR_FLAG_EOM)
 262#define FL_TO	(MCTP_HDR_FLAG_TO)
 263#define FL_T(t)	((t) & MCTP_HDR_TAG_MASK)
 264
 265static const struct mctp_route_input_sk_test mctp_route_input_sk_tests[] = {
 266	{ .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 0, .deliver = true },
 267	{ .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 1, .deliver = false },
 268	{ .hdr = RX_HDR(1, 10, 8, FL_S | FL_E), .type = 0, .deliver = false },
 269	{ .hdr = RX_HDR(1, 10, 8, FL_E | FL_TO), .type = 0, .deliver = false },
 270	{ .hdr = RX_HDR(1, 10, 8, FL_TO), .type = 0, .deliver = false },
 271	{ .hdr = RX_HDR(1, 10, 8, 0), .type = 0, .deliver = false },
 272};
 273
 274static void mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test *t,
 275					char *desc)
 276{
 277	sprintf(desc, "{%x,%x,%x,%x} type %d", t->hdr.ver, t->hdr.src,
 278		t->hdr.dest, t->hdr.flags_seq_tag, t->type);
 279}
 280
 281KUNIT_ARRAY_PARAM(mctp_route_input_sk, mctp_route_input_sk_tests,
 282		  mctp_route_input_sk_to_desc);
 283
 284struct mctp_route_input_sk_reasm_test {
 285	const char *name;
 286	struct mctp_hdr hdrs[4];
 287	int n_hdrs;
 288	int rx_len;
 289};
 290
 291static void mctp_test_route_input_sk_reasm(struct kunit *test)
 292{
 293	const struct mctp_route_input_sk_reasm_test *params;
 294	struct sk_buff *skb, *skb2;
 295	struct mctp_test_dev *dev;
 296	struct mctp_dst dst;
 297	struct socket *sock;
 298	int i, rc;
 299	u8 c;
 300
 301	params = test->param_value;
 302
 303	__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);
 304
 305	for (i = 0; i < params->n_hdrs; i++) {
 306		c = i;
 307		skb = mctp_test_create_skb_data(&params->hdrs[i], &c);
 308		KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
 309
 310		mctp_test_skb_set_dev(skb, dev);
 311
 312		rc = mctp_dst_input(&dst, skb);
 313	}
 314
 315	skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
 316
 317	if (params->rx_len) {
 318		KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
 319		KUNIT_EXPECT_EQ(test, skb2->len, params->rx_len);
 320		skb_free_datagram(sock->sk, skb2);
 321
 322	} else {
 323		KUNIT_EXPECT_NULL(test, skb2);
 324	}
 325
 326	__mctp_route_test_fini(test, dev, &dst, sock);
 327}
 328
 329#define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_TO | (f) | ((s) << MCTP_HDR_SEQ_SHIFT))
 330
 331static const struct mctp_route_input_sk_reasm_test mctp_route_input_sk_reasm_tests[] = {
 332	{
 333		.name = "single packet",
 334		.hdrs = {
 335			RX_FRAG(FL_S | FL_E, 0),
 336		},
 337		.n_hdrs = 1,
 338		.rx_len = 1,
 339	},
 340	{
 341		.name = "single packet, offset seq",
 342		.hdrs = {
 343			RX_FRAG(FL_S | FL_E, 1),
 344		},
 345		.n_hdrs = 1,
 346		.rx_len = 1,
 347	},
 348	{
 349		.name = "start & end packets",
 350		.hdrs = {
 351			RX_FRAG(FL_S, 0),
 352			RX_FRAG(FL_E, 1),
 353		},
 354		.n_hdrs = 2,
 355		.rx_len = 2,
 356	},
 357	{
 358		.name = "start & end packets, offset seq",
 359		.hdrs = {
 360			RX_FRAG(FL_S, 1),
 361			RX_FRAG(FL_E, 2),
 362		},
 363		.n_hdrs = 2,
 364		.rx_len = 2,
 365	},
 366	{
 367		.name = "start & end packets, out of order",
 368		.hdrs = {
 369			RX_FRAG(FL_E, 1),
 370			RX_FRAG(FL_S, 0),
 371		},
 372		.n_hdrs = 2,
 373		.rx_len = 0,
 374	},
 375	{
 376		.name = "start, middle & end packets",
 377		.hdrs = {
 378			RX_FRAG(FL_S, 0),
 379			RX_FRAG(0,    1),
 380			RX_FRAG(FL_E, 2),
 381		},
 382		.n_hdrs = 3,
 383		.rx_len = 3,
 384	},
 385	{
 386		.name = "missing seq",
 387		.hdrs = {
 388			RX_FRAG(FL_S, 0),
 389			RX_FRAG(FL_E, 2),
 390		},
 391		.n_hdrs = 2,
 392		.rx_len = 0,
 393	},
 394	{
 395		.name = "seq wrap",
 396		.hdrs = {
 397			RX_FRAG(FL_S, 3),
 398			RX_FRAG(FL_E, 0),
 399		},
 400		.n_hdrs = 2,
 401		.rx_len = 2,
 402	},
 403};
 404
 405static void mctp_route_input_sk_reasm_to_desc(
 406				const struct mctp_route_input_sk_reasm_test *t,
 407				char *desc)
 408{
 409	sprintf(desc, "%s", t->name);
 410}
 411
 412KUNIT_ARRAY_PARAM(mctp_route_input_sk_reasm, mctp_route_input_sk_reasm_tests,
 413		  mctp_route_input_sk_reasm_to_desc);
 414
 415struct mctp_route_input_sk_keys_test {
 416	const char	*name;
 417	mctp_eid_t	key_peer_addr;
 418	mctp_eid_t	key_local_addr;
 419	u8		key_tag;
 420	struct mctp_hdr hdr;
 421	bool		deliver;
 422};
 423
 424/* test packet rx in the presence of various key configurations */
 425static void mctp_test_route_input_sk_keys(struct kunit *test)
 426{
 427	const struct mctp_route_input_sk_keys_test *params;
 428	struct sk_buff *skb, *skb2;
 429	struct mctp_test_dev *dev;
 430	struct mctp_sk_key *key;
 431	struct netns_mctp *mns;
 432	struct mctp_sock *msk;
 433	struct socket *sock;
 434	unsigned long flags;
 435	struct mctp_dst dst;
 436	unsigned int net;
 437	int rc;
 438	u8 c;
 439
 440	params = test->param_value;
 441
 442	dev = mctp_test_create_dev();
 443	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 444	net = READ_ONCE(dev->mdev->net);
 445
 446	mctp_test_dst_setup(test, &dst, dev, 68);
 447
 448	rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
 449	KUNIT_ASSERT_EQ(test, rc, 0);
 450
 451	msk = container_of(sock->sk, struct mctp_sock, sk);
 452	mns = &sock_net(sock->sk)->mctp;
 453
 454	/* set the incoming tag according to test params */
 455	key = mctp_key_alloc(msk, net, params->key_local_addr,
 456			     params->key_peer_addr, params->key_tag,
 457			     GFP_KERNEL);
 458
 459	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, key);
 460
 461	spin_lock_irqsave(&mns->keys_lock, flags);
 462	mctp_reserve_tag(&init_net, key, msk);
 463	spin_unlock_irqrestore(&mns->keys_lock, flags);
 464
 465	/* create packet and route */
 466	c = 0;
 467	skb = mctp_test_create_skb_data(&params->hdr, &c);
 468	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
 469
 470	mctp_test_skb_set_dev(skb, dev);
 471
 472	rc = mctp_dst_input(&dst, skb);
 473
 474	/* (potentially) receive message */
 475	skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
 476
 477	if (params->deliver)
 478		KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
 479	else
 480		KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
 481
 482	if (skb2)
 483		skb_free_datagram(sock->sk, skb2);
 484
 485	mctp_key_unref(key);
 486	__mctp_route_test_fini(test, dev, &dst, sock);
 487}
 488
 489static const struct mctp_route_input_sk_keys_test mctp_route_input_sk_keys_tests[] = {
 490	{
 491		.name = "direct match",
 492		.key_peer_addr = 9,
 493		.key_local_addr = 8,
 494		.key_tag = 1,
 495		.hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)),
 496		.deliver = true,
 497	},
 498	{
 499		.name = "flipped src/dest",
 500		.key_peer_addr = 8,
 501		.key_local_addr = 9,
 502		.key_tag = 1,
 503		.hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)),
 504		.deliver = false,
 505	},
 506	{
 507		.name = "peer addr mismatch",
 508		.key_peer_addr = 9,
 509		.key_local_addr = 8,
 510		.key_tag = 1,
 511		.hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T(1)),
 512		.deliver = false,
 513	},
 514	{
 515		.name = "tag value mismatch",
 516		.key_peer_addr = 9,
 517		.key_local_addr = 8,
 518		.key_tag = 1,
 519		.hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(2)),
 520		.deliver = false,
 521	},
 522	{
 523		.name = "TO mismatch",
 524		.key_peer_addr = 9,
 525		.key_local_addr = 8,
 526		.key_tag = 1,
 527		.hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO),
 528		.deliver = false,
 529	},
 530	{
 531		.name = "broadcast response",
 532		.key_peer_addr = MCTP_ADDR_ANY,
 533		.key_local_addr = 8,
 534		.key_tag = 1,
 535		.hdr = RX_HDR(1, 11, 8, FL_S | FL_E | FL_T(1)),
 536		.deliver = true,
 537	},
 538	{
 539		.name = "any local match",
 540		.key_peer_addr = 12,
 541		.key_local_addr = MCTP_ADDR_ANY,
 542		.key_tag = 1,
 543		.hdr = RX_HDR(1, 12, 8, FL_S | FL_E | FL_T(1)),
 544		.deliver = true,
 545	},
 546};
 547
 548static void mctp_route_input_sk_keys_to_desc(
 549				const struct mctp_route_input_sk_keys_test *t,
 550				char *desc)
 551{
 552	sprintf(desc, "%s", t->name);
 553}
 554
 555KUNIT_ARRAY_PARAM(mctp_route_input_sk_keys, mctp_route_input_sk_keys_tests,
 556		  mctp_route_input_sk_keys_to_desc);
 557
 558struct test_net {
 559	unsigned int netid;
 560	struct mctp_test_dev *dev;
 561	struct mctp_dst dst;
 562	struct socket *sock;
 563	struct sk_buff *skb;
 564	struct mctp_sk_key *key;
 565	struct {
 566		u8 type;
 567		unsigned int data;
 568	} msg;
 569};
 570
 571static void
 572mctp_test_route_input_multiple_nets_bind_init(struct kunit *test,
 573					      struct test_net *t)
 574{
 575	struct mctp_hdr hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO);
 576
 577	t->msg.data = t->netid;
 578
 579	__mctp_route_test_init(test, &t->dev, &t->dst, &t->sock, t->netid);
 580
 581	t->skb = mctp_test_create_skb_data(&hdr, &t->msg);
 582	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->skb);
 583	mctp_test_skb_set_dev(t->skb, t->dev);
 584}
 585
 586static void
 587mctp_test_route_input_multiple_nets_bind_fini(struct kunit *test,
 588					      struct test_net *t)
 589{
 590	__mctp_route_test_fini(test, t->dev, &t->dst, t->sock);
 591}
 592
 593/* Test that skbs from different nets (otherwise identical) get routed to their
 594 * corresponding socket via the sockets' bind()
 595 */
 596static void mctp_test_route_input_multiple_nets_bind(struct kunit *test)
 597{
 598	struct sk_buff *rx_skb1, *rx_skb2;
 599	struct test_net t1, t2;
 600	int rc;
 601
 602	t1.netid = 1;
 603	t2.netid = 2;
 604
 605	t1.msg.type = 0;
 606	t2.msg.type = 0;
 607
 608	mctp_test_route_input_multiple_nets_bind_init(test, &t1);
 609	mctp_test_route_input_multiple_nets_bind_init(test, &t2);
 610
 611	rc = mctp_dst_input(&t1.dst, t1.skb);
 612	KUNIT_ASSERT_EQ(test, rc, 0);
 613	rc = mctp_dst_input(&t2.dst, t2.skb);
 614	KUNIT_ASSERT_EQ(test, rc, 0);
 615
 616	rx_skb1 = skb_recv_datagram(t1.sock->sk, MSG_DONTWAIT, &rc);
 617	KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb1);
 618	KUNIT_EXPECT_EQ(test, rx_skb1->len, sizeof(t1.msg));
 619	KUNIT_EXPECT_EQ(test,
 620			*(unsigned int *)skb_pull(rx_skb1, sizeof(t1.msg.data)),
 621			t1.netid);
 622	kfree_skb(rx_skb1);
 623
 624	rx_skb2 = skb_recv_datagram(t2.sock->sk, MSG_DONTWAIT, &rc);
 625	KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb2);
 626	KUNIT_EXPECT_EQ(test, rx_skb2->len, sizeof(t2.msg));
 627	KUNIT_EXPECT_EQ(test,
 628			*(unsigned int *)skb_pull(rx_skb2, sizeof(t2.msg.data)),
 629			t2.netid);
 630	kfree_skb(rx_skb2);
 631
 632	mctp_test_route_input_multiple_nets_bind_fini(test, &t1);
 633	mctp_test_route_input_multiple_nets_bind_fini(test, &t2);
 634}
 635
 636static void
 637mctp_test_route_input_multiple_nets_key_init(struct kunit *test,
 638					     struct test_net *t)
 639{
 640	struct mctp_hdr hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1));
 641	struct mctp_sock *msk;
 642	struct netns_mctp *mns;
 643	unsigned long flags;
 644
 645	t->msg.data = t->netid;
 646
 647	__mctp_route_test_init(test, &t->dev, &t->dst, &t->sock, t->netid);
 648
 649	msk = container_of(t->sock->sk, struct mctp_sock, sk);
 650
 651	t->key = mctp_key_alloc(msk, t->netid, hdr.dest, hdr.src, 1, GFP_KERNEL);
 652	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->key);
 653
 654	mns = &sock_net(t->sock->sk)->mctp;
 655	spin_lock_irqsave(&mns->keys_lock, flags);
 656	mctp_reserve_tag(&init_net, t->key, msk);
 657	spin_unlock_irqrestore(&mns->keys_lock, flags);
 658
 659	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->key);
 660	t->skb = mctp_test_create_skb_data(&hdr, &t->msg);
 661	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->skb);
 662	mctp_test_skb_set_dev(t->skb, t->dev);
 663}
 664
 665static void
 666mctp_test_route_input_multiple_nets_key_fini(struct kunit *test,
 667					     struct test_net *t)
 668{
 669	mctp_key_unref(t->key);
 670	__mctp_route_test_fini(test, t->dev, &t->dst, t->sock);
 671}
 672
 673/* test that skbs from different nets (otherwise identical) get routed to their
 674 * corresponding socket via the sk_key
 675 */
 676static void mctp_test_route_input_multiple_nets_key(struct kunit *test)
 677{
 678	struct sk_buff *rx_skb1, *rx_skb2;
 679	struct test_net t1, t2;
 680	int rc;
 681
 682	t1.netid = 1;
 683	t2.netid = 2;
 684
 685	/* use type 1 which is not bound */
 686	t1.msg.type = 1;
 687	t2.msg.type = 1;
 688
 689	mctp_test_route_input_multiple_nets_key_init(test, &t1);
 690	mctp_test_route_input_multiple_nets_key_init(test, &t2);
 691
 692	rc = mctp_dst_input(&t1.dst, t1.skb);
 693	KUNIT_ASSERT_EQ(test, rc, 0);
 694	rc = mctp_dst_input(&t2.dst, t2.skb);
 695	KUNIT_ASSERT_EQ(test, rc, 0);
 696
 697	rx_skb1 = skb_recv_datagram(t1.sock->sk, MSG_DONTWAIT, &rc);
 698	KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb1);
 699	KUNIT_EXPECT_EQ(test, rx_skb1->len, sizeof(t1.msg));
 700	KUNIT_EXPECT_EQ(test,
 701			*(unsigned int *)skb_pull(rx_skb1, sizeof(t1.msg.data)),
 702			t1.netid);
 703	kfree_skb(rx_skb1);
 704
 705	rx_skb2 = skb_recv_datagram(t2.sock->sk, MSG_DONTWAIT, &rc);
 706	KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb2);
 707	KUNIT_EXPECT_EQ(test, rx_skb2->len, sizeof(t2.msg));
 708	KUNIT_EXPECT_EQ(test,
 709			*(unsigned int *)skb_pull(rx_skb2, sizeof(t2.msg.data)),
 710			t2.netid);
 711	kfree_skb(rx_skb2);
 712
 713	mctp_test_route_input_multiple_nets_key_fini(test, &t1);
 714	mctp_test_route_input_multiple_nets_key_fini(test, &t2);
 715}
 716
 717/* Input route to socket, using a single-packet message, where sock delivery
 718 * fails. Ensure we're handling the failure appropriately.
 719 */
 720static void mctp_test_route_input_sk_fail_single(struct kunit *test)
 721{
 722	const struct mctp_hdr hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO);
 723	struct mctp_test_dev *dev;
 724	struct mctp_dst dst;
 725	struct socket *sock;
 726	struct sk_buff *skb;
 727	int rc;
 728
 729	__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);
 730
 731	/* No rcvbuf space, so delivery should fail. __sock_set_rcvbuf will
 732	 * clamp the minimum to SOCK_MIN_RCVBUF, so we open-code this.
 733	 */
 734	lock_sock(sock->sk);
 735	WRITE_ONCE(sock->sk->sk_rcvbuf, 0);
 736	release_sock(sock->sk);
 737
 738	skb = mctp_test_create_skb(&hdr, 10);
 739	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
 740	skb_get(skb);
 741
 742	mctp_test_skb_set_dev(skb, dev);
 743
 744	/* do route input, which should fail */
 745	rc = mctp_dst_input(&dst, skb);
 746	KUNIT_EXPECT_NE(test, rc, 0);
 747
 748	/* we should hold the only reference to skb */
 749	KUNIT_EXPECT_EQ(test, refcount_read(&skb->users), 1);
 750	kfree_skb(skb);
 751
 752	__mctp_route_test_fini(test, dev, &dst, sock);
 753}
 754
 755/* Input route to socket, using a fragmented message, where sock delivery fails.
 756 */
 757static void mctp_test_route_input_sk_fail_frag(struct kunit *test)
 758{
 759	const struct mctp_hdr hdrs[2] = { RX_FRAG(FL_S, 0), RX_FRAG(FL_E, 1) };
 760	struct mctp_test_dev *dev;
 761	struct sk_buff *skbs[2];
 762	struct mctp_dst dst;
 763	struct socket *sock;
 764	unsigned int i;
 765	int rc;
 766
 767	__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);
 768
 769	lock_sock(sock->sk);
 770	WRITE_ONCE(sock->sk->sk_rcvbuf, 0);
 771	release_sock(sock->sk);
 772
 773	for (i = 0; i < ARRAY_SIZE(skbs); i++) {
 774		skbs[i] = mctp_test_create_skb(&hdrs[i], 10);
 775		KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skbs[i]);
 776		skb_get(skbs[i]);
 777
 778		mctp_test_skb_set_dev(skbs[i], dev);
 779	}
 780
 781	/* first route input should succeed, we're only queueing to the
 782	 * frag list
 783	 */
 784	rc = mctp_dst_input(&dst, skbs[0]);
 785	KUNIT_EXPECT_EQ(test, rc, 0);
 786
 787	/* final route input should fail to deliver to the socket */
 788	rc = mctp_dst_input(&dst, skbs[1]);
 789	KUNIT_EXPECT_NE(test, rc, 0);
 790
 791	/* we should hold the only reference to both skbs */
 792	KUNIT_EXPECT_EQ(test, refcount_read(&skbs[0]->users), 1);
 793	kfree_skb(skbs[0]);
 794
 795	KUNIT_EXPECT_EQ(test, refcount_read(&skbs[1]->users), 1);
 796	kfree_skb(skbs[1]);
 797
 798	__mctp_route_test_fini(test, dev, &dst, sock);
 799}
 800
 801/* Input route to socket, using a fragmented message created from clones.
 802 */
 803static void mctp_test_route_input_cloned_frag(struct kunit *test)
 804{
 805	/* 5 packet fragments, forming 2 complete messages */
 806	const struct mctp_hdr hdrs[5] = {
 807		RX_FRAG(FL_S, 0),
 808		RX_FRAG(0, 1),
 809		RX_FRAG(FL_E, 2),
 810		RX_FRAG(FL_S, 0),
 811		RX_FRAG(FL_E, 1),
 812	};
 813	const size_t data_len = 3; /* arbitrary */
 814	u8 compare[3 * ARRAY_SIZE(hdrs)];
 815	u8 flat[3 * ARRAY_SIZE(hdrs)];
 816	struct mctp_test_dev *dev;
 817	struct sk_buff *skb[5];
 818	struct sk_buff *rx_skb;
 819	struct mctp_dst dst;
 820	struct socket *sock;
 821	size_t total;
 822	void *p;
 823	int rc;
 824
 825	total = data_len + sizeof(struct mctp_hdr);
 826
 827	__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);
 828
 829	/* Create a single skb initially with concatenated packets */
 830	skb[0] = mctp_test_create_skb(&hdrs[0], 5 * total);
 831	mctp_test_skb_set_dev(skb[0], dev);
 832	memset(skb[0]->data, 0 * 0x11, skb[0]->len);
 833	memcpy(skb[0]->data, &hdrs[0], sizeof(struct mctp_hdr));
 834
 835	/* Extract and populate packets */
 836	for (int i = 1; i < 5; i++) {
 837		skb[i] = skb_clone(skb[i - 1], GFP_ATOMIC);
 838		KUNIT_ASSERT_TRUE(test, skb[i]);
 839		p = skb_pull(skb[i], total);
 840		KUNIT_ASSERT_TRUE(test, p);
 841		skb_reset_network_header(skb[i]);
 842		memcpy(skb[i]->data, &hdrs[i], sizeof(struct mctp_hdr));
 843		memset(&skb[i]->data[sizeof(struct mctp_hdr)], i * 0x11, data_len);
 844	}
 845	for (int i = 0; i < 5; i++)
 846		skb_trim(skb[i], total);
 847
 848	/* SOM packets have a type byte to match the socket */
 849	skb[0]->data[4] = 0;
 850	skb[3]->data[4] = 0;
 851
 852	skb_dump("pkt1 ", skb[0], false);
 853	skb_dump("pkt2 ", skb[1], false);
 854	skb_dump("pkt3 ", skb[2], false);
 855	skb_dump("pkt4 ", skb[3], false);
 856	skb_dump("pkt5 ", skb[4], false);
 857
 858	for (int i = 0; i < 5; i++) {
 859		KUNIT_EXPECT_EQ(test, refcount_read(&skb[i]->users), 1);
 860		/* Take a reference so we can check refcounts at the end */
 861		skb_get(skb[i]);
 862	}
 863
 864	/* Feed the fragments into MCTP core */
 865	for (int i = 0; i < 5; i++) {
 866		rc = mctp_dst_input(&dst, skb[i]);
 867		KUNIT_EXPECT_EQ(test, rc, 0);
 868	}
 869
 870	/* Receive first reassembled message */
 871	rx_skb = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
 872	KUNIT_EXPECT_EQ(test, rc, 0);
 873	KUNIT_EXPECT_EQ(test, rx_skb->len, 3 * data_len);
 874	rc = skb_copy_bits(rx_skb, 0, flat, rx_skb->len);
 875	for (int i = 0; i < rx_skb->len; i++)
 876		compare[i] = (i / data_len) * 0x11;
 877	/* Set type byte */
 878	compare[0] = 0;
 879
 880	KUNIT_EXPECT_MEMEQ(test, flat, compare, rx_skb->len);
 881	KUNIT_EXPECT_EQ(test, refcount_read(&rx_skb->users), 1);
 882	kfree_skb(rx_skb);
 883
 884	/* Receive second reassembled message */
 885	rx_skb = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
 886	KUNIT_EXPECT_EQ(test, rc, 0);
 887	KUNIT_EXPECT_EQ(test, rx_skb->len, 2 * data_len);
 888	rc = skb_copy_bits(rx_skb, 0, flat, rx_skb->len);
 889	for (int i = 0; i < rx_skb->len; i++)
 890		compare[i] = (i / data_len + 3) * 0x11;
 891	/* Set type byte */
 892	compare[0] = 0;
 893
 894	KUNIT_EXPECT_MEMEQ(test, flat, compare, rx_skb->len);
 895	KUNIT_EXPECT_EQ(test, refcount_read(&rx_skb->users), 1);
 896	kfree_skb(rx_skb);
 897
 898	/* Check input skb refcounts */
 899	for (int i = 0; i < 5; i++) {
 900		KUNIT_EXPECT_EQ(test, refcount_read(&skb[i]->users), 1);
 901		kfree_skb(skb[i]);
 902	}
 903
 904	__mctp_route_test_fini(test, dev, &dst, sock);
 905}
 906
 907#if IS_ENABLED(CONFIG_MCTP_FLOWS)
 908
 909static void mctp_test_flow_init(struct kunit *test,
 910				struct mctp_test_dev **devp,
 911				struct mctp_dst *dst,
 912				struct socket **sock,
 913				struct sk_buff **skbp,
 914				unsigned int len)
 915{
 916	struct mctp_test_dev *dev;
 917	struct sk_buff *skb;
 918
 919	/* we have a slightly odd routing setup here; the test route
 920	 * is for EID 8, which is our local EID. We don't do a routing
 921	 * lookup, so that's fine - all we require is a path through
 922	 * mctp_local_output, which will call dst->output on whatever
 923	 * route we provide
 924	 */
 925	__mctp_route_test_init(test, &dev, dst, sock, MCTP_NET_ANY);
 926
 927	/* Assign a single EID. ->addrs is freed on mctp netdev release */
 928	dev->mdev->addrs = kmalloc(sizeof(u8), GFP_KERNEL);
 929	dev->mdev->num_addrs = 1;
 930	dev->mdev->addrs[0] = 8;
 931
 932	skb = alloc_skb(len + sizeof(struct mctp_hdr) + 1, GFP_KERNEL);
 933	KUNIT_ASSERT_TRUE(test, skb);
 934	__mctp_cb(skb);
 935	skb_reserve(skb, sizeof(struct mctp_hdr) + 1);
 936	memset(skb_put(skb, len), 0, len);
 937
 938
 939	*devp = dev;
 940	*skbp = skb;
 941}
 942
 943static void mctp_test_flow_fini(struct kunit *test,
 944				struct mctp_test_dev *dev,
 945				struct mctp_dst *dst,
 946				struct socket *sock)
 947{
 948	__mctp_route_test_fini(test, dev, dst, sock);
 949}
 950
 951/* test that an outgoing skb has the correct MCTP extension data set */
 952static void mctp_test_packet_flow(struct kunit *test)
 953{
 954	struct sk_buff *skb, *skb2;
 955	struct mctp_test_dev *dev;
 956	struct mctp_dst dst;
 957	struct mctp_flow *flow;
 958	struct socket *sock;
 959	u8 dst_eid = 8;
 960	int n, rc;
 961
 962	mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 30);
 963
 964	rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER);
 965	KUNIT_ASSERT_EQ(test, rc, 0);
 966
 967	n = dev->pkts.qlen;
 968	KUNIT_ASSERT_EQ(test, n, 1);
 969
 970	skb2 = skb_dequeue(&dev->pkts);
 971	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2);
 972
 973	flow = skb_ext_find(skb2, SKB_EXT_MCTP);
 974	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flow);
 975	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flow->key);
 976	KUNIT_ASSERT_PTR_EQ(test, flow->key->sk, sock->sk);
 977
 978	kfree_skb(skb2);
 979	mctp_test_flow_fini(test, dev, &dst, sock);
 980}
 981
 982/* test that outgoing skbs, after fragmentation, all have the correct MCTP
 983 * extension data set.
 984 */
 985static void mctp_test_fragment_flow(struct kunit *test)
 986{
 987	struct mctp_flow *flows[2];
 988	struct sk_buff *tx_skbs[2];
 989	struct mctp_test_dev *dev;
 990	struct mctp_dst dst;
 991	struct sk_buff *skb;
 992	struct socket *sock;
 993	u8 dst_eid = 8;
 994	int n, rc;
 995
 996	mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 100);
 997
 998	rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER);
 999	KUNIT_ASSERT_EQ(test, rc, 0);
1000
1001	n = dev->pkts.qlen;
1002	KUNIT_ASSERT_EQ(test, n, 2);
1003
1004	/* both resulting packets should have the same flow data */
1005	tx_skbs[0] = skb_dequeue(&dev->pkts);
1006	tx_skbs[1] = skb_dequeue(&dev->pkts);
1007
1008	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[0]);
1009	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[1]);
1010
1011	flows[0] = skb_ext_find(tx_skbs[0], SKB_EXT_MCTP);
1012	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[0]);
1013	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[0]->key);
1014	KUNIT_ASSERT_PTR_EQ(test, flows[0]->key->sk, sock->sk);
1015
1016	flows[1] = skb_ext_find(tx_skbs[1], SKB_EXT_MCTP);
1017	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[1]);
1018	KUNIT_ASSERT_PTR_EQ(test, flows[1]->key, flows[0]->key);
1019
1020	kfree_skb(tx_skbs[0]);
1021	kfree_skb(tx_skbs[1]);
1022	mctp_test_flow_fini(test, dev, &dst, sock);
1023}
1024
1025#else
1026static void mctp_test_packet_flow(struct kunit *test)
1027{
1028	kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y");
1029}
1030
1031static void mctp_test_fragment_flow(struct kunit *test)
1032{
1033	kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y");
1034}
1035#endif
1036
1037/* Test that outgoing skbs cause a suitable tag to be created */
1038static void mctp_test_route_output_key_create(struct kunit *test)
1039{
1040	const u8 dst_eid = 26, src_eid = 15;
1041	const unsigned int netid = 50;
1042	struct mctp_test_dev *dev;
1043	struct mctp_sk_key *key;
1044	struct netns_mctp *mns;
1045	unsigned long flags;
1046	struct socket *sock;
1047	struct sk_buff *skb;
1048	struct mctp_dst dst;
1049	bool empty, single;
1050	const int len = 2;
1051	int rc;
1052
1053	dev = mctp_test_create_dev();
1054	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1055	WRITE_ONCE(dev->mdev->net, netid);
1056
1057	mctp_test_dst_setup(test, &dst, dev, 68);
1058
1059	rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
1060	KUNIT_ASSERT_EQ(test, rc, 0);
1061
1062	dev->mdev->addrs = kmalloc(sizeof(u8), GFP_KERNEL);
1063	dev->mdev->num_addrs = 1;
1064	dev->mdev->addrs[0] = src_eid;
1065
1066	skb = alloc_skb(sizeof(struct mctp_hdr) + 1 + len, GFP_KERNEL);
1067	KUNIT_ASSERT_TRUE(test, skb);
1068	__mctp_cb(skb);
1069	skb_reserve(skb, sizeof(struct mctp_hdr) + 1 + len);
1070	memset(skb_put(skb, len), 0, len);
1071
1072	mns = &sock_net(sock->sk)->mctp;
1073
1074	/* We assume we're starting from an empty keys list, which requires
1075	 * preceding tests to clean up correctly!
1076	 */
1077	spin_lock_irqsave(&mns->keys_lock, flags);
1078	empty = hlist_empty(&mns->keys);
1079	spin_unlock_irqrestore(&mns->keys_lock, flags);
1080	KUNIT_ASSERT_TRUE(test, empty);
1081
1082	rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER);
1083	KUNIT_ASSERT_EQ(test, rc, 0);
1084
1085	key = NULL;
1086	single = false;
1087	spin_lock_irqsave(&mns->keys_lock, flags);
1088	if (!hlist_empty(&mns->keys)) {
1089		key = hlist_entry(mns->keys.first, struct mctp_sk_key, hlist);
1090		single = hlist_is_singular_node(&key->hlist, &mns->keys);
1091	}
1092	spin_unlock_irqrestore(&mns->keys_lock, flags);
1093
1094	KUNIT_ASSERT_NOT_NULL(test, key);
1095	KUNIT_ASSERT_TRUE(test, single);
1096
1097	KUNIT_EXPECT_EQ(test, key->net, netid);
1098	KUNIT_EXPECT_EQ(test, key->local_addr, src_eid);
1099	KUNIT_EXPECT_EQ(test, key->peer_addr, dst_eid);
1100	/* key has incoming tag, so inverse of what we sent */
1101	KUNIT_EXPECT_FALSE(test, key->tag & MCTP_TAG_OWNER);
1102
1103	sock_release(sock);
1104	mctp_dst_release(&dst);
1105	mctp_test_destroy_dev(dev);
1106}
1107
1108static void mctp_test_route_extaddr_input(struct kunit *test)
1109{
1110	static const unsigned char haddr[] = { 0xaa, 0x55 };
1111	struct mctp_skb_cb *cb, *cb2;
1112	const unsigned int len = 40;
1113	struct mctp_test_dev *dev;
1114	struct sk_buff *skb, *skb2;
1115	struct mctp_dst dst;
1116	struct mctp_hdr hdr;
1117	struct socket *sock;
1118	int rc;
1119
1120	hdr.ver = 1;
1121	hdr.src = 10;
1122	hdr.dest = 8;
1123	hdr.flags_seq_tag = FL_S | FL_E | FL_TO;
1124
1125	__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);
1126
1127	skb = mctp_test_create_skb(&hdr, len);
1128	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
1129
1130	/* set our hardware addressing data */
1131	cb = mctp_cb(skb);
1132	memcpy(cb->haddr, haddr, sizeof(haddr));
1133	cb->halen = sizeof(haddr);
1134
1135	mctp_test_skb_set_dev(skb, dev);
1136
1137	rc = mctp_dst_input(&dst, skb);
1138	KUNIT_ASSERT_EQ(test, rc, 0);
1139
1140	skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
1141	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2);
1142	KUNIT_ASSERT_EQ(test, skb2->len, len);
1143
1144	cb2 = mctp_cb(skb2);
1145
1146	/* Received SKB should have the hardware addressing as set above.
1147	 * We're likely to have the same actual cb here (ie., cb == cb2),
1148	 * but it's the comparison that we care about
1149	 */
1150	KUNIT_EXPECT_EQ(test, cb2->halen, sizeof(haddr));
1151	KUNIT_EXPECT_MEMEQ(test, cb2->haddr, haddr, sizeof(haddr));
1152
1153	kfree_skb(skb2);
1154	__mctp_route_test_fini(test, dev, &dst, sock);
1155}
1156
1157static void mctp_test_route_gw_lookup(struct kunit *test)
1158{
1159	struct mctp_test_route *rt1, *rt2;
1160	struct mctp_dst dst = { 0 };
1161	struct mctp_test_dev *dev;
1162	int rc;
1163
1164	dev = mctp_test_create_dev();
1165	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1166
1167	/* 8 (local) -> 10 (gateway) via 9 (direct) */
1168	rt1 = mctp_test_create_route_direct(&init_net, dev->mdev, 9, 0);
1169	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1);
1170	rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0);
1171	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2);
1172
1173	rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst);
1174	KUNIT_EXPECT_EQ(test, rc, 0);
1175	KUNIT_EXPECT_PTR_EQ(test, dst.dev, dev->mdev);
1176	KUNIT_EXPECT_EQ(test, dst.mtu, dev->ndev->mtu);
1177	KUNIT_EXPECT_EQ(test, dst.nexthop, 9);
1178	KUNIT_EXPECT_EQ(test, dst.halen, 0);
1179
1180	mctp_dst_release(&dst);
1181
1182	mctp_test_route_destroy(test, rt2);
1183	mctp_test_route_destroy(test, rt1);
1184	mctp_test_destroy_dev(dev);
1185}
1186
1187static void mctp_test_route_gw_loop(struct kunit *test)
1188{
1189	struct mctp_test_route *rt1, *rt2;
1190	struct mctp_dst dst = { 0 };
1191	struct mctp_test_dev *dev;
1192	int rc;
1193
1194	dev = mctp_test_create_dev();
1195	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1196
1197	/* two routes using each other as the gw */
1198	rt1 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 9, 10, 0);
1199	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1);
1200	rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0);
1201	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2);
1202
1203	/* this should fail, rather than infinite-loop */
1204	rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst);
1205	KUNIT_EXPECT_NE(test, rc, 0);
1206
1207	mctp_test_route_destroy(test, rt2);
1208	mctp_test_route_destroy(test, rt1);
1209	mctp_test_destroy_dev(dev);
1210}
1211
1212struct mctp_route_gw_mtu_test {
1213	/* working away from the local stack */
1214	unsigned int dev, neigh, gw, dst;
1215	unsigned int exp;
1216};
1217
1218static void mctp_route_gw_mtu_to_desc(const struct mctp_route_gw_mtu_test *t,
1219				      char *desc)
1220{
1221	sprintf(desc, "dev %d, neigh %d, gw %d, dst %d -> %d",
1222		t->dev, t->neigh, t->gw, t->dst, t->exp);
1223}
1224
1225static const struct mctp_route_gw_mtu_test mctp_route_gw_mtu_tests[] = {
1226	/* no route-specific MTUs */
1227	{ 68, 0, 0, 0, 68 },
1228	{ 100, 0, 0, 0, 100 },
1229	/* one route MTU (smaller than dev mtu), others unrestricted */
1230	{ 100, 68, 0, 0, 68 },
1231	{ 100, 0, 68, 0, 68 },
1232	{ 100, 0, 0, 68, 68 },
1233	/* smallest applied, regardless of order */
1234	{ 100, 99, 98, 68, 68 },
1235	{ 99, 100, 98, 68, 68 },
1236	{ 98, 99, 100, 68, 68 },
1237	{ 68, 98, 99, 100, 68 },
1238};
1239
1240KUNIT_ARRAY_PARAM(mctp_route_gw_mtu, mctp_route_gw_mtu_tests,
1241		  mctp_route_gw_mtu_to_desc);
1242
1243static void mctp_test_route_gw_mtu(struct kunit *test)
1244{
1245	const struct mctp_route_gw_mtu_test *mtus = test->param_value;
1246	struct mctp_test_route *rt1, *rt2, *rt3;
1247	struct mctp_dst dst = { 0 };
1248	struct mctp_test_dev *dev;
1249	struct mctp_dev *mdev;
1250	unsigned int netid;
1251	int rc;
1252
1253	dev = mctp_test_create_dev();
1254	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1255	dev->ndev->mtu = mtus->dev;
1256	mdev = dev->mdev;
1257	netid = mdev->net;
1258
1259	/* 8 (local) -> 11 (dst) via 10 (gw) via 9 (neigh) */
1260	rt1 = mctp_test_create_route_direct(&init_net, mdev, 9, mtus->neigh);
1261	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1);
1262
1263	rt2 = mctp_test_create_route_gw(&init_net, netid, 10, 9, mtus->gw);
1264	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2);
1265
1266	rt3 = mctp_test_create_route_gw(&init_net, netid, 11, 10, mtus->dst);
1267	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt3);
1268
1269	rc = mctp_route_lookup(&init_net, dev->mdev->net, 11, &dst);
1270	KUNIT_EXPECT_EQ(test, rc, 0);
1271	KUNIT_EXPECT_EQ(test, dst.mtu, mtus->exp);
1272
1273	mctp_dst_release(&dst);
1274
1275	mctp_test_route_destroy(test, rt3);
1276	mctp_test_route_destroy(test, rt2);
1277	mctp_test_route_destroy(test, rt1);
1278	mctp_test_destroy_dev(dev);
1279}
1280
1281#define MCTP_TEST_LLADDR_LEN 2
1282struct mctp_test_llhdr {
1283	unsigned int magic;
1284	unsigned char src[MCTP_TEST_LLADDR_LEN];
1285	unsigned char dst[MCTP_TEST_LLADDR_LEN];
1286};
1287
1288static const unsigned int mctp_test_llhdr_magic = 0x5c78339c;
1289
1290static int test_dev_header_create(struct sk_buff *skb, struct net_device *dev,
1291				  unsigned short type, const void *daddr,
1292				  const void *saddr, unsigned int len)
1293{
1294	struct kunit *test = current->kunit_test;
1295	struct mctp_test_llhdr *hdr;
1296
1297	hdr = skb_push(skb, sizeof(*hdr));
1298	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hdr);
1299	skb_reset_mac_header(skb);
1300
1301	hdr->magic = mctp_test_llhdr_magic;
1302	memcpy(&hdr->src, saddr, sizeof(hdr->src));
1303	memcpy(&hdr->dst, daddr, sizeof(hdr->dst));
1304
1305	return 0;
1306}
1307
1308/* Test the dst_output path for a gateway-routed skb: we should have it
1309 * lookup the nexthop EID in the neighbour table, and call into
1310 * header_ops->create to resolve that to a lladdr. Our mock header_ops->create
1311 * will just set a synthetic link-layer header, which we check after transmit.
1312 */
1313static void mctp_test_route_gw_output(struct kunit *test)
1314{
1315	const unsigned char haddr_self[MCTP_TEST_LLADDR_LEN] = { 0xaa, 0x03 };
1316	const unsigned char haddr_peer[MCTP_TEST_LLADDR_LEN] = { 0xaa, 0x02 };
1317	const struct header_ops ops = {
1318		.create = test_dev_header_create,
1319	};
1320	struct mctp_neigh neigh = { 0 };
1321	struct mctp_test_llhdr *ll_hdr;
1322	struct mctp_dst dst = { 0 };
1323	struct mctp_hdr hdr = { 0 };
1324	struct mctp_test_dev *dev;
1325	struct sk_buff *skb;
1326	unsigned char *buf;
1327	int i, rc;
1328
1329	dev = mctp_test_create_dev_lladdr(sizeof(haddr_self), haddr_self);
1330	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1331	dev->ndev->header_ops = &ops;
1332
1333	dst.dev = dev->mdev;
1334	__mctp_dev_get(dst.dev->dev);
1335	dst.mtu = 68;
1336	dst.nexthop = 9;
1337
1338	/* simple mctp_neigh_add for the gateway (not dest!) endpoint */
1339	INIT_LIST_HEAD(&neigh.list);
1340	neigh.dev = dev->mdev;
1341	mctp_dev_hold(dev->mdev);
1342	neigh.eid = 9;
1343	neigh.source = MCTP_NEIGH_STATIC;
1344	memcpy(neigh.ha, haddr_peer, sizeof(haddr_peer));
1345	list_add_rcu(&neigh.list, &init_net.mctp.neighbours);
1346
1347	hdr.ver = 1;
1348	hdr.src = 8;
1349	hdr.dest = 10;
1350	hdr.flags_seq_tag = FL_S | FL_E | FL_TO;
1351
1352	/* construct enough for a future link-layer header, the provided
1353	 * mctp header, and 4 bytes of data
1354	 */
1355	skb = alloc_skb(sizeof(*ll_hdr) + sizeof(hdr) + 4, GFP_KERNEL);
1356	skb->dev = dev->ndev;
1357	__mctp_cb(skb);
1358
1359	skb_reserve(skb, sizeof(*ll_hdr));
1360
1361	memcpy(skb_put(skb, sizeof(hdr)), &hdr, sizeof(hdr));
1362	buf = skb_put(skb, 4);
1363	for (i = 0; i < 4; i++)
1364		buf[i] = i;
1365
1366	/* extra ref over the dev_xmit */
1367	skb_get(skb);
1368
1369	rc = mctp_dst_output(&dst, skb);
1370	KUNIT_EXPECT_EQ(test, rc, 0);
1371
1372	mctp_dst_release(&dst);
1373	list_del_rcu(&neigh.list);
1374	mctp_dev_put(dev->mdev);
1375
1376	/* check that we have our header created with the correct neighbour */
1377	ll_hdr = (void *)skb_mac_header(skb);
1378	KUNIT_EXPECT_EQ(test, ll_hdr->magic, mctp_test_llhdr_magic);
1379	KUNIT_EXPECT_MEMEQ(test, ll_hdr->src, haddr_self, sizeof(haddr_self));
1380	KUNIT_EXPECT_MEMEQ(test, ll_hdr->dst, haddr_peer, sizeof(haddr_peer));
1381	kfree_skb(skb);
1382}
1383
1384struct mctp_bind_lookup_test {
1385	/* header of incoming message */
1386	struct mctp_hdr hdr;
1387	u8 ty;
1388	/* mctp network of incoming interface (smctp_network) */
1389	unsigned int net;
1390
1391	/* expected socket, matches .name in lookup_binds, NULL for dropped */
1392	const char *expect;
1393};
1394
1395/* Single-packet TO-set message */
1396#define LK(src, dst) RX_HDR(1, (src), (dst), FL_S | FL_E | FL_TO)
1397
1398/* Input message test cases for bind lookup tests.
1399 *
1400 * 10 and 11 are local EIDs.
1401 * 20 and 21 are remote EIDs.
1402 */
1403static const struct mctp_bind_lookup_test mctp_bind_lookup_tests[] = {
1404	/* both local-eid and remote-eid binds, remote eid is preferenced */
1405	{ .hdr = LK(20, 10),  .ty = 1, .net = 1, .expect = "remote20" },
1406
1407	{ .hdr = LK(20, 255), .ty = 1, .net = 1, .expect = "remote20" },
1408	{ .hdr = LK(20, 0),   .ty = 1, .net = 1, .expect = "remote20" },
1409	{ .hdr = LK(0, 255),  .ty = 1, .net = 1, .expect = "any" },
1410	{ .hdr = LK(0, 11),   .ty = 1, .net = 1, .expect = "any" },
1411	{ .hdr = LK(0, 0),    .ty = 1, .net = 1, .expect = "any" },
1412	{ .hdr = LK(0, 10),   .ty = 1, .net = 1, .expect = "local10" },
1413	{ .hdr = LK(21, 10),  .ty = 1, .net = 1, .expect = "local10" },
1414	{ .hdr = LK(21, 11),  .ty = 1, .net = 1, .expect = "remote21local11" },
1415
1416	/* both src and dest set to eid=99. unusual, but accepted
1417	 * by MCTP stack currently.
1418	 */
1419	{ .hdr = LK(99, 99),  .ty = 1, .net = 1, .expect = "any" },
1420
1421	/* unbound smctp_type */
1422	{ .hdr = LK(20, 10),  .ty = 3, .net = 1, .expect = NULL },
1423
1424	/* smctp_network tests */
1425
1426	{ .hdr = LK(0, 0),    .ty = 1, .net = 7, .expect = "any" },
1427	{ .hdr = LK(21, 10),  .ty = 1, .net = 2, .expect = "any" },
1428
1429	/* remote EID 20 matches, but MCTP_NET_ANY in "remote20" resolved
1430	 * to net=1, so lookup doesn't match "remote20"
1431	 */
1432	{ .hdr = LK(20, 10),  .ty = 1, .net = 3, .expect = "any" },
1433
1434	{ .hdr = LK(21, 10),  .ty = 1, .net = 3, .expect = "remote21net3" },
1435	{ .hdr = LK(21, 10),  .ty = 1, .net = 4, .expect = "remote21net4" },
1436	{ .hdr = LK(21, 10),  .ty = 1, .net = 5, .expect = "remote21net5" },
1437
1438	{ .hdr = LK(21, 10),  .ty = 1, .net = 5, .expect = "remote21net5" },
1439
1440	{ .hdr = LK(99, 10),  .ty = 1, .net = 8, .expect = "local10net8" },
1441
1442	{ .hdr = LK(99, 10),  .ty = 1, .net = 9, .expect = "anynet9" },
1443	{ .hdr = LK(0, 0),    .ty = 1, .net = 9, .expect = "anynet9" },
1444	{ .hdr = LK(99, 99),  .ty = 1, .net = 9, .expect = "anynet9" },
1445	{ .hdr = LK(20, 10),  .ty = 1, .net = 9, .expect = "anynet9" },
1446};
1447
1448/* Binds to create during the lookup tests */
1449static const struct mctp_test_bind_setup lookup_binds[] = {
1450	/* any address and net, type 1 */
1451	{ .name = "any", .bind_addr = MCTP_ADDR_ANY,
1452		.bind_net = MCTP_NET_ANY, .bind_type = 1, },
1453	/* local eid 10, net 1 (resolved from MCTP_NET_ANY) */
1454	{ .name = "local10", .bind_addr = 10,
1455		.bind_net = MCTP_NET_ANY, .bind_type = 1, },
1456	/* local eid 10, net 8 */
1457	{ .name = "local10net8", .bind_addr = 10,
1458		.bind_net = 8, .bind_type = 1, },
1459	/* any EID, net 9 */
1460	{ .name = "anynet9", .bind_addr = MCTP_ADDR_ANY,
1461		.bind_net = 9, .bind_type = 1, },
1462
1463	/* remote eid 20, net 1, any local eid */
1464	{ .name = "remote20", .bind_addr = MCTP_ADDR_ANY,
1465		.bind_net = MCTP_NET_ANY, .bind_type = 1,
1466		.have_peer = true, .peer_addr = 20, .peer_net = MCTP_NET_ANY, },
1467
1468	/* remote eid 20, net 1, local eid 11 */
1469	{ .name = "remote21local11", .bind_addr = 11,
1470		.bind_net = MCTP_NET_ANY, .bind_type = 1,
1471		.have_peer = true, .peer_addr = 21, .peer_net = MCTP_NET_ANY, },
1472
1473	/* remote eid 21, specific net=3 for connect() */
1474	{ .name = "remote21net3", .bind_addr = MCTP_ADDR_ANY,
1475		.bind_net = MCTP_NET_ANY, .bind_type = 1,
1476		.have_peer = true, .peer_addr = 21, .peer_net = 3, },
1477
1478	/* remote eid 21, net 4 for bind, specific net=4 for connect() */
1479	{ .name = "remote21net4", .bind_addr = MCTP_ADDR_ANY,
1480		.bind_net = 4, .bind_type = 1,
1481		.have_peer = true, .peer_addr = 21, .peer_net = 4, },
1482
1483	/* remote eid 21, net 5 for bind, specific net=5 for connect() */
1484	{ .name = "remote21net5", .bind_addr = MCTP_ADDR_ANY,
1485		.bind_net = 5, .bind_type = 1,
1486		.have_peer = true, .peer_addr = 21, .peer_net = 5, },
1487};
1488
1489static void mctp_bind_lookup_desc(const struct mctp_bind_lookup_test *t,
1490				  char *desc)
1491{
1492	snprintf(desc, KUNIT_PARAM_DESC_SIZE,
1493		 "{src %d dst %d ty %d net %d expect %s}",
1494		 t->hdr.src, t->hdr.dest, t->ty, t->net, t->expect);
1495}
1496
1497KUNIT_ARRAY_PARAM(mctp_bind_lookup, mctp_bind_lookup_tests,
1498		  mctp_bind_lookup_desc);
1499
1500static void mctp_test_bind_lookup(struct kunit *test)
1501{
1502	const struct mctp_bind_lookup_test *rx;
1503	struct socket *socks[ARRAY_SIZE(lookup_binds)];
1504	struct sk_buff *skb_pkt = NULL, *skb_sock = NULL;
1505	struct socket *sock_ty0, *sock_expect = NULL;
1506	struct mctp_test_dev *dev;
1507	struct mctp_dst dst;
1508	int rc;
1509
1510	rx = test->param_value;
1511
1512	__mctp_route_test_init(test, &dev, &dst, &sock_ty0, rx->net);
1513	/* Create all binds */
1514	for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) {
1515		mctp_test_bind_run(test, &lookup_binds[i],
1516				   &rc, &socks[i]);
1517		KUNIT_ASSERT_EQ(test, rc, 0);
1518
1519		/* Record the expected receive socket */
1520		if (rx->expect &&
1521		    strcmp(rx->expect, lookup_binds[i].name) == 0) {
1522			KUNIT_ASSERT_NULL(test, sock_expect);
1523			sock_expect = socks[i];
1524		}
1525	}
1526	KUNIT_ASSERT_EQ(test, !!sock_expect, !!rx->expect);
1527
1528	/* Create test message */
1529	skb_pkt = mctp_test_create_skb_data(&rx->hdr, &rx->ty);
1530	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb_pkt);
1531	mctp_test_skb_set_dev(skb_pkt, dev);
1532
1533	rc = mctp_dst_input(&dst, skb_pkt);
1534	if (rx->expect) {
1535		/* Test the message is received on the expected socket */
1536		KUNIT_EXPECT_EQ(test, rc, 0);
1537		skb_sock = skb_recv_datagram(sock_expect->sk,
1538					     MSG_DONTWAIT, &rc);
1539		if (!skb_sock) {
1540			/* Find which socket received it instead */
1541			for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) {
1542				skb_sock = skb_recv_datagram(socks[i]->sk,
1543							     MSG_DONTWAIT, &rc);
1544				if (skb_sock) {
1545					KUNIT_FAIL(test,
1546						   "received on incorrect socket '%s', expect '%s'",
1547						   lookup_binds[i].name,
1548						   rx->expect);
1549					goto cleanup;
1550				}
1551			}
1552			KUNIT_FAIL(test, "no message received");
1553		}
1554	} else {
1555		KUNIT_EXPECT_NE(test, rc, 0);
1556	}
1557
1558cleanup:
1559	kfree_skb(skb_sock);
1560
1561	/* Drop all binds */
1562	for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++)
1563		sock_release(socks[i]);
1564
1565	__mctp_route_test_fini(test, dev, &dst, sock_ty0);
1566}
1567
1568static struct kunit_case mctp_test_cases[] = {
1569	KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params),
1570	KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params),
1571	KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params),
1572	KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm,
1573			 mctp_route_input_sk_reasm_gen_params),
1574	KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys,
1575			 mctp_route_input_sk_keys_gen_params),
1576	KUNIT_CASE(mctp_test_route_input_sk_fail_single),
1577	KUNIT_CASE(mctp_test_route_input_sk_fail_frag),
1578	KUNIT_CASE(mctp_test_route_input_multiple_nets_bind),
1579	KUNIT_CASE(mctp_test_route_input_multiple_nets_key),
1580	KUNIT_CASE(mctp_test_packet_flow),
1581	KUNIT_CASE(mctp_test_fragment_flow),
1582	KUNIT_CASE(mctp_test_route_output_key_create),
1583	KUNIT_CASE(mctp_test_route_input_cloned_frag),
1584	KUNIT_CASE(mctp_test_route_extaddr_input),
1585	KUNIT_CASE(mctp_test_route_gw_lookup),
1586	KUNIT_CASE(mctp_test_route_gw_loop),
1587	KUNIT_CASE_PARAM(mctp_test_route_gw_mtu, mctp_route_gw_mtu_gen_params),
1588	KUNIT_CASE(mctp_test_route_gw_output),
1589	KUNIT_CASE_PARAM(mctp_test_bind_lookup, mctp_bind_lookup_gen_params),
1590	{}
1591};
1592
1593static struct kunit_suite mctp_test_suite = {
1594	.name = "mctp-route",
1595	.test_cases = mctp_test_cases,
1596};
1597
1598kunit_test_suite(mctp_test_suite);