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