1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <kunit/test.h> 4 5 #include "utils.h" 6 7 struct mctp_test_route { 8 struct mctp_route rt; 9 struct sk_buff_head pkts; 10 }; 11 12 static int mctp_test_route_output(struct mctp_route *rt, struct sk_buff *skb) 13 { 14 struct mctp_test_route *test_rt = container_of(rt, struct mctp_test_route, rt); 15 16 skb_queue_tail(&test_rt->pkts, skb); 17 18 return 0; 19 } 20 21 /* local version of mctp_route_alloc() */ 22 static struct mctp_test_route *mctp_route_test_alloc(void) 23 { 24 struct mctp_test_route *rt; 25 26 rt = kzalloc(sizeof(*rt), GFP_KERNEL); 27 if (!rt) 28 return NULL; 29 30 INIT_LIST_HEAD(&rt->rt.list); 31 refcount_set(&rt->rt.refs, 1); 32 rt->rt.output = mctp_test_route_output; 33 34 skb_queue_head_init(&rt->pkts); 35 36 return rt; 37 } 38 39 static struct mctp_test_route *mctp_test_create_route(struct net *net, 40 struct mctp_dev *dev, 41 mctp_eid_t eid, 42 unsigned int mtu) 43 { 44 struct mctp_test_route *rt; 45 46 rt = mctp_route_test_alloc(); 47 if (!rt) 48 return NULL; 49 50 rt->rt.min = eid; 51 rt->rt.max = eid; 52 rt->rt.mtu = mtu; 53 rt->rt.type = RTN_UNSPEC; 54 if (dev) 55 mctp_dev_hold(dev); 56 rt->rt.dev = dev; 57 58 list_add_rcu(&rt->rt.list, &net->mctp.routes); 59 60 return rt; 61 } 62 63 static void mctp_test_route_destroy(struct kunit *test, 64 struct mctp_test_route *rt) 65 { 66 unsigned int refs; 67 68 rtnl_lock(); 69 list_del_rcu(&rt->rt.list); 70 rtnl_unlock(); 71 72 skb_queue_purge(&rt->pkts); 73 if (rt->rt.dev) 74 mctp_dev_put(rt->rt.dev); 75 76 refs = refcount_read(&rt->rt.refs); 77 KUNIT_ASSERT_EQ_MSG(test, refs, 1, "route ref imbalance"); 78 79 kfree_rcu(&rt->rt, rcu); 80 } 81 82 static void mctp_test_skb_set_dev(struct sk_buff *skb, 83 struct mctp_test_dev *dev) 84 { 85 struct mctp_skb_cb *cb; 86 87 cb = mctp_cb(skb); 88 cb->net = READ_ONCE(dev->mdev->net); 89 skb->dev = dev->ndev; 90 } 91 92 static struct sk_buff *mctp_test_create_skb(const struct mctp_hdr *hdr, 93 unsigned int data_len) 94 { 95 size_t hdr_len = sizeof(*hdr); 96 struct sk_buff *skb; 97 unsigned int i; 98 u8 *buf; 99 100 skb = alloc_skb(hdr_len + data_len, GFP_KERNEL); 101 if (!skb) 102 return NULL; 103 104 __mctp_cb(skb); 105 memcpy(skb_put(skb, hdr_len), hdr, hdr_len); 106 107 buf = skb_put(skb, data_len); 108 for (i = 0; i < data_len; i++) 109 buf[i] = i & 0xff; 110 111 return skb; 112 } 113 114 static struct sk_buff *__mctp_test_create_skb_data(const struct mctp_hdr *hdr, 115 const void *data, 116 size_t data_len) 117 { 118 size_t hdr_len = sizeof(*hdr); 119 struct sk_buff *skb; 120 121 skb = alloc_skb(hdr_len + data_len, GFP_KERNEL); 122 if (!skb) 123 return NULL; 124 125 __mctp_cb(skb); 126 memcpy(skb_put(skb, hdr_len), hdr, hdr_len); 127 memcpy(skb_put(skb, data_len), data, data_len); 128 129 return skb; 130 } 131 132 #define mctp_test_create_skb_data(h, d) \ 133 __mctp_test_create_skb_data(h, d, sizeof(*d)) 134 135 struct mctp_frag_test { 136 unsigned int mtu; 137 unsigned int msgsize; 138 unsigned int n_frags; 139 }; 140 141 static void mctp_test_fragment(struct kunit *test) 142 { 143 const struct mctp_frag_test *params; 144 int rc, i, n, mtu, msgsize; 145 struct mctp_test_route *rt; 146 struct sk_buff *skb; 147 struct mctp_hdr hdr; 148 u8 seq; 149 150 params = test->param_value; 151 mtu = params->mtu; 152 msgsize = params->msgsize; 153 154 hdr.ver = 1; 155 hdr.src = 8; 156 hdr.dest = 10; 157 hdr.flags_seq_tag = MCTP_HDR_FLAG_TO; 158 159 skb = mctp_test_create_skb(&hdr, msgsize); 160 KUNIT_ASSERT_TRUE(test, skb); 161 162 rt = mctp_test_create_route(&init_net, NULL, 10, mtu); 163 KUNIT_ASSERT_TRUE(test, rt); 164 165 rc = mctp_do_fragment_route(&rt->rt, skb, mtu, MCTP_TAG_OWNER); 166 KUNIT_EXPECT_FALSE(test, rc); 167 168 n = rt->pkts.qlen; 169 170 KUNIT_EXPECT_EQ(test, n, params->n_frags); 171 172 for (i = 0;; i++) { 173 struct mctp_hdr *hdr2; 174 struct sk_buff *skb2; 175 u8 tag_mask, seq2; 176 bool first, last; 177 178 first = i == 0; 179 last = i == (n - 1); 180 181 skb2 = skb_dequeue(&rt->pkts); 182 183 if (!skb2) 184 break; 185 186 hdr2 = mctp_hdr(skb2); 187 188 tag_mask = MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO; 189 190 KUNIT_EXPECT_EQ(test, hdr2->ver, hdr.ver); 191 KUNIT_EXPECT_EQ(test, hdr2->src, hdr.src); 192 KUNIT_EXPECT_EQ(test, hdr2->dest, hdr.dest); 193 KUNIT_EXPECT_EQ(test, hdr2->flags_seq_tag & tag_mask, 194 hdr.flags_seq_tag & tag_mask); 195 196 KUNIT_EXPECT_EQ(test, 197 !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_SOM), first); 198 KUNIT_EXPECT_EQ(test, 199 !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_EOM), last); 200 201 seq2 = (hdr2->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) & 202 MCTP_HDR_SEQ_MASK; 203 204 if (first) { 205 seq = seq2; 206 } else { 207 seq++; 208 KUNIT_EXPECT_EQ(test, seq2, seq & MCTP_HDR_SEQ_MASK); 209 } 210 211 if (!last) 212 KUNIT_EXPECT_EQ(test, skb2->len, mtu); 213 else 214 KUNIT_EXPECT_LE(test, skb2->len, mtu); 215 216 kfree_skb(skb2); 217 } 218 219 mctp_test_route_destroy(test, rt); 220 } 221 222 static const struct mctp_frag_test mctp_frag_tests[] = { 223 {.mtu = 68, .msgsize = 63, .n_frags = 1}, 224 {.mtu = 68, .msgsize = 64, .n_frags = 1}, 225 {.mtu = 68, .msgsize = 65, .n_frags = 2}, 226 {.mtu = 68, .msgsize = 66, .n_frags = 2}, 227 {.mtu = 68, .msgsize = 127, .n_frags = 2}, 228 {.mtu = 68, .msgsize = 128, .n_frags = 2}, 229 {.mtu = 68, .msgsize = 129, .n_frags = 3}, 230 {.mtu = 68, .msgsize = 130, .n_frags = 3}, 231 }; 232 233 static void mctp_frag_test_to_desc(const struct mctp_frag_test *t, char *desc) 234 { 235 sprintf(desc, "mtu %d len %d -> %d frags", 236 t->msgsize, t->mtu, t->n_frags); 237 } 238 239 KUNIT_ARRAY_PARAM(mctp_frag, mctp_frag_tests, mctp_frag_test_to_desc); 240 241 struct mctp_rx_input_test { 242 struct mctp_hdr hdr; 243 bool input; 244 }; 245 246 static void mctp_test_rx_input(struct kunit *test) 247 { 248 const struct mctp_rx_input_test *params; 249 struct mctp_test_route *rt; 250 struct mctp_test_dev *dev; 251 struct sk_buff *skb; 252 253 params = test->param_value; 254 255 dev = mctp_test_create_dev(); 256 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 257 258 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68); 259 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 260 261 skb = mctp_test_create_skb(¶ms->hdr, 1); 262 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 263 264 mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL); 265 266 KUNIT_EXPECT_EQ(test, !!rt->pkts.qlen, params->input); 267 268 mctp_test_route_destroy(test, rt); 269 mctp_test_destroy_dev(dev); 270 } 271 272 #define RX_HDR(_ver, _src, _dest, _fst) \ 273 { .ver = _ver, .src = _src, .dest = _dest, .flags_seq_tag = _fst } 274 275 /* we have a route for EID 8 only */ 276 static const struct mctp_rx_input_test mctp_rx_input_tests[] = { 277 { .hdr = RX_HDR(1, 10, 8, 0), .input = true }, 278 { .hdr = RX_HDR(1, 10, 9, 0), .input = false }, /* no input route */ 279 { .hdr = RX_HDR(2, 10, 8, 0), .input = false }, /* invalid version */ 280 }; 281 282 static void mctp_rx_input_test_to_desc(const struct mctp_rx_input_test *t, 283 char *desc) 284 { 285 sprintf(desc, "{%x,%x,%x,%x}", t->hdr.ver, t->hdr.src, t->hdr.dest, 286 t->hdr.flags_seq_tag); 287 } 288 289 KUNIT_ARRAY_PARAM(mctp_rx_input, mctp_rx_input_tests, 290 mctp_rx_input_test_to_desc); 291 292 /* set up a local dev, route on EID 8, and a socket listening on type 0 */ 293 static void __mctp_route_test_init(struct kunit *test, 294 struct mctp_test_dev **devp, 295 struct mctp_test_route **rtp, 296 struct socket **sockp, 297 unsigned int netid) 298 { 299 struct sockaddr_mctp addr = {0}; 300 struct mctp_test_route *rt; 301 struct mctp_test_dev *dev; 302 struct socket *sock; 303 int rc; 304 305 dev = mctp_test_create_dev(); 306 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 307 if (netid != MCTP_NET_ANY) 308 WRITE_ONCE(dev->mdev->net, netid); 309 310 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68); 311 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 312 313 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 314 KUNIT_ASSERT_EQ(test, rc, 0); 315 316 addr.smctp_family = AF_MCTP; 317 addr.smctp_network = netid; 318 addr.smctp_addr.s_addr = 8; 319 addr.smctp_type = 0; 320 rc = kernel_bind(sock, (struct sockaddr *)&addr, sizeof(addr)); 321 KUNIT_ASSERT_EQ(test, rc, 0); 322 323 *rtp = rt; 324 *devp = dev; 325 *sockp = sock; 326 } 327 328 static void __mctp_route_test_fini(struct kunit *test, 329 struct mctp_test_dev *dev, 330 struct mctp_test_route *rt, 331 struct socket *sock) 332 { 333 sock_release(sock); 334 mctp_test_route_destroy(test, rt); 335 mctp_test_destroy_dev(dev); 336 } 337 338 struct mctp_route_input_sk_test { 339 struct mctp_hdr hdr; 340 u8 type; 341 bool deliver; 342 }; 343 344 static void mctp_test_route_input_sk(struct kunit *test) 345 { 346 const struct mctp_route_input_sk_test *params; 347 struct sk_buff *skb, *skb2; 348 struct mctp_test_route *rt; 349 struct mctp_test_dev *dev; 350 struct socket *sock; 351 int rc; 352 353 params = test->param_value; 354 355 __mctp_route_test_init(test, &dev, &rt, &sock, MCTP_NET_ANY); 356 357 skb = mctp_test_create_skb_data(¶ms->hdr, ¶ms->type); 358 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 359 360 mctp_test_skb_set_dev(skb, dev); 361 362 rc = mctp_route_input(&rt->rt, skb); 363 364 if (params->deliver) { 365 KUNIT_EXPECT_EQ(test, rc, 0); 366 367 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 368 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 369 KUNIT_EXPECT_EQ(test, skb->len, 1); 370 371 skb_free_datagram(sock->sk, skb2); 372 373 } else { 374 KUNIT_EXPECT_NE(test, rc, 0); 375 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 376 KUNIT_EXPECT_NULL(test, skb2); 377 } 378 379 __mctp_route_test_fini(test, dev, rt, sock); 380 } 381 382 #define FL_S (MCTP_HDR_FLAG_SOM) 383 #define FL_E (MCTP_HDR_FLAG_EOM) 384 #define FL_TO (MCTP_HDR_FLAG_TO) 385 #define FL_T(t) ((t) & MCTP_HDR_TAG_MASK) 386 387 static const struct mctp_route_input_sk_test mctp_route_input_sk_tests[] = { 388 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 0, .deliver = true }, 389 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 1, .deliver = false }, 390 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E), .type = 0, .deliver = false }, 391 { .hdr = RX_HDR(1, 10, 8, FL_E | FL_TO), .type = 0, .deliver = false }, 392 { .hdr = RX_HDR(1, 10, 8, FL_TO), .type = 0, .deliver = false }, 393 { .hdr = RX_HDR(1, 10, 8, 0), .type = 0, .deliver = false }, 394 }; 395 396 static void mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test *t, 397 char *desc) 398 { 399 sprintf(desc, "{%x,%x,%x,%x} type %d", t->hdr.ver, t->hdr.src, 400 t->hdr.dest, t->hdr.flags_seq_tag, t->type); 401 } 402 403 KUNIT_ARRAY_PARAM(mctp_route_input_sk, mctp_route_input_sk_tests, 404 mctp_route_input_sk_to_desc); 405 406 struct mctp_route_input_sk_reasm_test { 407 const char *name; 408 struct mctp_hdr hdrs[4]; 409 int n_hdrs; 410 int rx_len; 411 }; 412 413 static void mctp_test_route_input_sk_reasm(struct kunit *test) 414 { 415 const struct mctp_route_input_sk_reasm_test *params; 416 struct sk_buff *skb, *skb2; 417 struct mctp_test_route *rt; 418 struct mctp_test_dev *dev; 419 struct socket *sock; 420 int i, rc; 421 u8 c; 422 423 params = test->param_value; 424 425 __mctp_route_test_init(test, &dev, &rt, &sock, MCTP_NET_ANY); 426 427 for (i = 0; i < params->n_hdrs; i++) { 428 c = i; 429 skb = mctp_test_create_skb_data(¶ms->hdrs[i], &c); 430 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 431 432 mctp_test_skb_set_dev(skb, dev); 433 434 rc = mctp_route_input(&rt->rt, skb); 435 } 436 437 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 438 439 if (params->rx_len) { 440 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 441 KUNIT_EXPECT_EQ(test, skb2->len, params->rx_len); 442 skb_free_datagram(sock->sk, skb2); 443 444 } else { 445 KUNIT_EXPECT_NULL(test, skb2); 446 } 447 448 __mctp_route_test_fini(test, dev, rt, sock); 449 } 450 451 #define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_TO | (f) | ((s) << MCTP_HDR_SEQ_SHIFT)) 452 453 static const struct mctp_route_input_sk_reasm_test mctp_route_input_sk_reasm_tests[] = { 454 { 455 .name = "single packet", 456 .hdrs = { 457 RX_FRAG(FL_S | FL_E, 0), 458 }, 459 .n_hdrs = 1, 460 .rx_len = 1, 461 }, 462 { 463 .name = "single packet, offset seq", 464 .hdrs = { 465 RX_FRAG(FL_S | FL_E, 1), 466 }, 467 .n_hdrs = 1, 468 .rx_len = 1, 469 }, 470 { 471 .name = "start & end packets", 472 .hdrs = { 473 RX_FRAG(FL_S, 0), 474 RX_FRAG(FL_E, 1), 475 }, 476 .n_hdrs = 2, 477 .rx_len = 2, 478 }, 479 { 480 .name = "start & end packets, offset seq", 481 .hdrs = { 482 RX_FRAG(FL_S, 1), 483 RX_FRAG(FL_E, 2), 484 }, 485 .n_hdrs = 2, 486 .rx_len = 2, 487 }, 488 { 489 .name = "start & end packets, out of order", 490 .hdrs = { 491 RX_FRAG(FL_E, 1), 492 RX_FRAG(FL_S, 0), 493 }, 494 .n_hdrs = 2, 495 .rx_len = 0, 496 }, 497 { 498 .name = "start, middle & end packets", 499 .hdrs = { 500 RX_FRAG(FL_S, 0), 501 RX_FRAG(0, 1), 502 RX_FRAG(FL_E, 2), 503 }, 504 .n_hdrs = 3, 505 .rx_len = 3, 506 }, 507 { 508 .name = "missing seq", 509 .hdrs = { 510 RX_FRAG(FL_S, 0), 511 RX_FRAG(FL_E, 2), 512 }, 513 .n_hdrs = 2, 514 .rx_len = 0, 515 }, 516 { 517 .name = "seq wrap", 518 .hdrs = { 519 RX_FRAG(FL_S, 3), 520 RX_FRAG(FL_E, 0), 521 }, 522 .n_hdrs = 2, 523 .rx_len = 2, 524 }, 525 }; 526 527 static void mctp_route_input_sk_reasm_to_desc( 528 const struct mctp_route_input_sk_reasm_test *t, 529 char *desc) 530 { 531 sprintf(desc, "%s", t->name); 532 } 533 534 KUNIT_ARRAY_PARAM(mctp_route_input_sk_reasm, mctp_route_input_sk_reasm_tests, 535 mctp_route_input_sk_reasm_to_desc); 536 537 struct mctp_route_input_sk_keys_test { 538 const char *name; 539 mctp_eid_t key_peer_addr; 540 mctp_eid_t key_local_addr; 541 u8 key_tag; 542 struct mctp_hdr hdr; 543 bool deliver; 544 }; 545 546 /* test packet rx in the presence of various key configurations */ 547 static void mctp_test_route_input_sk_keys(struct kunit *test) 548 { 549 const struct mctp_route_input_sk_keys_test *params; 550 struct mctp_test_route *rt; 551 struct sk_buff *skb, *skb2; 552 struct mctp_test_dev *dev; 553 struct mctp_sk_key *key; 554 struct netns_mctp *mns; 555 struct mctp_sock *msk; 556 struct socket *sock; 557 unsigned long flags; 558 unsigned int net; 559 int rc; 560 u8 c; 561 562 params = test->param_value; 563 564 dev = mctp_test_create_dev(); 565 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 566 net = READ_ONCE(dev->mdev->net); 567 568 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68); 569 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 570 571 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 572 KUNIT_ASSERT_EQ(test, rc, 0); 573 574 msk = container_of(sock->sk, struct mctp_sock, sk); 575 mns = &sock_net(sock->sk)->mctp; 576 577 /* set the incoming tag according to test params */ 578 key = mctp_key_alloc(msk, net, params->key_local_addr, 579 params->key_peer_addr, params->key_tag, 580 GFP_KERNEL); 581 582 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, key); 583 584 spin_lock_irqsave(&mns->keys_lock, flags); 585 mctp_reserve_tag(&init_net, key, msk); 586 spin_unlock_irqrestore(&mns->keys_lock, flags); 587 588 /* create packet and route */ 589 c = 0; 590 skb = mctp_test_create_skb_data(¶ms->hdr, &c); 591 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 592 593 mctp_test_skb_set_dev(skb, dev); 594 595 rc = mctp_route_input(&rt->rt, skb); 596 597 /* (potentially) receive message */ 598 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 599 600 if (params->deliver) 601 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 602 else 603 KUNIT_EXPECT_PTR_EQ(test, skb2, NULL); 604 605 if (skb2) 606 skb_free_datagram(sock->sk, skb2); 607 608 mctp_key_unref(key); 609 __mctp_route_test_fini(test, dev, rt, sock); 610 } 611 612 static const struct mctp_route_input_sk_keys_test mctp_route_input_sk_keys_tests[] = { 613 { 614 .name = "direct match", 615 .key_peer_addr = 9, 616 .key_local_addr = 8, 617 .key_tag = 1, 618 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)), 619 .deliver = true, 620 }, 621 { 622 .name = "flipped src/dest", 623 .key_peer_addr = 8, 624 .key_local_addr = 9, 625 .key_tag = 1, 626 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)), 627 .deliver = false, 628 }, 629 { 630 .name = "peer addr mismatch", 631 .key_peer_addr = 9, 632 .key_local_addr = 8, 633 .key_tag = 1, 634 .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T(1)), 635 .deliver = false, 636 }, 637 { 638 .name = "tag value mismatch", 639 .key_peer_addr = 9, 640 .key_local_addr = 8, 641 .key_tag = 1, 642 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(2)), 643 .deliver = false, 644 }, 645 { 646 .name = "TO mismatch", 647 .key_peer_addr = 9, 648 .key_local_addr = 8, 649 .key_tag = 1, 650 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO), 651 .deliver = false, 652 }, 653 { 654 .name = "broadcast response", 655 .key_peer_addr = MCTP_ADDR_ANY, 656 .key_local_addr = 8, 657 .key_tag = 1, 658 .hdr = RX_HDR(1, 11, 8, FL_S | FL_E | FL_T(1)), 659 .deliver = true, 660 }, 661 { 662 .name = "any local match", 663 .key_peer_addr = 12, 664 .key_local_addr = MCTP_ADDR_ANY, 665 .key_tag = 1, 666 .hdr = RX_HDR(1, 12, 8, FL_S | FL_E | FL_T(1)), 667 .deliver = true, 668 }, 669 }; 670 671 static void mctp_route_input_sk_keys_to_desc( 672 const struct mctp_route_input_sk_keys_test *t, 673 char *desc) 674 { 675 sprintf(desc, "%s", t->name); 676 } 677 678 KUNIT_ARRAY_PARAM(mctp_route_input_sk_keys, mctp_route_input_sk_keys_tests, 679 mctp_route_input_sk_keys_to_desc); 680 681 struct test_net { 682 unsigned int netid; 683 struct mctp_test_dev *dev; 684 struct mctp_test_route *rt; 685 struct socket *sock; 686 struct sk_buff *skb; 687 struct mctp_sk_key *key; 688 struct { 689 u8 type; 690 unsigned int data; 691 } msg; 692 }; 693 694 static void 695 mctp_test_route_input_multiple_nets_bind_init(struct kunit *test, 696 struct test_net *t) 697 { 698 struct mctp_hdr hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO); 699 700 t->msg.data = t->netid; 701 702 __mctp_route_test_init(test, &t->dev, &t->rt, &t->sock, t->netid); 703 704 t->skb = mctp_test_create_skb_data(&hdr, &t->msg); 705 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->skb); 706 mctp_test_skb_set_dev(t->skb, t->dev); 707 } 708 709 static void 710 mctp_test_route_input_multiple_nets_bind_fini(struct kunit *test, 711 struct test_net *t) 712 { 713 __mctp_route_test_fini(test, t->dev, t->rt, t->sock); 714 } 715 716 /* Test that skbs from different nets (otherwise identical) get routed to their 717 * corresponding socket via the sockets' bind() 718 */ 719 static void mctp_test_route_input_multiple_nets_bind(struct kunit *test) 720 { 721 struct sk_buff *rx_skb1, *rx_skb2; 722 struct test_net t1, t2; 723 int rc; 724 725 t1.netid = 1; 726 t2.netid = 2; 727 728 t1.msg.type = 0; 729 t2.msg.type = 0; 730 731 mctp_test_route_input_multiple_nets_bind_init(test, &t1); 732 mctp_test_route_input_multiple_nets_bind_init(test, &t2); 733 734 rc = mctp_route_input(&t1.rt->rt, t1.skb); 735 KUNIT_ASSERT_EQ(test, rc, 0); 736 rc = mctp_route_input(&t2.rt->rt, t2.skb); 737 KUNIT_ASSERT_EQ(test, rc, 0); 738 739 rx_skb1 = skb_recv_datagram(t1.sock->sk, MSG_DONTWAIT, &rc); 740 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb1); 741 KUNIT_EXPECT_EQ(test, rx_skb1->len, sizeof(t1.msg)); 742 KUNIT_EXPECT_EQ(test, 743 *(unsigned int *)skb_pull(rx_skb1, sizeof(t1.msg.data)), 744 t1.netid); 745 kfree_skb(rx_skb1); 746 747 rx_skb2 = skb_recv_datagram(t2.sock->sk, MSG_DONTWAIT, &rc); 748 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb2); 749 KUNIT_EXPECT_EQ(test, rx_skb2->len, sizeof(t2.msg)); 750 KUNIT_EXPECT_EQ(test, 751 *(unsigned int *)skb_pull(rx_skb2, sizeof(t2.msg.data)), 752 t2.netid); 753 kfree_skb(rx_skb2); 754 755 mctp_test_route_input_multiple_nets_bind_fini(test, &t1); 756 mctp_test_route_input_multiple_nets_bind_fini(test, &t2); 757 } 758 759 static void 760 mctp_test_route_input_multiple_nets_key_init(struct kunit *test, 761 struct test_net *t) 762 { 763 struct mctp_hdr hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)); 764 struct mctp_sock *msk; 765 struct netns_mctp *mns; 766 unsigned long flags; 767 768 t->msg.data = t->netid; 769 770 __mctp_route_test_init(test, &t->dev, &t->rt, &t->sock, t->netid); 771 772 msk = container_of(t->sock->sk, struct mctp_sock, sk); 773 774 t->key = mctp_key_alloc(msk, t->netid, hdr.dest, hdr.src, 1, GFP_KERNEL); 775 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->key); 776 777 mns = &sock_net(t->sock->sk)->mctp; 778 spin_lock_irqsave(&mns->keys_lock, flags); 779 mctp_reserve_tag(&init_net, t->key, msk); 780 spin_unlock_irqrestore(&mns->keys_lock, flags); 781 782 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->key); 783 t->skb = mctp_test_create_skb_data(&hdr, &t->msg); 784 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->skb); 785 mctp_test_skb_set_dev(t->skb, t->dev); 786 } 787 788 static void 789 mctp_test_route_input_multiple_nets_key_fini(struct kunit *test, 790 struct test_net *t) 791 { 792 mctp_key_unref(t->key); 793 __mctp_route_test_fini(test, t->dev, t->rt, t->sock); 794 } 795 796 /* test that skbs from different nets (otherwise identical) get routed to their 797 * corresponding socket via the sk_key 798 */ 799 static void mctp_test_route_input_multiple_nets_key(struct kunit *test) 800 { 801 struct sk_buff *rx_skb1, *rx_skb2; 802 struct test_net t1, t2; 803 int rc; 804 805 t1.netid = 1; 806 t2.netid = 2; 807 808 /* use type 1 which is not bound */ 809 t1.msg.type = 1; 810 t2.msg.type = 1; 811 812 mctp_test_route_input_multiple_nets_key_init(test, &t1); 813 mctp_test_route_input_multiple_nets_key_init(test, &t2); 814 815 rc = mctp_route_input(&t1.rt->rt, t1.skb); 816 KUNIT_ASSERT_EQ(test, rc, 0); 817 rc = mctp_route_input(&t2.rt->rt, t2.skb); 818 KUNIT_ASSERT_EQ(test, rc, 0); 819 820 rx_skb1 = skb_recv_datagram(t1.sock->sk, MSG_DONTWAIT, &rc); 821 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb1); 822 KUNIT_EXPECT_EQ(test, rx_skb1->len, sizeof(t1.msg)); 823 KUNIT_EXPECT_EQ(test, 824 *(unsigned int *)skb_pull(rx_skb1, sizeof(t1.msg.data)), 825 t1.netid); 826 kfree_skb(rx_skb1); 827 828 rx_skb2 = skb_recv_datagram(t2.sock->sk, MSG_DONTWAIT, &rc); 829 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, rx_skb2); 830 KUNIT_EXPECT_EQ(test, rx_skb2->len, sizeof(t2.msg)); 831 KUNIT_EXPECT_EQ(test, 832 *(unsigned int *)skb_pull(rx_skb2, sizeof(t2.msg.data)), 833 t2.netid); 834 kfree_skb(rx_skb2); 835 836 mctp_test_route_input_multiple_nets_key_fini(test, &t1); 837 mctp_test_route_input_multiple_nets_key_fini(test, &t2); 838 } 839 840 #if IS_ENABLED(CONFIG_MCTP_FLOWS) 841 842 static void mctp_test_flow_init(struct kunit *test, 843 struct mctp_test_dev **devp, 844 struct mctp_test_route **rtp, 845 struct socket **sock, 846 struct sk_buff **skbp, 847 unsigned int len) 848 { 849 struct mctp_test_route *rt; 850 struct mctp_test_dev *dev; 851 struct sk_buff *skb; 852 853 /* we have a slightly odd routing setup here; the test route 854 * is for EID 8, which is our local EID. We don't do a routing 855 * lookup, so that's fine - all we require is a path through 856 * mctp_local_output, which will call rt->output on whatever 857 * route we provide 858 */ 859 __mctp_route_test_init(test, &dev, &rt, sock, MCTP_NET_ANY); 860 861 /* Assign a single EID. ->addrs is freed on mctp netdev release */ 862 dev->mdev->addrs = kmalloc(sizeof(u8), GFP_KERNEL); 863 dev->mdev->num_addrs = 1; 864 dev->mdev->addrs[0] = 8; 865 866 skb = alloc_skb(len + sizeof(struct mctp_hdr) + 1, GFP_KERNEL); 867 KUNIT_ASSERT_TRUE(test, skb); 868 __mctp_cb(skb); 869 skb_reserve(skb, sizeof(struct mctp_hdr) + 1); 870 memset(skb_put(skb, len), 0, len); 871 872 /* take a ref for the route, we'll decrement in local output */ 873 refcount_inc(&rt->rt.refs); 874 875 *devp = dev; 876 *rtp = rt; 877 *skbp = skb; 878 } 879 880 static void mctp_test_flow_fini(struct kunit *test, 881 struct mctp_test_dev *dev, 882 struct mctp_test_route *rt, 883 struct socket *sock) 884 { 885 __mctp_route_test_fini(test, dev, rt, sock); 886 } 887 888 /* test that an outgoing skb has the correct MCTP extension data set */ 889 static void mctp_test_packet_flow(struct kunit *test) 890 { 891 struct sk_buff *skb, *skb2; 892 struct mctp_test_route *rt; 893 struct mctp_test_dev *dev; 894 struct mctp_flow *flow; 895 struct socket *sock; 896 u8 dst = 8; 897 int n, rc; 898 899 mctp_test_flow_init(test, &dev, &rt, &sock, &skb, 30); 900 901 rc = mctp_local_output(sock->sk, &rt->rt, skb, dst, MCTP_TAG_OWNER); 902 KUNIT_ASSERT_EQ(test, rc, 0); 903 904 n = rt->pkts.qlen; 905 KUNIT_ASSERT_EQ(test, n, 1); 906 907 skb2 = skb_dequeue(&rt->pkts); 908 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2); 909 910 flow = skb_ext_find(skb2, SKB_EXT_MCTP); 911 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flow); 912 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flow->key); 913 KUNIT_ASSERT_PTR_EQ(test, flow->key->sk, sock->sk); 914 915 kfree_skb(skb2); 916 mctp_test_flow_fini(test, dev, rt, sock); 917 } 918 919 /* test that outgoing skbs, after fragmentation, all have the correct MCTP 920 * extension data set. 921 */ 922 static void mctp_test_fragment_flow(struct kunit *test) 923 { 924 struct mctp_flow *flows[2]; 925 struct sk_buff *tx_skbs[2]; 926 struct mctp_test_route *rt; 927 struct mctp_test_dev *dev; 928 struct sk_buff *skb; 929 struct socket *sock; 930 u8 dst = 8; 931 int n, rc; 932 933 mctp_test_flow_init(test, &dev, &rt, &sock, &skb, 100); 934 935 rc = mctp_local_output(sock->sk, &rt->rt, skb, dst, MCTP_TAG_OWNER); 936 KUNIT_ASSERT_EQ(test, rc, 0); 937 938 n = rt->pkts.qlen; 939 KUNIT_ASSERT_EQ(test, n, 2); 940 941 /* both resulting packets should have the same flow data */ 942 tx_skbs[0] = skb_dequeue(&rt->pkts); 943 tx_skbs[1] = skb_dequeue(&rt->pkts); 944 945 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[0]); 946 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[1]); 947 948 flows[0] = skb_ext_find(tx_skbs[0], SKB_EXT_MCTP); 949 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[0]); 950 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[0]->key); 951 KUNIT_ASSERT_PTR_EQ(test, flows[0]->key->sk, sock->sk); 952 953 flows[1] = skb_ext_find(tx_skbs[1], SKB_EXT_MCTP); 954 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[1]); 955 KUNIT_ASSERT_PTR_EQ(test, flows[1]->key, flows[0]->key); 956 957 kfree_skb(tx_skbs[0]); 958 kfree_skb(tx_skbs[1]); 959 mctp_test_flow_fini(test, dev, rt, sock); 960 } 961 962 #else 963 static void mctp_test_packet_flow(struct kunit *test) 964 { 965 kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y"); 966 } 967 968 static void mctp_test_fragment_flow(struct kunit *test) 969 { 970 kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y"); 971 } 972 #endif 973 974 /* Test that outgoing skbs cause a suitable tag to be created */ 975 static void mctp_test_route_output_key_create(struct kunit *test) 976 { 977 const unsigned int netid = 50; 978 const u8 dst = 26, src = 15; 979 struct mctp_test_route *rt; 980 struct mctp_test_dev *dev; 981 struct mctp_sk_key *key; 982 struct netns_mctp *mns; 983 unsigned long flags; 984 struct socket *sock; 985 struct sk_buff *skb; 986 bool empty, single; 987 const int len = 2; 988 int rc; 989 990 dev = mctp_test_create_dev(); 991 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 992 WRITE_ONCE(dev->mdev->net, netid); 993 994 rt = mctp_test_create_route(&init_net, dev->mdev, dst, 68); 995 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 996 997 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 998 KUNIT_ASSERT_EQ(test, rc, 0); 999 1000 dev->mdev->addrs = kmalloc(sizeof(u8), GFP_KERNEL); 1001 dev->mdev->num_addrs = 1; 1002 dev->mdev->addrs[0] = src; 1003 1004 skb = alloc_skb(sizeof(struct mctp_hdr) + 1 + len, GFP_KERNEL); 1005 KUNIT_ASSERT_TRUE(test, skb); 1006 __mctp_cb(skb); 1007 skb_reserve(skb, sizeof(struct mctp_hdr) + 1 + len); 1008 memset(skb_put(skb, len), 0, len); 1009 1010 refcount_inc(&rt->rt.refs); 1011 1012 mns = &sock_net(sock->sk)->mctp; 1013 1014 /* We assume we're starting from an empty keys list, which requires 1015 * preceding tests to clean up correctly! 1016 */ 1017 spin_lock_irqsave(&mns->keys_lock, flags); 1018 empty = hlist_empty(&mns->keys); 1019 spin_unlock_irqrestore(&mns->keys_lock, flags); 1020 KUNIT_ASSERT_TRUE(test, empty); 1021 1022 rc = mctp_local_output(sock->sk, &rt->rt, skb, dst, MCTP_TAG_OWNER); 1023 KUNIT_ASSERT_EQ(test, rc, 0); 1024 1025 key = NULL; 1026 single = false; 1027 spin_lock_irqsave(&mns->keys_lock, flags); 1028 if (!hlist_empty(&mns->keys)) { 1029 key = hlist_entry(mns->keys.first, struct mctp_sk_key, hlist); 1030 single = hlist_is_singular_node(&key->hlist, &mns->keys); 1031 } 1032 spin_unlock_irqrestore(&mns->keys_lock, flags); 1033 1034 KUNIT_ASSERT_NOT_NULL(test, key); 1035 KUNIT_ASSERT_TRUE(test, single); 1036 1037 KUNIT_EXPECT_EQ(test, key->net, netid); 1038 KUNIT_EXPECT_EQ(test, key->local_addr, src); 1039 KUNIT_EXPECT_EQ(test, key->peer_addr, dst); 1040 /* key has incoming tag, so inverse of what we sent */ 1041 KUNIT_EXPECT_FALSE(test, key->tag & MCTP_TAG_OWNER); 1042 1043 sock_release(sock); 1044 mctp_test_route_destroy(test, rt); 1045 mctp_test_destroy_dev(dev); 1046 } 1047 1048 static struct kunit_case mctp_test_cases[] = { 1049 KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params), 1050 KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params), 1051 KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params), 1052 KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm, 1053 mctp_route_input_sk_reasm_gen_params), 1054 KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys, 1055 mctp_route_input_sk_keys_gen_params), 1056 KUNIT_CASE(mctp_test_route_input_multiple_nets_bind), 1057 KUNIT_CASE(mctp_test_route_input_multiple_nets_key), 1058 KUNIT_CASE(mctp_test_packet_flow), 1059 KUNIT_CASE(mctp_test_fragment_flow), 1060 KUNIT_CASE(mctp_test_route_output_key_create), 1061 {} 1062 }; 1063 1064 static struct kunit_suite mctp_test_suite = { 1065 .name = "mctp", 1066 .test_cases = mctp_test_cases, 1067 }; 1068 1069 kunit_test_suite(mctp_test_suite); 1070