1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <kunit/test.h> 4 5 #include "utils.h" 6 7 struct mctp_test_route { 8 struct mctp_route rt; 9 struct sk_buff_head pkts; 10 }; 11 12 static int mctp_test_route_output(struct mctp_route *rt, struct sk_buff *skb) 13 { 14 struct mctp_test_route *test_rt = container_of(rt, struct mctp_test_route, rt); 15 16 skb_queue_tail(&test_rt->pkts, skb); 17 18 return 0; 19 } 20 21 /* local version of mctp_route_alloc() */ 22 static struct mctp_test_route *mctp_route_test_alloc(void) 23 { 24 struct mctp_test_route *rt; 25 26 rt = kzalloc(sizeof(*rt), GFP_KERNEL); 27 if (!rt) 28 return NULL; 29 30 INIT_LIST_HEAD(&rt->rt.list); 31 refcount_set(&rt->rt.refs, 1); 32 rt->rt.output = mctp_test_route_output; 33 34 skb_queue_head_init(&rt->pkts); 35 36 return rt; 37 } 38 39 static struct mctp_test_route *mctp_test_create_route(struct net *net, 40 struct mctp_dev *dev, 41 mctp_eid_t eid, 42 unsigned int mtu) 43 { 44 struct mctp_test_route *rt; 45 46 rt = mctp_route_test_alloc(); 47 if (!rt) 48 return NULL; 49 50 rt->rt.min = eid; 51 rt->rt.max = eid; 52 rt->rt.mtu = mtu; 53 rt->rt.type = RTN_UNSPEC; 54 if (dev) 55 mctp_dev_hold(dev); 56 rt->rt.dev = dev; 57 58 list_add_rcu(&rt->rt.list, &net->mctp.routes); 59 60 return rt; 61 } 62 63 static void mctp_test_route_destroy(struct kunit *test, 64 struct mctp_test_route *rt) 65 { 66 unsigned int refs; 67 68 rtnl_lock(); 69 list_del_rcu(&rt->rt.list); 70 rtnl_unlock(); 71 72 skb_queue_purge(&rt->pkts); 73 if (rt->rt.dev) 74 mctp_dev_put(rt->rt.dev); 75 76 refs = refcount_read(&rt->rt.refs); 77 KUNIT_ASSERT_EQ_MSG(test, refs, 1, "route ref imbalance"); 78 79 kfree_rcu(&rt->rt, rcu); 80 } 81 82 static struct sk_buff *mctp_test_create_skb(const struct mctp_hdr *hdr, 83 unsigned int data_len) 84 { 85 size_t hdr_len = sizeof(*hdr); 86 struct sk_buff *skb; 87 unsigned int i; 88 u8 *buf; 89 90 skb = alloc_skb(hdr_len + data_len, GFP_KERNEL); 91 if (!skb) 92 return NULL; 93 94 memcpy(skb_put(skb, hdr_len), hdr, hdr_len); 95 96 buf = skb_put(skb, data_len); 97 for (i = 0; i < data_len; i++) 98 buf[i] = i & 0xff; 99 100 return skb; 101 } 102 103 static struct sk_buff *__mctp_test_create_skb_data(const struct mctp_hdr *hdr, 104 const void *data, 105 size_t data_len) 106 { 107 size_t hdr_len = sizeof(*hdr); 108 struct sk_buff *skb; 109 110 skb = alloc_skb(hdr_len + data_len, GFP_KERNEL); 111 if (!skb) 112 return NULL; 113 114 memcpy(skb_put(skb, hdr_len), hdr, hdr_len); 115 memcpy(skb_put(skb, data_len), data, data_len); 116 117 return skb; 118 } 119 120 #define mctp_test_create_skb_data(h, d) \ 121 __mctp_test_create_skb_data(h, d, sizeof(*d)) 122 123 struct mctp_frag_test { 124 unsigned int mtu; 125 unsigned int msgsize; 126 unsigned int n_frags; 127 }; 128 129 static void mctp_test_fragment(struct kunit *test) 130 { 131 const struct mctp_frag_test *params; 132 int rc, i, n, mtu, msgsize; 133 struct mctp_test_route *rt; 134 struct sk_buff *skb; 135 struct mctp_hdr hdr; 136 u8 seq; 137 138 params = test->param_value; 139 mtu = params->mtu; 140 msgsize = params->msgsize; 141 142 hdr.ver = 1; 143 hdr.src = 8; 144 hdr.dest = 10; 145 hdr.flags_seq_tag = MCTP_HDR_FLAG_TO; 146 147 skb = mctp_test_create_skb(&hdr, msgsize); 148 KUNIT_ASSERT_TRUE(test, skb); 149 150 rt = mctp_test_create_route(&init_net, NULL, 10, mtu); 151 KUNIT_ASSERT_TRUE(test, rt); 152 153 rc = mctp_do_fragment_route(&rt->rt, skb, mtu, MCTP_TAG_OWNER); 154 KUNIT_EXPECT_FALSE(test, rc); 155 156 n = rt->pkts.qlen; 157 158 KUNIT_EXPECT_EQ(test, n, params->n_frags); 159 160 for (i = 0;; i++) { 161 struct mctp_hdr *hdr2; 162 struct sk_buff *skb2; 163 u8 tag_mask, seq2; 164 bool first, last; 165 166 first = i == 0; 167 last = i == (n - 1); 168 169 skb2 = skb_dequeue(&rt->pkts); 170 171 if (!skb2) 172 break; 173 174 hdr2 = mctp_hdr(skb2); 175 176 tag_mask = MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO; 177 178 KUNIT_EXPECT_EQ(test, hdr2->ver, hdr.ver); 179 KUNIT_EXPECT_EQ(test, hdr2->src, hdr.src); 180 KUNIT_EXPECT_EQ(test, hdr2->dest, hdr.dest); 181 KUNIT_EXPECT_EQ(test, hdr2->flags_seq_tag & tag_mask, 182 hdr.flags_seq_tag & tag_mask); 183 184 KUNIT_EXPECT_EQ(test, 185 !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_SOM), first); 186 KUNIT_EXPECT_EQ(test, 187 !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_EOM), last); 188 189 seq2 = (hdr2->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) & 190 MCTP_HDR_SEQ_MASK; 191 192 if (first) { 193 seq = seq2; 194 } else { 195 seq++; 196 KUNIT_EXPECT_EQ(test, seq2, seq & MCTP_HDR_SEQ_MASK); 197 } 198 199 if (!last) 200 KUNIT_EXPECT_EQ(test, skb2->len, mtu); 201 else 202 KUNIT_EXPECT_LE(test, skb2->len, mtu); 203 204 kfree_skb(skb2); 205 } 206 207 mctp_test_route_destroy(test, rt); 208 } 209 210 static const struct mctp_frag_test mctp_frag_tests[] = { 211 {.mtu = 68, .msgsize = 63, .n_frags = 1}, 212 {.mtu = 68, .msgsize = 64, .n_frags = 1}, 213 {.mtu = 68, .msgsize = 65, .n_frags = 2}, 214 {.mtu = 68, .msgsize = 66, .n_frags = 2}, 215 {.mtu = 68, .msgsize = 127, .n_frags = 2}, 216 {.mtu = 68, .msgsize = 128, .n_frags = 2}, 217 {.mtu = 68, .msgsize = 129, .n_frags = 3}, 218 {.mtu = 68, .msgsize = 130, .n_frags = 3}, 219 }; 220 221 static void mctp_frag_test_to_desc(const struct mctp_frag_test *t, char *desc) 222 { 223 sprintf(desc, "mtu %d len %d -> %d frags", 224 t->msgsize, t->mtu, t->n_frags); 225 } 226 227 KUNIT_ARRAY_PARAM(mctp_frag, mctp_frag_tests, mctp_frag_test_to_desc); 228 229 struct mctp_rx_input_test { 230 struct mctp_hdr hdr; 231 bool input; 232 }; 233 234 static void mctp_test_rx_input(struct kunit *test) 235 { 236 const struct mctp_rx_input_test *params; 237 struct mctp_test_route *rt; 238 struct mctp_test_dev *dev; 239 struct sk_buff *skb; 240 241 params = test->param_value; 242 243 dev = mctp_test_create_dev(); 244 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 245 246 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68); 247 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 248 249 skb = mctp_test_create_skb(¶ms->hdr, 1); 250 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 251 252 __mctp_cb(skb); 253 254 mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL); 255 256 KUNIT_EXPECT_EQ(test, !!rt->pkts.qlen, params->input); 257 258 mctp_test_route_destroy(test, rt); 259 mctp_test_destroy_dev(dev); 260 } 261 262 #define RX_HDR(_ver, _src, _dest, _fst) \ 263 { .ver = _ver, .src = _src, .dest = _dest, .flags_seq_tag = _fst } 264 265 /* we have a route for EID 8 only */ 266 static const struct mctp_rx_input_test mctp_rx_input_tests[] = { 267 { .hdr = RX_HDR(1, 10, 8, 0), .input = true }, 268 { .hdr = RX_HDR(1, 10, 9, 0), .input = false }, /* no input route */ 269 { .hdr = RX_HDR(2, 10, 8, 0), .input = false }, /* invalid version */ 270 }; 271 272 static void mctp_rx_input_test_to_desc(const struct mctp_rx_input_test *t, 273 char *desc) 274 { 275 sprintf(desc, "{%x,%x,%x,%x}", t->hdr.ver, t->hdr.src, t->hdr.dest, 276 t->hdr.flags_seq_tag); 277 } 278 279 KUNIT_ARRAY_PARAM(mctp_rx_input, mctp_rx_input_tests, 280 mctp_rx_input_test_to_desc); 281 282 /* set up a local dev, route on EID 8, and a socket listening on type 0 */ 283 static void __mctp_route_test_init(struct kunit *test, 284 struct mctp_test_dev **devp, 285 struct mctp_test_route **rtp, 286 struct socket **sockp) 287 { 288 struct sockaddr_mctp addr = {0}; 289 struct mctp_test_route *rt; 290 struct mctp_test_dev *dev; 291 struct socket *sock; 292 int rc; 293 294 dev = mctp_test_create_dev(); 295 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 296 297 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68); 298 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 299 300 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 301 KUNIT_ASSERT_EQ(test, rc, 0); 302 303 addr.smctp_family = AF_MCTP; 304 addr.smctp_network = MCTP_NET_ANY; 305 addr.smctp_addr.s_addr = 8; 306 addr.smctp_type = 0; 307 rc = kernel_bind(sock, (struct sockaddr *)&addr, sizeof(addr)); 308 KUNIT_ASSERT_EQ(test, rc, 0); 309 310 *rtp = rt; 311 *devp = dev; 312 *sockp = sock; 313 } 314 315 static void __mctp_route_test_fini(struct kunit *test, 316 struct mctp_test_dev *dev, 317 struct mctp_test_route *rt, 318 struct socket *sock) 319 { 320 sock_release(sock); 321 mctp_test_route_destroy(test, rt); 322 mctp_test_destroy_dev(dev); 323 } 324 325 struct mctp_route_input_sk_test { 326 struct mctp_hdr hdr; 327 u8 type; 328 bool deliver; 329 }; 330 331 static void mctp_test_route_input_sk(struct kunit *test) 332 { 333 const struct mctp_route_input_sk_test *params; 334 struct sk_buff *skb, *skb2; 335 struct mctp_test_route *rt; 336 struct mctp_test_dev *dev; 337 struct socket *sock; 338 int rc; 339 340 params = test->param_value; 341 342 __mctp_route_test_init(test, &dev, &rt, &sock); 343 344 skb = mctp_test_create_skb_data(¶ms->hdr, ¶ms->type); 345 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 346 347 skb->dev = dev->ndev; 348 __mctp_cb(skb); 349 350 rc = mctp_route_input(&rt->rt, skb); 351 352 if (params->deliver) { 353 KUNIT_EXPECT_EQ(test, rc, 0); 354 355 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 356 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 357 KUNIT_EXPECT_EQ(test, skb->len, 1); 358 359 skb_free_datagram(sock->sk, skb2); 360 361 } else { 362 KUNIT_EXPECT_NE(test, rc, 0); 363 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 364 KUNIT_EXPECT_NULL(test, skb2); 365 } 366 367 __mctp_route_test_fini(test, dev, rt, sock); 368 } 369 370 #define FL_S (MCTP_HDR_FLAG_SOM) 371 #define FL_E (MCTP_HDR_FLAG_EOM) 372 #define FL_TO (MCTP_HDR_FLAG_TO) 373 #define FL_T(t) ((t) & MCTP_HDR_TAG_MASK) 374 375 static const struct mctp_route_input_sk_test mctp_route_input_sk_tests[] = { 376 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 0, .deliver = true }, 377 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 1, .deliver = false }, 378 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E), .type = 0, .deliver = false }, 379 { .hdr = RX_HDR(1, 10, 8, FL_E | FL_TO), .type = 0, .deliver = false }, 380 { .hdr = RX_HDR(1, 10, 8, FL_TO), .type = 0, .deliver = false }, 381 { .hdr = RX_HDR(1, 10, 8, 0), .type = 0, .deliver = false }, 382 }; 383 384 static void mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test *t, 385 char *desc) 386 { 387 sprintf(desc, "{%x,%x,%x,%x} type %d", t->hdr.ver, t->hdr.src, 388 t->hdr.dest, t->hdr.flags_seq_tag, t->type); 389 } 390 391 KUNIT_ARRAY_PARAM(mctp_route_input_sk, mctp_route_input_sk_tests, 392 mctp_route_input_sk_to_desc); 393 394 struct mctp_route_input_sk_reasm_test { 395 const char *name; 396 struct mctp_hdr hdrs[4]; 397 int n_hdrs; 398 int rx_len; 399 }; 400 401 static void mctp_test_route_input_sk_reasm(struct kunit *test) 402 { 403 const struct mctp_route_input_sk_reasm_test *params; 404 struct sk_buff *skb, *skb2; 405 struct mctp_test_route *rt; 406 struct mctp_test_dev *dev; 407 struct socket *sock; 408 int i, rc; 409 u8 c; 410 411 params = test->param_value; 412 413 __mctp_route_test_init(test, &dev, &rt, &sock); 414 415 for (i = 0; i < params->n_hdrs; i++) { 416 c = i; 417 skb = mctp_test_create_skb_data(¶ms->hdrs[i], &c); 418 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 419 420 skb->dev = dev->ndev; 421 __mctp_cb(skb); 422 423 rc = mctp_route_input(&rt->rt, skb); 424 } 425 426 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 427 428 if (params->rx_len) { 429 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 430 KUNIT_EXPECT_EQ(test, skb2->len, params->rx_len); 431 skb_free_datagram(sock->sk, skb2); 432 433 } else { 434 KUNIT_EXPECT_NULL(test, skb2); 435 } 436 437 __mctp_route_test_fini(test, dev, rt, sock); 438 } 439 440 #define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_TO | (f) | ((s) << MCTP_HDR_SEQ_SHIFT)) 441 442 static const struct mctp_route_input_sk_reasm_test mctp_route_input_sk_reasm_tests[] = { 443 { 444 .name = "single packet", 445 .hdrs = { 446 RX_FRAG(FL_S | FL_E, 0), 447 }, 448 .n_hdrs = 1, 449 .rx_len = 1, 450 }, 451 { 452 .name = "single packet, offset seq", 453 .hdrs = { 454 RX_FRAG(FL_S | FL_E, 1), 455 }, 456 .n_hdrs = 1, 457 .rx_len = 1, 458 }, 459 { 460 .name = "start & end packets", 461 .hdrs = { 462 RX_FRAG(FL_S, 0), 463 RX_FRAG(FL_E, 1), 464 }, 465 .n_hdrs = 2, 466 .rx_len = 2, 467 }, 468 { 469 .name = "start & end packets, offset seq", 470 .hdrs = { 471 RX_FRAG(FL_S, 1), 472 RX_FRAG(FL_E, 2), 473 }, 474 .n_hdrs = 2, 475 .rx_len = 2, 476 }, 477 { 478 .name = "start & end packets, out of order", 479 .hdrs = { 480 RX_FRAG(FL_E, 1), 481 RX_FRAG(FL_S, 0), 482 }, 483 .n_hdrs = 2, 484 .rx_len = 0, 485 }, 486 { 487 .name = "start, middle & end packets", 488 .hdrs = { 489 RX_FRAG(FL_S, 0), 490 RX_FRAG(0, 1), 491 RX_FRAG(FL_E, 2), 492 }, 493 .n_hdrs = 3, 494 .rx_len = 3, 495 }, 496 { 497 .name = "missing seq", 498 .hdrs = { 499 RX_FRAG(FL_S, 0), 500 RX_FRAG(FL_E, 2), 501 }, 502 .n_hdrs = 2, 503 .rx_len = 0, 504 }, 505 { 506 .name = "seq wrap", 507 .hdrs = { 508 RX_FRAG(FL_S, 3), 509 RX_FRAG(FL_E, 0), 510 }, 511 .n_hdrs = 2, 512 .rx_len = 2, 513 }, 514 }; 515 516 static void mctp_route_input_sk_reasm_to_desc( 517 const struct mctp_route_input_sk_reasm_test *t, 518 char *desc) 519 { 520 sprintf(desc, "%s", t->name); 521 } 522 523 KUNIT_ARRAY_PARAM(mctp_route_input_sk_reasm, mctp_route_input_sk_reasm_tests, 524 mctp_route_input_sk_reasm_to_desc); 525 526 struct mctp_route_input_sk_keys_test { 527 const char *name; 528 mctp_eid_t key_peer_addr; 529 mctp_eid_t key_local_addr; 530 u8 key_tag; 531 struct mctp_hdr hdr; 532 bool deliver; 533 }; 534 535 /* test packet rx in the presence of various key configurations */ 536 static void mctp_test_route_input_sk_keys(struct kunit *test) 537 { 538 const struct mctp_route_input_sk_keys_test *params; 539 struct mctp_test_route *rt; 540 struct sk_buff *skb, *skb2; 541 struct mctp_test_dev *dev; 542 struct mctp_sk_key *key; 543 struct netns_mctp *mns; 544 struct mctp_sock *msk; 545 struct socket *sock; 546 unsigned long flags; 547 int rc; 548 u8 c; 549 550 params = test->param_value; 551 552 dev = mctp_test_create_dev(); 553 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 554 555 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68); 556 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt); 557 558 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 559 KUNIT_ASSERT_EQ(test, rc, 0); 560 561 msk = container_of(sock->sk, struct mctp_sock, sk); 562 mns = &sock_net(sock->sk)->mctp; 563 564 /* set the incoming tag according to test params */ 565 key = mctp_key_alloc(msk, params->key_local_addr, params->key_peer_addr, 566 params->key_tag, GFP_KERNEL); 567 568 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, key); 569 570 spin_lock_irqsave(&mns->keys_lock, flags); 571 mctp_reserve_tag(&init_net, key, msk); 572 spin_unlock_irqrestore(&mns->keys_lock, flags); 573 574 /* create packet and route */ 575 c = 0; 576 skb = mctp_test_create_skb_data(¶ms->hdr, &c); 577 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 578 579 skb->dev = dev->ndev; 580 __mctp_cb(skb); 581 582 rc = mctp_route_input(&rt->rt, skb); 583 584 /* (potentially) receive message */ 585 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 586 587 if (params->deliver) 588 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 589 else 590 KUNIT_EXPECT_PTR_EQ(test, skb2, NULL); 591 592 if (skb2) 593 skb_free_datagram(sock->sk, skb2); 594 595 mctp_key_unref(key); 596 __mctp_route_test_fini(test, dev, rt, sock); 597 } 598 599 static const struct mctp_route_input_sk_keys_test mctp_route_input_sk_keys_tests[] = { 600 { 601 .name = "direct match", 602 .key_peer_addr = 9, 603 .key_local_addr = 8, 604 .key_tag = 1, 605 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)), 606 .deliver = true, 607 }, 608 { 609 .name = "flipped src/dest", 610 .key_peer_addr = 8, 611 .key_local_addr = 9, 612 .key_tag = 1, 613 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)), 614 .deliver = false, 615 }, 616 { 617 .name = "peer addr mismatch", 618 .key_peer_addr = 9, 619 .key_local_addr = 8, 620 .key_tag = 1, 621 .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T(1)), 622 .deliver = false, 623 }, 624 { 625 .name = "tag value mismatch", 626 .key_peer_addr = 9, 627 .key_local_addr = 8, 628 .key_tag = 1, 629 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(2)), 630 .deliver = false, 631 }, 632 { 633 .name = "TO mismatch", 634 .key_peer_addr = 9, 635 .key_local_addr = 8, 636 .key_tag = 1, 637 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO), 638 .deliver = false, 639 }, 640 { 641 .name = "broadcast response", 642 .key_peer_addr = MCTP_ADDR_ANY, 643 .key_local_addr = 8, 644 .key_tag = 1, 645 .hdr = RX_HDR(1, 11, 8, FL_S | FL_E | FL_T(1)), 646 .deliver = true, 647 }, 648 { 649 .name = "any local match", 650 .key_peer_addr = 12, 651 .key_local_addr = MCTP_ADDR_ANY, 652 .key_tag = 1, 653 .hdr = RX_HDR(1, 12, 8, FL_S | FL_E | FL_T(1)), 654 .deliver = true, 655 }, 656 }; 657 658 static void mctp_route_input_sk_keys_to_desc( 659 const struct mctp_route_input_sk_keys_test *t, 660 char *desc) 661 { 662 sprintf(desc, "%s", t->name); 663 } 664 665 KUNIT_ARRAY_PARAM(mctp_route_input_sk_keys, mctp_route_input_sk_keys_tests, 666 mctp_route_input_sk_keys_to_desc); 667 668 static struct kunit_case mctp_test_cases[] = { 669 KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params), 670 KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params), 671 KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params), 672 KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm, 673 mctp_route_input_sk_reasm_gen_params), 674 KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys, 675 mctp_route_input_sk_keys_gen_params), 676 {} 677 }; 678 679 static struct kunit_suite mctp_test_suite = { 680 .name = "mctp", 681 .test_cases = mctp_test_cases, 682 }; 683 684 kunit_test_suite(mctp_test_suite); 685