forked from Minki/linux
Revert "Merge branch 'mctp-kunit-tests'"
This reverts commit4f42ad2011, reversing changes made toea2dd331bf. These chanfges break the build when mctp is modular. Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
parent
bfaf03935f
commit
b022f8866e
@ -11,8 +11,3 @@ menuconfig MCTP
|
|||||||
This option enables core MCTP support. For communicating with other
|
This option enables core MCTP support. For communicating with other
|
||||||
devices, you'll want to enable a driver for a specific hardware
|
devices, you'll want to enable a driver for a specific hardware
|
||||||
channel.
|
channel.
|
||||||
|
|
||||||
config MCTP_TEST
|
|
||||||
tristate "MCTP core tests" if !KUNIT_ALL_TESTS
|
|
||||||
depends on MCTP && KUNIT
|
|
||||||
default KUNIT_ALL_TESTS
|
|
||||||
|
|||||||
@ -1,6 +1,3 @@
|
|||||||
# SPDX-License-Identifier: GPL-2.0
|
# SPDX-License-Identifier: GPL-2.0
|
||||||
obj-$(CONFIG_MCTP) += mctp.o
|
obj-$(CONFIG_MCTP) += mctp.o
|
||||||
mctp-objs := af_mctp.o device.o route.o neigh.o
|
mctp-objs := af_mctp.o device.o route.o neigh.o
|
||||||
|
|
||||||
# tests
|
|
||||||
obj-$(CONFIG_MCTP_TEST) += test/utils.o
|
|
||||||
|
|||||||
@ -11,7 +11,6 @@
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
#include <linux/idr.h>
|
#include <linux/idr.h>
|
||||||
#include <linux/kconfig.h>
|
|
||||||
#include <linux/mctp.h>
|
#include <linux/mctp.h>
|
||||||
#include <linux/netdevice.h>
|
#include <linux/netdevice.h>
|
||||||
#include <linux/rtnetlink.h>
|
#include <linux/rtnetlink.h>
|
||||||
@ -1229,7 +1228,3 @@ void __exit mctp_routes_exit(void)
|
|||||||
rtnl_unregister(PF_MCTP, RTM_GETROUTE);
|
rtnl_unregister(PF_MCTP, RTM_GETROUTE);
|
||||||
dev_remove_pack(&mctp_packet_type);
|
dev_remove_pack(&mctp_packet_type);
|
||||||
}
|
}
|
||||||
|
|
||||||
#if IS_ENABLED(CONFIG_MCTP_TEST)
|
|
||||||
#include "test/route-test.c"
|
|
||||||
#endif
|
|
||||||
|
|||||||
@ -1,532 +0,0 @@
|
|||||||
// SPDX-License-Identifier: GPL-2.0
|
|
||||||
|
|
||||||
#include <kunit/test.h>
|
|
||||||
|
|
||||||
#include "utils.h"
|
|
||||||
|
|
||||||
struct mctp_test_route {
|
|
||||||
struct mctp_route rt;
|
|
||||||
struct sk_buff_head pkts;
|
|
||||||
};
|
|
||||||
|
|
||||||
static int mctp_test_route_output(struct mctp_route *rt, struct sk_buff *skb)
|
|
||||||
{
|
|
||||||
struct mctp_test_route *test_rt = container_of(rt, struct mctp_test_route, rt);
|
|
||||||
|
|
||||||
skb_queue_tail(&test_rt->pkts, skb);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* local version of mctp_route_alloc() */
|
|
||||||
static struct mctp_test_route *mctp_route_test_alloc(void)
|
|
||||||
{
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
|
|
||||||
rt = kzalloc(sizeof(*rt), GFP_KERNEL);
|
|
||||||
if (!rt)
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
INIT_LIST_HEAD(&rt->rt.list);
|
|
||||||
refcount_set(&rt->rt.refs, 1);
|
|
||||||
rt->rt.output = mctp_test_route_output;
|
|
||||||
|
|
||||||
skb_queue_head_init(&rt->pkts);
|
|
||||||
|
|
||||||
return rt;
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct mctp_test_route *mctp_test_create_route(struct net *net,
|
|
||||||
struct mctp_dev *dev,
|
|
||||||
mctp_eid_t eid,
|
|
||||||
unsigned int mtu)
|
|
||||||
{
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
|
|
||||||
rt = mctp_route_test_alloc();
|
|
||||||
if (!rt)
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
rt->rt.min = eid;
|
|
||||||
rt->rt.max = eid;
|
|
||||||
rt->rt.mtu = mtu;
|
|
||||||
rt->rt.type = RTN_UNSPEC;
|
|
||||||
if (dev)
|
|
||||||
mctp_dev_hold(dev);
|
|
||||||
rt->rt.dev = dev;
|
|
||||||
|
|
||||||
list_add_rcu(&rt->rt.list, &net->mctp.routes);
|
|
||||||
|
|
||||||
return rt;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void mctp_test_route_destroy(struct mctp_test_route *rt)
|
|
||||||
{
|
|
||||||
rtnl_lock();
|
|
||||||
list_del_rcu(&rt->rt.list);
|
|
||||||
rtnl_unlock();
|
|
||||||
|
|
||||||
skb_queue_purge(&rt->pkts);
|
|
||||||
if (rt->rt.dev)
|
|
||||||
mctp_dev_put(rt->rt.dev);
|
|
||||||
|
|
||||||
kfree_rcu(&rt->rt, rcu);
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct sk_buff *mctp_test_create_skb(const struct mctp_hdr *hdr,
|
|
||||||
unsigned int data_len)
|
|
||||||
{
|
|
||||||
size_t hdr_len = sizeof(*hdr);
|
|
||||||
struct sk_buff *skb;
|
|
||||||
unsigned int i;
|
|
||||||
u8 *buf;
|
|
||||||
|
|
||||||
skb = alloc_skb(hdr_len + data_len, GFP_KERNEL);
|
|
||||||
if (!skb)
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
memcpy(skb_put(skb, hdr_len), hdr, hdr_len);
|
|
||||||
|
|
||||||
buf = skb_put(skb, data_len);
|
|
||||||
for (i = 0; i < data_len; i++)
|
|
||||||
buf[i] = i & 0xff;
|
|
||||||
|
|
||||||
return skb;
|
|
||||||
}
|
|
||||||
|
|
||||||
static struct sk_buff *__mctp_test_create_skb_data(const struct mctp_hdr *hdr,
|
|
||||||
const void *data,
|
|
||||||
size_t data_len)
|
|
||||||
{
|
|
||||||
size_t hdr_len = sizeof(*hdr);
|
|
||||||
struct sk_buff *skb;
|
|
||||||
|
|
||||||
skb = alloc_skb(hdr_len + data_len, GFP_KERNEL);
|
|
||||||
if (!skb)
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
memcpy(skb_put(skb, hdr_len), hdr, hdr_len);
|
|
||||||
memcpy(skb_put(skb, data_len), data, data_len);
|
|
||||||
|
|
||||||
return skb;
|
|
||||||
}
|
|
||||||
|
|
||||||
#define mctp_test_create_skb_data(h, d) \
|
|
||||||
__mctp_test_create_skb_data(h, d, sizeof(*d))
|
|
||||||
|
|
||||||
struct mctp_frag_test {
|
|
||||||
unsigned int mtu;
|
|
||||||
unsigned int msgsize;
|
|
||||||
unsigned int n_frags;
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_test_fragment(struct kunit *test)
|
|
||||||
{
|
|
||||||
const struct mctp_frag_test *params;
|
|
||||||
int rc, i, n, mtu, msgsize;
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
struct sk_buff *skb;
|
|
||||||
struct mctp_hdr hdr;
|
|
||||||
u8 seq;
|
|
||||||
|
|
||||||
params = test->param_value;
|
|
||||||
mtu = params->mtu;
|
|
||||||
msgsize = params->msgsize;
|
|
||||||
|
|
||||||
hdr.ver = 1;
|
|
||||||
hdr.src = 8;
|
|
||||||
hdr.dest = 10;
|
|
||||||
hdr.flags_seq_tag = MCTP_HDR_FLAG_TO;
|
|
||||||
|
|
||||||
skb = mctp_test_create_skb(&hdr, msgsize);
|
|
||||||
KUNIT_ASSERT_TRUE(test, skb);
|
|
||||||
|
|
||||||
rt = mctp_test_create_route(&init_net, NULL, 10, mtu);
|
|
||||||
KUNIT_ASSERT_TRUE(test, rt);
|
|
||||||
|
|
||||||
rc = mctp_do_fragment_route(&rt->rt, skb, mtu, MCTP_TAG_OWNER);
|
|
||||||
KUNIT_EXPECT_FALSE(test, rc);
|
|
||||||
|
|
||||||
n = rt->pkts.qlen;
|
|
||||||
|
|
||||||
KUNIT_EXPECT_EQ(test, n, params->n_frags);
|
|
||||||
|
|
||||||
for (i = 0;; i++) {
|
|
||||||
struct mctp_hdr *hdr2;
|
|
||||||
struct sk_buff *skb2;
|
|
||||||
u8 tag_mask, seq2;
|
|
||||||
bool first, last;
|
|
||||||
|
|
||||||
first = i == 0;
|
|
||||||
last = i == (n - 1);
|
|
||||||
|
|
||||||
skb2 = skb_dequeue(&rt->pkts);
|
|
||||||
|
|
||||||
if (!skb2)
|
|
||||||
break;
|
|
||||||
|
|
||||||
hdr2 = mctp_hdr(skb2);
|
|
||||||
|
|
||||||
tag_mask = MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO;
|
|
||||||
|
|
||||||
KUNIT_EXPECT_EQ(test, hdr2->ver, hdr.ver);
|
|
||||||
KUNIT_EXPECT_EQ(test, hdr2->src, hdr.src);
|
|
||||||
KUNIT_EXPECT_EQ(test, hdr2->dest, hdr.dest);
|
|
||||||
KUNIT_EXPECT_EQ(test, hdr2->flags_seq_tag & tag_mask,
|
|
||||||
hdr.flags_seq_tag & tag_mask);
|
|
||||||
|
|
||||||
KUNIT_EXPECT_EQ(test,
|
|
||||||
!!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_SOM), first);
|
|
||||||
KUNIT_EXPECT_EQ(test,
|
|
||||||
!!(hdr2->flags_seq_tag & MCTP_HDR_FLAG_EOM), last);
|
|
||||||
|
|
||||||
seq2 = (hdr2->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) &
|
|
||||||
MCTP_HDR_SEQ_MASK;
|
|
||||||
|
|
||||||
if (first) {
|
|
||||||
seq = seq2;
|
|
||||||
} else {
|
|
||||||
seq++;
|
|
||||||
KUNIT_EXPECT_EQ(test, seq2, seq & MCTP_HDR_SEQ_MASK);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!last)
|
|
||||||
KUNIT_EXPECT_EQ(test, skb2->len, mtu);
|
|
||||||
else
|
|
||||||
KUNIT_EXPECT_LE(test, skb2->len, mtu);
|
|
||||||
|
|
||||||
kfree_skb(skb2);
|
|
||||||
}
|
|
||||||
|
|
||||||
mctp_test_route_destroy(rt);
|
|
||||||
}
|
|
||||||
|
|
||||||
static const struct mctp_frag_test mctp_frag_tests[] = {
|
|
||||||
{.mtu = 68, .msgsize = 63, .n_frags = 1},
|
|
||||||
{.mtu = 68, .msgsize = 64, .n_frags = 1},
|
|
||||||
{.mtu = 68, .msgsize = 65, .n_frags = 2},
|
|
||||||
{.mtu = 68, .msgsize = 66, .n_frags = 2},
|
|
||||||
{.mtu = 68, .msgsize = 127, .n_frags = 2},
|
|
||||||
{.mtu = 68, .msgsize = 128, .n_frags = 2},
|
|
||||||
{.mtu = 68, .msgsize = 129, .n_frags = 3},
|
|
||||||
{.mtu = 68, .msgsize = 130, .n_frags = 3},
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_frag_test_to_desc(const struct mctp_frag_test *t, char *desc)
|
|
||||||
{
|
|
||||||
sprintf(desc, "mtu %d len %d -> %d frags",
|
|
||||||
t->msgsize, t->mtu, t->n_frags);
|
|
||||||
}
|
|
||||||
|
|
||||||
KUNIT_ARRAY_PARAM(mctp_frag, mctp_frag_tests, mctp_frag_test_to_desc);
|
|
||||||
|
|
||||||
struct mctp_rx_input_test {
|
|
||||||
struct mctp_hdr hdr;
|
|
||||||
bool input;
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_test_rx_input(struct kunit *test)
|
|
||||||
{
|
|
||||||
const struct mctp_rx_input_test *params;
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
struct mctp_test_dev *dev;
|
|
||||||
struct sk_buff *skb;
|
|
||||||
|
|
||||||
params = test->param_value;
|
|
||||||
|
|
||||||
dev = mctp_test_create_dev();
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
|
|
||||||
|
|
||||||
rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
|
|
||||||
|
|
||||||
skb = mctp_test_create_skb(¶ms->hdr, 1);
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
|
|
||||||
|
|
||||||
__mctp_cb(skb);
|
|
||||||
|
|
||||||
mctp_pkttype_receive(skb, dev->ndev, &mctp_packet_type, NULL);
|
|
||||||
|
|
||||||
KUNIT_EXPECT_EQ(test, !!rt->pkts.qlen, params->input);
|
|
||||||
|
|
||||||
mctp_test_route_destroy(rt);
|
|
||||||
mctp_test_destroy_dev(dev);
|
|
||||||
}
|
|
||||||
|
|
||||||
#define RX_HDR(_ver, _src, _dest, _fst) \
|
|
||||||
{ .ver = _ver, .src = _src, .dest = _dest, .flags_seq_tag = _fst }
|
|
||||||
|
|
||||||
/* we have a route for EID 8 only */
|
|
||||||
static const struct mctp_rx_input_test mctp_rx_input_tests[] = {
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, 0), .input = true },
|
|
||||||
{ .hdr = RX_HDR(1, 10, 9, 0), .input = false }, /* no input route */
|
|
||||||
{ .hdr = RX_HDR(2, 10, 8, 0), .input = false }, /* invalid version */
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_rx_input_test_to_desc(const struct mctp_rx_input_test *t,
|
|
||||||
char *desc)
|
|
||||||
{
|
|
||||||
sprintf(desc, "{%x,%x,%x,%x}", t->hdr.ver, t->hdr.src, t->hdr.dest,
|
|
||||||
t->hdr.flags_seq_tag);
|
|
||||||
}
|
|
||||||
|
|
||||||
KUNIT_ARRAY_PARAM(mctp_rx_input, mctp_rx_input_tests,
|
|
||||||
mctp_rx_input_test_to_desc);
|
|
||||||
|
|
||||||
/* set up a local dev, route on EID 8, and a socket listening on type 0 */
|
|
||||||
static void __mctp_route_test_init(struct kunit *test,
|
|
||||||
struct mctp_test_dev **devp,
|
|
||||||
struct mctp_test_route **rtp,
|
|
||||||
struct socket **sockp)
|
|
||||||
{
|
|
||||||
struct sockaddr_mctp addr;
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
struct mctp_test_dev *dev;
|
|
||||||
struct socket *sock;
|
|
||||||
int rc;
|
|
||||||
|
|
||||||
dev = mctp_test_create_dev();
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
|
|
||||||
|
|
||||||
rt = mctp_test_create_route(&init_net, dev->mdev, 8, 68);
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
|
|
||||||
|
|
||||||
rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
|
|
||||||
KUNIT_ASSERT_EQ(test, rc, 0);
|
|
||||||
|
|
||||||
addr.smctp_family = AF_MCTP;
|
|
||||||
addr.smctp_network = MCTP_NET_ANY;
|
|
||||||
addr.smctp_addr.s_addr = 8;
|
|
||||||
addr.smctp_type = 0;
|
|
||||||
rc = kernel_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
|
|
||||||
KUNIT_ASSERT_EQ(test, rc, 0);
|
|
||||||
|
|
||||||
*rtp = rt;
|
|
||||||
*devp = dev;
|
|
||||||
*sockp = sock;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void __mctp_route_test_fini(struct mctp_test_dev *dev,
|
|
||||||
struct mctp_test_route *rt,
|
|
||||||
struct socket *sock)
|
|
||||||
{
|
|
||||||
sock_release(sock);
|
|
||||||
mctp_test_route_destroy(rt);
|
|
||||||
mctp_test_destroy_dev(dev);
|
|
||||||
}
|
|
||||||
|
|
||||||
struct mctp_route_input_sk_test {
|
|
||||||
struct mctp_hdr hdr;
|
|
||||||
u8 type;
|
|
||||||
bool deliver;
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_test_route_input_sk(struct kunit *test)
|
|
||||||
{
|
|
||||||
const struct mctp_route_input_sk_test *params;
|
|
||||||
struct sk_buff *skb, *skb2;
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
struct mctp_test_dev *dev;
|
|
||||||
struct socket *sock;
|
|
||||||
int rc;
|
|
||||||
|
|
||||||
params = test->param_value;
|
|
||||||
|
|
||||||
__mctp_route_test_init(test, &dev, &rt, &sock);
|
|
||||||
|
|
||||||
skb = mctp_test_create_skb_data(¶ms->hdr, ¶ms->type);
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
|
|
||||||
|
|
||||||
skb->dev = dev->ndev;
|
|
||||||
__mctp_cb(skb);
|
|
||||||
|
|
||||||
rc = mctp_route_input(&rt->rt, skb);
|
|
||||||
|
|
||||||
if (params->deliver) {
|
|
||||||
KUNIT_EXPECT_EQ(test, rc, 0);
|
|
||||||
|
|
||||||
skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc);
|
|
||||||
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
|
|
||||||
KUNIT_EXPECT_EQ(test, skb->len, 1);
|
|
||||||
|
|
||||||
skb_free_datagram(sock->sk, skb2);
|
|
||||||
|
|
||||||
} else {
|
|
||||||
KUNIT_EXPECT_NE(test, rc, 0);
|
|
||||||
skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc);
|
|
||||||
KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
__mctp_route_test_fini(dev, rt, sock);
|
|
||||||
}
|
|
||||||
|
|
||||||
#define FL_S (MCTP_HDR_FLAG_SOM)
|
|
||||||
#define FL_E (MCTP_HDR_FLAG_EOM)
|
|
||||||
#define FL_T (MCTP_HDR_FLAG_TO)
|
|
||||||
|
|
||||||
static const struct mctp_route_input_sk_test mctp_route_input_sk_tests[] = {
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T), .type = 0, .deliver = true },
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, FL_S | FL_E | FL_T), .type = 1, .deliver = false },
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, FL_S | FL_E), .type = 0, .deliver = false },
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, FL_E | FL_T), .type = 0, .deliver = false },
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, FL_T), .type = 0, .deliver = false },
|
|
||||||
{ .hdr = RX_HDR(1, 10, 8, 0), .type = 0, .deliver = false },
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_route_input_sk_to_desc(const struct mctp_route_input_sk_test *t,
|
|
||||||
char *desc)
|
|
||||||
{
|
|
||||||
sprintf(desc, "{%x,%x,%x,%x} type %d", t->hdr.ver, t->hdr.src,
|
|
||||||
t->hdr.dest, t->hdr.flags_seq_tag, t->type);
|
|
||||||
}
|
|
||||||
|
|
||||||
KUNIT_ARRAY_PARAM(mctp_route_input_sk, mctp_route_input_sk_tests,
|
|
||||||
mctp_route_input_sk_to_desc);
|
|
||||||
|
|
||||||
struct mctp_route_input_sk_reasm_test {
|
|
||||||
const char *name;
|
|
||||||
struct mctp_hdr hdrs[4];
|
|
||||||
int n_hdrs;
|
|
||||||
int rx_len;
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_test_route_input_sk_reasm(struct kunit *test)
|
|
||||||
{
|
|
||||||
const struct mctp_route_input_sk_reasm_test *params;
|
|
||||||
struct sk_buff *skb, *skb2;
|
|
||||||
struct mctp_test_route *rt;
|
|
||||||
struct mctp_test_dev *dev;
|
|
||||||
struct socket *sock;
|
|
||||||
int i, rc;
|
|
||||||
u8 c;
|
|
||||||
|
|
||||||
params = test->param_value;
|
|
||||||
|
|
||||||
__mctp_route_test_init(test, &dev, &rt, &sock);
|
|
||||||
|
|
||||||
for (i = 0; i < params->n_hdrs; i++) {
|
|
||||||
c = i;
|
|
||||||
skb = mctp_test_create_skb_data(¶ms->hdrs[i], &c);
|
|
||||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
|
|
||||||
|
|
||||||
skb->dev = dev->ndev;
|
|
||||||
__mctp_cb(skb);
|
|
||||||
|
|
||||||
rc = mctp_route_input(&rt->rt, skb);
|
|
||||||
}
|
|
||||||
|
|
||||||
skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc);
|
|
||||||
|
|
||||||
if (params->rx_len) {
|
|
||||||
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
|
|
||||||
KUNIT_EXPECT_EQ(test, skb2->len, params->rx_len);
|
|
||||||
skb_free_datagram(sock->sk, skb2);
|
|
||||||
|
|
||||||
} else {
|
|
||||||
KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
__mctp_route_test_fini(dev, rt, sock);
|
|
||||||
}
|
|
||||||
|
|
||||||
#define RX_FRAG(f, s) RX_HDR(1, 10, 8, FL_T | (f) | ((s) << MCTP_HDR_SEQ_SHIFT))
|
|
||||||
|
|
||||||
static const struct mctp_route_input_sk_reasm_test mctp_route_input_sk_reasm_tests[] = {
|
|
||||||
{
|
|
||||||
.name = "single packet",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S | FL_E, 0),
|
|
||||||
},
|
|
||||||
.n_hdrs = 1,
|
|
||||||
.rx_len = 1,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "single packet, offset seq",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S | FL_E, 1),
|
|
||||||
},
|
|
||||||
.n_hdrs = 1,
|
|
||||||
.rx_len = 1,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "start & end packets",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S, 0),
|
|
||||||
RX_FRAG(FL_E, 1),
|
|
||||||
},
|
|
||||||
.n_hdrs = 2,
|
|
||||||
.rx_len = 2,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "start & end packets, offset seq",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S, 1),
|
|
||||||
RX_FRAG(FL_E, 2),
|
|
||||||
},
|
|
||||||
.n_hdrs = 2,
|
|
||||||
.rx_len = 2,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "start & end packets, out of order",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_E, 1),
|
|
||||||
RX_FRAG(FL_S, 0),
|
|
||||||
},
|
|
||||||
.n_hdrs = 2,
|
|
||||||
.rx_len = 0,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "start, middle & end packets",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S, 0),
|
|
||||||
RX_FRAG(0, 1),
|
|
||||||
RX_FRAG(FL_E, 2),
|
|
||||||
},
|
|
||||||
.n_hdrs = 3,
|
|
||||||
.rx_len = 3,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "missing seq",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S, 0),
|
|
||||||
RX_FRAG(FL_E, 2),
|
|
||||||
},
|
|
||||||
.n_hdrs = 2,
|
|
||||||
.rx_len = 0,
|
|
||||||
},
|
|
||||||
{
|
|
||||||
.name = "seq wrap",
|
|
||||||
.hdrs = {
|
|
||||||
RX_FRAG(FL_S, 3),
|
|
||||||
RX_FRAG(FL_E, 0),
|
|
||||||
},
|
|
||||||
.n_hdrs = 2,
|
|
||||||
.rx_len = 2,
|
|
||||||
},
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_route_input_sk_reasm_to_desc(
|
|
||||||
const struct mctp_route_input_sk_reasm_test *t,
|
|
||||||
char *desc)
|
|
||||||
{
|
|
||||||
sprintf(desc, "%s", t->name);
|
|
||||||
}
|
|
||||||
|
|
||||||
KUNIT_ARRAY_PARAM(mctp_route_input_sk_reasm, mctp_route_input_sk_reasm_tests,
|
|
||||||
mctp_route_input_sk_reasm_to_desc);
|
|
||||||
|
|
||||||
static struct kunit_case mctp_test_cases[] = {
|
|
||||||
KUNIT_CASE_PARAM(mctp_test_fragment, mctp_frag_gen_params),
|
|
||||||
KUNIT_CASE_PARAM(mctp_test_rx_input, mctp_rx_input_gen_params),
|
|
||||||
KUNIT_CASE_PARAM(mctp_test_route_input_sk, mctp_route_input_sk_gen_params),
|
|
||||||
KUNIT_CASE_PARAM(mctp_test_route_input_sk_reasm,
|
|
||||||
mctp_route_input_sk_reasm_gen_params),
|
|
||||||
{}
|
|
||||||
};
|
|
||||||
|
|
||||||
static struct kunit_suite mctp_test_suite = {
|
|
||||||
.name = "mctp",
|
|
||||||
.test_cases = mctp_test_cases,
|
|
||||||
};
|
|
||||||
|
|
||||||
kunit_test_suite(mctp_test_suite);
|
|
||||||
@ -1,67 +0,0 @@
|
|||||||
// SPDX-License-Identifier: GPL-2.0
|
|
||||||
|
|
||||||
#include <linux/netdevice.h>
|
|
||||||
#include <linux/mctp.h>
|
|
||||||
#include <linux/if_arp.h>
|
|
||||||
|
|
||||||
#include <net/mctpdevice.h>
|
|
||||||
#include <net/pkt_sched.h>
|
|
||||||
|
|
||||||
#include "utils.h"
|
|
||||||
|
|
||||||
static netdev_tx_t mctp_test_dev_tx(struct sk_buff *skb,
|
|
||||||
struct net_device *ndev)
|
|
||||||
{
|
|
||||||
kfree(skb);
|
|
||||||
return NETDEV_TX_OK;
|
|
||||||
}
|
|
||||||
|
|
||||||
static const struct net_device_ops mctp_test_netdev_ops = {
|
|
||||||
.ndo_start_xmit = mctp_test_dev_tx,
|
|
||||||
};
|
|
||||||
|
|
||||||
static void mctp_test_dev_setup(struct net_device *ndev)
|
|
||||||
{
|
|
||||||
ndev->type = ARPHRD_MCTP;
|
|
||||||
ndev->mtu = MCTP_DEV_TEST_MTU;
|
|
||||||
ndev->hard_header_len = 0;
|
|
||||||
ndev->addr_len = 0;
|
|
||||||
ndev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
|
|
||||||
ndev->flags = IFF_NOARP;
|
|
||||||
ndev->netdev_ops = &mctp_test_netdev_ops;
|
|
||||||
ndev->needs_free_netdev = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
struct mctp_test_dev *mctp_test_create_dev(void)
|
|
||||||
{
|
|
||||||
struct mctp_test_dev *dev;
|
|
||||||
struct net_device *ndev;
|
|
||||||
int rc;
|
|
||||||
|
|
||||||
ndev = alloc_netdev(sizeof(*dev), "mctptest%d", NET_NAME_ENUM,
|
|
||||||
mctp_test_dev_setup);
|
|
||||||
if (!ndev)
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
dev = netdev_priv(ndev);
|
|
||||||
dev->ndev = ndev;
|
|
||||||
|
|
||||||
rcu_read_lock();
|
|
||||||
dev->mdev = __mctp_dev_get(ndev);
|
|
||||||
mctp_dev_hold(dev->mdev);
|
|
||||||
rcu_read_unlock();
|
|
||||||
|
|
||||||
rc = register_netdev(ndev);
|
|
||||||
if (rc) {
|
|
||||||
free_netdev(ndev);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
return dev;
|
|
||||||
}
|
|
||||||
|
|
||||||
void mctp_test_destroy_dev(struct mctp_test_dev *dev)
|
|
||||||
{
|
|
||||||
mctp_dev_put(dev->mdev);
|
|
||||||
unregister_netdev(dev->ndev);
|
|
||||||
}
|
|
||||||
@ -1,20 +0,0 @@
|
|||||||
/* SPDX-License-Identifier: GPL-2.0 */
|
|
||||||
|
|
||||||
#ifndef __NET_MCTP_TEST_UTILS_H
|
|
||||||
#define __NET_MCTP_TEST_UTILS_H
|
|
||||||
|
|
||||||
#include <kunit/test.h>
|
|
||||||
|
|
||||||
#define MCTP_DEV_TEST_MTU 68
|
|
||||||
|
|
||||||
struct mctp_test_dev {
|
|
||||||
struct net_device *ndev;
|
|
||||||
struct mctp_dev *mdev;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct mctp_test_dev;
|
|
||||||
|
|
||||||
struct mctp_test_dev *mctp_test_create_dev(void);
|
|
||||||
void mctp_test_destroy_dev(struct mctp_test_dev *dev);
|
|
||||||
|
|
||||||
#endif /* __NET_MCTP_TEST_UTILS_H */
|
|
||||||
Loading…
Reference in New Issue
Block a user