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