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