linuxmsm/laptops-kernel
0
0
Fork 0
mirror of https://github.com/linux-msm/laptops-kernel.git synced 2026-08-13 14:19:53 -07:00
Code Issues Packages Projects Releases Wiki Activity

net: mctp: test: Add initial socket tests

Browse Source 
Recent changes have modified the extaddr path a little, so add a couple
of kunit tests to af-mctp.c. These check that we're correctly passing
lladdr data between sendmsg/recvmsg and the routing layer.

Signed-off-by: Jeremy Kerr <jk@codeconstruct.com.au>
Link: https://patch.msgid.link/20250702-dev-forwarding-v5-9-1468191da8a4@codeconstruct.com.au
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
This commit is contained in:
Jeremy Kerr
2025-07-08 12:39:24 +02:00
committed by Paolo Abeni
parent 19396179a0
commit 9b4a8c38f4
2 changed files with 218 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
net/mctp/route.c
+5
View File
@@ -17,6 +17,8 @@
#include <linux/rtnetlink.h>
#include <linux/skbuff.h>
#include <kunit/static_stub.h>
#include <uapi/linux/if_arp.h>
#include <net/mctp.h>
@@ -1011,6 +1013,9 @@ int mctp_local_output(struct sock *sk, struct mctp_dst *dst,
int rc;
u8 tag;
KUNIT_STATIC_STUB_REDIRECT(mctp_local_output, sk, dst, skb, daddr,
req_tag);
rc = -ENODEV;
spin_lock_irqsave(&dst->dev->addrs_lock, flags);
net/mctp/test/sock-test.c
+213
View File
@@ -1,10 +1,223 @@
// SPDX-License-Identifier: GPL-2.0
#include <kunit/static_stub.h>
#include <kunit/test.h>
#include <linux/socket.h>
#include <linux/spinlock.h>
#include "utils.h"
static const u8 dev_default_lladdr[] = { 0x01, 0x02 };
/* helper for simple sock setup: single device, with dev_default_lladdr as its
* hardware address, assigned with a local EID 8, and a route to EID 9
*/
static void __mctp_sock_test_init(struct kunit *test,
struct mctp_test_dev **devp,
struct mctp_test_route **rtp,
struct socket **sockp)
{
struct mctp_test_route *rt;
struct mctp_test_dev *dev;
struct socket *sock;
unsigned long flags;
u8 *addrs;
int rc;
dev = mctp_test_create_dev_lladdr(sizeof(dev_default_lladdr),
dev_default_lladdr);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
addrs = kmalloc(1, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, addrs);
addrs[0] = 8;
spin_lock_irqsave(&dev->mdev->addrs_lock, flags);
dev->mdev->num_addrs = 1;
swap(addrs, dev->mdev->addrs);
spin_unlock_irqrestore(&dev->mdev->addrs_lock, flags);
kfree(addrs);
rt = mctp_test_create_route(dev_net(dev->ndev), dev->mdev, 9, 0);
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);
*devp = dev;
*rtp = rt;
*sockp = sock;
}
static void __mctp_sock_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_test_sock_local_output_config {
struct mctp_test_dev *dev;
size_t halen;
u8 haddr[MAX_ADDR_LEN];
bool invoked;
int rc;
};
static int mctp_test_sock_local_output(struct sock *sk,
struct mctp_dst *dst,
struct sk_buff *skb,
mctp_eid_t daddr, u8 req_tag)
{
struct kunit *test = kunit_get_current_test();
struct mctp_test_sock_local_output_config *cfg = test->priv;
KUNIT_EXPECT_PTR_EQ(test, dst->dev, cfg->dev->mdev);
KUNIT_EXPECT_EQ(test, dst->halen, cfg->halen);
KUNIT_EXPECT_MEMEQ(test, dst->haddr, cfg->haddr, dst->halen);
cfg->invoked = true;
kfree_skb(skb);
return cfg->rc;
}
static void mctp_test_sock_sendmsg_extaddr(struct kunit *test)
{
struct sockaddr_mctp_ext addr = {
.smctp_base = {
.smctp_family = AF_MCTP,
.smctp_tag = MCTP_TAG_OWNER,
.smctp_network = MCTP_NET_ANY,
},
};
struct mctp_test_sock_local_output_config cfg = { 0 };
u8 haddr[] = { 0xaa, 0x01 };
u8 buf[4] = { 0, 1, 2, 3 };
struct mctp_test_route *rt;
struct msghdr msg = { 0 };
struct mctp_test_dev *dev;
struct mctp_sock *msk;
struct socket *sock;
ssize_t send_len;
struct kvec vec = {
.iov_base = buf,
.iov_len = sizeof(buf),
};
__mctp_sock_test_init(test, &dev, &rt, &sock);
/* Expect to see the dst configured up with the addressing data we
* provide in the struct sockaddr_mctp_ext
*/
cfg.dev = dev;
cfg.halen = sizeof(haddr);
memcpy(cfg.haddr, haddr, sizeof(haddr));
test->priv = &cfg;
kunit_activate_static_stub(test, mctp_local_output,
mctp_test_sock_local_output);
/* enable and configure direct addressing */
msk = container_of(sock->sk, struct mctp_sock, sk);
msk->addr_ext = true;
addr.smctp_ifindex = dev->ndev->ifindex;
addr.smctp_halen = sizeof(haddr);
memcpy(addr.smctp_haddr, haddr, sizeof(haddr));
msg.msg_name = &addr;
msg.msg_namelen = sizeof(addr);
iov_iter_kvec(&msg.msg_iter, ITER_SOURCE, &vec, 1, sizeof(buf));
send_len = mctp_sendmsg(sock, &msg, sizeof(buf));
KUNIT_EXPECT_EQ(test, send_len, sizeof(buf));
KUNIT_EXPECT_TRUE(test, cfg.invoked);
__mctp_sock_test_fini(test, dev, rt, sock);
}
static void mctp_test_sock_recvmsg_extaddr(struct kunit *test)
{
struct sockaddr_mctp_ext recv_addr = { 0 };
u8 rcv_buf[1], rcv_data[] = { 0, 1 };
u8 haddr[] = { 0xaa, 0x02 };
struct mctp_test_route *rt;
struct mctp_test_dev *dev;
struct mctp_skb_cb *cb;
struct mctp_sock *msk;
struct sk_buff *skb;
struct mctp_hdr hdr;
struct socket *sock;
struct msghdr msg;
ssize_t recv_len;
int rc;
struct kvec vec = {
.iov_base = rcv_buf,
.iov_len = sizeof(rcv_buf),
};
__mctp_sock_test_init(test, &dev, &rt, &sock);
/* enable extended addressing on recv */
msk = container_of(sock->sk, struct mctp_sock, sk);
msk->addr_ext = true;
/* base incoming header, using a nul-EID dest */
hdr.ver = 1;
hdr.dest = 0;
hdr.src = 9;
hdr.flags_seq_tag = MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM |
MCTP_HDR_FLAG_TO;
skb = mctp_test_create_skb_data(&hdr, &rcv_data);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
mctp_test_skb_set_dev(skb, dev);
/* set incoming extended address data */
cb = mctp_cb(skb);
cb->halen = sizeof(haddr);
cb->ifindex = dev->ndev->ifindex;
memcpy(cb->haddr, haddr, sizeof(haddr));
/* Deliver to socket. The route input path pulls the network header,
* leaving skb data at type byte onwards. recvmsg will consume the
* type for addr.smctp_type
*/
skb_pull(skb, sizeof(hdr));
rc = sock_queue_rcv_skb(sock->sk, skb);
KUNIT_ASSERT_EQ(test, rc, 0);
msg.msg_name = &recv_addr;
msg.msg_namelen = sizeof(recv_addr);
iov_iter_kvec(&msg.msg_iter, ITER_DEST, &vec, 1, sizeof(rcv_buf));
recv_len = mctp_recvmsg(sock, &msg, sizeof(rcv_buf),
MSG_DONTWAIT | MSG_TRUNC);
KUNIT_EXPECT_EQ(test, recv_len, sizeof(rcv_buf));
/* expect our extended address to be populated from hdr and cb */
KUNIT_EXPECT_EQ(test, msg.msg_namelen, sizeof(recv_addr));
KUNIT_EXPECT_EQ(test, recv_addr.smctp_base.smctp_family, AF_MCTP);
KUNIT_EXPECT_EQ(test, recv_addr.smctp_ifindex, dev->ndev->ifindex);
KUNIT_EXPECT_EQ(test, recv_addr.smctp_halen, sizeof(haddr));
KUNIT_EXPECT_MEMEQ(test, recv_addr.smctp_haddr, haddr, sizeof(haddr));
__mctp_sock_test_fini(test, dev, rt, sock);
}
static struct kunit_case mctp_test_cases[] = {
KUNIT_CASE(mctp_test_sock_sendmsg_extaddr),
KUNIT_CASE(mctp_test_sock_recvmsg_extaddr),
{}
};