route-test.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <kunit/test.h>
  3. #include "utils.h"
  4. struct mctp_test_route {
  5. struct mctp_route rt;
  6. struct sk_buff_head pkts;
  7. };
  8. static int mctp_test_route_output(struct mctp_route *rt, struct sk_buff *skb)
  9. {
  10. struct mctp_test_route *test_rt = container_of(rt, struct mctp_test_route, rt);
  11. skb_queue_tail(&test_rt->pkts, skb);
  12. return 0;
  13. }
  14. /* local version of mctp_route_alloc() */
  15. static struct mctp_test_route *mctp_route_test_alloc(void)
  16. {
  17. struct mctp_test_route *rt;
  18. rt = kzalloc(sizeof(*rt), GFP_KERNEL);
  19. if (!rt)
  20. return NULL;
  21. INIT_LIST_HEAD(&rt->rt.list);
  22. refcount_set(&rt->rt.refs, 1);
  23. rt->rt.output = mctp_test_route_output;
  24. skb_queue_head_init(&rt->pkts);
  25. return rt;
  26. }
  27. static struct mctp_test_route *mctp_test_create_route(struct net *net,
  28. struct mctp_dev *dev,
  29. mctp_eid_t eid,
  30. unsigned int mtu)
  31. {
  32. struct mctp_test_route *rt;
  33. rt = mctp_route_test_alloc();
  34. if (!rt)
  35. return NULL;
  36. rt->rt.min = eid;
  37. rt->rt.max = eid;
  38. rt->rt.mtu = mtu;
  39. rt->rt.type = RTN_UNSPEC;
  40. if (dev)
  41. mctp_dev_hold(dev);
  42. rt->rt.dev = dev;
  43. list_add_rcu(&rt->rt.list, &net->mctp.routes);
  44. return rt;
  45. }
  46. static void mctp_test_route_destroy(struct kunit *test,
  47. struct mctp_test_route *rt)
  48. {
  49. unsigned int refs;
  50. rtnl_lock();
  51. list_del_rcu(&rt->rt.list);
  52. rtnl_unlock();
  53. skb_queue_purge(&rt->pkts);
  54. if (rt->rt.dev)
  55. mctp_dev_put(rt->rt.dev);
  56. refs = refcount_read(&rt->rt.refs);
  57. KUNIT_ASSERT_EQ_MSG(test, refs, 1, "route ref imbalance");
  58. kfree_rcu(&rt->rt, rcu);
  59. }
  60. static struct sk_buff *mctp_test_create_skb(const struct mctp_hdr *hdr,
  61. unsigned int data_len)
  62. {
  63. size_t hdr_len = sizeof(*hdr);
  64. struct sk_buff *skb;
  65. unsigned int i;
  66. u8 *buf;
  67. skb = alloc_skb(hdr_len + data_len, GFP_KERNEL);
  68. if (!skb)
  69. return NULL;
  70. memcpy(skb_put(skb, hdr_len), hdr, hdr_len);
  71. buf = skb_put(skb, data_len);
  72. for (i = 0; i < data_len; i++)
  73. buf[i] = i & 0xff;
  74. return skb;
  75. }
  76. static struct sk_buff *__mctp_test_create_skb_data(const struct mctp_hdr *hdr,
  77. const void *data,
  78. size_t data_len)
  79. {
  80. size_t hdr_len = sizeof(*hdr);
  81. struct sk_buff *skb;
  82. skb = alloc_skb(hdr_len + data_len, GFP_KERNEL);
  83. if (!skb)
  84. return NULL;
  85. memcpy(skb_put(skb, hdr_len), hdr, hdr_len);
  86. memcpy(skb_put(skb, data_len), data, data_len);
  87. return skb;
  88. }
  89. #define mctp_test_create_skb_data(h, d) \
  90. __mctp_test_create_skb_data(h, d, sizeof(*d))
  91. struct mctp_frag_test {
  92. unsigned int mtu;
  93. unsigned int msgsize;
  94. unsigned int n_frags;
  95. };
  96. static void mctp_test_fragment(struct kunit *test)
  97. {
  98. const struct mctp_frag_test *params;
  99. int rc, i, n, mtu, msgsize;
  100. struct mctp_test_route *rt;
  101. struct sk_buff *skb;
  102. struct mctp_hdr hdr;
  103. u8 seq;
  104. params = test->param_value;
  105. mtu = params->mtu;
  106. msgsize = params->msgsize;
  107. hdr.ver = 1;
  108. hdr.src = 8;
  109. hdr.dest = 10;
  110. hdr.flags_seq_tag = MCTP_HDR_FLAG_TO;
  111. skb = mctp_test_create_skb(&hdr, msgsize);
  112. KUNIT_ASSERT_TRUE(test, skb);
  113. rt = mctp_test_create_route(&init_net, NULL, 10, mtu);
  114. KUNIT_ASSERT_TRUE(test, rt);
  115. rc = mctp_do_fragment_route(&rt->rt, skb, mtu, MCTP_TAG_OWNER);
  116. KUNIT_EXPECT_FALSE(test, rc);
  117. n = rt->pkts.qlen;
  118. KUNIT_EXPECT_EQ(test, n, params->n_frags);
  119. for (i = 0;; i++) {
  120. struct mctp_hdr *hdr2;
  121. struct sk_buff *skb2;
  122. u8 tag_mask, seq2;
  123. bool first, last;
  124. first = i == 0;
  125. last = i == (n - 1);
  126. skb2 = skb_dequeue(&rt->pkts);
  127. if (!skb2)
  128. break;
  129. hdr2 = mctp_hdr(skb2);
  130. tag_mask = MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO;
  131. KUNIT_EXPECT_EQ(test, hdr2->ver, hdr.ver);
  132. KUNIT_EXPECT_EQ(test, hdr2->src, hdr.src);
  133. KUNIT_EXPECT_EQ(test, hdr2->dest, hdr.dest);
  134. KUNIT_EXPECT_EQ(test, hdr2->flags_seq_tag & tag_mask,
  135. hdr.flags_seq_tag & tag_mask);
  136. KUNIT_EXPECT_EQ(test,
  137. !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_SOM), first);
  138. KUNIT_EXPECT_EQ(test,
  139. !!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_EOM), last);
  140. seq2 = (hdr2->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) &
  141. MCTP_HDR_SEQ_MASK;
  142. if (first) {
  143. seq = seq2;
  144. } else {
  145. seq++;
  146. KUNIT_EXPECT_EQ(test, seq2, seq & MCTP_HDR_SEQ_MASK);
  147. }
  148. if (!last)
  149. KUNIT_EXPECT_EQ(test, skb2->len, mtu);
  150. else
  151. KUNIT_EXPECT_LE(test, skb2->len, mtu);
  152. kfree_skb(skb2);
  153. }
  154. mctp_test_route_destroy(test, rt);
  155. }
  156. static const struct mctp_frag_test mctp_frag_tests[] = {
  157. {.mtu = 68, .msgsize = 63, .n_frags = 1},
  158. {.mtu = 68, .msgsize = 64, .n_frags = 1},
  159. {.mtu = 68, .msgsize = 65, .n_frags = 2},
  160. {.mtu = 68, .msgsize = 66, .n_frags = 2},
  161. {.mtu = 68, .msgsize = 127, .n_frags = 2},
  162. {.mtu = 68, .msgsize = 128, .n_frags = 2},
  163. {.mtu = 68, .msgsize = 129, .n_frags = 3},
  164. {.mtu = 68, .msgsize = 130, .n_frags = 3},
  165. };
  166. static void mctp_frag_test_to_desc(const struct mctp_frag_test *t, char *desc)
  167. {
  168. sprintf(desc, "mtu %d len %d -> %d frags",
  169. t->msgsize, t->mtu, t->n_frags);
  170. }
  171. KUNIT_ARRAY_PARAM(mctp_frag, mctp_frag_tests, mctp_frag_test_to_desc);
  172. struct mctp_rx_input_test {
  173. struct mctp_hdr hdr;
  174. bool input;
  175. };
  176. static void mctp_test_rx_input(struct kunit *test)
  177. {
  178. const struct mctp_rx_input_test *params;
  179. struct mctp_test_route *rt;
  180. struct mctp_test_dev *dev;
  181. struct sk_buff *skb;
  182. params = test->param_value;
  183. dev = mctp_test_create_dev();
  184. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
  185. rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
  186. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
  187. skb = mctp_test_create_skb(&params->hdr, 1);
  188. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
  189. __mctp_cb(skb);
  190. mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL);
  191. KUNIT_EXPECT_EQ(test, !!rt->pkts.qlen, params->input);
  192. mctp_test_route_destroy(test, rt);
  193. mctp_test_destroy_dev(dev);
  194. }
  195. #define RX_HDR(_ver, _src, _dest, _fst) \
  196. { .ver = _ver, .src = _src, .dest = _dest, .flags_seq_tag = _fst }
  197. /* we have a route for EID 8 only */
  198. static const struct mctp_rx_input_test mctp_rx_input_tests[] = {
  199. { .hdr = RX_HDR(1, 10, 8, 0), .input = true },
  200. { .hdr = RX_HDR(1, 10, 9, 0), .input = false }, /* no input route */
  201. { .hdr = RX_HDR(2, 10, 8, 0), .input = false }, /* invalid version */
  202. };
  203. static void mctp_rx_input_test_to_desc(const struct mctp_rx_input_test *t,
  204. char *desc)
  205. {
  206. sprintf(desc, "{%x,%x,%x,%x}", t->hdr.ver, t->hdr.src, t->hdr.dest,
  207. t->hdr.flags_seq_tag);
  208. }
  209. KUNIT_ARRAY_PARAM(mctp_rx_input, mctp_rx_input_tests,
  210. mctp_rx_input_test_to_desc);
  211. /* set up a local dev, route on EID 8, and a socket listening on type 0 */
  212. static void __mctp_route_test_init(struct kunit *test,
  213. struct mctp_test_dev **devp,
  214. struct mctp_test_route **rtp,
  215. struct socket **sockp)
  216. {
  217. struct sockaddr_mctp addr = {0};
  218. struct mctp_test_route *rt;
  219. struct mctp_test_dev *dev;
  220. struct socket *sock;
  221. int rc;
  222. dev = mctp_test_create_dev();
  223. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
  224. rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
  225. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
  226. rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
  227. KUNIT_ASSERT_EQ(test, rc, 0);
  228. addr.smctp_family = AF_MCTP;
  229. addr.smctp_network = MCTP_NET_ANY;
  230. addr.smctp_addr.s_addr = 8;
  231. addr.smctp_type = 0;
  232. rc = kernel_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
  233. KUNIT_ASSERT_EQ(test, rc, 0);
  234. *rtp = rt;
  235. *devp = dev;
  236. *sockp = sock;
  237. }
  238. static void __mctp_route_test_fini(struct kunit *test,
  239. struct mctp_test_dev *dev,
  240. struct mctp_test_route *rt,
  241. struct socket *sock)
  242. {
  243. sock_release(sock);
  244. mctp_test_route_destroy(test, rt);
  245. mctp_test_destroy_dev(dev);
  246. }
  247. struct mctp_route_input_sk_test {
  248. struct mctp_hdr hdr;
  249. u8 type;
  250. bool deliver;
  251. };
  252. static void mctp_test_route_input_sk(struct kunit *test)
  253. {
  254. const struct mctp_route_input_sk_test *params;
  255. struct sk_buff *skb, *skb2;
  256. struct mctp_test_route *rt;
  257. struct mctp_test_dev *dev;
  258. struct socket *sock;
  259. int rc;
  260. params = test->param_value;
  261. __mctp_route_test_init(test, &dev, &rt, &sock);
  262. skb = mctp_test_create_skb_data(&params->hdr, &params->type);
  263. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
  264. skb->dev = dev->ndev;
  265. __mctp_cb(skb);
  266. rc = mctp_route_input(&rt->rt, skb);
  267. if (params->deliver) {
  268. KUNIT_EXPECT_EQ(test, rc, 0);
  269. skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
  270. KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
  271. KUNIT_EXPECT_EQ(test, skb->len, 1);
  272. skb_free_datagram(sock->sk, skb2);
  273. } else {
  274. KUNIT_EXPECT_NE(test, rc, 0);
  275. skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
  276. KUNIT_EXPECT_NULL(test, skb2);
  277. }
  278. __mctp_route_test_fini(test, dev, rt, sock);
  279. }
  280. #define FL_S (MCTP_HDR_FLAG_SOM)
  281. #define FL_E (MCTP_HDR_FLAG_EOM)
  282. #define FL_TO (MCTP_HDR_FLAG_TO)
  283. #define FL_T(t) ((t) & MCTP_HDR_TAG_MASK)
  284. static const struct mctp_route_input_sk_test mctp_route_input_sk_tests[] = {
  285. { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 0, .deliver = true },
  286. { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO), .type = 1, .deliver = false },
  287. { .hdr = RX_HDR(1, 10, 8, FL_S | FL_E), .type = 0, .deliver = false },
  288. { .hdr = RX_HDR(1, 10, 8, FL_E | FL_TO), .type = 0, .deliver = false },
  289. { .hdr = RX_HDR(1, 10, 8, FL_TO), .type = 0, .deliver = false },
  290. { .hdr = RX_HDR(1, 10, 8, 0), .type = 0, .deliver = false },
  291. };
  292. static void mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test *t,
  293. char *desc)
  294. {
  295. sprintf(desc, "{%x,%x,%x,%x} type %d", t->hdr.ver, t->hdr.src,
  296. t->hdr.dest, t->hdr.flags_seq_tag, t->type);
  297. }
  298. KUNIT_ARRAY_PARAM(mctp_route_input_sk, mctp_route_input_sk_tests,
  299. mctp_route_input_sk_to_desc);
  300. struct mctp_route_input_sk_reasm_test {
  301. const char *name;
  302. struct mctp_hdr hdrs[4];
  303. int n_hdrs;
  304. int rx_len;
  305. };
  306. static void mctp_test_route_input_sk_reasm(struct kunit *test)
  307. {
  308. const struct mctp_route_input_sk_reasm_test *params;
  309. struct sk_buff *skb, *skb2;
  310. struct mctp_test_route *rt;
  311. struct mctp_test_dev *dev;
  312. struct socket *sock;
  313. int i, rc;
  314. u8 c;
  315. params = test->param_value;
  316. __mctp_route_test_init(test, &dev, &rt, &sock);
  317. for (i = 0; i < params->n_hdrs; i++) {
  318. c = i;
  319. skb = mctp_test_create_skb_data(&params->hdrs[i], &c);
  320. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
  321. skb->dev = dev->ndev;
  322. __mctp_cb(skb);
  323. rc = mctp_route_input(&rt->rt, skb);
  324. }
  325. skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
  326. if (params->rx_len) {
  327. KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
  328. KUNIT_EXPECT_EQ(test, skb2->len, params->rx_len);
  329. skb_free_datagram(sock->sk, skb2);
  330. } else {
  331. KUNIT_EXPECT_NULL(test, skb2);
  332. }
  333. __mctp_route_test_fini(test, dev, rt, sock);
  334. }
  335. #define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_TO | (f) | ((s) << MCTP_HDR_SEQ_SHIFT))
  336. static const struct mctp_route_input_sk_reasm_test mctp_route_input_sk_reasm_tests[] = {
  337. {
  338. .name = "single packet",
  339. .hdrs = {
  340. RX_FRAG(FL_S | FL_E, 0),
  341. },
  342. .n_hdrs = 1,
  343. .rx_len = 1,
  344. },
  345. {
  346. .name = "single packet, offset seq",
  347. .hdrs = {
  348. RX_FRAG(FL_S | FL_E, 1),
  349. },
  350. .n_hdrs = 1,
  351. .rx_len = 1,
  352. },
  353. {
  354. .name = "start & end packets",
  355. .hdrs = {
  356. RX_FRAG(FL_S, 0),
  357. RX_FRAG(FL_E, 1),
  358. },
  359. .n_hdrs = 2,
  360. .rx_len = 2,
  361. },
  362. {
  363. .name = "start & end packets, offset seq",
  364. .hdrs = {
  365. RX_FRAG(FL_S, 1),
  366. RX_FRAG(FL_E, 2),
  367. },
  368. .n_hdrs = 2,
  369. .rx_len = 2,
  370. },
  371. {
  372. .name = "start & end packets, out of order",
  373. .hdrs = {
  374. RX_FRAG(FL_E, 1),
  375. RX_FRAG(FL_S, 0),
  376. },
  377. .n_hdrs = 2,
  378. .rx_len = 0,
  379. },
  380. {
  381. .name = "start, middle & end packets",
  382. .hdrs = {
  383. RX_FRAG(FL_S, 0),
  384. RX_FRAG(0, 1),
  385. RX_FRAG(FL_E, 2),
  386. },
  387. .n_hdrs = 3,
  388. .rx_len = 3,
  389. },
  390. {
  391. .name = "missing seq",
  392. .hdrs = {
  393. RX_FRAG(FL_S, 0),
  394. RX_FRAG(FL_E, 2),
  395. },
  396. .n_hdrs = 2,
  397. .rx_len = 0,
  398. },
  399. {
  400. .name = "seq wrap",
  401. .hdrs = {
  402. RX_FRAG(FL_S, 3),
  403. RX_FRAG(FL_E, 0),
  404. },
  405. .n_hdrs = 2,
  406. .rx_len = 2,
  407. },
  408. };
  409. static void mctp_route_input_sk_reasm_to_desc(
  410. const struct mctp_route_input_sk_reasm_test *t,
  411. char *desc)
  412. {
  413. sprintf(desc, "%s", t->name);
  414. }
  415. KUNIT_ARRAY_PARAM(mctp_route_input_sk_reasm, mctp_route_input_sk_reasm_tests,
  416. mctp_route_input_sk_reasm_to_desc);
  417. struct mctp_route_input_sk_keys_test {
  418. const char *name;
  419. mctp_eid_t key_peer_addr;
  420. mctp_eid_t key_local_addr;
  421. u8 key_tag;
  422. struct mctp_hdr hdr;
  423. bool deliver;
  424. };
  425. /* test packet rx in the presence of various key configurations */
  426. static void mctp_test_route_input_sk_keys(struct kunit *test)
  427. {
  428. const struct mctp_route_input_sk_keys_test *params;
  429. struct mctp_test_route *rt;
  430. struct sk_buff *skb, *skb2;
  431. struct mctp_test_dev *dev;
  432. struct mctp_sk_key *key;
  433. struct netns_mctp *mns;
  434. struct mctp_sock *msk;
  435. struct socket *sock;
  436. unsigned long flags;
  437. int rc;
  438. u8 c;
  439. params = test->param_value;
  440. dev = mctp_test_create_dev();
  441. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
  442. rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
  443. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
  444. rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
  445. KUNIT_ASSERT_EQ(test, rc, 0);
  446. msk = container_of(sock->sk, struct mctp_sock, sk);
  447. mns = &sock_net(sock->sk)->mctp;
  448. /* set the incoming tag according to test params */
  449. key = mctp_key_alloc(msk, params->key_local_addr, params->key_peer_addr,
  450. params->key_tag, GFP_KERNEL);
  451. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, key);
  452. spin_lock_irqsave(&mns->keys_lock, flags);
  453. mctp_reserve_tag(&init_net, key, msk);
  454. spin_unlock_irqrestore(&mns->keys_lock, flags);
  455. /* create packet and route */
  456. c = 0;
  457. skb = mctp_test_create_skb_data(&params->hdr, &c);
  458. KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
  459. skb->dev = dev->ndev;
  460. __mctp_cb(skb);
  461. rc = mctp_route_input(&rt->rt, skb);
  462. /* (potentially) receive message */
  463. skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc);
  464. if (params->deliver)
  465. KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
  466. else
  467. KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
  468. if (skb2)
  469. skb_free_datagram(sock->sk, skb2);
  470. mctp_key_unref(key);
  471. __mctp_route_test_fini(test, dev, rt, sock);
  472. }
  473. static const struct mctp_route_input_sk_keys_test mctp_route_input_sk_keys_tests[] = {
  474. {
  475. .name = "direct match",
  476. .key_peer_addr = 9,
  477. .key_local_addr = 8,
  478. .key_tag = 1,
  479. .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)),
  480. .deliver = true,
  481. },
  482. {
  483. .name = "flipped src/dest",
  484. .key_peer_addr = 8,
  485. .key_local_addr = 9,
  486. .key_tag = 1,
  487. .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1)),
  488. .deliver = false,
  489. },
  490. {
  491. .name = "peer addr mismatch",
  492. .key_peer_addr = 9,
  493. .key_local_addr = 8,
  494. .key_tag = 1,
  495. .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T(1)),
  496. .deliver = false,
  497. },
  498. {
  499. .name = "tag value mismatch",
  500. .key_peer_addr = 9,
  501. .key_local_addr = 8,
  502. .key_tag = 1,
  503. .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(2)),
  504. .deliver = false,
  505. },
  506. {
  507. .name = "TO mismatch",
  508. .key_peer_addr = 9,
  509. .key_local_addr = 8,
  510. .key_tag = 1,
  511. .hdr = RX_HDR(1, 9, 8, FL_S | FL_E | FL_T(1) | FL_TO),
  512. .deliver = false,
  513. },
  514. {
  515. .name = "broadcast response",
  516. .key_peer_addr = MCTP_ADDR_ANY,
  517. .key_local_addr = 8,
  518. .key_tag = 1,
  519. .hdr = RX_HDR(1, 11, 8, FL_S | FL_E | FL_T(1)),
  520. .deliver = true,
  521. },
  522. {
  523. .name = "any local match",
  524. .key_peer_addr = 12,
  525. .key_local_addr = MCTP_ADDR_ANY,
  526. .key_tag = 1,
  527. .hdr = RX_HDR(1, 12, 8, FL_S | FL_E | FL_T(1)),
  528. .deliver = true,
  529. },
  530. };
  531. static void mctp_route_input_sk_keys_to_desc(
  532. const struct mctp_route_input_sk_keys_test *t,
  533. char *desc)
  534. {
  535. sprintf(desc, "%s", t->name);
  536. }
  537. KUNIT_ARRAY_PARAM(mctp_route_input_sk_keys, mctp_route_input_sk_keys_tests,
  538. mctp_route_input_sk_keys_to_desc);
  539. static struct kunit_case mctp_test_cases[] = {
  540. KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params),
  541. KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params),
  542. KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params),
  543. KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm,
  544. mctp_route_input_sk_reasm_gen_params),
  545. KUNIT_CASE_PARAM(mctp_test_route_input_sk_keys,
  546. mctp_route_input_sk_keys_gen_params),
  547. {}
  548. };
  549. static struct kunit_suite mctp_test_suite = {
  550. .name = "mctp",
  551. .test_cases = mctp_test_cases,
  552. };
  553. kunit_test_suite(mctp_test_suite);