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