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 skb_dump("pkt1 ", skb[0], false); 863 skb_dump("pkt2 ", skb[1], false); 864 skb_dump("pkt3 ", skb[2], false); 865 skb_dump("pkt4 ", skb[3], false); 866 skb_dump("pkt5 ", skb[4], false); 867 868 for (int i = 0; i < 5; i++) { 869 KUNIT_EXPECT_EQ(test, refcount_read(&skb[i]->users), 1); 870 /* Take a reference so we can check refcounts at the end */ 871 skb_get(skb[i]); 872 } 873 874 /* Feed the fragments into MCTP core */ 875 for (int i = 0; i < 5; i++) { 876 rc = mctp_dst_input(&dst, skb[i]); 877 KUNIT_EXPECT_EQ(test, rc, 0); 878 } 879 880 /* Receive first reassembled message */ 881 rx_skb = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 882 KUNIT_EXPECT_EQ(test, rc, 0); 883 KUNIT_EXPECT_EQ(test, rx_skb->len, 3 * data_len); 884 rc = skb_copy_bits(rx_skb, 0, flat, rx_skb->len); 885 for (int i = 0; i < rx_skb->len; i++) 886 compare[i] = (i / data_len) * 0x11; 887 /* Set type byte */ 888 compare[0] = 0; 889 890 KUNIT_EXPECT_MEMEQ(test, flat, compare, rx_skb->len); 891 KUNIT_EXPECT_EQ(test, refcount_read(&rx_skb->users), 1); 892 kfree_skb(rx_skb); 893 894 /* Receive second reassembled message */ 895 rx_skb = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 896 KUNIT_EXPECT_EQ(test, rc, 0); 897 KUNIT_EXPECT_EQ(test, rx_skb->len, 2 * data_len); 898 rc = skb_copy_bits(rx_skb, 0, flat, rx_skb->len); 899 for (int i = 0; i < rx_skb->len; i++) 900 compare[i] = (i / data_len + 3) * 0x11; 901 /* Set type byte */ 902 compare[0] = 0; 903 904 KUNIT_EXPECT_MEMEQ(test, flat, compare, rx_skb->len); 905 KUNIT_EXPECT_EQ(test, refcount_read(&rx_skb->users), 1); 906 kfree_skb(rx_skb); 907 908 /* Check input skb refcounts */ 909 for (int i = 0; i < 5; i++) { 910 KUNIT_EXPECT_EQ(test, refcount_read(&skb[i]->users), 1); 911 kfree_skb(skb[i]); 912 } 913 914 __mctp_route_test_fini(test, dev, &dst, sock); 915 } 916 917 /* check we can receive an incoming packet with the null EID as daddr, when 918 * no RTN_LOCAL routes are present. 919 */ 920 static void mctp_test_route_input_null_eid(struct kunit *test) 921 { 922 struct mctp_hdr hdr = RX_HDR(1, 10, 0, FL_S | FL_E | FL_TO); 923 struct sockaddr_mctp addr = { 0 }; 924 struct sk_buff *skb_pkt, *skb_sk; 925 struct mctp_test_dev *dev; 926 struct socket *sock; 927 u8 type = 0; 928 int rc; 929 930 dev = mctp_test_create_dev(); 931 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 932 933 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 934 KUNIT_ASSERT_EQ(test, rc, 0); 935 936 addr.smctp_family = AF_MCTP; 937 addr.smctp_network = MCTP_NET_ANY; 938 addr.smctp_addr.s_addr = MCTP_ADDR_ANY; 939 addr.smctp_type = type; 940 rc = kernel_bind(sock, (struct sockaddr_unsized *)&addr, sizeof(addr)); 941 KUNIT_ASSERT_EQ(test, rc, 0); 942 943 skb_pkt = mctp_test_create_skb_data(&hdr, &type); 944 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb_pkt); 945 946 skb_pkt->dev = dev->ndev; 947 skb_pkt->pkt_type = PACKET_HOST; 948 949 mctp_pkttype_receive(skb_pkt, dev->ndev, &mctp_packet_type, NULL); 950 951 skb_sk = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 952 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb_sk); 953 954 skb_free_datagram(sock->sk, skb_sk); 955 sock_release(sock); 956 mctp_test_destroy_dev(dev); 957 } 958 959 #if IS_ENABLED(CONFIG_MCTP_FLOWS) 960 961 static void mctp_test_flow_init(struct kunit *test, 962 struct mctp_test_dev **devp, 963 struct mctp_dst *dst, 964 struct socket **sock, 965 struct sk_buff **skbp, 966 unsigned int len) 967 { 968 struct mctp_test_dev *dev; 969 struct sk_buff *skb; 970 971 /* we have a slightly odd routing setup here; the test route 972 * is for EID 8, which is our local EID. We don't do a routing 973 * lookup, so that's fine - all we require is a path through 974 * mctp_local_output, which will call dst->output on whatever 975 * route we provide 976 */ 977 __mctp_route_test_init(test, &dev, dst, sock, MCTP_NET_ANY); 978 979 skb = alloc_skb(len + sizeof(struct mctp_hdr) + 1, GFP_KERNEL); 980 KUNIT_ASSERT_TRUE(test, skb); 981 __mctp_cb(skb); 982 skb_reserve(skb, sizeof(struct mctp_hdr) + 1); 983 memset(skb_put(skb, len), 0, len); 984 985 986 *devp = dev; 987 *skbp = skb; 988 } 989 990 static void mctp_test_flow_fini(struct kunit *test, 991 struct mctp_test_dev *dev, 992 struct mctp_dst *dst, 993 struct socket *sock) 994 { 995 __mctp_route_test_fini(test, dev, dst, sock); 996 } 997 998 /* test that an outgoing skb has the correct MCTP extension data set */ 999 static void mctp_test_packet_flow(struct kunit *test) 1000 { 1001 struct sk_buff *skb, *skb2; 1002 struct mctp_test_dev *dev; 1003 struct mctp_dst dst; 1004 struct mctp_flow *flow; 1005 struct socket *sock; 1006 u8 dst_eid = 8; 1007 int n, rc; 1008 1009 mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 30); 1010 1011 rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER); 1012 KUNIT_ASSERT_EQ(test, rc, 0); 1013 1014 n = dev->pkts.qlen; 1015 KUNIT_ASSERT_EQ(test, n, 1); 1016 1017 skb2 = skb_dequeue(&dev->pkts); 1018 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2); 1019 1020 flow = skb_ext_find(skb2, SKB_EXT_MCTP); 1021 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flow); 1022 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flow->key); 1023 KUNIT_ASSERT_PTR_EQ(test, flow->key->sk, sock->sk); 1024 1025 kfree_skb(skb2); 1026 mctp_test_flow_fini(test, dev, &dst, sock); 1027 } 1028 1029 /* test that outgoing skbs, after fragmentation, all have the correct MCTP 1030 * extension data set. 1031 */ 1032 static void mctp_test_fragment_flow(struct kunit *test) 1033 { 1034 struct mctp_flow *flows[2]; 1035 struct sk_buff *tx_skbs[2]; 1036 struct mctp_test_dev *dev; 1037 struct mctp_dst dst; 1038 struct sk_buff *skb; 1039 struct socket *sock; 1040 u8 dst_eid = 8; 1041 int n, rc; 1042 1043 mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 100); 1044 1045 rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER); 1046 KUNIT_ASSERT_EQ(test, rc, 0); 1047 1048 n = dev->pkts.qlen; 1049 KUNIT_ASSERT_EQ(test, n, 2); 1050 1051 /* both resulting packets should have the same flow data */ 1052 tx_skbs[0] = skb_dequeue(&dev->pkts); 1053 tx_skbs[1] = skb_dequeue(&dev->pkts); 1054 1055 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[0]); 1056 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[1]); 1057 1058 flows[0] = skb_ext_find(tx_skbs[0], SKB_EXT_MCTP); 1059 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[0]); 1060 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[0]->key); 1061 KUNIT_ASSERT_PTR_EQ(test, flows[0]->key->sk, sock->sk); 1062 1063 flows[1] = skb_ext_find(tx_skbs[1], SKB_EXT_MCTP); 1064 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, flows[1]); 1065 KUNIT_ASSERT_PTR_EQ(test, flows[1]->key, flows[0]->key); 1066 1067 kfree_skb(tx_skbs[0]); 1068 kfree_skb(tx_skbs[1]); 1069 mctp_test_flow_fini(test, dev, &dst, sock); 1070 } 1071 1072 #else 1073 static void mctp_test_packet_flow(struct kunit *test) 1074 { 1075 kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y"); 1076 } 1077 1078 static void mctp_test_fragment_flow(struct kunit *test) 1079 { 1080 kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y"); 1081 } 1082 #endif 1083 1084 /* Test that outgoing skbs cause a suitable tag to be created */ 1085 static void mctp_test_route_output_key_create(struct kunit *test) 1086 { 1087 const u8 dst_eid = 26, src_eid = 15; 1088 const unsigned int netid = 50; 1089 struct mctp_test_dev *dev; 1090 struct mctp_sk_key *key; 1091 struct netns_mctp *mns; 1092 unsigned long flags; 1093 struct socket *sock; 1094 struct sk_buff *skb; 1095 struct mctp_dst dst; 1096 bool empty, single; 1097 const int len = 2; 1098 int rc; 1099 1100 dev = mctp_test_create_dev(); 1101 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1102 WRITE_ONCE(dev->mdev->net, netid); 1103 1104 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 1105 KUNIT_ASSERT_EQ(test, rc, 0); 1106 1107 dev->mdev->addrs = kmalloc(sizeof(u8), GFP_KERNEL); 1108 dev->mdev->num_addrs = 1; 1109 dev->mdev->addrs[0] = src_eid; 1110 1111 mctp_test_dst_setup(test, &dst, dev, 68); 1112 1113 skb = alloc_skb(sizeof(struct mctp_hdr) + 1 + len, GFP_KERNEL); 1114 KUNIT_ASSERT_TRUE(test, skb); 1115 __mctp_cb(skb); 1116 skb_reserve(skb, sizeof(struct mctp_hdr) + 1 + len); 1117 memset(skb_put(skb, len), 0, len); 1118 1119 mns = &sock_net(sock->sk)->mctp; 1120 1121 /* We assume we're starting from an empty keys list, which requires 1122 * preceding tests to clean up correctly! 1123 */ 1124 spin_lock_irqsave(&mns->keys_lock, flags); 1125 empty = hlist_empty(&mns->keys); 1126 spin_unlock_irqrestore(&mns->keys_lock, flags); 1127 KUNIT_ASSERT_TRUE(test, empty); 1128 1129 rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER); 1130 KUNIT_ASSERT_EQ(test, rc, 0); 1131 1132 key = NULL; 1133 single = false; 1134 spin_lock_irqsave(&mns->keys_lock, flags); 1135 if (!hlist_empty(&mns->keys)) { 1136 key = hlist_entry(mns->keys.first, struct mctp_sk_key, hlist); 1137 single = hlist_is_singular_node(&key->hlist, &mns->keys); 1138 } 1139 spin_unlock_irqrestore(&mns->keys_lock, flags); 1140 1141 KUNIT_ASSERT_NOT_NULL(test, key); 1142 KUNIT_ASSERT_TRUE(test, single); 1143 1144 KUNIT_EXPECT_EQ(test, key->net, netid); 1145 KUNIT_EXPECT_EQ(test, key->local_addr, src_eid); 1146 KUNIT_EXPECT_EQ(test, key->peer_addr, dst_eid); 1147 /* key has incoming tag, so inverse of what we sent */ 1148 KUNIT_EXPECT_FALSE(test, key->tag & MCTP_TAG_OWNER); 1149 1150 sock_release(sock); 1151 mctp_dst_release(&dst); 1152 mctp_test_destroy_dev(dev); 1153 } 1154 1155 static void mctp_test_route_extaddr_input(struct kunit *test) 1156 { 1157 static const unsigned char haddr[] = { 0xaa, 0x55 }; 1158 struct mctp_skb_cb *cb, *cb2; 1159 const unsigned int len = 40; 1160 struct mctp_test_dev *dev; 1161 struct sk_buff *skb, *skb2; 1162 struct mctp_dst dst; 1163 struct mctp_hdr hdr; 1164 struct socket *sock; 1165 int rc; 1166 1167 hdr.ver = 1; 1168 hdr.src = 10; 1169 hdr.dest = 8; 1170 hdr.flags_seq_tag = FL_S | FL_E | FL_TO; 1171 1172 __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 1173 1174 skb = mctp_test_create_skb(&hdr, len); 1175 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 1176 1177 /* set our hardware addressing data */ 1178 cb = mctp_cb(skb); 1179 memcpy(cb->haddr, haddr, sizeof(haddr)); 1180 cb->halen = sizeof(haddr); 1181 1182 mctp_test_skb_set_dev(skb, dev); 1183 1184 rc = mctp_dst_input(&dst, skb); 1185 KUNIT_ASSERT_EQ(test, rc, 0); 1186 1187 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 1188 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2); 1189 KUNIT_ASSERT_EQ(test, skb2->len, len); 1190 1191 cb2 = mctp_cb(skb2); 1192 1193 /* Received SKB should have the hardware addressing as set above. 1194 * We're likely to have the same actual cb here (ie., cb == cb2), 1195 * but it's the comparison that we care about 1196 */ 1197 KUNIT_EXPECT_EQ(test, cb2->halen, sizeof(haddr)); 1198 KUNIT_EXPECT_MEMEQ(test, cb2->haddr, haddr, sizeof(haddr)); 1199 1200 kfree_skb(skb2); 1201 __mctp_route_test_fini(test, dev, &dst, sock); 1202 } 1203 1204 static void mctp_test_route_gw_lookup(struct kunit *test) 1205 { 1206 struct mctp_test_route *rt1, *rt2; 1207 struct mctp_dst dst = { 0 }; 1208 struct mctp_test_dev *dev; 1209 int rc; 1210 1211 dev = mctp_test_create_dev_with_addr(8); 1212 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1213 1214 /* 8 (local) -> 10 (gateway) via 9 (direct) */ 1215 rt1 = mctp_test_create_route_direct(&init_net, dev->mdev, 9, 0); 1216 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1); 1217 rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0); 1218 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2); 1219 1220 rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst); 1221 KUNIT_EXPECT_EQ(test, rc, 0); 1222 KUNIT_EXPECT_PTR_EQ(test, dst.dev, dev->mdev); 1223 KUNIT_EXPECT_EQ(test, dst.mtu, dev->ndev->mtu); 1224 KUNIT_EXPECT_EQ(test, dst.nexthop, 9); 1225 KUNIT_EXPECT_EQ(test, dst.halen, 0); 1226 1227 mctp_dst_release(&dst); 1228 1229 mctp_test_route_destroy(test, rt2); 1230 mctp_test_route_destroy(test, rt1); 1231 mctp_test_destroy_dev(dev); 1232 } 1233 1234 static void mctp_test_route_gw_loop(struct kunit *test) 1235 { 1236 struct mctp_test_route *rt1, *rt2; 1237 struct mctp_dst dst = { 0 }; 1238 struct mctp_test_dev *dev; 1239 int rc; 1240 1241 dev = mctp_test_create_dev_with_addr(8); 1242 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1243 1244 /* two routes using each other as the gw */ 1245 rt1 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 9, 10, 0); 1246 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1); 1247 rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0); 1248 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2); 1249 1250 /* this should fail, rather than infinite-loop */ 1251 rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst); 1252 KUNIT_EXPECT_NE(test, rc, 0); 1253 1254 mctp_test_route_destroy(test, rt2); 1255 mctp_test_route_destroy(test, rt1); 1256 mctp_test_destroy_dev(dev); 1257 } 1258 1259 struct mctp_route_gw_mtu_test { 1260 /* working away from the local stack */ 1261 unsigned int dev, neigh, gw, dst; 1262 unsigned int exp; 1263 }; 1264 1265 static void mctp_route_gw_mtu_to_desc(const struct mctp_route_gw_mtu_test *t, 1266 char *desc) 1267 { 1268 sprintf(desc, "dev %d, neigh %d, gw %d, dst %d -> %d", 1269 t->dev, t->neigh, t->gw, t->dst, t->exp); 1270 } 1271 1272 static const struct mctp_route_gw_mtu_test mctp_route_gw_mtu_tests[] = { 1273 /* no route-specific MTUs */ 1274 { 68, 0, 0, 0, 68 }, 1275 { 100, 0, 0, 0, 100 }, 1276 /* one route MTU (smaller than dev mtu), others unrestricted */ 1277 { 100, 68, 0, 0, 68 }, 1278 { 100, 0, 68, 0, 68 }, 1279 { 100, 0, 0, 68, 68 }, 1280 /* smallest applied, regardless of order */ 1281 { 100, 99, 98, 68, 68 }, 1282 { 99, 100, 98, 68, 68 }, 1283 { 98, 99, 100, 68, 68 }, 1284 { 68, 98, 99, 100, 68 }, 1285 }; 1286 1287 KUNIT_ARRAY_PARAM(mctp_route_gw_mtu, mctp_route_gw_mtu_tests, 1288 mctp_route_gw_mtu_to_desc); 1289 1290 static void mctp_test_route_gw_mtu(struct kunit *test) 1291 { 1292 const struct mctp_route_gw_mtu_test *mtus = test->param_value; 1293 struct mctp_test_route *rt1, *rt2, *rt3; 1294 struct mctp_dst dst = { 0 }; 1295 struct mctp_test_dev *dev; 1296 struct mctp_dev *mdev; 1297 unsigned int netid; 1298 int rc; 1299 1300 dev = mctp_test_create_dev_with_addr(8); 1301 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1302 dev->ndev->mtu = mtus->dev; 1303 mdev = dev->mdev; 1304 netid = mdev->net; 1305 1306 /* 8 (local) -> 11 (dst) via 10 (gw) via 9 (neigh) */ 1307 rt1 = mctp_test_create_route_direct(&init_net, mdev, 9, mtus->neigh); 1308 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1); 1309 1310 rt2 = mctp_test_create_route_gw(&init_net, netid, 10, 9, mtus->gw); 1311 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2); 1312 1313 rt3 = mctp_test_create_route_gw(&init_net, netid, 11, 10, mtus->dst); 1314 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt3); 1315 1316 rc = mctp_route_lookup(&init_net, dev->mdev->net, 11, &dst); 1317 KUNIT_EXPECT_EQ(test, rc, 0); 1318 KUNIT_EXPECT_EQ(test, dst.mtu, mtus->exp); 1319 1320 mctp_dst_release(&dst); 1321 1322 mctp_test_route_destroy(test, rt3); 1323 mctp_test_route_destroy(test, rt2); 1324 mctp_test_route_destroy(test, rt1); 1325 mctp_test_destroy_dev(dev); 1326 } 1327 1328 #define MCTP_TEST_LLADDR_LEN 2 1329 struct mctp_test_llhdr { 1330 unsigned int magic; 1331 unsigned char src[MCTP_TEST_LLADDR_LEN]; 1332 unsigned char dst[MCTP_TEST_LLADDR_LEN]; 1333 }; 1334 1335 static const unsigned int mctp_test_llhdr_magic = 0x5c78339c; 1336 1337 static int test_dev_header_create(struct sk_buff *skb, struct net_device *dev, 1338 unsigned short type, const void *daddr, 1339 const void *saddr, unsigned int len) 1340 { 1341 struct kunit *test = current->kunit_test; 1342 struct mctp_test_llhdr *hdr; 1343 1344 hdr = skb_push(skb, sizeof(*hdr)); 1345 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hdr); 1346 skb_reset_mac_header(skb); 1347 1348 hdr->magic = mctp_test_llhdr_magic; 1349 memcpy(&hdr->src, saddr, sizeof(hdr->src)); 1350 memcpy(&hdr->dst, daddr, sizeof(hdr->dst)); 1351 1352 return 0; 1353 } 1354 1355 /* Test the dst_output path for a gateway-routed skb: we should have it 1356 * lookup the nexthop EID in the neighbour table, and call into 1357 * header_ops->create to resolve that to a lladdr. Our mock header_ops->create 1358 * will just set a synthetic link-layer header, which we check after transmit. 1359 */ 1360 static void mctp_test_route_gw_output(struct kunit *test) 1361 { 1362 const unsigned char haddr_self[MCTP_TEST_LLADDR_LEN] = { 0xaa, 0x03 }; 1363 const unsigned char haddr_peer[MCTP_TEST_LLADDR_LEN] = { 0xaa, 0x02 }; 1364 const struct header_ops ops = { 1365 .create = test_dev_header_create, 1366 }; 1367 struct mctp_neigh neigh = { 0 }; 1368 struct mctp_test_llhdr *ll_hdr; 1369 struct mctp_dst dst = { 0 }; 1370 struct mctp_hdr hdr = { 0 }; 1371 struct mctp_test_dev *dev; 1372 struct sk_buff *skb; 1373 unsigned char *buf; 1374 int i, rc; 1375 1376 dev = mctp_test_create_dev_lladdr(sizeof(haddr_self), haddr_self); 1377 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1378 dev->ndev->header_ops = &ops; 1379 1380 dst.dev = dev->mdev; 1381 __mctp_dev_get(dst.dev->dev); 1382 dst.mtu = 68; 1383 dst.nexthop = 9; 1384 1385 /* simple mctp_neigh_add for the gateway (not dest!) endpoint */ 1386 INIT_LIST_HEAD(&neigh.list); 1387 neigh.dev = dev->mdev; 1388 mctp_dev_hold(dev->mdev); 1389 neigh.eid = 9; 1390 neigh.source = MCTP_NEIGH_STATIC; 1391 memcpy(neigh.ha, haddr_peer, sizeof(haddr_peer)); 1392 list_add_rcu(&neigh.list, &init_net.mctp.neighbours); 1393 1394 hdr.ver = 1; 1395 hdr.src = 8; 1396 hdr.dest = 10; 1397 hdr.flags_seq_tag = FL_S | FL_E | FL_TO; 1398 1399 /* construct enough for a future link-layer header, the provided 1400 * mctp header, and 4 bytes of data 1401 */ 1402 skb = alloc_skb(sizeof(*ll_hdr) + sizeof(hdr) + 4, GFP_KERNEL); 1403 skb->dev = dev->ndev; 1404 __mctp_cb(skb); 1405 1406 skb_reserve(skb, sizeof(*ll_hdr)); 1407 1408 memcpy(skb_put(skb, sizeof(hdr)), &hdr, sizeof(hdr)); 1409 buf = skb_put(skb, 4); 1410 for (i = 0; i < 4; i++) 1411 buf[i] = i; 1412 1413 /* extra ref over the dev_xmit */ 1414 skb_get(skb); 1415 1416 rc = mctp_dst_output(&dst, skb); 1417 KUNIT_EXPECT_EQ(test, rc, 0); 1418 1419 mctp_dst_release(&dst); 1420 list_del_rcu(&neigh.list); 1421 mctp_dev_put(dev->mdev); 1422 1423 /* check that we have our header created with the correct neighbour */ 1424 ll_hdr = (void *)skb_mac_header(skb); 1425 KUNIT_EXPECT_EQ(test, ll_hdr->magic, mctp_test_llhdr_magic); 1426 KUNIT_EXPECT_MEMEQ(test, ll_hdr->src, haddr_self, sizeof(haddr_self)); 1427 KUNIT_EXPECT_MEMEQ(test, ll_hdr->dst, haddr_peer, sizeof(haddr_peer)); 1428 kfree_skb(skb); 1429 } 1430 1431 struct mctp_bind_lookup_test { 1432 /* header of incoming message */ 1433 struct mctp_hdr hdr; 1434 u8 ty; 1435 /* mctp network of incoming interface (smctp_network) */ 1436 unsigned int net; 1437 1438 /* expected socket, matches .name in lookup_binds, NULL for dropped */ 1439 const char *expect; 1440 }; 1441 1442 /* Single-packet TO-set message */ 1443 #define LK(src, dst) RX_HDR(1, (src), (dst), FL_S | FL_E | FL_TO) 1444 1445 /* Input message test cases for bind lookup tests. 1446 * 1447 * 10 and 11 are local EIDs. 1448 * 20 and 21 are remote EIDs. 1449 */ 1450 static const struct mctp_bind_lookup_test mctp_bind_lookup_tests[] = { 1451 /* both local-eid and remote-eid binds, remote eid is preferenced */ 1452 { .hdr = LK(20, 10), .ty = 1, .net = 1, .expect = "remote20" }, 1453 1454 { .hdr = LK(20, 255), .ty = 1, .net = 1, .expect = "remote20" }, 1455 { .hdr = LK(20, 0), .ty = 1, .net = 1, .expect = "remote20" }, 1456 { .hdr = LK(0, 255), .ty = 1, .net = 1, .expect = "any" }, 1457 { .hdr = LK(0, 11), .ty = 1, .net = 1, .expect = "any" }, 1458 { .hdr = LK(0, 0), .ty = 1, .net = 1, .expect = "any" }, 1459 { .hdr = LK(0, 10), .ty = 1, .net = 1, .expect = "local10" }, 1460 { .hdr = LK(21, 10), .ty = 1, .net = 1, .expect = "local10" }, 1461 { .hdr = LK(21, 11), .ty = 1, .net = 1, .expect = "remote21local11" }, 1462 1463 /* both src and dest set to eid=99. unusual, but accepted 1464 * by MCTP stack currently. 1465 */ 1466 { .hdr = LK(99, 99), .ty = 1, .net = 1, .expect = "any" }, 1467 1468 /* unbound smctp_type */ 1469 { .hdr = LK(20, 10), .ty = 3, .net = 1, .expect = NULL }, 1470 1471 /* smctp_network tests */ 1472 1473 { .hdr = LK(0, 0), .ty = 1, .net = 7, .expect = "any" }, 1474 { .hdr = LK(21, 10), .ty = 1, .net = 2, .expect = "any" }, 1475 1476 /* remote EID 20 matches, but MCTP_NET_ANY in "remote20" resolved 1477 * to net=1, so lookup doesn't match "remote20" 1478 */ 1479 { .hdr = LK(20, 10), .ty = 1, .net = 3, .expect = "any" }, 1480 1481 { .hdr = LK(21, 10), .ty = 1, .net = 3, .expect = "remote21net3" }, 1482 { .hdr = LK(21, 10), .ty = 1, .net = 4, .expect = "remote21net4" }, 1483 { .hdr = LK(21, 10), .ty = 1, .net = 5, .expect = "remote21net5" }, 1484 1485 { .hdr = LK(21, 10), .ty = 1, .net = 5, .expect = "remote21net5" }, 1486 1487 { .hdr = LK(99, 10), .ty = 1, .net = 8, .expect = "local10net8" }, 1488 1489 { .hdr = LK(99, 10), .ty = 1, .net = 9, .expect = "anynet9" }, 1490 { .hdr = LK(0, 0), .ty = 1, .net = 9, .expect = "anynet9" }, 1491 { .hdr = LK(99, 99), .ty = 1, .net = 9, .expect = "anynet9" }, 1492 { .hdr = LK(20, 10), .ty = 1, .net = 9, .expect = "anynet9" }, 1493 }; 1494 1495 /* Binds to create during the lookup tests */ 1496 static const struct mctp_test_bind_setup lookup_binds[] = { 1497 /* any address and net, type 1 */ 1498 { .name = "any", .bind_addr = MCTP_ADDR_ANY, 1499 .bind_net = MCTP_NET_ANY, .bind_type = 1, }, 1500 /* local eid 10, net 1 (resolved from MCTP_NET_ANY) */ 1501 { .name = "local10", .bind_addr = 10, 1502 .bind_net = MCTP_NET_ANY, .bind_type = 1, }, 1503 /* local eid 10, net 8 */ 1504 { .name = "local10net8", .bind_addr = 10, 1505 .bind_net = 8, .bind_type = 1, }, 1506 /* any EID, net 9 */ 1507 { .name = "anynet9", .bind_addr = MCTP_ADDR_ANY, 1508 .bind_net = 9, .bind_type = 1, }, 1509 1510 /* remote eid 20, net 1, any local eid */ 1511 { .name = "remote20", .bind_addr = MCTP_ADDR_ANY, 1512 .bind_net = MCTP_NET_ANY, .bind_type = 1, 1513 .have_peer = true, .peer_addr = 20, .peer_net = MCTP_NET_ANY, }, 1514 1515 /* remote eid 20, net 1, local eid 11 */ 1516 { .name = "remote21local11", .bind_addr = 11, 1517 .bind_net = MCTP_NET_ANY, .bind_type = 1, 1518 .have_peer = true, .peer_addr = 21, .peer_net = MCTP_NET_ANY, }, 1519 1520 /* remote eid 21, specific net=3 for connect() */ 1521 { .name = "remote21net3", .bind_addr = MCTP_ADDR_ANY, 1522 .bind_net = MCTP_NET_ANY, .bind_type = 1, 1523 .have_peer = true, .peer_addr = 21, .peer_net = 3, }, 1524 1525 /* remote eid 21, net 4 for bind, specific net=4 for connect() */ 1526 { .name = "remote21net4", .bind_addr = MCTP_ADDR_ANY, 1527 .bind_net = 4, .bind_type = 1, 1528 .have_peer = true, .peer_addr = 21, .peer_net = 4, }, 1529 1530 /* remote eid 21, net 5 for bind, specific net=5 for connect() */ 1531 { .name = "remote21net5", .bind_addr = MCTP_ADDR_ANY, 1532 .bind_net = 5, .bind_type = 1, 1533 .have_peer = true, .peer_addr = 21, .peer_net = 5, }, 1534 }; 1535 1536 static void mctp_bind_lookup_desc(const struct mctp_bind_lookup_test *t, 1537 char *desc) 1538 { 1539 snprintf(desc, KUNIT_PARAM_DESC_SIZE, 1540 "{src %d dst %d ty %d net %d expect %s}", 1541 t->hdr.src, t->hdr.dest, t->ty, t->net, t->expect); 1542 } 1543 1544 KUNIT_ARRAY_PARAM(mctp_bind_lookup, mctp_bind_lookup_tests, 1545 mctp_bind_lookup_desc); 1546 1547 static void mctp_test_bind_lookup(struct kunit *test) 1548 { 1549 const struct mctp_bind_lookup_test *rx; 1550 struct socket *socks[ARRAY_SIZE(lookup_binds)]; 1551 struct sk_buff *skb_pkt = NULL, *skb_sock = NULL; 1552 struct socket *sock_ty0, *sock_expect = NULL; 1553 struct mctp_test_dev *dev; 1554 struct mctp_dst dst; 1555 int rc; 1556 1557 rx = test->param_value; 1558 1559 __mctp_route_test_init(test, &dev, &dst, &sock_ty0, rx->net); 1560 /* Create all binds */ 1561 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) { 1562 mctp_test_bind_run(test, &lookup_binds[i], 1563 &rc, &socks[i]); 1564 KUNIT_ASSERT_EQ(test, rc, 0); 1565 1566 /* Record the expected receive socket */ 1567 if (rx->expect && 1568 strcmp(rx->expect, lookup_binds[i].name) == 0) { 1569 KUNIT_ASSERT_NULL(test, sock_expect); 1570 sock_expect = socks[i]; 1571 } 1572 } 1573 KUNIT_ASSERT_EQ(test, !!sock_expect, !!rx->expect); 1574 1575 /* Create test message */ 1576 skb_pkt = mctp_test_create_skb_data(&rx->hdr, &rx->ty); 1577 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb_pkt); 1578 mctp_test_skb_set_dev(skb_pkt, dev); 1579 1580 rc = mctp_dst_input(&dst, skb_pkt); 1581 if (rx->expect) { 1582 /* Test the message is received on the expected socket */ 1583 KUNIT_EXPECT_EQ(test, rc, 0); 1584 skb_sock = skb_recv_datagram(sock_expect->sk, 1585 MSG_DONTWAIT, &rc); 1586 if (!skb_sock) { 1587 /* Find which socket received it instead */ 1588 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) { 1589 skb_sock = skb_recv_datagram(socks[i]->sk, 1590 MSG_DONTWAIT, &rc); 1591 if (skb_sock) { 1592 KUNIT_FAIL(test, 1593 "received on incorrect socket '%s', expect '%s'", 1594 lookup_binds[i].name, 1595 rx->expect); 1596 goto cleanup; 1597 } 1598 } 1599 KUNIT_FAIL(test, "no message received"); 1600 } 1601 } else { 1602 KUNIT_EXPECT_NE(test, rc, 0); 1603 } 1604 1605 cleanup: 1606 kfree_skb(skb_sock); 1607 1608 /* Drop all binds */ 1609 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) 1610 sock_release(socks[i]); 1611 1612 __mctp_route_test_fini(test, dev, &dst, sock_ty0); 1613 } 1614 1615 static void mctp_test_route_output_direct_no_eids(struct kunit *test) 1616 { 1617 struct mctp_dst dst = { 0 }; 1618 struct sk_buff *skb, *skb2; 1619 struct mctp_test_route *rt; 1620 struct mctp_test_dev *dev; 1621 struct socket *sock; 1622 const int len = 2; 1623 int rc; 1624 1625 dev = mctp_test_create_dev(); 1626 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1627 1628 rt = mctp_test_create_route_direct(&init_net, dev->mdev, 9, 68); 1629 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 1630 1631 rc = mctp_route_lookup(&init_net, dev->mdev->net, 9, &dst); 1632 KUNIT_ASSERT_EQ(test, rc, 0); 1633 1634 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 1635 KUNIT_ASSERT_EQ(test, rc, 0); 1636 1637 skb = alloc_skb(sizeof(struct mctp_hdr) + 1 + len, GFP_KERNEL); 1638 KUNIT_ASSERT_TRUE(test, skb); 1639 __mctp_cb(skb); 1640 skb_reserve(skb, sizeof(struct mctp_hdr) + 1 + len); 1641 memset(skb_put(skb, len), 0, len); 1642 1643 rc = mctp_local_output(sock->sk, &dst, skb, 9, MCTP_TAG_OWNER); 1644 KUNIT_ASSERT_EQ(test, rc, 0); 1645 1646 KUNIT_ASSERT_EQ(test, dev->pkts.qlen, 1); 1647 1648 skb2 = skb_dequeue(&dev->pkts); 1649 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2); 1650 1651 kfree_skb(skb2); 1652 sock_release(sock); 1653 mctp_dst_release(&dst); 1654 mctp_test_route_destroy(test, rt); 1655 mctp_test_destroy_dev(dev); 1656 } 1657 1658 static void mctp_test_route_output_gw_no_eids(struct kunit *test) 1659 { 1660 struct mctp_test_route *rt1, *rt2; 1661 struct mctp_test_dev *dev; 1662 struct mctp_dst dst = { 0 }; 1663 int rc; 1664 1665 dev = mctp_test_create_dev(); 1666 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1667 1668 /* route: direct to bridge */ 1669 rt1 = mctp_test_create_route_direct(&init_net, dev->mdev, 9, 68); 1670 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1); 1671 1672 /* route: bridge gw to final dest */ 1673 rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0); 1674 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2); 1675 1676 /* route lookup should fail, due to no source address on dev */ 1677 rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst); 1678 KUNIT_ASSERT_NE(test, rc, 0); 1679 1680 mctp_test_route_destroy(test, rt1); 1681 mctp_test_route_destroy(test, rt2); 1682 mctp_test_destroy_dev(dev); 1683 } 1684 1685 static void mctp_test_route_output_extaddr_no_eids(struct kunit *test) 1686 { 1687 struct mctp_dst dst = { 0 }; 1688 struct sk_buff *skb, *skb2; 1689 struct mctp_test_dev *dev; 1690 struct socket *sock; 1691 const int len = 1; 1692 struct net *net; 1693 int rc; 1694 1695 dev = mctp_test_create_dev(); 1696 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1697 1698 net = dev_net(dev->ndev); 1699 1700 rc = mctp_dst_from_extaddr(&dst, net, dev->ndev->ifindex, 0, NULL); 1701 KUNIT_ASSERT_EQ(test, rc, 0); 1702 1703 rc = sock_create_kern(net, AF_MCTP, SOCK_DGRAM, 0, &sock); 1704 KUNIT_ASSERT_EQ(test, rc, 0); 1705 1706 skb = alloc_skb(sizeof(struct mctp_hdr) + 1 + len, GFP_KERNEL); 1707 KUNIT_ASSERT_TRUE(test, skb); 1708 __mctp_cb(skb); 1709 skb_reserve(skb, sizeof(struct mctp_hdr) + 1 + len); 1710 memset(skb_put(skb, len), 0, len); 1711 1712 rc = mctp_local_output(sock->sk, &dst, skb, 9, MCTP_TAG_OWNER); 1713 KUNIT_ASSERT_EQ(test, rc, 0); 1714 1715 KUNIT_ASSERT_EQ(test, dev->pkts.qlen, 1); 1716 1717 skb2 = skb_dequeue(&dev->pkts); 1718 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2); 1719 1720 kfree_skb(skb2); 1721 sock_release(sock); 1722 mctp_dst_release(&dst); 1723 mctp_test_destroy_dev(dev); 1724 } 1725 1726 static struct kunit_case mctp_test_cases[] = { 1727 KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params), 1728 KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params), 1729 KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params), 1730 KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm, 1731 mctp_route_input_sk_reasm_gen_params), 1732 KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys, 1733 mctp_route_input_sk_keys_gen_params), 1734 KUNIT_CASE(mctp_test_route_input_sk_fail_single), 1735 KUNIT_CASE(mctp_test_route_input_sk_fail_frag), 1736 KUNIT_CASE(mctp_test_route_input_multiple_nets_bind), 1737 KUNIT_CASE(mctp_test_route_input_multiple_nets_key), 1738 KUNIT_CASE(mctp_test_route_input_null_eid), 1739 KUNIT_CASE(mctp_test_packet_flow), 1740 KUNIT_CASE(mctp_test_fragment_flow), 1741 KUNIT_CASE(mctp_test_route_output_key_create), 1742 KUNIT_CASE(mctp_test_route_input_cloned_frag), 1743 KUNIT_CASE(mctp_test_route_extaddr_input), 1744 KUNIT_CASE(mctp_test_route_gw_lookup), 1745 KUNIT_CASE(mctp_test_route_gw_loop), 1746 KUNIT_CASE_PARAM(mctp_test_route_gw_mtu, mctp_route_gw_mtu_gen_params), 1747 KUNIT_CASE(mctp_test_route_gw_output), 1748 KUNIT_CASE_PARAM(mctp_test_bind_lookup, mctp_bind_lookup_gen_params), 1749 KUNIT_CASE(mctp_test_route_output_direct_no_eids), 1750 KUNIT_CASE(mctp_test_route_output_gw_no_eids), 1751 KUNIT_CASE(mctp_test_route_output_extaddr_no_eids), 1752 {} 1753 }; 1754 1755 static struct kunit_suite mctp_test_suite = { 1756 .name = "mctp-route", 1757 .test_cases = mctp_test_cases, 1758 }; 1759 1760 kunit_test_suite(mctp_test_suite); 1761