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