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