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
mctp_test_fragment(struct kunit * test)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
mctp_frag_test_to_desc(const struct mctp_frag_test * t,char * desc)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
mctp_test_rx_input(struct kunit * test)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
mctp_rx_input_test_to_desc(const struct mctp_rx_input_test * t,char * desc)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 */
__mctp_route_test_init(struct kunit * test,struct mctp_test_dev ** devp,struct mctp_dst * dst,struct mctp_test_pktqueue * tpq,struct socket ** sockp,unsigned int netid)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
__mctp_route_test_fini(struct kunit * test,struct mctp_test_dev * dev,struct mctp_dst * dst,struct mctp_test_pktqueue * tpq,struct socket * sock)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
mctp_test_route_input_sk(struct kunit * test)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
mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test * t,char * desc)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
mctp_test_route_input_sk_reasm(struct kunit * test)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
mctp_route_input_sk_reasm_to_desc(const struct mctp_route_input_sk_reasm_test * t,char * desc)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 */
mctp_test_route_input_sk_keys(struct kunit * test)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
mctp_route_input_sk_keys_to_desc(const struct mctp_route_input_sk_keys_test * t,char * desc)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
mctp_test_route_input_multiple_nets_bind_init(struct kunit * test,struct test_net * t)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
mctp_test_route_input_multiple_nets_bind_fini(struct kunit * test,struct test_net * t)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 */
mctp_test_route_input_multiple_nets_bind(struct kunit * test)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
mctp_test_route_input_multiple_nets_key_init(struct kunit * test,struct test_net * t)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
mctp_test_route_input_multiple_nets_key_fini(struct kunit * test,struct test_net * t)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 */
mctp_test_route_input_multiple_nets_key(struct kunit * test)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 */
mctp_test_route_input_sk_fail_single(struct kunit * test)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 */
mctp_test_route_input_sk_fail_frag(struct kunit * test)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 */
mctp_test_route_input_cloned_frag(struct kunit * test)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
mctp_test_flow_init(struct kunit * test,struct mctp_test_dev ** devp,struct mctp_dst * dst,struct mctp_test_pktqueue * tpq,struct socket ** sock,struct sk_buff ** skbp,unsigned int len)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
mctp_test_flow_fini(struct kunit * test,struct mctp_test_dev * dev,struct mctp_dst * dst,struct mctp_test_pktqueue * tpq,struct socket * sock)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 */
mctp_test_packet_flow(struct kunit * test)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 */
mctp_test_fragment_flow(struct kunit * test)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
mctp_test_packet_flow(struct kunit * test)1051 static void mctp_test_packet_flow(struct kunit *test)
1052 {
1053 kunit_skip(test, "Requires CONFIG_MCTP_FLOWS=y");
1054 }
1055
mctp_test_fragment_flow(struct kunit * test)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 */
mctp_test_route_output_key_create(struct kunit * test)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
mctp_test_route_extaddr_input(struct kunit * test)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 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
1168 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2);
1169 KUNIT_ASSERT_EQ(test, skb2->len, len);
1170
1171 cb2 = mctp_cb(skb2);
1172
1173 /* Received SKB should have the hardware addressing as set above.
1174 * We're likely to have the same actual cb here (ie., cb == cb2),
1175 * but it's the comparison that we care about
1176 */
1177 KUNIT_EXPECT_EQ(test, cb2->halen, sizeof(haddr));
1178 KUNIT_EXPECT_MEMEQ(test, cb2->haddr, haddr, sizeof(haddr));
1179
1180 kfree_skb(skb2);
1181 __mctp_route_test_fini(test, dev, &dst, &tpq, sock);
1182 }
1183
mctp_test_route_gw_lookup(struct kunit * test)1184 static void mctp_test_route_gw_lookup(struct kunit *test)
1185 {
1186 struct mctp_test_route *rt1, *rt2;
1187 struct mctp_dst dst = { 0 };
1188 struct mctp_test_dev *dev;
1189 int rc;
1190
1191 dev = mctp_test_create_dev();
1192 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1193
1194 /* 8 (local) -> 10 (gateway) via 9 (direct) */
1195 rt1 = mctp_test_create_route_direct(&init_net, dev->mdev, 9, 0);
1196 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1);
1197 rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0);
1198 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2);
1199
1200 rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst);
1201 KUNIT_EXPECT_EQ(test, rc, 0);
1202 KUNIT_EXPECT_PTR_EQ(test, dst.dev, dev->mdev);
1203 KUNIT_EXPECT_EQ(test, dst.mtu, dev->ndev->mtu);
1204 KUNIT_EXPECT_EQ(test, dst.nexthop, 9);
1205 KUNIT_EXPECT_EQ(test, dst.halen, 0);
1206
1207 mctp_dst_release(&dst);
1208
1209 mctp_test_route_destroy(test, rt2);
1210 mctp_test_route_destroy(test, rt1);
1211 mctp_test_destroy_dev(dev);
1212 }
1213
mctp_test_route_gw_loop(struct kunit * test)1214 static void mctp_test_route_gw_loop(struct kunit *test)
1215 {
1216 struct mctp_test_route *rt1, *rt2;
1217 struct mctp_dst dst = { 0 };
1218 struct mctp_test_dev *dev;
1219 int rc;
1220
1221 dev = mctp_test_create_dev();
1222 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1223
1224 /* two routes using each other as the gw */
1225 rt1 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 9, 10, 0);
1226 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1);
1227 rt2 = mctp_test_create_route_gw(&init_net, dev->mdev->net, 10, 9, 0);
1228 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2);
1229
1230 /* this should fail, rather than infinite-loop */
1231 rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst);
1232 KUNIT_EXPECT_NE(test, rc, 0);
1233
1234 mctp_test_route_destroy(test, rt2);
1235 mctp_test_route_destroy(test, rt1);
1236 mctp_test_destroy_dev(dev);
1237 }
1238
1239 struct mctp_route_gw_mtu_test {
1240 /* working away from the local stack */
1241 unsigned int dev, neigh, gw, dst;
1242 unsigned int exp;
1243 };
1244
mctp_route_gw_mtu_to_desc(const struct mctp_route_gw_mtu_test * t,char * desc)1245 static void mctp_route_gw_mtu_to_desc(const struct mctp_route_gw_mtu_test *t,
1246 char *desc)
1247 {
1248 sprintf(desc, "dev %d, neigh %d, gw %d, dst %d -> %d",
1249 t->dev, t->neigh, t->gw, t->dst, t->exp);
1250 }
1251
1252 static const struct mctp_route_gw_mtu_test mctp_route_gw_mtu_tests[] = {
1253 /* no route-specific MTUs */
1254 { 68, 0, 0, 0, 68 },
1255 { 100, 0, 0, 0, 100 },
1256 /* one route MTU (smaller than dev mtu), others unrestricted */
1257 { 100, 68, 0, 0, 68 },
1258 { 100, 0, 68, 0, 68 },
1259 { 100, 0, 0, 68, 68 },
1260 /* smallest applied, regardless of order */
1261 { 100, 99, 98, 68, 68 },
1262 { 99, 100, 98, 68, 68 },
1263 { 98, 99, 100, 68, 68 },
1264 { 68, 98, 99, 100, 68 },
1265 };
1266
1267 KUNIT_ARRAY_PARAM(mctp_route_gw_mtu, mctp_route_gw_mtu_tests,
1268 mctp_route_gw_mtu_to_desc);
1269
mctp_test_route_gw_mtu(struct kunit * test)1270 static void mctp_test_route_gw_mtu(struct kunit *test)
1271 {
1272 const struct mctp_route_gw_mtu_test *mtus = test->param_value;
1273 struct mctp_test_route *rt1, *rt2, *rt3;
1274 struct mctp_dst dst = { 0 };
1275 struct mctp_test_dev *dev;
1276 struct mctp_dev *mdev;
1277 unsigned int netid;
1278 int rc;
1279
1280 dev = mctp_test_create_dev();
1281 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1282 dev->ndev->mtu = mtus->dev;
1283 mdev = dev->mdev;
1284 netid = mdev->net;
1285
1286 /* 8 (local) -> 11 (dst) via 10 (gw) via 9 (neigh) */
1287 rt1 = mctp_test_create_route_direct(&init_net, mdev, 9, mtus->neigh);
1288 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt1);
1289
1290 rt2 = mctp_test_create_route_gw(&init_net, netid, 10, 9, mtus->gw);
1291 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt2);
1292
1293 rt3 = mctp_test_create_route_gw(&init_net, netid, 11, 10, mtus->dst);
1294 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt3);
1295
1296 rc = mctp_route_lookup(&init_net, dev->mdev->net, 11, &dst);
1297 KUNIT_EXPECT_EQ(test, rc, 0);
1298 KUNIT_EXPECT_EQ(test, dst.mtu, mtus->exp);
1299
1300 mctp_dst_release(&dst);
1301
1302 mctp_test_route_destroy(test, rt3);
1303 mctp_test_route_destroy(test, rt2);
1304 mctp_test_route_destroy(test, rt1);
1305 mctp_test_destroy_dev(dev);
1306 }
1307
1308 #define MCTP_TEST_LLADDR_LEN 2
1309 struct mctp_test_llhdr {
1310 unsigned int magic;
1311 unsigned char src[MCTP_TEST_LLADDR_LEN];
1312 unsigned char dst[MCTP_TEST_LLADDR_LEN];
1313 };
1314
1315 static const unsigned int mctp_test_llhdr_magic = 0x5c78339c;
1316
test_dev_header_create(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)1317 static int test_dev_header_create(struct sk_buff *skb, struct net_device *dev,
1318 unsigned short type, const void *daddr,
1319 const void *saddr, unsigned int len)
1320 {
1321 struct kunit *test = current->kunit_test;
1322 struct mctp_test_llhdr *hdr;
1323
1324 hdr = skb_push(skb, sizeof(*hdr));
1325 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hdr);
1326 skb_reset_mac_header(skb);
1327
1328 hdr->magic = mctp_test_llhdr_magic;
1329 memcpy(&hdr->src, saddr, sizeof(hdr->src));
1330 memcpy(&hdr->dst, daddr, sizeof(hdr->dst));
1331
1332 return 0;
1333 }
1334
1335 /* Test the dst_output path for a gateway-routed skb: we should have it
1336 * lookup the nexthop EID in the neighbour table, and call into
1337 * header_ops->create to resolve that to a lladdr. Our mock header_ops->create
1338 * will just set a synthetic link-layer header, which we check after transmit.
1339 */
mctp_test_route_gw_output(struct kunit * test)1340 static void mctp_test_route_gw_output(struct kunit *test)
1341 {
1342 const unsigned char haddr_self[MCTP_TEST_LLADDR_LEN] = { 0xaa, 0x03 };
1343 const unsigned char haddr_peer[MCTP_TEST_LLADDR_LEN] = { 0xaa, 0x02 };
1344 const struct header_ops ops = {
1345 .create = test_dev_header_create,
1346 };
1347 struct mctp_neigh neigh = { 0 };
1348 struct mctp_test_llhdr *ll_hdr;
1349 struct mctp_dst dst = { 0 };
1350 struct mctp_hdr hdr = { 0 };
1351 struct mctp_test_dev *dev;
1352 struct sk_buff *skb;
1353 unsigned char *buf;
1354 int i, rc;
1355
1356 dev = mctp_test_create_dev_lladdr(sizeof(haddr_self), haddr_self);
1357 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
1358 dev->ndev->header_ops = &ops;
1359
1360 dst.dev = dev->mdev;
1361 __mctp_dev_get(dst.dev->dev);
1362 dst.mtu = 68;
1363 dst.nexthop = 9;
1364
1365 /* simple mctp_neigh_add for the gateway (not dest!) endpoint */
1366 INIT_LIST_HEAD(&neigh.list);
1367 neigh.dev = dev->mdev;
1368 mctp_dev_hold(dev->mdev);
1369 neigh.eid = 9;
1370 neigh.source = MCTP_NEIGH_STATIC;
1371 memcpy(neigh.ha, haddr_peer, sizeof(haddr_peer));
1372 list_add_rcu(&neigh.list, &init_net.mctp.neighbours);
1373
1374 hdr.ver = 1;
1375 hdr.src = 8;
1376 hdr.dest = 10;
1377 hdr.flags_seq_tag = FL_S | FL_E | FL_TO;
1378
1379 /* construct enough for a future link-layer header, the provided
1380 * mctp header, and 4 bytes of data
1381 */
1382 skb = alloc_skb(sizeof(*ll_hdr) + sizeof(hdr) + 4, GFP_KERNEL);
1383 skb->dev = dev->ndev;
1384 __mctp_cb(skb);
1385
1386 skb_reserve(skb, sizeof(*ll_hdr));
1387
1388 memcpy(skb_put(skb, sizeof(hdr)), &hdr, sizeof(hdr));
1389 buf = skb_put(skb, 4);
1390 for (i = 0; i < 4; i++)
1391 buf[i] = i;
1392
1393 /* extra ref over the dev_xmit */
1394 skb_get(skb);
1395
1396 rc = mctp_dst_output(&dst, skb);
1397 KUNIT_EXPECT_EQ(test, rc, 0);
1398
1399 mctp_dst_release(&dst);
1400 list_del_rcu(&neigh.list);
1401 mctp_dev_put(dev->mdev);
1402
1403 /* check that we have our header created with the correct neighbour */
1404 ll_hdr = (void *)skb_mac_header(skb);
1405 KUNIT_EXPECT_EQ(test, ll_hdr->magic, mctp_test_llhdr_magic);
1406 KUNIT_EXPECT_MEMEQ(test, ll_hdr->src, haddr_self, sizeof(haddr_self));
1407 KUNIT_EXPECT_MEMEQ(test, ll_hdr->dst, haddr_peer, sizeof(haddr_peer));
1408 kfree_skb(skb);
1409 }
1410
1411 struct mctp_bind_lookup_test {
1412 /* header of incoming message */
1413 struct mctp_hdr hdr;
1414 u8 ty;
1415 /* mctp network of incoming interface (smctp_network) */
1416 unsigned int net;
1417
1418 /* expected socket, matches .name in lookup_binds, NULL for dropped */
1419 const char *expect;
1420 };
1421
1422 /* Single-packet TO-set message */
1423 #define LK(src, dst) RX_HDR(1, (src), (dst), FL_S | FL_E | FL_TO)
1424
1425 /* Input message test cases for bind lookup tests.
1426 *
1427 * 10 and 11 are local EIDs.
1428 * 20 and 21 are remote EIDs.
1429 */
1430 static const struct mctp_bind_lookup_test mctp_bind_lookup_tests[] = {
1431 /* both local-eid and remote-eid binds, remote eid is preferenced */
1432 { .hdr = LK(20, 10), .ty = 1, .net = 1, .expect = "remote20" },
1433
1434 { .hdr = LK(20, 255), .ty = 1, .net = 1, .expect = "remote20" },
1435 { .hdr = LK(20, 0), .ty = 1, .net = 1, .expect = "remote20" },
1436 { .hdr = LK(0, 255), .ty = 1, .net = 1, .expect = "any" },
1437 { .hdr = LK(0, 11), .ty = 1, .net = 1, .expect = "any" },
1438 { .hdr = LK(0, 0), .ty = 1, .net = 1, .expect = "any" },
1439 { .hdr = LK(0, 10), .ty = 1, .net = 1, .expect = "local10" },
1440 { .hdr = LK(21, 10), .ty = 1, .net = 1, .expect = "local10" },
1441 { .hdr = LK(21, 11), .ty = 1, .net = 1, .expect = "remote21local11" },
1442
1443 /* both src and dest set to eid=99. unusual, but accepted
1444 * by MCTP stack currently.
1445 */
1446 { .hdr = LK(99, 99), .ty = 1, .net = 1, .expect = "any" },
1447
1448 /* unbound smctp_type */
1449 { .hdr = LK(20, 10), .ty = 3, .net = 1, .expect = NULL },
1450
1451 /* smctp_network tests */
1452
1453 { .hdr = LK(0, 0), .ty = 1, .net = 7, .expect = "any" },
1454 { .hdr = LK(21, 10), .ty = 1, .net = 2, .expect = "any" },
1455
1456 /* remote EID 20 matches, but MCTP_NET_ANY in "remote20" resolved
1457 * to net=1, so lookup doesn't match "remote20"
1458 */
1459 { .hdr = LK(20, 10), .ty = 1, .net = 3, .expect = "any" },
1460
1461 { .hdr = LK(21, 10), .ty = 1, .net = 3, .expect = "remote21net3" },
1462 { .hdr = LK(21, 10), .ty = 1, .net = 4, .expect = "remote21net4" },
1463 { .hdr = LK(21, 10), .ty = 1, .net = 5, .expect = "remote21net5" },
1464
1465 { .hdr = LK(21, 10), .ty = 1, .net = 5, .expect = "remote21net5" },
1466
1467 { .hdr = LK(99, 10), .ty = 1, .net = 8, .expect = "local10net8" },
1468
1469 { .hdr = LK(99, 10), .ty = 1, .net = 9, .expect = "anynet9" },
1470 { .hdr = LK(0, 0), .ty = 1, .net = 9, .expect = "anynet9" },
1471 { .hdr = LK(99, 99), .ty = 1, .net = 9, .expect = "anynet9" },
1472 { .hdr = LK(20, 10), .ty = 1, .net = 9, .expect = "anynet9" },
1473 };
1474
1475 /* Binds to create during the lookup tests */
1476 static const struct mctp_test_bind_setup lookup_binds[] = {
1477 /* any address and net, type 1 */
1478 { .name = "any", .bind_addr = MCTP_ADDR_ANY,
1479 .bind_net = MCTP_NET_ANY, .bind_type = 1, },
1480 /* local eid 10, net 1 (resolved from MCTP_NET_ANY) */
1481 { .name = "local10", .bind_addr = 10,
1482 .bind_net = MCTP_NET_ANY, .bind_type = 1, },
1483 /* local eid 10, net 8 */
1484 { .name = "local10net8", .bind_addr = 10,
1485 .bind_net = 8, .bind_type = 1, },
1486 /* any EID, net 9 */
1487 { .name = "anynet9", .bind_addr = MCTP_ADDR_ANY,
1488 .bind_net = 9, .bind_type = 1, },
1489
1490 /* remote eid 20, net 1, any local eid */
1491 { .name = "remote20", .bind_addr = MCTP_ADDR_ANY,
1492 .bind_net = MCTP_NET_ANY, .bind_type = 1,
1493 .have_peer = true, .peer_addr = 20, .peer_net = MCTP_NET_ANY, },
1494
1495 /* remote eid 20, net 1, local eid 11 */
1496 { .name = "remote21local11", .bind_addr = 11,
1497 .bind_net = MCTP_NET_ANY, .bind_type = 1,
1498 .have_peer = true, .peer_addr = 21, .peer_net = MCTP_NET_ANY, },
1499
1500 /* remote eid 21, specific net=3 for connect() */
1501 { .name = "remote21net3", .bind_addr = MCTP_ADDR_ANY,
1502 .bind_net = MCTP_NET_ANY, .bind_type = 1,
1503 .have_peer = true, .peer_addr = 21, .peer_net = 3, },
1504
1505 /* remote eid 21, net 4 for bind, specific net=4 for connect() */
1506 { .name = "remote21net4", .bind_addr = MCTP_ADDR_ANY,
1507 .bind_net = 4, .bind_type = 1,
1508 .have_peer = true, .peer_addr = 21, .peer_net = 4, },
1509
1510 /* remote eid 21, net 5 for bind, specific net=5 for connect() */
1511 { .name = "remote21net5", .bind_addr = MCTP_ADDR_ANY,
1512 .bind_net = 5, .bind_type = 1,
1513 .have_peer = true, .peer_addr = 21, .peer_net = 5, },
1514 };
1515
mctp_bind_lookup_desc(const struct mctp_bind_lookup_test * t,char * desc)1516 static void mctp_bind_lookup_desc(const struct mctp_bind_lookup_test *t,
1517 char *desc)
1518 {
1519 snprintf(desc, KUNIT_PARAM_DESC_SIZE,
1520 "{src %d dst %d ty %d net %d expect %s}",
1521 t->hdr.src, t->hdr.dest, t->ty, t->net, t->expect);
1522 }
1523
1524 KUNIT_ARRAY_PARAM(mctp_bind_lookup, mctp_bind_lookup_tests,
1525 mctp_bind_lookup_desc);
1526
mctp_test_bind_lookup(struct kunit * test)1527 static void mctp_test_bind_lookup(struct kunit *test)
1528 {
1529 const struct mctp_bind_lookup_test *rx;
1530 struct socket *socks[ARRAY_SIZE(lookup_binds)];
1531 struct sk_buff *skb_pkt = NULL, *skb_sock = NULL;
1532 struct socket *sock_ty0, *sock_expect = NULL;
1533 struct mctp_test_pktqueue tpq;
1534 struct mctp_test_dev *dev;
1535 struct mctp_dst dst;
1536 int rc;
1537
1538 rx = test->param_value;
1539
1540 __mctp_route_test_init(test, &dev, &dst, &tpq, &sock_ty0, rx->net);
1541 /* Create all binds */
1542 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) {
1543 mctp_test_bind_run(test, &lookup_binds[i],
1544 &rc, &socks[i]);
1545 KUNIT_ASSERT_EQ(test, rc, 0);
1546
1547 /* Record the expected receive socket */
1548 if (rx->expect &&
1549 strcmp(rx->expect, lookup_binds[i].name) == 0) {
1550 KUNIT_ASSERT_NULL(test, sock_expect);
1551 sock_expect = socks[i];
1552 }
1553 }
1554 KUNIT_ASSERT_EQ(test, !!sock_expect, !!rx->expect);
1555
1556 /* Create test message */
1557 skb_pkt = mctp_test_create_skb_data(&rx->hdr, &rx->ty);
1558 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb_pkt);
1559 mctp_test_skb_set_dev(skb_pkt, dev);
1560 mctp_test_pktqueue_init(&tpq);
1561
1562 rc = mctp_dst_input(&dst, skb_pkt);
1563 if (rx->expect) {
1564 /* Test the message is received on the expected socket */
1565 KUNIT_EXPECT_EQ(test, rc, 0);
1566 skb_sock = skb_recv_datagram(sock_expect->sk,
1567 MSG_DONTWAIT, &rc);
1568 if (!skb_sock) {
1569 /* Find which socket received it instead */
1570 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) {
1571 skb_sock = skb_recv_datagram(socks[i]->sk,
1572 MSG_DONTWAIT, &rc);
1573 if (skb_sock) {
1574 KUNIT_FAIL(test,
1575 "received on incorrect socket '%s', expect '%s'",
1576 lookup_binds[i].name,
1577 rx->expect);
1578 goto cleanup;
1579 }
1580 }
1581 KUNIT_FAIL(test, "no message received");
1582 }
1583 } else {
1584 KUNIT_EXPECT_NE(test, rc, 0);
1585 }
1586
1587 cleanup:
1588 kfree_skb(skb_sock);
1589
1590 /* Drop all binds */
1591 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++)
1592 sock_release(socks[i]);
1593
1594 __mctp_route_test_fini(test, dev, &dst, &tpq, sock_ty0);
1595 }
1596
1597 static struct kunit_case mctp_test_cases[] = {
1598 KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params),
1599 KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params),
1600 KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params),
1601 KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm,
1602 mctp_route_input_sk_reasm_gen_params),
1603 KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys,
1604 mctp_route_input_sk_keys_gen_params),
1605 KUNIT_CASE(mctp_test_route_input_sk_fail_single),
1606 KUNIT_CASE(mctp_test_route_input_sk_fail_frag),
1607 KUNIT_CASE(mctp_test_route_input_multiple_nets_bind),
1608 KUNIT_CASE(mctp_test_route_input_multiple_nets_key),
1609 KUNIT_CASE(mctp_test_packet_flow),
1610 KUNIT_CASE(mctp_test_fragment_flow),
1611 KUNIT_CASE(mctp_test_route_output_key_create),
1612 KUNIT_CASE(mctp_test_route_input_cloned_frag),
1613 KUNIT_CASE(mctp_test_route_extaddr_input),
1614 KUNIT_CASE(mctp_test_route_gw_lookup),
1615 KUNIT_CASE(mctp_test_route_gw_loop),
1616 KUNIT_CASE_PARAM(mctp_test_route_gw_mtu, mctp_route_gw_mtu_gen_params),
1617 KUNIT_CASE(mctp_test_route_gw_output),
1618 KUNIT_CASE_PARAM(mctp_test_bind_lookup, mctp_bind_lookup_gen_params),
1619 {}
1620 };
1621
1622 static struct kunit_suite mctp_test_suite = {
1623 .name = "mctp-route",
1624 .test_cases = mctp_test_cases,
1625 };
1626
1627 kunit_test_suite(mctp_test_suite);
1628