Commit 0693b276 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'mctp-kunit-tests' 



Jeremy Kerr says:

====================
MCTP kunit tests

This change adds some initial kunit tests for the MCTP core. We'll
expand the coverage in a future series, and augment with a few
selftests, but this establishes a baseline set of tests for now.

Thanks to the kunit folks for the framework!

---

v2:
 - fix MCTP=m, KUNIT={y,m} breakage
 - fix mctp test netdev initialisation
 - strict route reference count checking
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents b8aa1654 1e5e9250

net/mctp/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -11,3 +11,8 @@ menuconfig MCTP 
	  This option enables core MCTP support. For communicating with other

	  devices, you'll want to enable a driver for a specific hardware

	  channel.



config MCTP_TEST

        bool "MCTP core tests" if !KUNIT_ALL_TESTS

        depends on MCTP=y && KUNIT=y

        default KUNIT_ALL_TESTS

net/mctp/Makefile

+3 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

obj-$(CONFIG_MCTP) += mctp.o

mctp-objs := af_mctp.o device.o route.o neigh.o



# tests

obj-$(CONFIG_MCTP_TEST) += test/utils.o

net/mctp/route.c

+5 −0
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
 */



#include <linux/idr.h>

#include <linux/kconfig.h>

#include <linux/mctp.h>

#include <linux/netdevice.h>

#include <linux/rtnetlink.h>
@@ -1228,3 +1229,7 @@ void __exit mctp_routes_exit(void) 
	rtnl_unregister(PF_MCTP, RTM_GETROUTE);

	dev_remove_pack(&mctp_packet_type);

}



#if IS_ENABLED(CONFIG_MCTP_TEST)

#include "test/route-test.c"

#endif

net/mctp/test/route-test.c

0 → 100644
+544 −0
Original line number Diff line number Diff line 
// 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 kunit *test,

				    struct mctp_test_route *rt)

{

	unsigned int refs;



	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);



	refs = refcount_read(&rt->rt.refs);

	KUNIT_ASSERT_EQ_MSG(test, refs, 1, "route ref imbalance");



	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);



	/* The refcount would usually be incremented as part of a route lookup,

	 * but we're setting the route directly here.

	 */

	refcount_inc(&rt->rt.refs);



	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(test, 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(&params->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(test, 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 kunit *test,

				   struct mctp_test_dev *dev,

				   struct mctp_test_route *rt,

				   struct socket *sock)

{

	sock_release(sock);

	mctp_test_route_destroy(test, 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(&params->hdr, &params->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(test, 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(&params->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(test, 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);

net/mctp/test/utils.c

0 → 100644
+67 −0
Original line number Diff line number Diff line 
// 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;



	rc = register_netdev(ndev);

	if (rc) {

		free_netdev(ndev);

		return NULL;

	}



	rcu_read_lock();

	dev->mdev = __mctp_dev_get(ndev);

	mctp_dev_hold(dev->mdev);

	rcu_read_unlock();



	return dev;

}



void mctp_test_destroy_dev(struct mctp_test_dev *dev)

{

	mctp_dev_put(dev->mdev);

	unregister_netdev(dev->ndev);

}