Akihiko Odaki wrote:
> The added tests confirm tun can perform RSS and hash reporting, and
> reject invalid configurations for them.
>
> Signed-off-by: Akihiko Odaki <akihiko.od...@daynix.com>
> Tested-by: Lei Yang <leiy...@redhat.com>
> ---
> tools/testing/selftests/net/Makefile | 2 +-
> tools/testing/selftests/net/tun.c | 584
> ++++++++++++++++++++++++++++++++++-
> 2 files changed, 576 insertions(+), 10 deletions(-)
>
> diff --git a/tools/testing/selftests/net/Makefile
> b/tools/testing/selftests/net/Makefile
> index
> 73ee88d6b043004be23b444de667a1d99a6045de..9772f691a9a011d99212df32463cdb930cf0a1a0
> 100644
> --- a/tools/testing/selftests/net/Makefile
> +++ b/tools/testing/selftests/net/Makefile
> @@ -123,6 +123,6 @@ $(OUTPUT)/reuseport_bpf_numa: LDLIBS += -lnuma
> $(OUTPUT)/tcp_mmap: LDLIBS += -lpthread -lcrypto
> $(OUTPUT)/tcp_inq: LDLIBS += -lpthread
> $(OUTPUT)/bind_bhash: LDLIBS += -lpthread
> -$(OUTPUT)/io_uring_zerocopy_tx: CFLAGS += -I../../../include/
> +$(OUTPUT)/io_uring_zerocopy_tx $(OUTPUT)/tun: CFLAGS += -I../../../include/
>
> include bpf.mk
> diff --git a/tools/testing/selftests/net/tun.c
> b/tools/testing/selftests/net/tun.c
> index
> 463dd98f2b80b1bdcb398cee43c834e7dc5cf784..acadeea7194eaea9416a605b47f99f7a5f1f80cd
> 100644
> --- a/tools/testing/selftests/net/tun.c
> +++ b/tools/testing/selftests/net/tun.c
> @@ -2,21 +2,38 @@
>
> #define _GNU_SOURCE
>
> +#include <endian.h>
> #include <errno.h>
> #include <fcntl.h>
> +#include <sched.h>
> +#include <stddef.h>
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> #include <unistd.h>
> -#include <linux/if.h>
> +#include <net/if.h>
> +#include <netinet/ip.h>
> +#include <sys/ioctl.h>
> +#include <sys/socket.h>
> +#include <linux/compiler.h>
> +#include <linux/icmp.h>
> +#include <linux/if_arp.h>
> #include <linux/if_tun.h>
> +#include <linux/ipv6.h>
> #include <linux/netlink.h>
> #include <linux/rtnetlink.h>
> -#include <sys/ioctl.h>
> -#include <sys/socket.h>
> +#include <linux/sockios.h>
> +#include <linux/tcp.h>
> +#include <linux/udp.h>
> +#include <linux/virtio_net.h>
>
> #include "../kselftest_harness.h"
>
> +#define TUN_HWADDR_SOURCE { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 }
> +#define TUN_HWADDR_DEST { 0x02, 0x00, 0x00, 0x00, 0x00, 0x01 }
> +#define TUN_IPADDR_SOURCE htonl((172 << 24) | (17 << 16) | 0)
> +#define TUN_IPADDR_DEST htonl((172 << 24) | (17 << 16) | 1)
> +
> static int tun_attach(int fd, char *dev)
> {
> struct ifreq ifr;
> @@ -39,7 +56,7 @@ static int tun_detach(int fd, char *dev)
> return ioctl(fd, TUNSETQUEUE, (void *) &ifr);
> }
>
> -static int tun_alloc(char *dev)
> +static int tun_alloc(char *dev, short flags)
> {
> struct ifreq ifr;
> int fd, err;
> @@ -52,7 +69,8 @@ static int tun_alloc(char *dev)
>
> memset(&ifr, 0, sizeof(ifr));
> strcpy(ifr.ifr_name, dev);
> - ifr.ifr_flags = IFF_TAP | IFF_NAPI | IFF_MULTI_QUEUE;
> + ifr.ifr_flags = flags | IFF_TAP | IFF_NAPI | IFF_NO_PI |
> + IFF_MULTI_QUEUE;
>
> err = ioctl(fd, TUNSETIFF, (void *) &ifr);
> if (err < 0) {
> @@ -64,6 +82,40 @@ static int tun_alloc(char *dev)
> return fd;
> }
>
> +static bool tun_add_to_bridge(int local_fd, const char *name)
> +{
> + struct ifreq ifreq = {
> + .ifr_name = "xbridge",
> + .ifr_ifindex = if_nametoindex(name)
> + };
> +
> + if (!ifreq.ifr_ifindex) {
> + perror("if_nametoindex");
> + return false;
> + }
> +
> + if (ioctl(local_fd, SIOCBRADDIF, &ifreq)) {
> + perror("SIOCBRADDIF");
> + return false;
> + }
> +
> + return true;
> +}
> +
> +static bool tun_set_flags(int local_fd, const char *name, short flags)
> +{
> + struct ifreq ifreq = { .ifr_flags = flags };
> +
> + strcpy(ifreq.ifr_name, name);
> +
> + if (ioctl(local_fd, SIOCSIFFLAGS, &ifreq)) {
> + perror("SIOCSIFFLAGS");
> + return false;
> + }
> +
> + return true;
> +}
> +
> static int tun_delete(char *dev)
> {
> struct {
> @@ -102,6 +154,156 @@ static int tun_delete(char *dev)
> return ret;
> }
>
> +static uint32_t tun_sum(const void *buf, size_t len)
> +{
> + const uint16_t *sbuf = buf;
> + uint32_t sum = 0;
> +
> + while (len > 1) {
> + sum += *sbuf++;
> + len -= 2;
> + }
> +
> + if (len)
> + sum += *(uint8_t *)sbuf;
> +
> + return sum;
> +}
> +
> +static uint16_t tun_build_ip_check(uint32_t sum)
> +{
> + return ~((sum & 0xffff) + (sum >> 16));
> +}
> +
> +static uint32_t tun_build_ip_pseudo_sum(const void *iphdr)
> +{
> + uint16_t tot_len = ntohs(((struct iphdr *)iphdr)->tot_len);
> +
> + return tun_sum((char *)iphdr + offsetof(struct iphdr, saddr), 8) +
> + htons(((struct iphdr *)iphdr)->protocol) +
> + htons(tot_len - sizeof(struct iphdr));
> +}
> +
> +static uint32_t tun_build_ipv6_pseudo_sum(const void *ipv6hdr)
> +{
> + return tun_sum((char *)ipv6hdr + offsetof(struct ipv6hdr, saddr), 32) +
> + ((struct ipv6hdr *)ipv6hdr)->payload_len +
> + htons(((struct ipv6hdr *)ipv6hdr)->nexthdr);
> +}
> +
> +static void tun_build_ethhdr(struct ethhdr *ethhdr, uint16_t proto)
> +{
> + *ethhdr = (struct ethhdr) {
> + .h_dest = TUN_HWADDR_DEST,
> + .h_source = TUN_HWADDR_SOURCE,
> + .h_proto = htons(proto)
> + };
> +}
> +
> +static void tun_build_iphdr(void *dest, uint16_t len, uint8_t protocol)
> +{
> + struct iphdr iphdr = {
> + .ihl = sizeof(iphdr) / 4,
> + .version = 4,
> + .tot_len = htons(sizeof(iphdr) + len),
> + .ttl = 255,
> + .protocol = protocol,
> + .saddr = TUN_IPADDR_SOURCE,
> + .daddr = TUN_IPADDR_DEST
> + };
> +
> + iphdr.check = tun_build_ip_check(tun_sum(&iphdr, sizeof(iphdr)));
> + memcpy(dest, &iphdr, sizeof(iphdr));
> +}
> +
> +static void tun_build_ipv6hdr(void *dest, uint16_t len, uint8_t protocol)
> +{
> + struct ipv6hdr ipv6hdr = {
> + .version = 6,
> + .payload_len = htons(len),
> + .nexthdr = protocol,
> + .saddr = {
> + .s6_addr32 = {
> + htonl(0xffff0000), 0, 0, TUN_IPADDR_SOURCE
> + }
> + },
> + .daddr = {
> + .s6_addr32 = {
> + htonl(0xffff0000), 0, 0, TUN_IPADDR_DEST
> + }
> + },
> + };
> +
> + memcpy(dest, &ipv6hdr, sizeof(ipv6hdr));
> +}
> +
> +static void tun_build_tcphdr(void *dest, uint32_t sum)
> +{
> + struct tcphdr tcphdr = {
> + .source = htons(9),
> + .dest = htons(9),
> + .fin = 1,
> + .doff = sizeof(tcphdr) / 4,
> + };
> + uint32_t tcp_sum = tun_sum(&tcphdr, sizeof(tcphdr));
> +
> + tcphdr.check = tun_build_ip_check(sum + tcp_sum);
> + memcpy(dest, &tcphdr, sizeof(tcphdr));
> +}
> +
> +static void tun_build_udphdr(void *dest, uint32_t sum)
> +{
> + struct udphdr udphdr = {
> + .source = htons(9),
> + .dest = htons(9),
> + .len = htons(sizeof(udphdr)),
> + };
> + uint32_t udp_sum = tun_sum(&udphdr, sizeof(udphdr));
> +
> + udphdr.check = tun_build_ip_check(sum + udp_sum);
> + memcpy(dest, &udphdr, sizeof(udphdr));
> +}
> +
> +static bool tun_vnet_hash_check(int source_fd, const int *dest_fds,
> + const void *buffer, size_t len,
> + uint8_t flags,
> + uint16_t hash_report, uint32_t hash_value)
> +{
> + size_t read_len = sizeof(struct virtio_net_hdr_v1_hash) + len;
> + struct virtio_net_hdr_v1_hash *read_buffer;
> + struct virtio_net_hdr_v1_hash hdr = {
> + .hdr = { .flags = flags },
> + .hash_value = htole32(hash_value),
> + .hash_report = htole16(hash_report)
> + };
> + int ret;
> + int txq = hash_report ? hash_value & 1 : 2;
> +
> + if (write(source_fd, buffer, len) != len) {
> + perror("write");
> + return false;
> + }
> +
> + read_buffer = malloc(read_len);
> + if (!read_buffer) {
> + perror("malloc");
> + return false;
> + }
> +
> + ret = read(dest_fds[txq], read_buffer, read_len);
> + if (ret != read_len) {
> + perror("read");
> + free(read_buffer);
> + return false;
> + }
> +
> + ret = !memcmp(read_buffer, &hdr, sizeof(*read_buffer)) &&
> + !memcmp(read_buffer + 1, buffer, len);
> +
> + free(read_buffer);
> + return ret;
> +}
> +
> FIXTURE(tun)
> {
> char ifname[IFNAMSIZ];
> @@ -112,10 +314,10 @@ FIXTURE_SETUP(tun)
> {
> memset(self->ifname, 0, sizeof(self->ifname));
>
> - self->fd = tun_alloc(self->ifname);
> + self->fd = tun_alloc(self->ifname, 0);
> ASSERT_GE(self->fd, 0);
>
> - self->fd2 = tun_alloc(self->ifname);
> + self->fd2 = tun_alloc(self->ifname, 0);
> ASSERT_GE(self->fd2, 0);
> }
>
> @@ -168,7 +370,7 @@ FIXTURE(tun_deleted)
> FIXTURE_SETUP(tun_deleted)
> {
> self->ifname[0] = 0;
> - self->fd = tun_alloc(self->ifname);
> + self->fd = tun_alloc(self->ifname, 0);
> ASSERT_LE(0, self->fd);
>
> ASSERT_EQ(0, tun_delete(self->ifname))
> @@ -233,4 +435,368 @@ TEST_F(tun_deleted, setvnethash)
> EXPECT_EQ(EBADFD, errno);
> }
>
> -TEST_HARNESS_MAIN
> +FIXTURE(tun_vnet_hash)
> +{
> + int local_fd;
> + int source_fd;
> + int dest_fds[3];
> +};
> +
> +FIXTURE_SETUP(tun_vnet_hash)
> +{
> + static const struct {
> + struct tun_vnet_hash hdr;
> + struct tun_vnet_hash_rss rss;
> + uint16_t rss_indirection_table[2];
> + uint8_t rss_key[40];
> + } vnet_hash = {
> + .hdr = {
> + .flags = TUN_VNET_HASH_REPORT | TUN_VNET_HASH_RSS,
> + .types = VIRTIO_NET_RSS_HASH_TYPE_IPv4 |
> + VIRTIO_NET_RSS_HASH_TYPE_TCPv4 |
> + VIRTIO_NET_RSS_HASH_TYPE_UDPv4 |
> + VIRTIO_NET_RSS_HASH_TYPE_IPv6 |
> + VIRTIO_NET_RSS_HASH_TYPE_TCPv6 |
> + VIRTIO_NET_RSS_HASH_TYPE_UDPv6
> + },
> + .rss = { .indirection_table_mask = 1, .unclassified_queue = 5 },
> + .rss_indirection_table = { 3, 4 },
> + .rss_key = {
> + 0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
> + 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f, 0xb0,
> + 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b, 0x30, 0xb4,
> + 0x77, 0xcb, 0x2d, 0xa3, 0x80, 0x30, 0xf2, 0x0c,
> + 0x6a, 0x42, 0xb7, 0x3b, 0xbe, 0xac, 0x01, 0xfa
> + }
> + };
> +
> + struct {
> + struct virtio_net_hdr_v1_hash vnet_hdr;
> + struct ethhdr ethhdr;
> + struct arphdr arphdr;
> + unsigned char sender_hwaddr[6];
> + uint32_t sender_ipaddr;
> + unsigned char target_hwaddr[6];
> + uint32_t target_ipaddr;
> + } __packed packet = {
> + .ethhdr = {
> + .h_source = TUN_HWADDR_SOURCE,
> + .h_dest = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff },
> + .h_proto = htons(ETH_P_ARP)
> + },
> + .arphdr = {
> + .ar_hrd = htons(ARPHRD_ETHER),
> + .ar_pro = htons(ETH_P_IP),
> + .ar_hln = ETH_ALEN,
> + .ar_pln = 4,
> + .ar_op = htons(ARPOP_REQUEST)
> + },
> + .sender_hwaddr = TUN_HWADDR_DEST,
> + .sender_ipaddr = TUN_IPADDR_DEST,
> + .target_ipaddr = TUN_IPADDR_DEST
> + };
> +
> + struct tun_vnet_hash cap;
> + char source_ifname[IFNAMSIZ] = "";
> + char dest_ifname[IFNAMSIZ] = "";
> + int i;
> +
> + self->local_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
> + ASSERT_LE(0, self->local_fd);
> +
> + self->source_fd = tun_alloc(source_ifname, 0);
> + ASSERT_LE(0, self->source_fd) {
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + i = ioctl(self->source_fd, TUNGETVNETHASHCAP, &cap);
> + if (i == -1 && errno == EINVAL) {
> + EXPECT_EQ(0, close(self->local_fd));
> + SKIP(return, "TUNGETVNETHASHCAP not supported");
> + }
> +
> + ASSERT_EQ(0, i)
> + EXPECT_EQ(0, close(self->local_fd));
> +
> + if ((cap.flags & vnet_hash.hdr.flags) != vnet_hash.hdr.flags) {
> + EXPECT_EQ(0, close(self->local_fd));
> + SKIP(return, "Lacks some hash flag support");
> + }
> +
> + if ((cap.types & vnet_hash.hdr.types) != vnet_hash.hdr.types) {
> + EXPECT_EQ(0, close(self->local_fd));
> + SKIP(return, "Lacks some hash type support");
> + }
> +
> + ASSERT_TRUE(tun_set_flags(self->local_fd, source_ifname, IFF_UP))
> + EXPECT_EQ(0, close(self->local_fd));
> +
> + self->dest_fds[0] = tun_alloc(dest_ifname, IFF_VNET_HDR);
> + ASSERT_LE(0, self->dest_fds[0]) {
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + i = sizeof(struct virtio_net_hdr_v1_hash);
> + ASSERT_EQ(0, ioctl(self->dest_fds[0], TUNSETVNETHDRSZ, &i)) {
> + EXPECT_EQ(0, close(self->dest_fds[0]));
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + i = 1;
> + ASSERT_EQ(0, ioctl(self->dest_fds[0], TUNSETVNETLE, &i)) {
> + EXPECT_EQ(0, close(self->dest_fds[0]));
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + ASSERT_TRUE(tun_set_flags(self->local_fd, dest_ifname, IFF_UP)) {
> + EXPECT_EQ(0, close(self->dest_fds[0]));
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + ASSERT_EQ(sizeof(packet),
> + write(self->dest_fds[0], &packet, sizeof(packet))) {
> + EXPECT_EQ(0, close(self->dest_fds[0]));
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + ASSERT_EQ(0, ioctl(self->dest_fds[0], TUNSETVNETHASH, &vnet_hash)) {
> + EXPECT_EQ(0, close(self->dest_fds[0]));
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + for (i = 1; i < ARRAY_SIZE(self->dest_fds); i++) {
> + self->dest_fds[i] = tun_alloc(dest_ifname, IFF_VNET_HDR);
> + ASSERT_LE(0, self->dest_fds[i]) {
> + while (i) {
> + i--;
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> + }
> +
> + ASSERT_EQ(0, ioctl(self->local_fd, SIOCBRADDBR, "xbridge")) {
> + EXPECT_EQ(0, ioctl(self->local_fd, SIOCBRDELBR, "xbridge"));
> +
> + for (i = 0; i < ARRAY_SIZE(self->dest_fds); i++)
> + EXPECT_EQ(0, close(self->dest_fds[i]));
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + ASSERT_TRUE(tun_add_to_bridge(self->local_fd, source_ifname)) {
> + EXPECT_EQ(0, ioctl(self->local_fd, SIOCBRDELBR, "xbridge"));
> +
> + for (i = 0; i < ARRAY_SIZE(self->dest_fds); i++)
> + EXPECT_EQ(0, close(self->dest_fds[i]));
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + ASSERT_TRUE(tun_add_to_bridge(self->local_fd, dest_ifname)) {
> + EXPECT_EQ(0, ioctl(self->local_fd, SIOCBRDELBR, "xbridge"));
> +
> + for (i = 0; i < ARRAY_SIZE(self->dest_fds); i++)
> + EXPECT_EQ(0, close(self->dest_fds[i]));
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + ASSERT_TRUE(tun_set_flags(self->local_fd, "xbridge", IFF_UP)) {
> + EXPECT_EQ(0, ioctl(self->local_fd, SIOCBRDELBR, "xbridge"));
> +
> + for (i = 0; i < ARRAY_SIZE(self->dest_fds); i++)
> + EXPECT_EQ(0, close(self->dest_fds[i]));
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +}
> +
> +FIXTURE_TEARDOWN(tun_vnet_hash)
> +{
> + ASSERT_TRUE(tun_set_flags(self->local_fd, "xbridge", 0)) {
> + for (size_t i = 0; i < ARRAY_SIZE(self->dest_fds); i++)
> + EXPECT_EQ(0, close(self->dest_fds[i]));
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> + }
> +
> + EXPECT_EQ(0, ioctl(self->local_fd, SIOCBRDELBR, "xbridge"));
> +
> + for (size_t i = 0; i < ARRAY_SIZE(self->dest_fds); i++)
> + EXPECT_EQ(0, close(self->dest_fds[i]));
> +
> + EXPECT_EQ(0, close(self->source_fd));
> + EXPECT_EQ(0, close(self->local_fd));
> +}
> +
> +TEST_F(tun_vnet_hash, unclassified)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct iphdr iphdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_LOOPBACK);
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet), 0,
> + VIRTIO_NET_HASH_REPORT_NONE, 0));
> +}
> +
> +TEST_F(tun_vnet_hash, ipv4)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct iphdr iphdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_IP);
> + tun_build_iphdr(&packet.iphdr, 0, 253);
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet), 0,
> + VIRTIO_NET_HASH_REPORT_IPv4,
> + 0x6e45d952));
> +}
> +
> +TEST_F(tun_vnet_hash, tcpv4)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct iphdr iphdr;
> + struct tcphdr tcphdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_IP);
> + tun_build_iphdr(&packet.iphdr, sizeof(struct tcphdr), IPPROTO_TCP);
> +
> + tun_build_tcphdr(&packet.tcphdr,
> + tun_build_ip_pseudo_sum(&packet.iphdr));
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet),
> + VIRTIO_NET_HDR_F_DATA_VALID,
> + VIRTIO_NET_HASH_REPORT_TCPv4,
> + 0xfb63539a));
> +}
> +
> +TEST_F(tun_vnet_hash, udpv4)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct iphdr iphdr;
> + struct udphdr udphdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_IP);
> + tun_build_iphdr(&packet.iphdr, sizeof(struct udphdr), IPPROTO_UDP);
> +
> + tun_build_udphdr(&packet.udphdr,
> + tun_build_ip_pseudo_sum(&packet.iphdr));
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet),
> + VIRTIO_NET_HDR_F_DATA_VALID,
> + VIRTIO_NET_HASH_REPORT_UDPv4,
> + 0xfb63539a));
> +}
> +
> +TEST_F(tun_vnet_hash, ipv6)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct ipv6hdr ipv6hdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_IPV6);
> + tun_build_ipv6hdr(&packet.ipv6hdr, 0, 253);
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet), 0,
> + VIRTIO_NET_HASH_REPORT_IPv6,
> + 0xd6eb560f));
> +}
> +
> +TEST_F(tun_vnet_hash, tcpv6)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct ipv6hdr ipv6hdr;
> + struct tcphdr tcphdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_IPV6);
> + tun_build_ipv6hdr(&packet.ipv6hdr, sizeof(struct tcphdr), IPPROTO_TCP);
> +
> + tun_build_tcphdr(&packet.tcphdr,
> + tun_build_ipv6_pseudo_sum(&packet.ipv6hdr));
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet),
> + VIRTIO_NET_HDR_F_DATA_VALID,
> + VIRTIO_NET_HASH_REPORT_TCPv6,
> + 0xc2b9f251));
> +}
> +
> +TEST_F(tun_vnet_hash, udpv6)
> +{
> + struct {
> + struct ethhdr ethhdr;
> + struct ipv6hdr ipv6hdr;
> + struct udphdr udphdr;
> + } __packed packet;
> +
> + tun_build_ethhdr(&packet.ethhdr, ETH_P_IPV6);
> + tun_build_ipv6hdr(&packet.ipv6hdr, sizeof(struct udphdr), IPPROTO_UDP);
> +
> + tun_build_udphdr(&packet.udphdr,
> + tun_build_ipv6_pseudo_sum(&packet.ipv6hdr));
> +
> + EXPECT_TRUE(tun_vnet_hash_check(self->source_fd, self->dest_fds,
> + &packet, sizeof(packet),
> + VIRTIO_NET_HDR_F_DATA_VALID,
> + VIRTIO_NET_HASH_REPORT_UDPv6,
> + 0xc2b9f251));
> +}
> +
> +int main(int argc, char **argv)
> +{
> + FILE *file;
> +
> + if (unshare(CLONE_NEWNET)) {
> + perror("unshare");
> + return KSFT_FAIL;
> + }
> +
> + file = fopen("/proc/sys/net/ipv6/conf/default/disable_ipv6", "w");
> + if (file) {
> + if (fputc('1', file) != '1') {
> + perror("fputc");
> + return KSFT_FAIL;
> + }
> +
> + if (fclose(file)) {
> + perror("fclose");
> + return KSFT_FAIL;
> + }
> + } else if (errno != ENOENT) {
> + perror("fopen");
> + return KSFT_FAIL;
> + }
What is the purpose of this disable_ipv6?
> +
> + return test_harness_run(argc, argv);
> +}
>
> --
> 2.48.1
>
