selftest: tun: Add test for receiving gso packet from tun

The test validate that GSO information are correctly exposed
when reading packets from a TUN device.

Signed-off-by: Xu Du <xudu@redhat.com>
Link: https://patch.msgid.link/fe75ac66466380490eba858eef50596a1bfbd071.1768979440.git.xudu@redhat.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Xu Du 2026-01-21 18:05:00 +08:00 committed by Jakub Kicinski
parent 400e658aa0
commit 6bdd7ae605

View File

@ -364,6 +364,116 @@ static int ip_route_check(const char *intf, int family, void *addr)
return 0;
}
static int send_gso_udp_msg(int socket, struct sockaddr_storage *addr,
uint8_t *send_buf, int send_len, int gso_size)
{
char control[CMSG_SPACE(sizeof(uint16_t))] = { 0 };
int alen = sockaddr_len(addr->ss_family);
struct msghdr msg = { 0 };
struct iovec iov = { 0 };
int ret;
iov.iov_base = send_buf;
iov.iov_len = send_len;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_name = addr;
msg.msg_namelen = alen;
if (gso_size > 0) {
struct cmsghdr *cmsg;
msg.msg_control = control;
msg.msg_controllen = sizeof(control);
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_UDP;
cmsg->cmsg_type = UDP_SEGMENT;
cmsg->cmsg_len = CMSG_LEN(sizeof(uint16_t));
*(uint16_t *)CMSG_DATA(cmsg) = gso_size;
}
ret = sendmsg(socket, &msg, 0);
if (ret < 0)
perror("sendmsg");
return ret;
}
static int validate_hdrlen(uint8_t **cur, int *len, int x)
{
if (*len < x)
return -1;
*cur += x;
*len -= x;
return 0;
}
static int parse_udp_tunnel_vnet_packet(uint8_t *buf, int len, int tunnel_type,
bool is_tap)
{
struct ipv6hdr *iph6;
struct udphdr *udph;
struct iphdr *iph4;
uint8_t *cur = buf;
if (validate_hdrlen(&cur, &len, TUN_VNET_TNL_SIZE))
return -1;
if (is_tap) {
if (validate_hdrlen(&cur, &len, ETH_HLEN))
return -1;
}
if (tunnel_type & UDP_TUNNEL_OUTER_IPV4) {
iph4 = (struct iphdr *)cur;
if (validate_hdrlen(&cur, &len, sizeof(struct iphdr)))
return -1;
if (iph4->version != 4 || iph4->protocol != IPPROTO_UDP)
return -1;
} else {
iph6 = (struct ipv6hdr *)cur;
if (validate_hdrlen(&cur, &len, sizeof(struct ipv6hdr)))
return -1;
if (iph6->version != 6 || iph6->nexthdr != IPPROTO_UDP)
return -1;
}
udph = (struct udphdr *)cur;
if (validate_hdrlen(&cur, &len, sizeof(struct udphdr)))
return -1;
if (ntohs(udph->dest) != VN_PORT)
return -1;
if (validate_hdrlen(&cur, &len, GENEVE_HLEN))
return -1;
if (validate_hdrlen(&cur, &len, ETH_HLEN))
return -1;
if (tunnel_type & UDP_TUNNEL_INNER_IPV4) {
iph4 = (struct iphdr *)cur;
if (validate_hdrlen(&cur, &len, sizeof(struct iphdr)))
return -1;
if (iph4->version != 4 || iph4->protocol != IPPROTO_UDP)
return -1;
} else {
iph6 = (struct ipv6hdr *)cur;
if (validate_hdrlen(&cur, &len, sizeof(struct ipv6hdr)))
return -1;
if (iph6->version != 6 || iph6->nexthdr != IPPROTO_UDP)
return -1;
}
udph = (struct udphdr *)cur;
if (validate_hdrlen(&cur, &len, sizeof(struct udphdr)))
return -1;
if (ntohs(udph->dest) != UDP_DST_PORT)
return -1;
return len;
}
FIXTURE(tun)
{
char ifname[IFNAMSIZ];
@ -664,6 +774,68 @@ receive_gso_packet_from_tunnel(FIXTURE_DATA(tun_vnet_udptnl) * self,
return total_len;
}
static int send_gso_packet_into_tunnel(FIXTURE_DATA(tun_vnet_udptnl) * self,
const FIXTURE_VARIANT(tun_vnet_udptnl) *
variant)
{
int family = (variant->tunnel_type & UDP_TUNNEL_INNER_IPV4) ? AF_INET :
AF_INET6;
uint8_t buf[MAX_VNET_TUNNEL_PACKET_SZ] = { 0 };
int payload_len = variant->data_size;
int gso_size = variant->gso_size;
struct sockaddr_storage ssa, dsa;
assign_sockaddr_vars(family, 0, &ssa, &dsa);
return send_gso_udp_msg(self->sock, &dsa, buf, payload_len, gso_size);
}
static int
receive_gso_packet_from_tun(FIXTURE_DATA(tun_vnet_udptnl) * self,
const FIXTURE_VARIANT(tun_vnet_udptnl) * variant,
struct virtio_net_hdr_v1_hash_tunnel *vnet_hdr)
{
struct timeval timeout = { .tv_sec = TIMEOUT_SEC };
uint8_t buf[MAX_VNET_TUNNEL_PACKET_SZ];
int tunnel_type = variant->tunnel_type;
int payload_len = variant->data_size;
bool is_tap = variant->is_tap;
int ret, len, total_len = 0;
int tun_fd = self->fd;
fd_set fdset;
while (total_len < payload_len) {
FD_ZERO(&fdset);
FD_SET(tun_fd, &fdset);
ret = select(tun_fd + 1, &fdset, NULL, NULL, &timeout);
if (ret <= 0) {
perror("select");
break;
}
if (!FD_ISSET(tun_fd, &fdset))
continue;
len = read(tun_fd, buf, sizeof(buf));
if (len <= 0) {
if (len < 0 && errno != EAGAIN && errno != EWOULDBLOCK)
perror("read");
break;
}
len = parse_udp_tunnel_vnet_packet(buf, len, tunnel_type,
is_tap);
if (len < 0)
continue;
if (total_len == 0)
memcpy(vnet_hdr, buf, TUN_VNET_TNL_SIZE);
total_len += len;
}
return total_len;
}
TEST_F(tun_vnet_udptnl, send_gso_packet)
{
uint8_t pkt[MAX_VNET_TUNNEL_PACKET_SZ];
@ -680,4 +852,26 @@ TEST_F(tun_vnet_udptnl, send_gso_packet)
ASSERT_EQ(r_num_mss, variant->r_num_mss);
}
TEST_F(tun_vnet_udptnl, recv_gso_packet)
{
struct virtio_net_hdr_v1_hash_tunnel vnet_hdr = { 0 };
struct virtio_net_hdr_v1 *vh = &vnet_hdr.hash_hdr.hdr;
int ret, gso_type = VIRTIO_NET_HDR_GSO_UDP_L4;
ret = send_gso_packet_into_tunnel(self, variant);
ASSERT_EQ(ret, variant->data_size);
memset(&vnet_hdr, 0, sizeof(vnet_hdr));
ret = receive_gso_packet_from_tun(self, variant, &vnet_hdr);
ASSERT_EQ(ret, variant->data_size);
if (!variant->no_gso) {
ASSERT_EQ(vh->gso_size, variant->gso_size);
gso_type |= (variant->tunnel_type & UDP_TUNNEL_OUTER_IPV4) ?
(VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV4) :
(VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV6);
ASSERT_EQ(vh->gso_type, gso_type);
}
}
TEST_HARNESS_MAIN