Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
net: mctp: test: Add initial socket tests
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>
authored by
Jeremy Kerr
and committed by
Paolo Abeni
9b4a8c38
19396179
+218
+5
net/mctp/route.c
+5
net/mctp/route.c
···
17
17
#include <linux/rtnetlink.h>
18
18
#include <linux/skbuff.h>
19
19
20
+
#include <kunit/static_stub.h>
21
+
20
22
#include <uapi/linux/if_arp.h>
21
23
22
24
#include <net/mctp.h>
···
1012
1010
mctp_eid_t saddr;
1013
1011
int rc;
1014
1012
u8 tag;
1013
+
1014
+
KUNIT_STATIC_STUB_REDIRECT(mctp_local_output, sk, dst, skb, daddr,
1015
+
req_tag);
1015
1016
1016
1017
rc = -ENODEV;
1017
1018
+213
net/mctp/test/sock-test.c
+213
net/mctp/test/sock-test.c
···
1
1
// SPDX-License-Identifier: GPL-2.0
2
2
3
+
#include <kunit/static_stub.h>
3
4
#include <kunit/test.h>
5
+
6
+
#include <linux/socket.h>
7
+
#include <linux/spinlock.h>
4
8
5
9
#include "utils.h"
6
10
11
+
static const u8 dev_default_lladdr[] = { 0x01, 0x02 };
12
+
13
+
/* helper for simple sock setup: single device, with dev_default_lladdr as its
14
+
* hardware address, assigned with a local EID 8, and a route to EID 9
15
+
*/
16
+
static void __mctp_sock_test_init(struct kunit *test,
17
+
struct mctp_test_dev **devp,
18
+
struct mctp_test_route **rtp,
19
+
struct socket **sockp)
20
+
{
21
+
struct mctp_test_route *rt;
22
+
struct mctp_test_dev *dev;
23
+
struct socket *sock;
24
+
unsigned long flags;
25
+
u8 *addrs;
26
+
int rc;
27
+
28
+
dev = mctp_test_create_dev_lladdr(sizeof(dev_default_lladdr),
29
+
dev_default_lladdr);
30
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
31
+
32
+
addrs = kmalloc(1, GFP_KERNEL);
33
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, addrs);
34
+
addrs[0] = 8;
35
+
36
+
spin_lock_irqsave(&dev->mdev->addrs_lock, flags);
37
+
dev->mdev->num_addrs = 1;
38
+
swap(addrs, dev->mdev->addrs);
39
+
spin_unlock_irqrestore(&dev->mdev->addrs_lock, flags);
40
+
41
+
kfree(addrs);
42
+
43
+
rt = mctp_test_create_route(dev_net(dev->ndev), dev->mdev, 9, 0);
44
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rt);
45
+
46
+
rc = sock_create_kern(&init_net, AF_MCTP, SOCK_DGRAM, 0, &sock);
47
+
KUNIT_ASSERT_EQ(test, rc, 0);
48
+
49
+
*devp = dev;
50
+
*rtp = rt;
51
+
*sockp = sock;
52
+
}
53
+
54
+
static void __mctp_sock_test_fini(struct kunit *test,
55
+
struct mctp_test_dev *dev,
56
+
struct mctp_test_route *rt,
57
+
struct socket *sock)
58
+
{
59
+
sock_release(sock);
60
+
mctp_test_route_destroy(test, rt);
61
+
mctp_test_destroy_dev(dev);
62
+
}
63
+
64
+
struct mctp_test_sock_local_output_config {
65
+
struct mctp_test_dev *dev;
66
+
size_t halen;
67
+
u8 haddr[MAX_ADDR_LEN];
68
+
bool invoked;
69
+
int rc;
70
+
};
71
+
72
+
static int mctp_test_sock_local_output(struct sock *sk,
73
+
struct mctp_dst *dst,
74
+
struct sk_buff *skb,
75
+
mctp_eid_t daddr, u8 req_tag)
76
+
{
77
+
struct kunit *test = kunit_get_current_test();
78
+
struct mctp_test_sock_local_output_config *cfg = test->priv;
79
+
80
+
KUNIT_EXPECT_PTR_EQ(test, dst->dev, cfg->dev->mdev);
81
+
KUNIT_EXPECT_EQ(test, dst->halen, cfg->halen);
82
+
KUNIT_EXPECT_MEMEQ(test, dst->haddr, cfg->haddr, dst->halen);
83
+
84
+
cfg->invoked = true;
85
+
86
+
kfree_skb(skb);
87
+
88
+
return cfg->rc;
89
+
}
90
+
91
+
static void mctp_test_sock_sendmsg_extaddr(struct kunit *test)
92
+
{
93
+
struct sockaddr_mctp_ext addr = {
94
+
.smctp_base = {
95
+
.smctp_family = AF_MCTP,
96
+
.smctp_tag = MCTP_TAG_OWNER,
97
+
.smctp_network = MCTP_NET_ANY,
98
+
},
99
+
};
100
+
struct mctp_test_sock_local_output_config cfg = { 0 };
101
+
u8 haddr[] = { 0xaa, 0x01 };
102
+
u8 buf[4] = { 0, 1, 2, 3 };
103
+
struct mctp_test_route *rt;
104
+
struct msghdr msg = { 0 };
105
+
struct mctp_test_dev *dev;
106
+
struct mctp_sock *msk;
107
+
struct socket *sock;
108
+
ssize_t send_len;
109
+
struct kvec vec = {
110
+
.iov_base = buf,
111
+
.iov_len = sizeof(buf),
112
+
};
113
+
114
+
__mctp_sock_test_init(test, &dev, &rt, &sock);
115
+
116
+
/* Expect to see the dst configured up with the addressing data we
117
+
* provide in the struct sockaddr_mctp_ext
118
+
*/
119
+
cfg.dev = dev;
120
+
cfg.halen = sizeof(haddr);
121
+
memcpy(cfg.haddr, haddr, sizeof(haddr));
122
+
123
+
test->priv = &cfg;
124
+
125
+
kunit_activate_static_stub(test, mctp_local_output,
126
+
mctp_test_sock_local_output);
127
+
128
+
/* enable and configure direct addressing */
129
+
msk = container_of(sock->sk, struct mctp_sock, sk);
130
+
msk->addr_ext = true;
131
+
132
+
addr.smctp_ifindex = dev->ndev->ifindex;
133
+
addr.smctp_halen = sizeof(haddr);
134
+
memcpy(addr.smctp_haddr, haddr, sizeof(haddr));
135
+
136
+
msg.msg_name = &addr;
137
+
msg.msg_namelen = sizeof(addr);
138
+
139
+
iov_iter_kvec(&msg.msg_iter, ITER_SOURCE, &vec, 1, sizeof(buf));
140
+
send_len = mctp_sendmsg(sock, &msg, sizeof(buf));
141
+
KUNIT_EXPECT_EQ(test, send_len, sizeof(buf));
142
+
KUNIT_EXPECT_TRUE(test, cfg.invoked);
143
+
144
+
__mctp_sock_test_fini(test, dev, rt, sock);
145
+
}
146
+
147
+
static void mctp_test_sock_recvmsg_extaddr(struct kunit *test)
148
+
{
149
+
struct sockaddr_mctp_ext recv_addr = { 0 };
150
+
u8 rcv_buf[1], rcv_data[] = { 0, 1 };
151
+
u8 haddr[] = { 0xaa, 0x02 };
152
+
struct mctp_test_route *rt;
153
+
struct mctp_test_dev *dev;
154
+
struct mctp_skb_cb *cb;
155
+
struct mctp_sock *msk;
156
+
struct sk_buff *skb;
157
+
struct mctp_hdr hdr;
158
+
struct socket *sock;
159
+
struct msghdr msg;
160
+
ssize_t recv_len;
161
+
int rc;
162
+
struct kvec vec = {
163
+
.iov_base = rcv_buf,
164
+
.iov_len = sizeof(rcv_buf),
165
+
};
166
+
167
+
__mctp_sock_test_init(test, &dev, &rt, &sock);
168
+
169
+
/* enable extended addressing on recv */
170
+
msk = container_of(sock->sk, struct mctp_sock, sk);
171
+
msk->addr_ext = true;
172
+
173
+
/* base incoming header, using a nul-EID dest */
174
+
hdr.ver = 1;
175
+
hdr.dest = 0;
176
+
hdr.src = 9;
177
+
hdr.flags_seq_tag = MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM |
178
+
MCTP_HDR_FLAG_TO;
179
+
180
+
skb = mctp_test_create_skb_data(&hdr, &rcv_data);
181
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, skb);
182
+
183
+
mctp_test_skb_set_dev(skb, dev);
184
+
185
+
/* set incoming extended address data */
186
+
cb = mctp_cb(skb);
187
+
cb->halen = sizeof(haddr);
188
+
cb->ifindex = dev->ndev->ifindex;
189
+
memcpy(cb->haddr, haddr, sizeof(haddr));
190
+
191
+
/* Deliver to socket. The route input path pulls the network header,
192
+
* leaving skb data at type byte onwards. recvmsg will consume the
193
+
* type for addr.smctp_type
194
+
*/
195
+
skb_pull(skb, sizeof(hdr));
196
+
rc = sock_queue_rcv_skb(sock->sk, skb);
197
+
KUNIT_ASSERT_EQ(test, rc, 0);
198
+
199
+
msg.msg_name = &recv_addr;
200
+
msg.msg_namelen = sizeof(recv_addr);
201
+
iov_iter_kvec(&msg.msg_iter, ITER_DEST, &vec, 1, sizeof(rcv_buf));
202
+
203
+
recv_len = mctp_recvmsg(sock, &msg, sizeof(rcv_buf),
204
+
MSG_DONTWAIT | MSG_TRUNC);
205
+
206
+
KUNIT_EXPECT_EQ(test, recv_len, sizeof(rcv_buf));
207
+
208
+
/* expect our extended address to be populated from hdr and cb */
209
+
KUNIT_EXPECT_EQ(test, msg.msg_namelen, sizeof(recv_addr));
210
+
KUNIT_EXPECT_EQ(test, recv_addr.smctp_base.smctp_family, AF_MCTP);
211
+
KUNIT_EXPECT_EQ(test, recv_addr.smctp_ifindex, dev->ndev->ifindex);
212
+
KUNIT_EXPECT_EQ(test, recv_addr.smctp_halen, sizeof(haddr));
213
+
KUNIT_EXPECT_MEMEQ(test, recv_addr.smctp_haddr, haddr, sizeof(haddr));
214
+
215
+
__mctp_sock_test_fini(test, dev, rt, sock);
216
+
}
217
+
7
218
static struct kunit_case mctp_test_cases[] = {
219
+
KUNIT_CASE(mctp_test_sock_sendmsg_extaddr),
220
+
KUNIT_CASE(mctp_test_sock_recvmsg_extaddr),
8
221
{}
9
222
};
10
223