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