net: mctp: test: move TX packetqueue from dst to dev

+40 -69

net/mctp/test/route-test.c

··· 20 20 static void mctp_test_fragment(struct kunit *test) 21 21 { 22 22 const struct mctp_frag_test *params; 23 - struct mctp_test_pktqueue tpq; 24 23 int rc, i, n, mtu, msgsize; 25 24 struct mctp_test_dev *dev; 26 25 struct mctp_dst dst; ··· 42 43 dev = mctp_test_create_dev(); 43 44 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 44 45 45 - mctp_test_dst_setup(test, &dst, dev, &tpq, mtu); 46 + mctp_test_dst_setup(test, &dst, dev, mtu); 46 47 47 48 rc = mctp_do_fragment_route(&dst, skb, mtu, MCTP_TAG_OWNER); 48 49 KUNIT_EXPECT_FALSE(test, rc); 49 50 50 - n = tpq.pkts.qlen; 51 - 51 + n = dev->pkts.qlen; 52 52 KUNIT_EXPECT_EQ(test, n, params->n_frags); 53 53 54 54 for (i = 0;; i++) { ··· 59 61 first = i == 0; 60 62 last = i == (n - 1); 61 63 62 - skb2 = skb_dequeue(&tpq.pkts); 63 - 64 + skb2 = skb_dequeue(&dev->pkts); 64 65 if (!skb2) 65 66 break; 66 67 ··· 96 99 kfree_skb(skb2); 97 100 } 98 101 99 - mctp_test_dst_release(&dst, &tpq); 102 + mctp_dst_release(&dst); 100 103 mctp_test_destroy_dev(dev); 101 104 } 102 105 ··· 127 130 static void mctp_test_rx_input(struct kunit *test) 128 131 { 129 132 const struct mctp_rx_input_test *params; 130 - struct mctp_test_pktqueue tpq; 131 133 struct mctp_test_route *rt; 132 134 struct mctp_test_dev *dev; 133 135 struct sk_buff *skb; 134 136 135 137 params = test->param_value; 136 - test->priv = &tpq; 137 138 138 139 dev = mctp_test_create_dev(); 139 140 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); ··· 142 147 skb = mctp_test_create_skb(&params->hdr, 1); 143 148 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 144 149 145 - mctp_test_pktqueue_init(&tpq); 146 - 147 150 mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL); 148 151 149 - KUNIT_EXPECT_EQ(test, !!tpq.pkts.qlen, params->input); 152 + KUNIT_EXPECT_EQ(test, !!dev->pkts.qlen, params->input); 150 153 151 - skb_queue_purge(&tpq.pkts); 152 154 mctp_test_route_destroy(test, rt); 153 155 mctp_test_destroy_dev(dev); 154 156 } ··· 174 182 static void __mctp_route_test_init(struct kunit *test, 175 183 struct mctp_test_dev **devp, 176 184 struct mctp_dst *dst, 177 - struct mctp_test_pktqueue *tpq, 178 185 struct socket **sockp, 179 186 unsigned int netid) 180 187 { ··· 187 196 if (netid != MCTP_NET_ANY) 188 197 WRITE_ONCE(dev->mdev->net, netid); 189 198 190 - mctp_test_dst_setup(test, dst, dev, tpq, 68); 199 + mctp_test_dst_setup(test, dst, dev, 68); 191 200 192 201 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 193 202 KUNIT_ASSERT_EQ(test, rc, 0); ··· 206 215 static void __mctp_route_test_fini(struct kunit *test, 207 216 struct mctp_test_dev *dev, 208 217 struct mctp_dst *dst, 209 - struct mctp_test_pktqueue *tpq, 210 218 struct socket *sock) 211 219 { 212 220 sock_release(sock); 213 - mctp_test_dst_release(dst, tpq); 221 + mctp_dst_release(dst); 214 222 mctp_test_destroy_dev(dev); 215 223 } 216 224 ··· 222 232 static void mctp_test_route_input_sk(struct kunit *test) 223 233 { 224 234 const struct mctp_route_input_sk_test *params; 225 - struct mctp_test_pktqueue tpq; 226 235 struct sk_buff *skb, *skb2; 227 236 struct mctp_test_dev *dev; 228 237 struct mctp_dst dst; ··· 230 241 231 242 params = test->param_value; 232 243 233 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock, MCTP_NET_ANY); 244 + __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 234 245 235 246 skb = mctp_test_create_skb_data(&params->hdr, &params->type); 236 247 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); 237 248 238 249 mctp_test_skb_set_dev(skb, dev); 239 - mctp_test_pktqueue_init(&tpq); 240 250 241 251 rc = mctp_dst_input(&dst, skb); 242 252 ··· 254 266 KUNIT_EXPECT_NULL(test, skb2); 255 267 } 256 268 257 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 269 + __mctp_route_test_fini(test, dev, &dst, sock); 258 270 } 259 271 260 272 #define FL_S (MCTP_HDR_FLAG_SOM) ··· 291 303 static void mctp_test_route_input_sk_reasm(struct kunit *test) 292 304 { 293 305 const struct mctp_route_input_sk_reasm_test *params; 294 - struct mctp_test_pktqueue tpq; 295 306 struct sk_buff *skb, *skb2; 296 307 struct mctp_test_dev *dev; 297 308 struct mctp_dst dst; ··· 300 313 301 314 params = test->param_value; 302 315 303 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock, MCTP_NET_ANY); 316 + __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 304 317 305 318 for (i = 0; i < params->n_hdrs; i++) { 306 319 c = i; ··· 323 336 KUNIT_EXPECT_NULL(test, skb2); 324 337 } 325 338 326 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 339 + __mctp_route_test_fini(test, dev, &dst, sock); 327 340 } 328 341 329 342 #define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_TO | (f) | ((s) << MCTP_HDR_SEQ_SHIFT)) ··· 425 438 static void mctp_test_route_input_sk_keys(struct kunit *test) 426 439 { 427 440 const struct mctp_route_input_sk_keys_test *params; 428 - struct mctp_test_pktqueue tpq; 429 441 struct sk_buff *skb, *skb2; 430 442 struct mctp_test_dev *dev; 431 443 struct mctp_sk_key *key; ··· 443 457 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 444 458 net = READ_ONCE(dev->mdev->net); 445 459 446 - mctp_test_dst_setup(test, &dst, dev, &tpq, 68); 460 + mctp_test_dst_setup(test, &dst, dev, 68); 447 461 448 462 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 449 463 KUNIT_ASSERT_EQ(test, rc, 0); ··· 483 497 skb_free_datagram(sock->sk, skb2); 484 498 485 499 mctp_key_unref(key); 486 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 500 + __mctp_route_test_fini(test, dev, &dst, sock); 487 501 } 488 502 489 503 static const struct mctp_route_input_sk_keys_test mctp_route_input_sk_keys_tests[] = { ··· 558 572 struct test_net { 559 573 unsigned int netid; 560 574 struct mctp_test_dev *dev; 561 - struct mctp_test_pktqueue tpq; 562 575 struct mctp_dst dst; 563 576 struct socket *sock; 564 577 struct sk_buff *skb; ··· 576 591 577 592 t->msg.data = t->netid; 578 593 579 - __mctp_route_test_init(test, &t->dev, &t->dst, &t->tpq, &t->sock, 580 - t->netid); 594 + __mctp_route_test_init(test, &t->dev, &t->dst, &t->sock, t->netid); 581 595 582 596 t->skb = mctp_test_create_skb_data(&hdr, &t->msg); 583 597 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, t->skb); 584 598 mctp_test_skb_set_dev(t->skb, t->dev); 585 - mctp_test_pktqueue_init(&t->tpq); 586 599 } 587 600 588 601 static void 589 602 mctp_test_route_input_multiple_nets_bind_fini(struct kunit *test, 590 603 struct test_net *t) 591 604 { 592 - __mctp_route_test_fini(test, t->dev, &t->dst, &t->tpq, t->sock); 605 + __mctp_route_test_fini(test, t->dev, &t->dst, t->sock); 593 606 } 594 607 595 608 /* Test that skbs from different nets (otherwise identical) get routed to their ··· 644 661 645 662 t->msg.data = t->netid; 646 663 647 - __mctp_route_test_init(test, &t->dev, &t->dst, &t->tpq, &t->sock, 648 - t->netid); 664 + __mctp_route_test_init(test, &t->dev, &t->dst, &t->sock, t->netid); 649 665 650 666 msk = container_of(t->sock->sk, struct mctp_sock, sk); 651 667 ··· 667 685 struct test_net *t) 668 686 { 669 687 mctp_key_unref(t->key); 670 - __mctp_route_test_fini(test, t->dev, &t->dst, &t->tpq, t->sock); 688 + __mctp_route_test_fini(test, t->dev, &t->dst, t->sock); 671 689 } 672 690 673 691 /* test that skbs from different nets (otherwise identical) get routed to their ··· 720 738 static void mctp_test_route_input_sk_fail_single(struct kunit *test) 721 739 { 722 740 const struct mctp_hdr hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_TO); 723 - struct mctp_test_pktqueue tpq; 724 741 struct mctp_test_dev *dev; 725 742 struct mctp_dst dst; 726 743 struct socket *sock; 727 744 struct sk_buff *skb; 728 745 int rc; 729 746 730 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock, MCTP_NET_ANY); 747 + __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 731 748 732 749 /* No rcvbuf space, so delivery should fail. __sock_set_rcvbuf will 733 750 * clamp the minimum to SOCK_MIN_RCVBUF, so we open-code this. ··· 749 768 KUNIT_EXPECT_EQ(test, refcount_read(&skb->users), 1); 750 769 kfree_skb(skb); 751 770 752 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 771 + __mctp_route_test_fini(test, dev, &dst, sock); 753 772 } 754 773 755 774 /* Input route to socket, using a fragmented message, where sock delivery fails. ··· 757 776 static void mctp_test_route_input_sk_fail_frag(struct kunit *test) 758 777 { 759 778 const struct mctp_hdr hdrs[2] = { RX_FRAG(FL_S, 0), RX_FRAG(FL_E, 1) }; 760 - struct mctp_test_pktqueue tpq; 761 779 struct mctp_test_dev *dev; 762 780 struct sk_buff *skbs[2]; 763 781 struct mctp_dst dst; ··· 764 784 unsigned int i; 765 785 int rc; 766 786 767 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock, MCTP_NET_ANY); 787 + __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 768 788 769 789 lock_sock(sock->sk); 770 790 WRITE_ONCE(sock->sk->sk_rcvbuf, 0); ··· 795 815 KUNIT_EXPECT_EQ(test, refcount_read(&skbs[1]->users), 1); 796 816 kfree_skb(skbs[1]); 797 817 798 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 818 + __mctp_route_test_fini(test, dev, &dst, sock); 799 819 } 800 820 801 821 /* Input route to socket, using a fragmented message created from clones. ··· 813 833 const size_t data_len = 3; /* arbitrary */ 814 834 u8 compare[3 * ARRAY_SIZE(hdrs)]; 815 835 u8 flat[3 * ARRAY_SIZE(hdrs)]; 816 - struct mctp_test_pktqueue tpq; 817 836 struct mctp_test_dev *dev; 818 837 struct sk_buff *skb[5]; 819 838 struct sk_buff *rx_skb; ··· 824 845 825 846 total = data_len + sizeof(struct mctp_hdr); 826 847 827 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock, MCTP_NET_ANY); 848 + __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 828 849 829 850 /* Create a single skb initially with concatenated packets */ 830 851 skb[0] = mctp_test_create_skb(&hdrs[0], 5 * total); ··· 901 922 kfree_skb(skb[i]); 902 923 } 903 924 904 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 925 + __mctp_route_test_fini(test, dev, &dst, sock); 905 926 } 906 927 907 928 #if IS_ENABLED(CONFIG_MCTP_FLOWS) ··· 909 930 static void mctp_test_flow_init(struct kunit *test, 910 931 struct mctp_test_dev **devp, 911 932 struct mctp_dst *dst, 912 - struct mctp_test_pktqueue *tpq, 913 933 struct socket **sock, 914 934 struct sk_buff **skbp, 915 935 unsigned int len) ··· 922 944 * mctp_local_output, which will call dst->output on whatever 923 945 * route we provide 924 946 */ 925 - __mctp_route_test_init(test, &dev, dst, tpq, sock, MCTP_NET_ANY); 947 + __mctp_route_test_init(test, &dev, dst, sock, MCTP_NET_ANY); 926 948 927 949 /* Assign a single EID. ->addrs is freed on mctp netdev release */ 928 950 dev->mdev->addrs = kmalloc(sizeof(u8), GFP_KERNEL); ··· 943 965 static void mctp_test_flow_fini(struct kunit *test, 944 966 struct mctp_test_dev *dev, 945 967 struct mctp_dst *dst, 946 - struct mctp_test_pktqueue *tpq, 947 968 struct socket *sock) 948 969 { 949 - __mctp_route_test_fini(test, dev, dst, tpq, sock); 970 + __mctp_route_test_fini(test, dev, dst, sock); 950 971 } 951 972 952 973 /* test that an outgoing skb has the correct MCTP extension data set */ 953 974 static void mctp_test_packet_flow(struct kunit *test) 954 975 { 955 - struct mctp_test_pktqueue tpq; 956 976 struct sk_buff *skb, *skb2; 957 977 struct mctp_test_dev *dev; 958 978 struct mctp_dst dst; ··· 959 983 u8 dst_eid = 8; 960 984 int n, rc; 961 985 962 - mctp_test_flow_init(test, &dev, &dst, &tpq, &sock, &skb, 30); 986 + mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 30); 963 987 964 988 rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER); 965 989 KUNIT_ASSERT_EQ(test, rc, 0); 966 990 967 - n = tpq.pkts.qlen; 991 + n = dev->pkts.qlen; 968 992 KUNIT_ASSERT_EQ(test, n, 1); 969 993 970 - skb2 = skb_dequeue(&tpq.pkts); 994 + skb2 = skb_dequeue(&dev->pkts); 971 995 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb2); 972 996 973 997 flow = skb_ext_find(skb2, SKB_EXT_MCTP); ··· 976 1000 KUNIT_ASSERT_PTR_EQ(test, flow->key->sk, sock->sk); 977 1001 978 1002 kfree_skb(skb2); 979 - mctp_test_flow_fini(test, dev, &dst, &tpq, sock); 1003 + mctp_test_flow_fini(test, dev, &dst, sock); 980 1004 } 981 1005 982 1006 /* test that outgoing skbs, after fragmentation, all have the correct MCTP ··· 984 1008 */ 985 1009 static void mctp_test_fragment_flow(struct kunit *test) 986 1010 { 987 - struct mctp_test_pktqueue tpq; 988 1011 struct mctp_flow *flows[2]; 989 1012 struct sk_buff *tx_skbs[2]; 990 1013 struct mctp_test_dev *dev; ··· 993 1018 u8 dst_eid = 8; 994 1019 int n, rc; 995 1020 996 - mctp_test_flow_init(test, &dev, &dst, &tpq, &sock, &skb, 100); 1021 + mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 100); 997 1022 998 1023 rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER); 999 1024 KUNIT_ASSERT_EQ(test, rc, 0); 1000 1025 1001 - n = tpq.pkts.qlen; 1026 + n = dev->pkts.qlen; 1002 1027 KUNIT_ASSERT_EQ(test, n, 2); 1003 1028 1004 1029 /* both resulting packets should have the same flow data */ 1005 - tx_skbs[0] = skb_dequeue(&tpq.pkts); 1006 - tx_skbs[1] = skb_dequeue(&tpq.pkts); 1030 + tx_skbs[0] = skb_dequeue(&dev->pkts); 1031 + tx_skbs[1] = skb_dequeue(&dev->pkts); 1007 1032 1008 1033 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[0]); 1009 1034 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tx_skbs[1]); ··· 1019 1044 1020 1045 kfree_skb(tx_skbs[0]); 1021 1046 kfree_skb(tx_skbs[1]); 1022 - mctp_test_flow_fini(test, dev, &dst, &tpq, sock); 1047 + mctp_test_flow_fini(test, dev, &dst, sock); 1023 1048 } 1024 1049 1025 1050 #else ··· 1038 1063 static void mctp_test_route_output_key_create(struct kunit *test) 1039 1064 { 1040 1065 const u8 dst_eid = 26, src_eid = 15; 1041 - struct mctp_test_pktqueue tpq; 1042 1066 const unsigned int netid = 50; 1043 1067 struct mctp_test_dev *dev; 1044 1068 struct mctp_sk_key *key; ··· 1054 1080 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 1055 1081 WRITE_ONCE(dev->mdev->net, netid); 1056 1082 1057 - mctp_test_dst_setup(test, &dst, dev, &tpq, 68); 1083 + mctp_test_dst_setup(test, &dst, dev, 68); 1058 1084 1059 1085 rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock); 1060 1086 KUNIT_ASSERT_EQ(test, rc, 0); ··· 1101 1127 KUNIT_EXPECT_FALSE(test, key->tag & MCTP_TAG_OWNER); 1102 1128 1103 1129 sock_release(sock); 1104 - mctp_test_dst_release(&dst, &tpq); 1130 + mctp_dst_release(&dst); 1105 1131 mctp_test_destroy_dev(dev); 1106 1132 } 1107 1133 1108 1134 static void mctp_test_route_extaddr_input(struct kunit *test) 1109 1135 { 1110 1136 static const unsigned char haddr[] = { 0xaa, 0x55 }; 1111 - struct mctp_test_pktqueue tpq; 1112 1137 struct mctp_skb_cb *cb, *cb2; 1113 1138 const unsigned int len = 40; 1114 1139 struct mctp_test_dev *dev; ··· 1122 1149 hdr.dest = 8; 1123 1150 hdr.flags_seq_tag = FL_S | FL_E | FL_TO; 1124 1151 1125 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock, MCTP_NET_ANY); 1152 + __mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY); 1126 1153 1127 1154 skb = mctp_test_create_skb(&hdr, len); 1128 1155 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb); ··· 1151 1178 KUNIT_EXPECT_MEMEQ(test, cb2->haddr, haddr, sizeof(haddr)); 1152 1179 1153 1180 kfree_skb(skb2); 1154 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock); 1181 + __mctp_route_test_fini(test, dev, &dst, sock); 1155 1182 } 1156 1183 1157 1184 static void mctp_test_route_gw_lookup(struct kunit *test) ··· 1503 1530 struct socket *socks[ARRAY_SIZE(lookup_binds)]; 1504 1531 struct sk_buff *skb_pkt = NULL, *skb_sock = NULL; 1505 1532 struct socket *sock_ty0, *sock_expect = NULL; 1506 - struct mctp_test_pktqueue tpq; 1507 1533 struct mctp_test_dev *dev; 1508 1534 struct mctp_dst dst; 1509 1535 int rc; 1510 1536 1511 1537 rx = test->param_value; 1512 1538 1513 - __mctp_route_test_init(test, &dev, &dst, &tpq, &sock_ty0, rx->net); 1539 + __mctp_route_test_init(test, &dev, &dst, &sock_ty0, rx->net); 1514 1540 /* Create all binds */ 1515 1541 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) { 1516 1542 mctp_test_bind_run(test, &lookup_binds[i], ··· 1529 1557 skb_pkt = mctp_test_create_skb_data(&rx->hdr, &rx->ty); 1530 1558 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb_pkt); 1531 1559 mctp_test_skb_set_dev(skb_pkt, dev); 1532 - mctp_test_pktqueue_init(&tpq); 1533 1560 1534 1561 rc = mctp_dst_input(&dst, skb_pkt); 1535 1562 if (rx->expect) { ··· 1562 1591 for (size_t i = 0; i < ARRAY_SIZE(lookup_binds); i++) 1563 1592 sock_release(socks[i]); 1564 1593 1565 - __mctp_route_test_fini(test, dev, &dst, &tpq, sock_ty0); 1594 + __mctp_route_test_fini(test, dev, &dst, sock_ty0); 1566 1595 } 1567 1596 1568 1597 static struct kunit_case mctp_test_cases[] = {

+16 -29

net/mctp/test/utils.c

··· 13 13 static netdev_tx_t mctp_test_dev_tx(struct sk_buff *skb, 14 14 struct net_device *ndev) 15 15 { 16 - kfree_skb(skb); 16 + struct mctp_test_dev *dev = netdev_priv(ndev); 17 + 18 + skb_queue_tail(&dev->pkts, skb); 19 + 17 20 return NETDEV_TX_OK; 18 21 } 19 22 ··· 29 26 ndev->type = ARPHRD_MCTP; 30 27 ndev->mtu = MCTP_DEV_TEST_MTU; 31 28 ndev->hard_header_len = 0; 32 - ndev->tx_queue_len = DEFAULT_TX_QUEUE_LEN; 29 + ndev->tx_queue_len = 0; 33 30 ndev->flags = IFF_NOARP; 34 31 ndev->netdev_ops = &mctp_test_netdev_ops; 35 32 ndev->needs_free_netdev = true; ··· 54 51 dev->ndev = ndev; 55 52 ndev->addr_len = lladdr_len; 56 53 dev_addr_set(ndev, lladdr); 54 + skb_queue_head_init(&dev->pkts); 57 55 58 56 rc = register_netdev(ndev); 59 57 if (rc) { ··· 66 62 dev->mdev = __mctp_dev_get(ndev); 67 63 dev->mdev->net = mctp_default_net(dev_net(ndev)); 68 64 rcu_read_unlock(); 65 + 66 + /* bring the device up; we want to be able to TX immediately */ 67 + rtnl_lock(); 68 + dev_open(ndev, NULL); 69 + rtnl_unlock(); 69 70 70 71 return dev; 71 72 } ··· 88 79 89 80 void mctp_test_destroy_dev(struct mctp_test_dev *dev) 90 81 { 82 + skb_queue_purge(&dev->pkts); 91 83 mctp_dev_put(dev->mdev); 92 84 unregister_netdev(dev->ndev); 93 85 } 94 86 95 - static const unsigned int test_pktqueue_magic = 0x5f713aef; 96 - 97 - void mctp_test_pktqueue_init(struct mctp_test_pktqueue *tpq) 98 - { 99 - tpq->magic = test_pktqueue_magic; 100 - skb_queue_head_init(&tpq->pkts); 101 - } 102 - 103 87 static int mctp_test_dst_output(struct mctp_dst *dst, struct sk_buff *skb) 104 88 { 105 - struct kunit *test = current->kunit_test; 106 - struct mctp_test_pktqueue *tpq = test->priv; 107 - 108 - KUNIT_ASSERT_EQ(test, tpq->magic, test_pktqueue_magic); 109 - 110 - skb_queue_tail(&tpq->pkts, skb); 89 + skb->dev = dst->dev->dev; 90 + dev_queue_xmit(skb); 111 91 112 92 return 0; 113 93 } ··· 167 169 return rt; 168 170 } 169 171 170 - /* Convenience function for our test dst; release with mctp_test_dst_release() 171 - */ 172 + /* Convenience function for our test dst; release with mctp_dst_release() */ 172 173 void mctp_test_dst_setup(struct kunit *test, struct mctp_dst *dst, 173 - struct mctp_test_dev *dev, 174 - struct mctp_test_pktqueue *tpq, unsigned int mtu) 174 + struct mctp_test_dev *dev, unsigned int mtu) 175 175 { 176 176 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, dev); 177 177 ··· 179 183 __mctp_dev_get(dst->dev->dev); 180 184 dst->mtu = mtu; 181 185 dst->output = mctp_test_dst_output; 182 - mctp_test_pktqueue_init(tpq); 183 - test->priv = tpq; 184 - } 185 - 186 - void mctp_test_dst_release(struct mctp_dst *dst, 187 - struct mctp_test_pktqueue *tpq) 188 - { 189 - mctp_dst_release(dst); 190 - skb_queue_purge(&tpq->pkts); 191 186 } 192 187 193 188 void mctp_test_route_destroy(struct kunit *test, struct mctp_test_route *rt)

+3 -10

net/mctp/test/utils.h

··· 18 18 19 19 unsigned short lladdr_len; 20 20 unsigned char lladdr[MAX_ADDR_LEN]; 21 + 22 + struct sk_buff_head pkts; 21 23 }; 22 24 23 25 struct mctp_test_dev; 24 26 25 27 struct mctp_test_route { 26 28 struct mctp_route rt; 27 - }; 28 - 29 - struct mctp_test_pktqueue { 30 - unsigned int magic; 31 - struct sk_buff_head pkts; 32 29 }; 33 30 34 31 struct mctp_test_bind_setup { ··· 56 59 mctp_eid_t gw, 57 60 unsigned int mtu); 58 61 void mctp_test_dst_setup(struct kunit *test, struct mctp_dst *dst, 59 - struct mctp_test_dev *dev, 60 - struct mctp_test_pktqueue *tpq, unsigned int mtu); 61 - void mctp_test_dst_release(struct mctp_dst *dst, 62 - struct mctp_test_pktqueue *tpq); 63 - void mctp_test_pktqueue_init(struct mctp_test_pktqueue *tpq); 62 + struct mctp_test_dev *dev, unsigned int mtu); 64 63 void mctp_test_route_destroy(struct kunit *test, struct mctp_test_route *rt); 65 64 void mctp_test_skb_set_dev(struct sk_buff *skb, struct mctp_test_dev *dev); 66 65 struct sk_buff *mctp_test_create_skb(const struct mctp_hdr *hdr,

Configure Feed

Configure Feed