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