Commit 56f9058e authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge branch 'selftest-extend-tun-virtio-coverage-for-gso-over-udp-tunnel' 

Xu Du says:

====================
selftest: Extend tun/virtio coverage for GSO over UDP tunnel

The design strategy is to extend the existing tun testing infrastructure
to support this new use-case, rather than introducing a new or parallel framework.
This allows for better integration and re-use of existing test logic.
====================

Link: https://patch.msgid.link/cover.1768979440.git.xudu@redhat.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents 35527de5 87db2fde

tools/testing/selftests/net/Makefile

+13 −3
Original line number Diff line number Diff line
@@ -183,7 +183,6 @@ TEST_GEN_PROGS := \ 
	tap \

	tcp_port_share \

	tls \

	tun \

# end of TEST_GEN_PROGS



TEST_FILES := \
@@ -195,7 +194,11 @@ TEST_FILES := \ 


# YNL files, must be before "include ..lib.mk"

YNL_GEN_FILES := busy_poller

YNL_GEN_PROGS := netlink-dumps

YNL_GEN_PROGS := \

	netlink-dumps \

	tun \

# end of YNL_GEN_PROGS



TEST_GEN_FILES += $(YNL_GEN_FILES)

TEST_GEN_PROGS += $(YNL_GEN_PROGS)
@@ -206,7 +209,14 @@ TEST_INCLUDES := forwarding/lib.sh 
include ../lib.mk



# YNL build

YNL_GENS := netdev

YNL_GENS := \

	netdev \

	rt-addr \

	rt-link \

	rt-neigh \

	rt-route \

# end of YNL_GENS



include ynl.mk



$(OUTPUT)/epoll_busy_poll: LDLIBS += -lcap

tools/testing/selftests/net/tun.c

+862 −36

File changed.

Preview size limit exceeded, changes collapsed.

tools/testing/selftests/net/tuntap_helpers.h

0 → 100644
+390 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */



#ifndef _TUNTAP_HELPERS_H

#define _TUNTAP_HELPERS_H



#include <errno.h>

#include <linux/if_packet.h>

#include <linux/ipv6.h>

#include <linux/virtio_net.h>

#include <netinet/in.h>

#include <netinet/if_ether.h>

#include <netinet/udp.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <ynl.h>



#include "rt-route-user.h"

#include "rt-addr-user.h"

#include "rt-neigh-user.h"

#include "rt-link-user.h"



#define GENEVE_HLEN 8

#define PKT_DATA 0xCB

#define TUNTAP_DEFAULT_TTL 8

#define TUNTAP_DEFAULT_IPID 1337



unsigned int if_nametoindex(const char *ifname);



static inline int ip_addr_len(int family)

{

	return (family == AF_INET) ? sizeof(struct in_addr) :

				     sizeof(struct in6_addr);

}



static inline void fill_ifaddr_msg(struct ifaddrmsg *ifam, int family,

				   int prefix, int flags, const char *dev)

{

	ifam->ifa_family = family;

	ifam->ifa_prefixlen = prefix;

	ifam->ifa_index = if_nametoindex(dev);

	ifam->ifa_flags = flags;

	ifam->ifa_scope = RT_SCOPE_UNIVERSE;

}



static inline int ip_addr_add(const char *dev, int family, void *addr,

			      uint8_t prefix)

{

	int nl_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;

	int ifa_flags = IFA_F_PERMANENT | IFA_F_NODAD;

	int ret = -1, ipalen = ip_addr_len(family);

	struct rt_addr_newaddr_req *req;

	struct ynl_sock *ys;



	ys = ynl_sock_create(&ynl_rt_addr_family, NULL);

	if (!ys)

		return -1;



	req = rt_addr_newaddr_req_alloc();

	if (!req)

		goto err_req_alloc;



	fill_ifaddr_msg(&req->_hdr, family, prefix, ifa_flags, dev);

	rt_addr_newaddr_req_set_nlflags(req, nl_flags);

	rt_addr_newaddr_req_set_local(req, addr, ipalen);



	ret = rt_addr_newaddr(ys, req);

	rt_addr_newaddr_req_free(req);

err_req_alloc:

	ynl_sock_destroy(ys);

	return ret;

}



static inline void fill_neigh_req_header(struct ndmsg *ndm, int family,

					 int state, const char *dev)

{

	ndm->ndm_family = family;

	ndm->ndm_ifindex = if_nametoindex(dev);

	ndm->ndm_state = state;

	ndm->ndm_flags = 0;

	ndm->ndm_type = RTN_UNICAST;

}



static inline int ip_neigh_add(const char *dev, int family, void *addr,

			       unsigned char *lladdr)

{

	int nl_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;

	int ret = -1, ipalen = ip_addr_len(family);

	struct rt_neigh_newneigh_req *req;

	struct ynl_sock *ys;



	ys = ynl_sock_create(&ynl_rt_neigh_family, NULL);

	if (!ys)

		return -1;



	req = rt_neigh_newneigh_req_alloc();

	if (!req)

		goto err_req_alloc;



	fill_neigh_req_header(&req->_hdr, family, NUD_PERMANENT, dev);

	rt_neigh_newneigh_req_set_nlflags(req, nl_flags);

	rt_neigh_newneigh_req_set_dst(req, addr, ipalen);

	rt_neigh_newneigh_req_set_lladdr(req, lladdr, ETH_ALEN);

	rt_neigh_newneigh_req_set_ifindex(req, if_nametoindex(dev));



	ret = rt_neigh_newneigh(ys, req);

	rt_neigh_newneigh_req_free(req);

err_req_alloc:

	ynl_sock_destroy(ys);

	return ret;

}



static inline void fill_route_req_header(struct rtmsg *rtm, int family,

					 int table)

{

	rtm->rtm_family = family;

	rtm->rtm_table = table;

}



static inline int

ip_route_get(const char *dev, int family, int table, void *dst,

	     void (*parse_rsp)(struct rt_route_getroute_rsp *rsp, void *out),

	     void *out)

{

	int ret = -1, ipalen = ip_addr_len(family);

	struct rt_route_getroute_req *req;

	struct rt_route_getroute_rsp *rsp;

	struct ynl_sock *ys;



	ys = ynl_sock_create(&ynl_rt_route_family, NULL);

	if (!ys)

		return -1;



	req = rt_route_getroute_req_alloc();

	if (!req)

		goto err_req_alloc;



	fill_route_req_header(&req->_hdr, family, table);

	rt_route_getroute_req_set_nlflags(req, NLM_F_REQUEST);

	rt_route_getroute_req_set_dst(req, dst, ipalen);

	rt_route_getroute_req_set_oif(req, if_nametoindex(dev));



	rsp = rt_route_getroute(ys, req);

	if (!rsp)

		goto err_rsp_get;



	ret = 0;

	if (parse_rsp)

		parse_rsp(rsp, out);



	rt_route_getroute_rsp_free(rsp);

err_rsp_get:

	rt_route_getroute_req_free(req);

err_req_alloc:

	ynl_sock_destroy(ys);

	return ret;

}



static inline int

ip_link_add(const char *dev, char *link_type,

	    int (*fill_link_attr)(struct rt_link_newlink_req *req, void *data),

	    void *data)

{

	int nl_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;

	struct rt_link_newlink_req *req;

	struct ynl_sock *ys;

	int ret = -1;



	ys = ynl_sock_create(&ynl_rt_link_family, NULL);

	if (!ys)

		return -1;



	req = rt_link_newlink_req_alloc();

	if (!req)

		goto err_req_alloc;



	req->_hdr.ifi_flags = IFF_UP;

	rt_link_newlink_req_set_nlflags(req, nl_flags);

	rt_link_newlink_req_set_ifname(req, dev);

	rt_link_newlink_req_set_linkinfo_kind(req, link_type);



	if (fill_link_attr && fill_link_attr(req, data) < 0)

		goto err_attr_fill;



	ret = rt_link_newlink(ys, req);

err_attr_fill:

	rt_link_newlink_req_free(req);

err_req_alloc:

	ynl_sock_destroy(ys);

	return ret;

}



static inline int ip_link_del(const char *dev)

{

	struct rt_link_dellink_req *req;

	struct ynl_sock *ys;

	int ret = -1;



	ys = ynl_sock_create(&ynl_rt_link_family, NULL);

	if (!ys)

		return -1;



	req = rt_link_dellink_req_alloc();

	if (!req)

		goto err_req_alloc;



	rt_link_dellink_req_set_nlflags(req, NLM_F_REQUEST);

	rt_link_dellink_req_set_ifname(req, dev);



	ret = rt_link_dellink(ys, req);

	rt_link_dellink_req_free(req);

err_req_alloc:

	ynl_sock_destroy(ys);

	return ret;

}



static inline size_t build_eth(uint8_t *buf, uint16_t proto, unsigned char *src,

			       unsigned char *dest)

{

	struct ethhdr *eth = (struct ethhdr *)buf;



	eth->h_proto = htons(proto);

	memcpy(eth->h_source, src, ETH_ALEN);

	memcpy(eth->h_dest, dest, ETH_ALEN);



	return ETH_HLEN;

}



static inline uint32_t add_csum(const uint8_t *buf, int len)

{

	uint16_t *sbuf = (uint16_t *)buf;

	uint32_t sum = 0;



	while (len > 1) {

		sum += *sbuf++;

		len -= 2;

	}



	if (len)

		sum += *(uint8_t *)sbuf;



	return sum;

}



static inline uint16_t finish_ip_csum(uint32_t sum)

{

	while (sum >> 16)

		sum = (sum & 0xffff) + (sum >> 16);

	return ~((uint16_t)sum);

}



static inline uint16_t build_ip_csum(const uint8_t *buf, int len, uint32_t sum)

{

	sum += add_csum(buf, len);

	return finish_ip_csum(sum);

}



static inline int build_ipv4_header(uint8_t *buf, uint8_t proto,

				    int payload_len, struct in_addr *src,

				    struct in_addr *dst)

{

	struct iphdr *iph = (struct iphdr *)buf;



	iph->ihl = 5;

	iph->version = 4;

	iph->ttl = TUNTAP_DEFAULT_TTL;

	iph->tot_len = htons(sizeof(*iph) + payload_len);

	iph->id = htons(TUNTAP_DEFAULT_IPID);

	iph->protocol = proto;

	iph->saddr = src->s_addr;

	iph->daddr = dst->s_addr;

	iph->check = build_ip_csum(buf, iph->ihl << 2, 0);



	return iph->ihl << 2;

}



static inline void ipv6_set_dsfield(struct ipv6hdr *ip6h, uint8_t dsfield)

{

	uint16_t val, *ptr = (uint16_t *)ip6h;



	val = ntohs(*ptr);

	val &= 0xF00F;

	val |= ((uint16_t)dsfield) << 4;

	*ptr = htons(val);

}



static inline int build_ipv6_header(uint8_t *buf, uint8_t proto,

				    uint8_t dsfield, int payload_len,

				    struct in6_addr *src, struct in6_addr *dst)

{

	struct ipv6hdr *ip6h = (struct ipv6hdr *)buf;



	ip6h->version = 6;

	ip6h->payload_len = htons(payload_len);

	ip6h->nexthdr = proto;

	ip6h->hop_limit = TUNTAP_DEFAULT_TTL;

	ipv6_set_dsfield(ip6h, dsfield);

	memcpy(&ip6h->saddr, src, sizeof(ip6h->saddr));

	memcpy(&ip6h->daddr, dst, sizeof(ip6h->daddr));



	return sizeof(struct ipv6hdr);

}



static inline int build_geneve_header(uint8_t *buf, uint32_t vni)

{

	uint16_t protocol = htons(ETH_P_TEB);

	uint32_t geneve_vni = htonl((vni << 8) & 0xffffff00);



	memcpy(buf + 2, &protocol, 2);

	memcpy(buf + 4, &geneve_vni, 4);

	return GENEVE_HLEN;

}



static inline int build_udp_header(uint8_t *buf, uint16_t sport, uint16_t dport,

				   int payload_len)

{

	struct udphdr *udph = (struct udphdr *)buf;



	udph->source = htons(sport);

	udph->dest = htons(dport);

	udph->len = htons(sizeof(*udph) + payload_len);

	return sizeof(*udph);

}



static inline void build_udp_packet_csum(uint8_t *buf, int family,

					 bool csum_off)

{

	struct udphdr *udph = (struct udphdr *)buf;

	size_t ipalen = ip_addr_len(family);

	uint32_t sum;



	/* No extension IPv4 and IPv6 headers addresses are the last fields */

	sum = add_csum(buf - 2 * ipalen, 2 * ipalen);

	sum += htons(IPPROTO_UDP) + udph->len;



	if (!csum_off)

		sum += add_csum(buf, udph->len);



	udph->check = finish_ip_csum(sum);

}



static inline int build_udp_packet(uint8_t *buf, uint16_t sport, uint16_t dport,

				   int payload_len, int family, bool csum_off)

{

	struct udphdr *udph = (struct udphdr *)buf;



	build_udp_header(buf, sport, dport, payload_len);

	memset(buf + sizeof(*udph), PKT_DATA, payload_len);

	build_udp_packet_csum(buf, family, csum_off);



	return sizeof(*udph) + payload_len;

}



static inline int build_virtio_net_hdr_v1_hash_tunnel(uint8_t *buf, bool is_tap,

						      int hdr_len, int gso_size,

						      int outer_family,

						      int inner_family)

{

	struct virtio_net_hdr_v1_hash_tunnel *vh_tunnel = (void *)buf;

	struct virtio_net_hdr_v1 *vh = &vh_tunnel->hash_hdr.hdr;

	int outer_iphlen, inner_iphlen, eth_hlen, gso_type;



	eth_hlen = is_tap ? ETH_HLEN : 0;

	outer_iphlen = (outer_family == AF_INET) ? sizeof(struct iphdr) :

						   sizeof(struct ipv6hdr);

	inner_iphlen = (inner_family == AF_INET) ? sizeof(struct iphdr) :

						   sizeof(struct ipv6hdr);



	vh_tunnel->outer_th_offset = eth_hlen + outer_iphlen;

	vh_tunnel->inner_nh_offset = vh_tunnel->outer_th_offset + ETH_HLEN +

				     GENEVE_HLEN + sizeof(struct udphdr);



	vh->csum_start = vh_tunnel->inner_nh_offset + inner_iphlen;

	vh->csum_offset = __builtin_offsetof(struct udphdr, check);

	vh->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;

	vh->hdr_len = hdr_len;

	vh->gso_size = gso_size;



	if (gso_size) {

		gso_type = outer_family == AF_INET ?

				   VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV4 :

				   VIRTIO_NET_HDR_GSO_UDP_TUNNEL_IPV6;

		vh->gso_type = VIRTIO_NET_HDR_GSO_UDP_L4 | gso_type;

	}



	return sizeof(struct virtio_net_hdr_v1_hash_tunnel);

}



#endif /* _TUNTAP_HELPERS_H */