1 // SPDX-License-Identifier: GPL-2.0
3 #include <kunit/test.h>
7 struct mctp_test_route {
9 struct sk_buff_head pkts;
12 static int mctp_test_route_output(struct mctp_route *rt, struct sk_buff *skb)
14 struct mctp_test_route *test_rt = container_of(rt, struct mctp_test_route, rt);
16 skb_queue_tail(&test_rt->pkts, skb);
21 /* local version of mctp_route_alloc() */
22 static struct mctp_test_route *mctp_route_test_alloc(void)
24 struct mctp_test_route *rt;
26 rt = kzalloc(sizeof(*rt), GFP_KERNEL);
30 INIT_LIST_HEAD(&rt->rt.list);
31 refcount_set(&rt->rt.refs, 1);
32 rt->rt.output = mctp_test_route_output;
34 skb_queue_head_init(&rt->pkts);
39 static struct mctp_test_route *mctp_test_create_route(struct net *net,
44 struct mctp_test_route *rt;
46 rt = mctp_route_test_alloc();
53 rt->rt.type = RTN_UNSPEC;
58 list_add_rcu(&rt->rt.list, &net->mctp.routes);
63 static void mctp_test_route_destroy(struct kunit *test,
64 struct mctp_test_route *rt)
69 list_del_rcu(&rt->rt.list);
72 skb_queue_purge(&rt->pkts);
74 mctp_dev_put(rt->rt.dev);
76 refs = refcount_read(&rt->rt.refs);
77 KUNIT_ASSERT_EQ_MSG(test, refs, 1, "route ref imbalance");
79 kfree_rcu(&rt->rt, rcu);
82 static struct sk_buff *mctp_test_create_skb(const struct mctp_hdr *hdr,
83 unsigned int data_len)
85 size_t hdr_len = sizeof(*hdr);
90 skb = alloc_skb(hdr_len + data_len, GFP_KERNEL);
94 memcpy(skb_put(skb, hdr_len), hdr, hdr_len);
96 buf = skb_put(skb, data_len);
97 for (i = 0; i < data_len; i++)
103 static struct sk_buff *__mctp_test_create_skb_data(const struct mctp_hdr *hdr,
107 size_t hdr_len = sizeof(*hdr);
110 skb = alloc_skb(hdr_len + data_len, GFP_KERNEL);
114 memcpy(skb_put(skb, hdr_len), hdr, hdr_len);
115 memcpy(skb_put(skb, data_len), data, data_len);
120 #define mctp_test_create_skb_data(h, d) \
121 __mctp_test_create_skb_data(h, d, sizeof(*d))
123 struct mctp_frag_test {
125 unsigned int msgsize;
126 unsigned int n_frags;
129 static void mctp_test_fragment(struct kunit *test)
131 const struct mctp_frag_test *params;
132 int rc, i, n, mtu, msgsize;
133 struct mctp_test_route *rt;
138 params = test->param_value;
140 msgsize = params->msgsize;
145 hdr.flags_seq_tag = MCTP_HDR_FLAG_TO;
147 skb = mctp_test_create_skb(&hdr, msgsize);
148 KUNIT_ASSERT_TRUE(test, skb);
150 rt = mctp_test_create_route(&init_net, NULL, 10, mtu);
151 KUNIT_ASSERT_TRUE(test, rt);
153 rc = mctp_do_fragment_route(&rt->rt, skb, mtu, MCTP_TAG_OWNER);
154 KUNIT_EXPECT_FALSE(test, rc);
158 KUNIT_EXPECT_EQ(test, n, params->n_frags);
161 struct mctp_hdr *hdr2;
162 struct sk_buff *skb2;
169 skb2 = skb_dequeue(&rt->pkts);
174 hdr2 = mctp_hdr(skb2);
176 tag_mask = MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO;
178 KUNIT_EXPECT_EQ(test, hdr2->ver, hdr.ver);
179 KUNIT_EXPECT_EQ(test, hdr2->src, hdr.src);
180 KUNIT_EXPECT_EQ(test, hdr2->dest, hdr.dest);
181 KUNIT_EXPECT_EQ(test, hdr2->flags_seq_tag & tag_mask,
182 hdr.flags_seq_tag & tag_mask);
184 KUNIT_EXPECT_EQ(test,
185 !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_SOM), first);
186 KUNIT_EXPECT_EQ(test,
187 !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_EOM), last);
189 seq2 = (hdr2->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) &
196 KUNIT_EXPECT_EQ(test, seq2, seq & MCTP_HDR_SEQ_MASK);
200 KUNIT_EXPECT_EQ(test, skb2->len, mtu);
202 KUNIT_EXPECT_LE(test, skb2->len, mtu);
207 mctp_test_route_destroy(test, rt);
210 static const struct mctp_frag_test mctp_frag_tests[] = {
211 {.mtu = 68, .msgsize = 63, .n_frags = 1},
212 {.mtu = 68, .msgsize = 64, .n_frags = 1},
213 {.mtu = 68, .msgsize = 65, .n_frags = 2},
214 {.mtu = 68, .msgsize = 66, .n_frags = 2},
215 {.mtu = 68, .msgsize = 127, .n_frags = 2},
216 {.mtu = 68, .msgsize = 128, .n_frags = 2},
217 {.mtu = 68, .msgsize = 129, .n_frags = 3},
218 {.mtu = 68, .msgsize = 130, .n_frags = 3},
221 static void mctp_frag_test_to_desc(const struct mctp_frag_test *t, char *desc)
223 sprintf(desc, "mtu %d len %d -> %d frags",
224 t->msgsize, t->mtu, t->n_frags);
227 KUNIT_ARRAY_PARAM(mctp_frag, mctp_frag_tests, mctp_frag_test_to_desc);
229 struct mctp_rx_input_test {
234 static void mctp_test_rx_input(struct kunit *test)
236 const struct mctp_rx_input_test *params;
237 struct mctp_test_route *rt;
238 struct mctp_test_dev *dev;
241 params = test->param_value;
243 dev = mctp_test_create_dev();
244 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
246 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
247 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
249 skb = mctp_test_create_skb(¶ms->hdr, 1);
250 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
254 mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL);
256 KUNIT_EXPECT_EQ(test, !!rt->pkts.qlen, params->input);
258 mctp_test_route_destroy(test, rt);
259 mctp_test_destroy_dev(dev);
262 #define RX_HDR(_ver, _src, _dest, _fst) \
263 { .ver = _ver, .src = _src, .dest = _dest, .flags_seq_tag = _fst }
265 /* we have a route for EID 8 only */
266 static const struct mctp_rx_input_test mctp_rx_input_tests[] = {
267 { .hdr = RX_HDR(1, 10, 8, 0), .input = true },
268 { .hdr = RX_HDR(1, 10, 9, 0), .input = false }, /* no input route */
269 { .hdr = RX_HDR(2, 10, 8, 0), .input = false }, /* invalid version */
272 static void mctp_rx_input_test_to_desc(const struct mctp_rx_input_test *t,
275 sprintf(desc, "{%x,%x,%x,%x}", t->hdr.ver, t->hdr.src, t->hdr.dest,
276 t->hdr.flags_seq_tag);
279 KUNIT_ARRAY_PARAM(mctp_rx_input, mctp_rx_input_tests,
280 mctp_rx_input_test_to_desc);
282 /* set up a local dev, route on EID 8, and a socket listening on type 0 */
283 static void __mctp_route_test_init(struct kunit *test,
284 struct mctp_test_dev **devp,
285 struct mctp_test_route **rtp,
286 struct socket **sockp)
288 struct sockaddr_mctp addr = {0};
289 struct mctp_test_route *rt;
290 struct mctp_test_dev *dev;
294 dev = mctp_test_create_dev();
295 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
297 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
298 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
300 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
301 KUNIT_ASSERT_EQ(test, rc, 0);
303 addr.smctp_family = AF_MCTP;
304 addr.smctp_network = MCTP_NET_ANY;
305 addr.smctp_addr.s_addr = 8;
307 rc = kernel_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
308 KUNIT_ASSERT_EQ(test, rc, 0);
315 static void __mctp_route_test_fini(struct kunit *test,
316 struct mctp_test_dev *dev,
317 struct mctp_test_route *rt,
321 mctp_test_route_destroy(test, rt);
322 mctp_test_destroy_dev(dev);
325 struct mctp_route_input_sk_test {
331 static void mctp_test_route_input_sk(struct kunit *test)
333 const struct mctp_route_input_sk_test *params;
334 struct sk_buff *skb, *skb2;
335 struct mctp_test_route *rt;
336 struct mctp_test_dev *dev;
340 params = test->param_value;
342 __mctp_route_test_init(test, &dev, &rt, &sock);
344 skb = mctp_test_create_skb_data(¶ms->hdr, ¶ms->type);
345 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
347 skb->dev = dev->ndev;
350 rc = mctp_route_input(&rt->rt, skb);
352 if (params->deliver) {
353 KUNIT_EXPECT_EQ(test, rc, 0);
355 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
356 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
357 KUNIT_EXPECT_EQ(test, skb->len, 1);
359 skb_free_datagram(sock->sk, skb2);
362 KUNIT_EXPECT_NE(test, rc, 0);
363 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
364 KUNIT_EXPECT_NULL(test, skb2);
367 __mctp_route_test_fini(test, dev, rt, sock);
370 #define FL_S (MCTP_HDR_FLAG_SOM)
371 #define FL_E (MCTP_HDR_FLAG_EOM)
372 #define FL_TO (MCTP_HDR_FLAG_TO)
373 #define FL_T(t) ((t) & MCTP_HDR_TAG_MASK)
375 static const struct mctp_route_input_sk_test mctp_route_input_sk_tests[] = {
376 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 0, .deliver = true },
377 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 1, .deliver = false },
378 { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E), .type = 0, .deliver = false },
379 { .hdr = RX_HDR(1, 10, 8, FL_E | FL_TO), .type = 0, .deliver = false },
380 { .hdr = RX_HDR(1, 10, 8, FL_TO), .type = 0, .deliver = false },
381 { .hdr = RX_HDR(1, 10, 8, 0), .type = 0, .deliver = false },
384 static void mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test *t,
387 sprintf(desc, "{%x,%x,%x,%x} type %d", t->hdr.ver, t->hdr.src,
388 t->hdr.dest, t->hdr.flags_seq_tag, t->type);
391 KUNIT_ARRAY_PARAM(mctp_route_input_sk, mctp_route_input_sk_tests,
392 mctp_route_input_sk_to_desc);
394 struct mctp_route_input_sk_reasm_test {
396 struct mctp_hdr hdrs[4];
401 static void mctp_test_route_input_sk_reasm(struct kunit *test)
403 const struct mctp_route_input_sk_reasm_test *params;
404 struct sk_buff *skb, *skb2;
405 struct mctp_test_route *rt;
406 struct mctp_test_dev *dev;
411 params = test->param_value;
413 __mctp_route_test_init(test, &dev, &rt, &sock);
415 for (i = 0; i < params->n_hdrs; i++) {
417 skb = mctp_test_create_skb_data(¶ms->hdrs[i], &c);
418 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
420 skb->dev = dev->ndev;
423 rc = mctp_route_input(&rt->rt, skb);
426 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
428 if (params->rx_len) {
429 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
430 KUNIT_EXPECT_EQ(test, skb2->len, params->rx_len);
431 skb_free_datagram(sock->sk, skb2);
434 KUNIT_EXPECT_NULL(test, skb2);
437 __mctp_route_test_fini(test, dev, rt, sock);
440 #define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_TO | (f) | ((s) << MCTP_HDR_SEQ_SHIFT))
442 static const struct mctp_route_input_sk_reasm_test mctp_route_input_sk_reasm_tests[] = {
444 .name = "single packet",
446 RX_FRAG(FL_S | FL_E, 0),
452 .name = "single packet, offset seq",
454 RX_FRAG(FL_S | FL_E, 1),
460 .name = "start & end packets",
469 .name = "start & end packets, offset seq",
478 .name = "start & end packets, out of order",
487 .name = "start, middle & end packets",
497 .name = "missing seq",
516 static void mctp_route_input_sk_reasm_to_desc(
517 const struct mctp_route_input_sk_reasm_test *t,
520 sprintf(desc, "%s", t->name);
523 KUNIT_ARRAY_PARAM(mctp_route_input_sk_reasm, mctp_route_input_sk_reasm_tests,
524 mctp_route_input_sk_reasm_to_desc);
526 struct mctp_route_input_sk_keys_test {
528 mctp_eid_t key_peer_addr;
529 mctp_eid_t key_local_addr;
535 /* test packet rx in the presence of various key configurations */
536 static void mctp_test_route_input_sk_keys(struct kunit *test)
538 const struct mctp_route_input_sk_keys_test *params;
539 struct mctp_test_route *rt;
540 struct sk_buff *skb, *skb2;
541 struct mctp_test_dev *dev;
542 struct mctp_sk_key *key;
543 struct netns_mctp *mns;
544 struct mctp_sock *msk;
550 params = test->param_value;
552 dev = mctp_test_create_dev();
553 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
555 rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
556 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
558 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
559 KUNIT_ASSERT_EQ(test, rc, 0);
561 msk = container_of(sock->sk, struct mctp_sock, sk);
562 mns = &sock_net(sock->sk)->mctp;
564 /* set the incoming tag according to test params */
565 key = mctp_key_alloc(msk, params->key_local_addr, params->key_peer_addr,
566 params->key_tag, GFP_KERNEL);
568 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, key);
570 spin_lock_irqsave(&mns->keys_lock, flags);
571 mctp_reserve_tag(&init_net, key, msk);
572 spin_unlock_irqrestore(&mns->keys_lock, flags);
574 /* create packet and route */
576 skb = mctp_test_create_skb_data(¶ms->hdr, &c);
577 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
579 skb->dev = dev->ndev;
582 rc = mctp_route_input(&rt->rt, skb);
584 /* (potentially) receive message */
585 skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
588 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
590 KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
593 skb_free_datagram(sock->sk, skb2);
596 __mctp_route_test_fini(test, dev, rt, sock);
599 static const struct mctp_route_input_sk_keys_test mctp_route_input_sk_keys_tests[] = {
601 .name = "direct match",
605 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)),
609 .name = "flipped src/dest",
613 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)),
617 .name = "peer addr mismatch",
621 .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T(1)),
625 .name = "tag value mismatch",
629 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(2)),
633 .name = "TO mismatch",
637 .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO),
641 .name = "broadcast response",
642 .key_peer_addr = MCTP_ADDR_ANY,
645 .hdr = RX_HDR(1, 11, 8, FL_S | FL_E | FL_T(1)),
649 .name = "any local match",
651 .key_local_addr = MCTP_ADDR_ANY,
653 .hdr = RX_HDR(1, 12, 8, FL_S | FL_E | FL_T(1)),
658 static void mctp_route_input_sk_keys_to_desc(
659 const struct mctp_route_input_sk_keys_test *t,
662 sprintf(desc, "%s", t->name);
665 KUNIT_ARRAY_PARAM(mctp_route_input_sk_keys, mctp_route_input_sk_keys_tests,
666 mctp_route_input_sk_keys_to_desc);
668 static struct kunit_case mctp_test_cases[] = {
669 KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params),
670 KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params),
671 KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params),
672 KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm,
673 mctp_route_input_sk_reasm_gen_params),
674 KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys,
675 mctp_route_input_sk_keys_gen_params),
679 static struct kunit_suite mctp_test_suite = {
681 .test_cases = mctp_test_cases,
684 kunit_test_suite(mctp_test_suite);