selftests: drv-net: add checksum tests
authorWillem de Bruijn <willemb@google.com>
Tue, 7 May 2024 15:40:58 +0000 (11:40 -0400)
committerJakub Kicinski <kuba@kernel.org>
Thu, 9 May 2024 01:57:55 +0000 (18:57 -0700)
Run tools/testing/selftest/net/csum.c as part of drv-net.
This binary covers multiple scenarios, based on arguments given,
for both IPv4 and IPv6:

- Accept UDP correct checksum
- Detect UDP invalid checksum
- Accept TCP correct checksum
- Detect TCP invalid checksum

- Transmit UDP: basic checksum offload
- Transmit UDP: zero checksum conversion

The test direction is reversed between receive and transmit tests, so
that the NIC under test is always the local machine.

In total this adds up to 12 testcases, with more to follow. For
conciseness, I replaced individual functions with a function factory.

Also detect hardware offload feature availability using Ethtool
netlink and skip tests when either feature is off. This need may be
common for offload feature tests and eventually deserving of a thin
wrapper in lib.py.

Missing are the PF_PACKET based send tests ('-P'). These use
virtio_net_hdr to program hardware checksum offload. Which requires
looking up the local MAC address and (harder) the MAC of the next hop.
I'll have to give it some though how to do that robustly and where
that code would belong.

Tested:

        make -C tools/testing/selftests/ \
                TARGETS="drivers/net drivers/net/hw" \
                install INSTALL_PATH=/tmp/ksft
        cd /tmp/ksft

sudo NETIF=ens4 REMOTE_TYPE=ssh \
REMOTE_ARGS="root@10.40.0.2" \
LOCAL_V4="10.40.0.1" \
REMOTE_V4="10.40.0.2" \
./run_kselftest.sh -t drivers/net/hw:csum.py

Signed-off-by: Willem de Bruijn <willemb@google.com>
Link: https://lore.kernel.org/r/20240507154216.501111-1-willemdebruijn.kernel@gmail.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
tools/testing/selftests/drivers/net/hw/Makefile
tools/testing/selftests/drivers/net/hw/csum.py [new file with mode: 0755]
tools/testing/selftests/net/.gitignore
tools/testing/selftests/net/Makefile
tools/testing/selftests/net/csum.c [deleted file]
tools/testing/selftests/net/lib/.gitignore [new file with mode: 0644]
tools/testing/selftests/net/lib/Makefile
tools/testing/selftests/net/lib/csum.c [new file with mode: 0644]

index 1dd7328..4933d04 100644 (file)
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0+ OR MIT
 
 TEST_PROGS = \
+       csum.py \
        devlink_port_split.py \
        ethtool.sh \
        ethtool_extended_state.sh \
diff --git a/tools/testing/selftests/drivers/net/hw/csum.py b/tools/testing/selftests/drivers/net/hw/csum.py
new file mode 100755 (executable)
index 0000000..cb40497
--- /dev/null
@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0
+
+"""Run the tools/testing/selftests/net/csum testsuite."""
+
+from os import path
+
+from lib.py import ksft_run, ksft_exit, KsftSkipEx
+from lib.py import EthtoolFamily, NetDrvEpEnv
+from lib.py import bkg, cmd, wait_port_listen
+
+def test_receive(cfg, ipv4=False, extra_args=None):
+    """Test local nic checksum receive. Remote host sends crafted packets."""
+    if not cfg.have_rx_csum:
+        raise KsftSkipEx(f"Test requires rx checksum offload on {cfg.ifname}")
+
+    if ipv4:
+        ip_args = f"-4 -S {cfg.remote_v4} -D {cfg.v4}"
+    else:
+        ip_args = f"-6 -S {cfg.remote_v6} -D {cfg.v6}"
+
+    rx_cmd = f"{cfg.bin_local} -i {cfg.ifname} -n 100 {ip_args} -r 1 -R {extra_args}"
+    tx_cmd = f"{cfg.bin_remote} -i {cfg.ifname} -n 100 {ip_args} -r 1 -T {extra_args}"
+
+    with bkg(rx_cmd, exit_wait=True):
+        wait_port_listen(34000, proto="udp")
+        cmd(tx_cmd, host=cfg.remote)
+
+
+def test_transmit(cfg, ipv4=False, extra_args=None):
+    """Test local nic checksum transmit. Remote host verifies packets."""
+    if (not cfg.have_tx_csum_generic and
+        not (cfg.have_tx_csum_ipv4 and ipv4) and
+        not (cfg.have_tx_csum_ipv6 and not ipv4)):
+        raise KsftSkipEx(f"Test requires tx checksum offload on {cfg.ifname}")
+
+    if ipv4:
+        ip_args = f"-4 -S {cfg.v4} -D {cfg.remote_v4}"
+    else:
+        ip_args = f"-6 -S {cfg.v6} -D {cfg.remote_v6}"
+
+    # Cannot randomize input when calculating zero checksum
+    if extra_args != "-U -Z":
+        extra_args += " -r 1"
+
+    rx_cmd = f"{cfg.bin_remote} -i {cfg.ifname} -L 1 -n 100 {ip_args} -R {extra_args}"
+    tx_cmd = f"{cfg.bin_local} -i {cfg.ifname} -L 1 -n 100 {ip_args} -T {extra_args}"
+
+    with bkg(rx_cmd, host=cfg.remote, exit_wait=True):
+        wait_port_listen(34000, proto="udp", host=cfg.remote)
+        cmd(tx_cmd)
+
+
+def test_builder(name, cfg, ipv4=False, tx=False, extra_args=""):
+    """Construct specific tests from the common template.
+
+       Most tests follow the same basic pattern, differing only in
+       Direction of the test and optional flags passed to csum."""
+    def f(cfg):
+        if ipv4:
+            cfg.require_v4()
+        else:
+            cfg.require_v6()
+
+        if tx:
+            test_transmit(cfg, ipv4, extra_args)
+        else:
+            test_receive(cfg, ipv4, extra_args)
+
+    if ipv4:
+        f.__name__ = "ipv4_" + name
+    else:
+        f.__name__ = "ipv6_" + name
+    return f
+
+
+def check_nic_features(cfg) -> None:
+    """Test whether Tx and Rx checksum offload are enabled.
+
+       If the device under test has either off, then skip the relevant tests."""
+    cfg.have_tx_csum_generic = False
+    cfg.have_tx_csum_ipv4 = False
+    cfg.have_tx_csum_ipv6 = False
+    cfg.have_rx_csum = False
+
+    ethnl = EthtoolFamily()
+    features = ethnl.features_get({"header": {"dev-index": cfg.ifindex}})
+    for f in features["active"]["bits"]["bit"]:
+        if f["name"] == "tx-checksum-ip-generic":
+            cfg.have_tx_csum_generic = True
+        elif f["name"] == "tx-checksum-ipv4":
+            cfg.have_tx_csum_ipv4 = True
+        elif f["name"] == "tx-checksum-ipv6":
+            cfg.have_tx_csum_ipv6 = True
+        elif f["name"] == "rx-checksum":
+            cfg.have_rx_csum = True
+
+
+def main() -> None:
+    with NetDrvEpEnv(__file__, nsim_test=False) as cfg:
+        check_nic_features(cfg)
+
+        cfg.bin_local = path.abspath(path.dirname(__file__) + "/../../../net/lib/csum")
+        cfg.bin_remote = cfg.remote.deploy(cfg.bin_local)
+
+        cases = []
+        for ipv4 in [True, False]:
+            cases.append(test_builder("rx_tcp", cfg, ipv4, False, "-t"))
+            cases.append(test_builder("rx_tcp_invalid", cfg, ipv4, False, "-t -E"))
+
+            cases.append(test_builder("rx_udp", cfg, ipv4, False, ""))
+            cases.append(test_builder("rx_udp_invalid", cfg, ipv4, False, "-E"))
+
+            cases.append(test_builder("tx_udp_csum_offload", cfg, ipv4, True, "-U"))
+            cases.append(test_builder("tx_udp_zero_checksum", cfg, ipv4, True, "-U -Z"))
+
+        ksft_run(cases=cases, args=(cfg, ))
+    ksft_exit()
+
+
+if __name__ == "__main__":
+    main()
index d996a0a..74ae106 100644 (file)
@@ -2,7 +2,6 @@
 bind_bhash
 bind_timewait
 bind_wildcard
-csum
 cmsg_sender
 diag_uid
 fin_ack_lat
index 5befca2..052c214 100644 (file)
@@ -81,7 +81,6 @@ TEST_PROGS += test_ingress_egress_chaining.sh
 TEST_GEN_PROGS += so_incoming_cpu
 TEST_PROGS += sctp_vrf.sh
 TEST_GEN_FILES += sctp_hello
-TEST_GEN_FILES += csum
 TEST_GEN_FILES += ip_local_port_range
 TEST_GEN_FILES += bind_wildcard
 TEST_PROGS += test_vxlan_mdb.sh
diff --git a/tools/testing/selftests/net/csum.c b/tools/testing/selftests/net/csum.c
deleted file mode 100644 (file)
index b9f3fc3..0000000
+++ /dev/null
@@ -1,1000 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-
-/* Test hardware checksum offload: Rx + Tx, IPv4 + IPv6, TCP + UDP.
- *
- * The test runs on two machines to exercise the NIC. For this reason it
- * is not integrated in kselftests.
- *
- *     CMD=$((./csum -[46] -[tu] -S $SADDR -D $DADDR -[RT] -r 1 $EXTRA_ARGS))
- *
- * Rx:
- *
- * The sender sends packets with a known checksum field using PF_INET(6)
- * SOCK_RAW sockets.
- *
- * good packet: $CMD [-t]
- * bad packet:  $CMD [-t] -E
- *
- * The receiver reads UDP packets with a UDP socket. This is not an
- * option for TCP packets ('-t'). Optionally insert an iptables filter
- * to avoid these entering the real protocol stack.
- *
- * The receiver also reads all packets with a PF_PACKET socket, to
- * observe whether both good and bad packets arrive on the host. And to
- * read the optional TP_STATUS_CSUM_VALID bit. This requires setting
- * option PACKET_AUXDATA, and works only for CHECKSUM_UNNECESSARY.
- *
- * Tx:
- *
- * The sender needs to build CHECKSUM_PARTIAL packets to exercise tx
- * checksum offload.
- *
- * The sender can sends packets with a UDP socket.
- *
- * Optionally crafts a packet that sums up to zero to verify that the
- * device writes negative zero 0xFFFF in this case to distinguish from
- * 0x0000 (checksum disabled), as required by RFC 768. Hit this case
- * by choosing a specific source port.
- *
- * good packet: $CMD -U
- * zero csum:   $CMD -U -Z
- *
- * The sender can also build packets with PF_PACKET with PACKET_VNET_HDR,
- * to cover more protocols. PF_PACKET requires passing src and dst mac
- * addresses.
- *
- * good packet: $CMD -s $smac -d $dmac -p [-t]
- *
- * Argument '-z' sends UDP packets with a 0x000 checksum disabled field,
- * to verify that the NIC passes these packets unmodified.
- *
- * Argument '-e' adds a transport mode encapsulation header between
- * network and transport header. This will fail for devices that parse
- *  headers. Should work on devices that implement protocol agnostic tx
- * checksum offload (NETIF_F_HW_CSUM).
- *
- * Argument '-r $SEED' optionally randomizes header, payload and length
- * to increase coverage between packets sent. SEED 1 further chooses a
- * different seed for each run (and logs this for reproducibility). It
- * is advised to enable this for extra coverage in continuous testing.
- */
-
-#define _GNU_SOURCE
-
-#include <arpa/inet.h>
-#include <asm/byteorder.h>
-#include <errno.h>
-#include <error.h>
-#include <linux/filter.h>
-#include <linux/if_packet.h>
-#include <linux/ipv6.h>
-#include <linux/virtio_net.h>
-#include <net/ethernet.h>
-#include <net/if.h>
-#include <netinet/if_ether.h>
-#include <netinet/in.h>
-#include <netinet/ip.h>
-#include <netinet/ip6.h>
-#include <netinet/tcp.h>
-#include <netinet/udp.h>
-#include <poll.h>
-#include <sched.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "kselftest.h"
-
-static bool cfg_bad_csum;
-static int cfg_family = PF_INET6;
-static int cfg_num_pkt = 4;
-static bool cfg_do_rx = true;
-static bool cfg_do_tx = true;
-static bool cfg_encap;
-static char *cfg_ifname = "eth0";
-static char *cfg_mac_dst;
-static char *cfg_mac_src;
-static int cfg_proto = IPPROTO_UDP;
-static int cfg_payload_char = 'a';
-static int cfg_payload_len = 100;
-static uint16_t cfg_port_dst = 34000;
-static uint16_t cfg_port_src = 33000;
-static uint16_t cfg_port_src_encap = 33001;
-static unsigned int cfg_random_seed;
-static int cfg_rcvbuf = 1 << 22;       /* be able to queue large cfg_num_pkt */
-static bool cfg_send_pfpacket;
-static bool cfg_send_udp;
-static int cfg_timeout_ms = 2000;
-static bool cfg_zero_disable; /* skip checksum: set to zero (udp only) */
-static bool cfg_zero_sum;     /* create packet that adds up to zero */
-
-static struct sockaddr_in cfg_daddr4 = {.sin_family = AF_INET};
-static struct sockaddr_in cfg_saddr4 = {.sin_family = AF_INET};
-static struct sockaddr_in6 cfg_daddr6 = {.sin6_family = AF_INET6};
-static struct sockaddr_in6 cfg_saddr6 = {.sin6_family = AF_INET6};
-
-#define ENC_HEADER_LEN (sizeof(struct udphdr) + sizeof(struct udp_encap_hdr))
-#define MAX_HEADER_LEN (sizeof(struct ipv6hdr) + ENC_HEADER_LEN + sizeof(struct tcphdr))
-#define MAX_PAYLOAD_LEN 1024
-
-/* Trivial demo encap. Stand-in for transport layer protocols like ESP or PSP */
-struct udp_encap_hdr {
-       uint8_t nexthdr;
-       uint8_t padding[3];
-};
-
-/* Ipaddrs, for pseudo csum. Global var is ugly, pass through funcs was worse */
-static void *iph_addr_p;
-
-static unsigned long gettimeofday_ms(void)
-{
-       struct timeval tv;
-
-       gettimeofday(&tv, NULL);
-       return (tv.tv_sec * 1000UL) + (tv.tv_usec / 1000UL);
-}
-
-static uint32_t checksum_nofold(char *data, size_t len, uint32_t sum)
-{
-       uint16_t *words = (uint16_t *)data;
-       int i;
-
-       for (i = 0; i < len / 2; i++)
-               sum += words[i];
-
-       if (len & 1)
-               sum += ((unsigned char *)data)[len - 1];
-
-       return sum;
-}
-
-static uint16_t checksum_fold(void *data, size_t len, uint32_t sum)
-{
-       sum = checksum_nofold(data, len, sum);
-
-       while (sum > 0xFFFF)
-               sum = (sum & 0xFFFF) + (sum >> 16);
-
-       return ~sum;
-}
-
-static uint16_t checksum(void *th, uint16_t proto, size_t len)
-{
-       uint32_t sum;
-       int alen;
-
-       alen = cfg_family == PF_INET6 ? 32 : 8;
-
-       sum = checksum_nofold(iph_addr_p, alen, 0);
-       sum += htons(proto);
-       sum += htons(len);
-
-       /* With CHECKSUM_PARTIAL kernel expects non-inverted pseudo csum */
-       if (cfg_do_tx && cfg_send_pfpacket)
-               return ~checksum_fold(NULL, 0, sum);
-       else
-               return checksum_fold(th, len, sum);
-}
-
-static void *build_packet_ipv4(void *_iph, uint8_t proto, unsigned int len)
-{
-       struct iphdr *iph = _iph;
-
-       memset(iph, 0, sizeof(*iph));
-
-       iph->version = 4;
-       iph->ihl = 5;
-       iph->ttl = 8;
-       iph->protocol = proto;
-       iph->saddr = cfg_saddr4.sin_addr.s_addr;
-       iph->daddr = cfg_daddr4.sin_addr.s_addr;
-       iph->tot_len = htons(sizeof(*iph) + len);
-       iph->check = checksum_fold(iph, sizeof(*iph), 0);
-
-       iph_addr_p = &iph->saddr;
-
-       return iph + 1;
-}
-
-static void *build_packet_ipv6(void *_ip6h, uint8_t proto, unsigned int len)
-{
-       struct ipv6hdr *ip6h = _ip6h;
-
-       memset(ip6h, 0, sizeof(*ip6h));
-
-       ip6h->version = 6;
-       ip6h->payload_len = htons(len);
-       ip6h->nexthdr = proto;
-       ip6h->hop_limit = 64;
-       ip6h->saddr = cfg_saddr6.sin6_addr;
-       ip6h->daddr = cfg_daddr6.sin6_addr;
-
-       iph_addr_p = &ip6h->saddr;
-
-       return ip6h + 1;
-}
-
-static void *build_packet_udp(void *_uh)
-{
-       struct udphdr *uh = _uh;
-
-       uh->source = htons(cfg_port_src);
-       uh->dest = htons(cfg_port_dst);
-       uh->len = htons(sizeof(*uh) + cfg_payload_len);
-       uh->check = 0;
-
-       /* choose source port so that uh->check adds up to zero */
-       if (cfg_zero_sum) {
-               uh->source = 0;
-               uh->source = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len);
-
-               fprintf(stderr, "tx: changing sport: %hu -> %hu\n",
-                       cfg_port_src, ntohs(uh->source));
-               cfg_port_src = ntohs(uh->source);
-       }
-
-       if (cfg_zero_disable)
-               uh->check = 0;
-       else
-               uh->check = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len);
-
-       if (cfg_bad_csum)
-               uh->check = ~uh->check;
-
-       fprintf(stderr, "tx: sending checksum: 0x%x\n", uh->check);
-       return uh + 1;
-}
-
-static void *build_packet_tcp(void *_th)
-{
-       struct tcphdr *th = _th;
-
-       th->source = htons(cfg_port_src);
-       th->dest = htons(cfg_port_dst);
-       th->doff = 5;
-       th->check = 0;
-
-       th->check = checksum(th, IPPROTO_TCP, sizeof(*th) + cfg_payload_len);
-
-       if (cfg_bad_csum)
-               th->check = ~th->check;
-
-       fprintf(stderr, "tx: sending checksum: 0x%x\n", th->check);
-       return th + 1;
-}
-
-static char *build_packet_udp_encap(void *_uh)
-{
-       struct udphdr *uh = _uh;
-       struct udp_encap_hdr *eh = _uh + sizeof(*uh);
-
-       /* outer dst == inner dst, to simplify BPF filter
-        * outer src != inner src, to demultiplex on recv
-        */
-       uh->dest = htons(cfg_port_dst);
-       uh->source = htons(cfg_port_src_encap);
-       uh->check = 0;
-       uh->len = htons(sizeof(*uh) +
-                       sizeof(*eh) +
-                       sizeof(struct tcphdr) +
-                       cfg_payload_len);
-
-       eh->nexthdr = IPPROTO_TCP;
-
-       return build_packet_tcp(eh + 1);
-}
-
-static char *build_packet(char *buf, int max_len, int *len)
-{
-       uint8_t proto;
-       char *off;
-       int tlen;
-
-       if (cfg_random_seed) {
-               int *buf32 = (void *)buf;
-               int i;
-
-               for (i = 0; i < (max_len / sizeof(int)); i++)
-                       buf32[i] = rand();
-       } else {
-               memset(buf, cfg_payload_char, max_len);
-       }
-
-       if (cfg_proto == IPPROTO_UDP)
-               tlen = sizeof(struct udphdr) + cfg_payload_len;
-       else
-               tlen = sizeof(struct tcphdr) + cfg_payload_len;
-
-       if (cfg_encap) {
-               proto = IPPROTO_UDP;
-               tlen += ENC_HEADER_LEN;
-       } else {
-               proto = cfg_proto;
-       }
-
-       if (cfg_family == PF_INET)
-               off = build_packet_ipv4(buf, proto, tlen);
-       else
-               off = build_packet_ipv6(buf, proto, tlen);
-
-       if (cfg_encap)
-               off = build_packet_udp_encap(off);
-       else if (cfg_proto == IPPROTO_UDP)
-               off = build_packet_udp(off);
-       else
-               off = build_packet_tcp(off);
-
-       /* only pass the payload, but still compute headers for cfg_zero_sum */
-       if (cfg_send_udp) {
-               *len = cfg_payload_len;
-               return off;
-       }
-
-       *len = off - buf + cfg_payload_len;
-       return buf;
-}
-
-static int open_inet(int ipproto, int protocol)
-{
-       int fd;
-
-       fd = socket(cfg_family, ipproto, protocol);
-       if (fd == -1)
-               error(1, errno, "socket inet");
-
-       if (cfg_family == PF_INET6) {
-               /* may have been updated by cfg_zero_sum */
-               cfg_saddr6.sin6_port = htons(cfg_port_src);
-
-               if (bind(fd, (void *)&cfg_saddr6, sizeof(cfg_saddr6)))
-                       error(1, errno, "bind dgram 6");
-               if (connect(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6)))
-                       error(1, errno, "connect dgram 6");
-       } else {
-               /* may have been updated by cfg_zero_sum */
-               cfg_saddr4.sin_port = htons(cfg_port_src);
-
-               if (bind(fd, (void *)&cfg_saddr4, sizeof(cfg_saddr4)))
-                       error(1, errno, "bind dgram 4");
-               if (connect(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4)))
-                       error(1, errno, "connect dgram 4");
-       }
-
-       return fd;
-}
-
-static int open_packet(void)
-{
-       int fd, one = 1;
-
-       fd = socket(PF_PACKET, SOCK_RAW, 0);
-       if (fd == -1)
-               error(1, errno, "socket packet");
-
-       if (setsockopt(fd, SOL_PACKET, PACKET_VNET_HDR, &one, sizeof(one)))
-               error(1, errno, "setsockopt packet_vnet_ndr");
-
-       return fd;
-}
-
-static void send_inet(int fd, const char *buf, int len)
-{
-       int ret;
-
-       ret = write(fd, buf, len);
-       if (ret == -1)
-               error(1, errno, "write");
-       if (ret != len)
-               error(1, 0, "write: %d", ret);
-}
-
-static void eth_str_to_addr(const char *str, unsigned char *eth)
-{
-       if (sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
-                  &eth[0], &eth[1], &eth[2], &eth[3], &eth[4], &eth[5]) != 6)
-               error(1, 0, "cannot parse mac addr %s", str);
-}
-
-static void send_packet(int fd, const char *buf, int len)
-{
-       struct virtio_net_hdr vh = {0};
-       struct sockaddr_ll addr = {0};
-       struct msghdr msg = {0};
-       struct ethhdr eth;
-       struct iovec iov[3];
-       int ret;
-
-       addr.sll_family = AF_PACKET;
-       addr.sll_halen = ETH_ALEN;
-       addr.sll_ifindex = if_nametoindex(cfg_ifname);
-       if (!addr.sll_ifindex)
-               error(1, errno, "if_nametoindex %s", cfg_ifname);
-
-       vh.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
-       if (cfg_family == PF_INET6) {
-               vh.csum_start = sizeof(struct ethhdr) + sizeof(struct ipv6hdr);
-               addr.sll_protocol = htons(ETH_P_IPV6);
-       } else {
-               vh.csum_start = sizeof(struct ethhdr) + sizeof(struct iphdr);
-               addr.sll_protocol = htons(ETH_P_IP);
-       }
-
-       if (cfg_encap)
-               vh.csum_start += ENC_HEADER_LEN;
-
-       if (cfg_proto == IPPROTO_TCP) {
-               vh.csum_offset = __builtin_offsetof(struct tcphdr, check);
-               vh.hdr_len = vh.csum_start + sizeof(struct tcphdr);
-       } else {
-               vh.csum_offset = __builtin_offsetof(struct udphdr, check);
-               vh.hdr_len = vh.csum_start + sizeof(struct udphdr);
-       }
-
-       eth_str_to_addr(cfg_mac_src, eth.h_source);
-       eth_str_to_addr(cfg_mac_dst, eth.h_dest);
-       eth.h_proto = addr.sll_protocol;
-
-       iov[0].iov_base = &vh;
-       iov[0].iov_len = sizeof(vh);
-
-       iov[1].iov_base = &eth;
-       iov[1].iov_len = sizeof(eth);
-
-       iov[2].iov_base = (void *)buf;
-       iov[2].iov_len = len;
-
-       msg.msg_iov = iov;
-       msg.msg_iovlen = ARRAY_SIZE(iov);
-
-       msg.msg_name = &addr;
-       msg.msg_namelen = sizeof(addr);
-
-       ret = sendmsg(fd, &msg, 0);
-       if (ret == -1)
-               error(1, errno, "sendmsg packet");
-       if (ret != sizeof(vh) + sizeof(eth) + len)
-               error(1, errno, "sendmsg packet: %u", ret);
-}
-
-static int recv_prepare_udp(void)
-{
-       int fd;
-
-       fd = socket(cfg_family, SOCK_DGRAM, 0);
-       if (fd == -1)
-               error(1, errno, "socket r");
-
-       if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
-                      &cfg_rcvbuf, sizeof(cfg_rcvbuf)))
-               error(1, errno, "setsockopt SO_RCVBUF r");
-
-       if (cfg_family == PF_INET6) {
-               if (bind(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6)))
-                       error(1, errno, "bind r");
-       } else {
-               if (bind(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4)))
-                       error(1, errno, "bind r");
-       }
-
-       return fd;
-}
-
-/* Filter out all traffic that is not cfg_proto with our destination port.
- *
- * Otherwise background noise may cause PF_PACKET receive queue overflow,
- * dropping the expected packets and failing the test.
- */
-static void __recv_prepare_packet_filter(int fd, int off_nexthdr, int off_dport)
-{
-       struct sock_filter filter[] = {
-               BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_PKTTYPE),
-               BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, PACKET_HOST, 0, 4),
-               BPF_STMT(BPF_LD + BPF_B + BPF_ABS, off_nexthdr),
-               BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_encap ? IPPROTO_UDP : cfg_proto, 0, 2),
-               BPF_STMT(BPF_LD + BPF_H + BPF_ABS, off_dport),
-               BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_port_dst, 1, 0),
-               BPF_STMT(BPF_RET + BPF_K, 0),
-               BPF_STMT(BPF_RET + BPF_K, 0xFFFF),
-       };
-       struct sock_fprog prog = {};
-
-       prog.filter = filter;
-       prog.len = ARRAY_SIZE(filter);
-       if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)))
-               error(1, errno, "setsockopt filter");
-}
-
-static void recv_prepare_packet_filter(int fd)
-{
-       const int off_dport = offsetof(struct tcphdr, dest); /* same for udp */
-
-       if (cfg_family == AF_INET)
-               __recv_prepare_packet_filter(fd, offsetof(struct iphdr, protocol),
-                                            sizeof(struct iphdr) + off_dport);
-       else
-               __recv_prepare_packet_filter(fd, offsetof(struct ipv6hdr, nexthdr),
-                                            sizeof(struct ipv6hdr) + off_dport);
-}
-
-static void recv_prepare_packet_bind(int fd)
-{
-       struct sockaddr_ll laddr = {0};
-
-       laddr.sll_family = AF_PACKET;
-
-       if (cfg_family == PF_INET)
-               laddr.sll_protocol = htons(ETH_P_IP);
-       else
-               laddr.sll_protocol = htons(ETH_P_IPV6);
-
-       laddr.sll_ifindex = if_nametoindex(cfg_ifname);
-       if (!laddr.sll_ifindex)
-               error(1, 0, "if_nametoindex %s", cfg_ifname);
-
-       if (bind(fd, (void *)&laddr, sizeof(laddr)))
-               error(1, errno, "bind pf_packet");
-}
-
-static int recv_prepare_packet(void)
-{
-       int fd, one = 1;
-
-       fd = socket(PF_PACKET, SOCK_DGRAM, 0);
-       if (fd == -1)
-               error(1, errno, "socket p");
-
-       if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
-                      &cfg_rcvbuf, sizeof(cfg_rcvbuf)))
-               error(1, errno, "setsockopt SO_RCVBUF p");
-
-       /* enable auxdata to recv checksum status (valid vs unknown) */
-       if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA, &one, sizeof(one)))
-               error(1, errno, "setsockopt auxdata");
-
-       /* install filter to restrict packet flow to match */
-       recv_prepare_packet_filter(fd);
-
-       /* bind to address family to start packet flow */
-       recv_prepare_packet_bind(fd);
-
-       return fd;
-}
-
-static int recv_udp(int fd)
-{
-       static char buf[MAX_PAYLOAD_LEN];
-       int ret, count = 0;
-
-       while (1) {
-               ret = recv(fd, buf, sizeof(buf), MSG_DONTWAIT);
-               if (ret == -1 && errno == EAGAIN)
-                       break;
-               if (ret == -1)
-                       error(1, errno, "recv r");
-
-               fprintf(stderr, "rx: udp: len=%u\n", ret);
-               count++;
-       }
-
-       return count;
-}
-
-static int recv_verify_csum(void *th, int len, uint16_t sport, uint16_t csum_field)
-{
-       uint16_t csum;
-
-       csum = checksum(th, cfg_proto, len);
-
-       fprintf(stderr, "rx: pkt: sport=%hu len=%u csum=0x%hx verify=0x%hx\n",
-               sport, len, csum_field, csum);
-
-       /* csum must be zero unless cfg_bad_csum indicates bad csum */
-       if (csum && !cfg_bad_csum) {
-               fprintf(stderr, "pkt: bad csum\n");
-               return 1;
-       } else if (cfg_bad_csum && !csum) {
-               fprintf(stderr, "pkt: good csum, while bad expected\n");
-               return 1;
-       }
-
-       if (cfg_zero_sum && csum_field != 0xFFFF) {
-               fprintf(stderr, "pkt: zero csum: field should be 0xFFFF, is 0x%hx\n", csum_field);
-               return 1;
-       }
-
-       return 0;
-}
-
-static int recv_verify_packet_tcp(void *th, int len)
-{
-       struct tcphdr *tcph = th;
-
-       if (len < sizeof(*tcph) || tcph->dest != htons(cfg_port_dst))
-               return -1;
-
-       return recv_verify_csum(th, len, ntohs(tcph->source), tcph->check);
-}
-
-static int recv_verify_packet_udp_encap(void *th, int len)
-{
-       struct udp_encap_hdr *eh = th;
-
-       if (len < sizeof(*eh) || eh->nexthdr != IPPROTO_TCP)
-               return -1;
-
-       return recv_verify_packet_tcp(eh + 1, len - sizeof(*eh));
-}
-
-static int recv_verify_packet_udp(void *th, int len)
-{
-       struct udphdr *udph = th;
-
-       if (len < sizeof(*udph))
-               return -1;
-
-       if (udph->dest != htons(cfg_port_dst))
-               return -1;
-
-       if (udph->source == htons(cfg_port_src_encap))
-               return recv_verify_packet_udp_encap(udph + 1,
-                                                   len - sizeof(*udph));
-
-       return recv_verify_csum(th, len, ntohs(udph->source), udph->check);
-}
-
-static int recv_verify_packet_ipv4(void *nh, int len)
-{
-       struct iphdr *iph = nh;
-       uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto;
-
-       if (len < sizeof(*iph) || iph->protocol != proto)
-               return -1;
-
-       iph_addr_p = &iph->saddr;
-       if (proto == IPPROTO_TCP)
-               return recv_verify_packet_tcp(iph + 1, len - sizeof(*iph));
-       else
-               return recv_verify_packet_udp(iph + 1, len - sizeof(*iph));
-}
-
-static int recv_verify_packet_ipv6(void *nh, int len)
-{
-       struct ipv6hdr *ip6h = nh;
-       uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto;
-
-       if (len < sizeof(*ip6h) || ip6h->nexthdr != proto)
-               return -1;
-
-       iph_addr_p = &ip6h->saddr;
-
-       if (proto == IPPROTO_TCP)
-               return recv_verify_packet_tcp(ip6h + 1, len - sizeof(*ip6h));
-       else
-               return recv_verify_packet_udp(ip6h + 1, len - sizeof(*ip6h));
-}
-
-/* return whether auxdata includes TP_STATUS_CSUM_VALID */
-static uint32_t recv_get_packet_csum_status(struct msghdr *msg)
-{
-       struct tpacket_auxdata *aux = NULL;
-       struct cmsghdr *cm;
-
-       if (msg->msg_flags & MSG_CTRUNC)
-               error(1, 0, "cmsg: truncated");
-
-       for (cm = CMSG_FIRSTHDR(msg); cm; cm = CMSG_NXTHDR(msg, cm)) {
-               if (cm->cmsg_level != SOL_PACKET ||
-                   cm->cmsg_type != PACKET_AUXDATA)
-                       error(1, 0, "cmsg: level=%d type=%d\n",
-                             cm->cmsg_level, cm->cmsg_type);
-
-               if (cm->cmsg_len != CMSG_LEN(sizeof(struct tpacket_auxdata)))
-                       error(1, 0, "cmsg: len=%lu expected=%lu",
-                             cm->cmsg_len, CMSG_LEN(sizeof(struct tpacket_auxdata)));
-
-               aux = (void *)CMSG_DATA(cm);
-       }
-
-       if (!aux)
-               error(1, 0, "cmsg: no auxdata");
-
-       return aux->tp_status;
-}
-
-static int recv_packet(int fd)
-{
-       static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN];
-       unsigned long total = 0, bad_csums = 0, bad_validations = 0;
-       char ctrl[CMSG_SPACE(sizeof(struct tpacket_auxdata))];
-       struct pkt *buf = (void *)_buf;
-       struct msghdr msg = {0};
-       uint32_t tp_status;
-       struct iovec iov;
-       int len, ret;
-
-       iov.iov_base = _buf;
-       iov.iov_len = sizeof(_buf);
-
-       msg.msg_iov = &iov;
-       msg.msg_iovlen = 1;
-
-       msg.msg_control = ctrl;
-       msg.msg_controllen = sizeof(ctrl);
-
-       while (1) {
-               msg.msg_flags = 0;
-
-               len = recvmsg(fd, &msg, MSG_DONTWAIT);
-               if (len == -1 && errno == EAGAIN)
-                       break;
-               if (len == -1)
-                       error(1, errno, "recv p");
-
-               tp_status = recv_get_packet_csum_status(&msg);
-
-               /* GRO might coalesce randomized packets. Such GSO packets are
-                * then reinitialized for csum offload (CHECKSUM_PARTIAL), with
-                * a pseudo csum. Do not try to validate these checksums.
-                */
-               if (tp_status & TP_STATUS_CSUMNOTREADY) {
-                       fprintf(stderr, "cmsg: GSO packet has partial csum: skip\n");
-                       continue;
-               }
-
-               if (cfg_family == PF_INET6)
-                       ret = recv_verify_packet_ipv6(buf, len);
-               else
-                       ret = recv_verify_packet_ipv4(buf, len);
-
-               if (ret == -1 /* skip: non-matching */)
-                       continue;
-
-               total++;
-               if (ret == 1)
-                       bad_csums++;
-
-               /* Fail if kernel returns valid for known bad csum.
-                * Do not fail if kernel does not validate a good csum:
-                * Absence of validation does not imply invalid.
-                */
-               if (tp_status & TP_STATUS_CSUM_VALID && cfg_bad_csum) {
-                       fprintf(stderr, "cmsg: expected bad csum, pf_packet returns valid\n");
-                       bad_validations++;
-               }
-       }
-
-       if (bad_csums || bad_validations)
-               error(1, 0, "rx: errors at pf_packet: total=%lu bad_csums=%lu bad_valids=%lu\n",
-                     total, bad_csums, bad_validations);
-
-       return total;
-}
-
-static void parse_args(int argc, char *const argv[])
-{
-       const char *daddr = NULL, *saddr = NULL;
-       int c;
-
-       while ((c = getopt(argc, argv, "46d:D:eEi:l:L:n:r:PRs:S:tTuUzZ")) != -1) {
-               switch (c) {
-               case '4':
-                       cfg_family = PF_INET;
-                       break;
-               case '6':
-                       cfg_family = PF_INET6;
-                       break;
-               case 'd':
-                       cfg_mac_dst = optarg;
-                       break;
-               case 'D':
-                       daddr = optarg;
-                       break;
-               case 'e':
-                       cfg_encap = true;
-                       break;
-               case 'E':
-                       cfg_bad_csum = true;
-                       break;
-               case 'i':
-                       cfg_ifname = optarg;
-                       break;
-               case 'l':
-                       cfg_payload_len = strtol(optarg, NULL, 0);
-                       break;
-               case 'L':
-                       cfg_timeout_ms = strtol(optarg, NULL, 0) * 1000;
-                       break;
-               case 'n':
-                       cfg_num_pkt = strtol(optarg, NULL, 0);
-                       break;
-               case 'r':
-                       cfg_random_seed = strtol(optarg, NULL, 0);
-                       break;
-               case 'P':
-                       cfg_send_pfpacket = true;
-                       break;
-               case 'R':
-                       /* only Rx: used with two machine tests */
-                       cfg_do_tx = false;
-                       break;
-               case 's':
-                       cfg_mac_src = optarg;
-                       break;
-               case 'S':
-                       saddr = optarg;
-                       break;
-               case 't':
-                       cfg_proto = IPPROTO_TCP;
-                       break;
-               case 'T':
-                       /* only Tx: used with two machine tests */
-                       cfg_do_rx = false;
-                       break;
-               case 'u':
-                       cfg_proto = IPPROTO_UDP;
-                       break;
-               case 'U':
-                       /* send using real udp socket,
-                        * to exercise tx checksum offload
-                        */
-                       cfg_send_udp = true;
-                       break;
-               case 'z':
-                       cfg_zero_disable = true;
-                       break;
-               case 'Z':
-                       cfg_zero_sum = true;
-                       break;
-               default:
-                       error(1, 0, "unknown arg %c", c);
-               }
-       }
-
-       if (!daddr || !saddr)
-               error(1, 0, "Must pass -D <daddr> and -S <saddr>");
-
-       if (cfg_do_tx && cfg_send_pfpacket && (!cfg_mac_src || !cfg_mac_dst))
-               error(1, 0, "Transmit with pf_packet requires mac addresses");
-
-       if (cfg_payload_len > MAX_PAYLOAD_LEN)
-               error(1, 0, "Payload length exceeds max");
-
-       if (cfg_proto != IPPROTO_UDP && (cfg_zero_sum || cfg_zero_disable))
-               error(1, 0, "Only UDP supports zero csum");
-
-       if (cfg_zero_sum && !cfg_send_udp)
-               error(1, 0, "Zero checksum conversion requires -U for tx csum offload");
-       if (cfg_zero_sum && cfg_bad_csum)
-               error(1, 0, "Cannot combine zero checksum conversion and invalid checksum");
-       if (cfg_zero_sum && cfg_random_seed)
-               error(1, 0, "Cannot combine zero checksum conversion with randomization");
-
-       if (cfg_family == PF_INET6) {
-               cfg_saddr6.sin6_port = htons(cfg_port_src);
-               cfg_daddr6.sin6_port = htons(cfg_port_dst);
-
-               if (inet_pton(cfg_family, daddr, &cfg_daddr6.sin6_addr) != 1)
-                       error(1, errno, "Cannot parse ipv6 -D");
-               if (inet_pton(cfg_family, saddr, &cfg_saddr6.sin6_addr) != 1)
-                       error(1, errno, "Cannot parse ipv6 -S");
-       } else {
-               cfg_saddr4.sin_port = htons(cfg_port_src);
-               cfg_daddr4.sin_port = htons(cfg_port_dst);
-
-               if (inet_pton(cfg_family, daddr, &cfg_daddr4.sin_addr) != 1)
-                       error(1, errno, "Cannot parse ipv4 -D");
-               if (inet_pton(cfg_family, saddr, &cfg_saddr4.sin_addr) != 1)
-                       error(1, errno, "Cannot parse ipv4 -S");
-       }
-
-       if (cfg_do_tx && cfg_random_seed) {
-               /* special case: time-based seed */
-               if (cfg_random_seed == 1)
-                       cfg_random_seed = (unsigned int)gettimeofday_ms();
-               srand(cfg_random_seed);
-               fprintf(stderr, "randomization seed: %u\n", cfg_random_seed);
-       }
-}
-
-static void do_tx(void)
-{
-       static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN];
-       char *buf;
-       int fd, len, i;
-
-       buf = build_packet(_buf, sizeof(_buf), &len);
-
-       if (cfg_send_pfpacket)
-               fd = open_packet();
-       else if (cfg_send_udp)
-               fd = open_inet(SOCK_DGRAM, 0);
-       else
-               fd = open_inet(SOCK_RAW, IPPROTO_RAW);
-
-       for (i = 0; i < cfg_num_pkt; i++) {
-               if (cfg_send_pfpacket)
-                       send_packet(fd, buf, len);
-               else
-                       send_inet(fd, buf, len);
-
-               /* randomize each packet individually to increase coverage */
-               if (cfg_random_seed) {
-                       cfg_payload_len = rand() % MAX_PAYLOAD_LEN;
-                       buf = build_packet(_buf, sizeof(_buf), &len);
-               }
-       }
-
-       if (close(fd))
-               error(1, errno, "close tx");
-}
-
-static void do_rx(int fdp, int fdr)
-{
-       unsigned long count_udp = 0, count_pkt = 0;
-       long tleft, tstop;
-       struct pollfd pfd;
-
-       tstop = gettimeofday_ms() + cfg_timeout_ms;
-       tleft = cfg_timeout_ms;
-
-       do {
-               pfd.events = POLLIN;
-               pfd.fd = fdp;
-               if (poll(&pfd, 1, tleft) == -1)
-                       error(1, errno, "poll");
-
-               if (pfd.revents & POLLIN)
-                       count_pkt += recv_packet(fdp);
-
-               if (cfg_proto == IPPROTO_UDP)
-                       count_udp += recv_udp(fdr);
-
-               tleft = tstop - gettimeofday_ms();
-       } while (tleft > 0);
-
-       if (close(fdr))
-               error(1, errno, "close r");
-       if (close(fdp))
-               error(1, errno, "close p");
-
-       if (count_pkt < cfg_num_pkt)
-               error(1, 0, "rx: missing packets at pf_packet: %lu < %u",
-                     count_pkt, cfg_num_pkt);
-
-       if (cfg_proto == IPPROTO_UDP) {
-               if (cfg_bad_csum && count_udp)
-                       error(1, 0, "rx: unexpected packets at udp");
-               if (!cfg_bad_csum && !count_udp)
-                       error(1, 0, "rx: missing packets at udp");
-       }
-}
-
-int main(int argc, char *const argv[])
-{
-       int fdp = -1, fdr = -1;         /* -1 to silence -Wmaybe-uninitialized */
-
-       parse_args(argc, argv);
-
-       /* open receive sockets before transmitting */
-       if (cfg_do_rx) {
-               fdp = recv_prepare_packet();
-               fdr = recv_prepare_udp();
-       }
-
-       if (cfg_do_tx)
-               do_tx();
-
-       if (cfg_do_rx)
-               do_rx(fdp, fdr);
-
-       fprintf(stderr, "OK\n");
-       return 0;
-}
diff --git a/tools/testing/selftests/net/lib/.gitignore b/tools/testing/selftests/net/lib/.gitignore
new file mode 100644 (file)
index 0000000..1ebc618
--- /dev/null
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+csum
index 48557e6..82c3264 100644 (file)
@@ -1,8 +1,15 @@
 # SPDX-License-Identifier: GPL-2.0
 
+CFLAGS =  -Wall -Wl,--no-as-needed -O2 -g
+CFLAGS += -I../../../../../usr/include/ $(KHDR_INCLUDES)
+# Additional include paths needed by kselftest.h
+CFLAGS += -I../../
+
 TEST_FILES := ../../../../../Documentation/netlink/specs
 TEST_FILES += ../../../../net/ynl
 
+TEST_GEN_FILES += csum
+
 TEST_INCLUDES := $(wildcard py/*.py)
 
 include ../../lib.mk
diff --git a/tools/testing/selftests/net/lib/csum.c b/tools/testing/selftests/net/lib/csum.c
new file mode 100644 (file)
index 0000000..b9f3fc3
--- /dev/null
@@ -0,0 +1,1000 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/* Test hardware checksum offload: Rx + Tx, IPv4 + IPv6, TCP + UDP.
+ *
+ * The test runs on two machines to exercise the NIC. For this reason it
+ * is not integrated in kselftests.
+ *
+ *     CMD=$((./csum -[46] -[tu] -S $SADDR -D $DADDR -[RT] -r 1 $EXTRA_ARGS))
+ *
+ * Rx:
+ *
+ * The sender sends packets with a known checksum field using PF_INET(6)
+ * SOCK_RAW sockets.
+ *
+ * good packet: $CMD [-t]
+ * bad packet:  $CMD [-t] -E
+ *
+ * The receiver reads UDP packets with a UDP socket. This is not an
+ * option for TCP packets ('-t'). Optionally insert an iptables filter
+ * to avoid these entering the real protocol stack.
+ *
+ * The receiver also reads all packets with a PF_PACKET socket, to
+ * observe whether both good and bad packets arrive on the host. And to
+ * read the optional TP_STATUS_CSUM_VALID bit. This requires setting
+ * option PACKET_AUXDATA, and works only for CHECKSUM_UNNECESSARY.
+ *
+ * Tx:
+ *
+ * The sender needs to build CHECKSUM_PARTIAL packets to exercise tx
+ * checksum offload.
+ *
+ * The sender can sends packets with a UDP socket.
+ *
+ * Optionally crafts a packet that sums up to zero to verify that the
+ * device writes negative zero 0xFFFF in this case to distinguish from
+ * 0x0000 (checksum disabled), as required by RFC 768. Hit this case
+ * by choosing a specific source port.
+ *
+ * good packet: $CMD -U
+ * zero csum:   $CMD -U -Z
+ *
+ * The sender can also build packets with PF_PACKET with PACKET_VNET_HDR,
+ * to cover more protocols. PF_PACKET requires passing src and dst mac
+ * addresses.
+ *
+ * good packet: $CMD -s $smac -d $dmac -p [-t]
+ *
+ * Argument '-z' sends UDP packets with a 0x000 checksum disabled field,
+ * to verify that the NIC passes these packets unmodified.
+ *
+ * Argument '-e' adds a transport mode encapsulation header between
+ * network and transport header. This will fail for devices that parse
+ *  headers. Should work on devices that implement protocol agnostic tx
+ * checksum offload (NETIF_F_HW_CSUM).
+ *
+ * Argument '-r $SEED' optionally randomizes header, payload and length
+ * to increase coverage between packets sent. SEED 1 further chooses a
+ * different seed for each run (and logs this for reproducibility). It
+ * is advised to enable this for extra coverage in continuous testing.
+ */
+
+#define _GNU_SOURCE
+
+#include <arpa/inet.h>
+#include <asm/byteorder.h>
+#include <errno.h>
+#include <error.h>
+#include <linux/filter.h>
+#include <linux/if_packet.h>
+#include <linux/ipv6.h>
+#include <linux/virtio_net.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+#include <netinet/if_ether.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/ip6.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <poll.h>
+#include <sched.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "kselftest.h"
+
+static bool cfg_bad_csum;
+static int cfg_family = PF_INET6;
+static int cfg_num_pkt = 4;
+static bool cfg_do_rx = true;
+static bool cfg_do_tx = true;
+static bool cfg_encap;
+static char *cfg_ifname = "eth0";
+static char *cfg_mac_dst;
+static char *cfg_mac_src;
+static int cfg_proto = IPPROTO_UDP;
+static int cfg_payload_char = 'a';
+static int cfg_payload_len = 100;
+static uint16_t cfg_port_dst = 34000;
+static uint16_t cfg_port_src = 33000;
+static uint16_t cfg_port_src_encap = 33001;
+static unsigned int cfg_random_seed;
+static int cfg_rcvbuf = 1 << 22;       /* be able to queue large cfg_num_pkt */
+static bool cfg_send_pfpacket;
+static bool cfg_send_udp;
+static int cfg_timeout_ms = 2000;
+static bool cfg_zero_disable; /* skip checksum: set to zero (udp only) */
+static bool cfg_zero_sum;     /* create packet that adds up to zero */
+
+static struct sockaddr_in cfg_daddr4 = {.sin_family = AF_INET};
+static struct sockaddr_in cfg_saddr4 = {.sin_family = AF_INET};
+static struct sockaddr_in6 cfg_daddr6 = {.sin6_family = AF_INET6};
+static struct sockaddr_in6 cfg_saddr6 = {.sin6_family = AF_INET6};
+
+#define ENC_HEADER_LEN (sizeof(struct udphdr) + sizeof(struct udp_encap_hdr))
+#define MAX_HEADER_LEN (sizeof(struct ipv6hdr) + ENC_HEADER_LEN + sizeof(struct tcphdr))
+#define MAX_PAYLOAD_LEN 1024
+
+/* Trivial demo encap. Stand-in for transport layer protocols like ESP or PSP */
+struct udp_encap_hdr {
+       uint8_t nexthdr;
+       uint8_t padding[3];
+};
+
+/* Ipaddrs, for pseudo csum. Global var is ugly, pass through funcs was worse */
+static void *iph_addr_p;
+
+static unsigned long gettimeofday_ms(void)
+{
+       struct timeval tv;
+
+       gettimeofday(&tv, NULL);
+       return (tv.tv_sec * 1000UL) + (tv.tv_usec / 1000UL);
+}
+
+static uint32_t checksum_nofold(char *data, size_t len, uint32_t sum)
+{
+       uint16_t *words = (uint16_t *)data;
+       int i;
+
+       for (i = 0; i < len / 2; i++)
+               sum += words[i];
+
+       if (len & 1)
+               sum += ((unsigned char *)data)[len - 1];
+
+       return sum;
+}
+
+static uint16_t checksum_fold(void *data, size_t len, uint32_t sum)
+{
+       sum = checksum_nofold(data, len, sum);
+
+       while (sum > 0xFFFF)
+               sum = (sum & 0xFFFF) + (sum >> 16);
+
+       return ~sum;
+}
+
+static uint16_t checksum(void *th, uint16_t proto, size_t len)
+{
+       uint32_t sum;
+       int alen;
+
+       alen = cfg_family == PF_INET6 ? 32 : 8;
+
+       sum = checksum_nofold(iph_addr_p, alen, 0);
+       sum += htons(proto);
+       sum += htons(len);
+
+       /* With CHECKSUM_PARTIAL kernel expects non-inverted pseudo csum */
+       if (cfg_do_tx && cfg_send_pfpacket)
+               return ~checksum_fold(NULL, 0, sum);
+       else
+               return checksum_fold(th, len, sum);
+}
+
+static void *build_packet_ipv4(void *_iph, uint8_t proto, unsigned int len)
+{
+       struct iphdr *iph = _iph;
+
+       memset(iph, 0, sizeof(*iph));
+
+       iph->version = 4;
+       iph->ihl = 5;
+       iph->ttl = 8;
+       iph->protocol = proto;
+       iph->saddr = cfg_saddr4.sin_addr.s_addr;
+       iph->daddr = cfg_daddr4.sin_addr.s_addr;
+       iph->tot_len = htons(sizeof(*iph) + len);
+       iph->check = checksum_fold(iph, sizeof(*iph), 0);
+
+       iph_addr_p = &iph->saddr;
+
+       return iph + 1;
+}
+
+static void *build_packet_ipv6(void *_ip6h, uint8_t proto, unsigned int len)
+{
+       struct ipv6hdr *ip6h = _ip6h;
+
+       memset(ip6h, 0, sizeof(*ip6h));
+
+       ip6h->version = 6;
+       ip6h->payload_len = htons(len);
+       ip6h->nexthdr = proto;
+       ip6h->hop_limit = 64;
+       ip6h->saddr = cfg_saddr6.sin6_addr;
+       ip6h->daddr = cfg_daddr6.sin6_addr;
+
+       iph_addr_p = &ip6h->saddr;
+
+       return ip6h + 1;
+}
+
+static void *build_packet_udp(void *_uh)
+{
+       struct udphdr *uh = _uh;
+
+       uh->source = htons(cfg_port_src);
+       uh->dest = htons(cfg_port_dst);
+       uh->len = htons(sizeof(*uh) + cfg_payload_len);
+       uh->check = 0;
+
+       /* choose source port so that uh->check adds up to zero */
+       if (cfg_zero_sum) {
+               uh->source = 0;
+               uh->source = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len);
+
+               fprintf(stderr, "tx: changing sport: %hu -> %hu\n",
+                       cfg_port_src, ntohs(uh->source));
+               cfg_port_src = ntohs(uh->source);
+       }
+
+       if (cfg_zero_disable)
+               uh->check = 0;
+       else
+               uh->check = checksum(uh, IPPROTO_UDP, sizeof(*uh) + cfg_payload_len);
+
+       if (cfg_bad_csum)
+               uh->check = ~uh->check;
+
+       fprintf(stderr, "tx: sending checksum: 0x%x\n", uh->check);
+       return uh + 1;
+}
+
+static void *build_packet_tcp(void *_th)
+{
+       struct tcphdr *th = _th;
+
+       th->source = htons(cfg_port_src);
+       th->dest = htons(cfg_port_dst);
+       th->doff = 5;
+       th->check = 0;
+
+       th->check = checksum(th, IPPROTO_TCP, sizeof(*th) + cfg_payload_len);
+
+       if (cfg_bad_csum)
+               th->check = ~th->check;
+
+       fprintf(stderr, "tx: sending checksum: 0x%x\n", th->check);
+       return th + 1;
+}
+
+static char *build_packet_udp_encap(void *_uh)
+{
+       struct udphdr *uh = _uh;
+       struct udp_encap_hdr *eh = _uh + sizeof(*uh);
+
+       /* outer dst == inner dst, to simplify BPF filter
+        * outer src != inner src, to demultiplex on recv
+        */
+       uh->dest = htons(cfg_port_dst);
+       uh->source = htons(cfg_port_src_encap);
+       uh->check = 0;
+       uh->len = htons(sizeof(*uh) +
+                       sizeof(*eh) +
+                       sizeof(struct tcphdr) +
+                       cfg_payload_len);
+
+       eh->nexthdr = IPPROTO_TCP;
+
+       return build_packet_tcp(eh + 1);
+}
+
+static char *build_packet(char *buf, int max_len, int *len)
+{
+       uint8_t proto;
+       char *off;
+       int tlen;
+
+       if (cfg_random_seed) {
+               int *buf32 = (void *)buf;
+               int i;
+
+               for (i = 0; i < (max_len / sizeof(int)); i++)
+                       buf32[i] = rand();
+       } else {
+               memset(buf, cfg_payload_char, max_len);
+       }
+
+       if (cfg_proto == IPPROTO_UDP)
+               tlen = sizeof(struct udphdr) + cfg_payload_len;
+       else
+               tlen = sizeof(struct tcphdr) + cfg_payload_len;
+
+       if (cfg_encap) {
+               proto = IPPROTO_UDP;
+               tlen += ENC_HEADER_LEN;
+       } else {
+               proto = cfg_proto;
+       }
+
+       if (cfg_family == PF_INET)
+               off = build_packet_ipv4(buf, proto, tlen);
+       else
+               off = build_packet_ipv6(buf, proto, tlen);
+
+       if (cfg_encap)
+               off = build_packet_udp_encap(off);
+       else if (cfg_proto == IPPROTO_UDP)
+               off = build_packet_udp(off);
+       else
+               off = build_packet_tcp(off);
+
+       /* only pass the payload, but still compute headers for cfg_zero_sum */
+       if (cfg_send_udp) {
+               *len = cfg_payload_len;
+               return off;
+       }
+
+       *len = off - buf + cfg_payload_len;
+       return buf;
+}
+
+static int open_inet(int ipproto, int protocol)
+{
+       int fd;
+
+       fd = socket(cfg_family, ipproto, protocol);
+       if (fd == -1)
+               error(1, errno, "socket inet");
+
+       if (cfg_family == PF_INET6) {
+               /* may have been updated by cfg_zero_sum */
+               cfg_saddr6.sin6_port = htons(cfg_port_src);
+
+               if (bind(fd, (void *)&cfg_saddr6, sizeof(cfg_saddr6)))
+                       error(1, errno, "bind dgram 6");
+               if (connect(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6)))
+                       error(1, errno, "connect dgram 6");
+       } else {
+               /* may have been updated by cfg_zero_sum */
+               cfg_saddr4.sin_port = htons(cfg_port_src);
+
+               if (bind(fd, (void *)&cfg_saddr4, sizeof(cfg_saddr4)))
+                       error(1, errno, "bind dgram 4");
+               if (connect(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4)))
+                       error(1, errno, "connect dgram 4");
+       }
+
+       return fd;
+}
+
+static int open_packet(void)
+{
+       int fd, one = 1;
+
+       fd = socket(PF_PACKET, SOCK_RAW, 0);
+       if (fd == -1)
+               error(1, errno, "socket packet");
+
+       if (setsockopt(fd, SOL_PACKET, PACKET_VNET_HDR, &one, sizeof(one)))
+               error(1, errno, "setsockopt packet_vnet_ndr");
+
+       return fd;
+}
+
+static void send_inet(int fd, const char *buf, int len)
+{
+       int ret;
+
+       ret = write(fd, buf, len);
+       if (ret == -1)
+               error(1, errno, "write");
+       if (ret != len)
+               error(1, 0, "write: %d", ret);
+}
+
+static void eth_str_to_addr(const char *str, unsigned char *eth)
+{
+       if (sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+                  &eth[0], &eth[1], &eth[2], &eth[3], &eth[4], &eth[5]) != 6)
+               error(1, 0, "cannot parse mac addr %s", str);
+}
+
+static void send_packet(int fd, const char *buf, int len)
+{
+       struct virtio_net_hdr vh = {0};
+       struct sockaddr_ll addr = {0};
+       struct msghdr msg = {0};
+       struct ethhdr eth;
+       struct iovec iov[3];
+       int ret;
+
+       addr.sll_family = AF_PACKET;
+       addr.sll_halen = ETH_ALEN;
+       addr.sll_ifindex = if_nametoindex(cfg_ifname);
+       if (!addr.sll_ifindex)
+               error(1, errno, "if_nametoindex %s", cfg_ifname);
+
+       vh.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+       if (cfg_family == PF_INET6) {
+               vh.csum_start = sizeof(struct ethhdr) + sizeof(struct ipv6hdr);
+               addr.sll_protocol = htons(ETH_P_IPV6);
+       } else {
+               vh.csum_start = sizeof(struct ethhdr) + sizeof(struct iphdr);
+               addr.sll_protocol = htons(ETH_P_IP);
+       }
+
+       if (cfg_encap)
+               vh.csum_start += ENC_HEADER_LEN;
+
+       if (cfg_proto == IPPROTO_TCP) {
+               vh.csum_offset = __builtin_offsetof(struct tcphdr, check);
+               vh.hdr_len = vh.csum_start + sizeof(struct tcphdr);
+       } else {
+               vh.csum_offset = __builtin_offsetof(struct udphdr, check);
+               vh.hdr_len = vh.csum_start + sizeof(struct udphdr);
+       }
+
+       eth_str_to_addr(cfg_mac_src, eth.h_source);
+       eth_str_to_addr(cfg_mac_dst, eth.h_dest);
+       eth.h_proto = addr.sll_protocol;
+
+       iov[0].iov_base = &vh;
+       iov[0].iov_len = sizeof(vh);
+
+       iov[1].iov_base = &eth;
+       iov[1].iov_len = sizeof(eth);
+
+       iov[2].iov_base = (void *)buf;
+       iov[2].iov_len = len;
+
+       msg.msg_iov = iov;
+       msg.msg_iovlen = ARRAY_SIZE(iov);
+
+       msg.msg_name = &addr;
+       msg.msg_namelen = sizeof(addr);
+
+       ret = sendmsg(fd, &msg, 0);
+       if (ret == -1)
+               error(1, errno, "sendmsg packet");
+       if (ret != sizeof(vh) + sizeof(eth) + len)
+               error(1, errno, "sendmsg packet: %u", ret);
+}
+
+static int recv_prepare_udp(void)
+{
+       int fd;
+
+       fd = socket(cfg_family, SOCK_DGRAM, 0);
+       if (fd == -1)
+               error(1, errno, "socket r");
+
+       if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
+                      &cfg_rcvbuf, sizeof(cfg_rcvbuf)))
+               error(1, errno, "setsockopt SO_RCVBUF r");
+
+       if (cfg_family == PF_INET6) {
+               if (bind(fd, (void *)&cfg_daddr6, sizeof(cfg_daddr6)))
+                       error(1, errno, "bind r");
+       } else {
+               if (bind(fd, (void *)&cfg_daddr4, sizeof(cfg_daddr4)))
+                       error(1, errno, "bind r");
+       }
+
+       return fd;
+}
+
+/* Filter out all traffic that is not cfg_proto with our destination port.
+ *
+ * Otherwise background noise may cause PF_PACKET receive queue overflow,
+ * dropping the expected packets and failing the test.
+ */
+static void __recv_prepare_packet_filter(int fd, int off_nexthdr, int off_dport)
+{
+       struct sock_filter filter[] = {
+               BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_PKTTYPE),
+               BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, PACKET_HOST, 0, 4),
+               BPF_STMT(BPF_LD + BPF_B + BPF_ABS, off_nexthdr),
+               BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_encap ? IPPROTO_UDP : cfg_proto, 0, 2),
+               BPF_STMT(BPF_LD + BPF_H + BPF_ABS, off_dport),
+               BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, cfg_port_dst, 1, 0),
+               BPF_STMT(BPF_RET + BPF_K, 0),
+               BPF_STMT(BPF_RET + BPF_K, 0xFFFF),
+       };
+       struct sock_fprog prog = {};
+
+       prog.filter = filter;
+       prog.len = ARRAY_SIZE(filter);
+       if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)))
+               error(1, errno, "setsockopt filter");
+}
+
+static void recv_prepare_packet_filter(int fd)
+{
+       const int off_dport = offsetof(struct tcphdr, dest); /* same for udp */
+
+       if (cfg_family == AF_INET)
+               __recv_prepare_packet_filter(fd, offsetof(struct iphdr, protocol),
+                                            sizeof(struct iphdr) + off_dport);
+       else
+               __recv_prepare_packet_filter(fd, offsetof(struct ipv6hdr, nexthdr),
+                                            sizeof(struct ipv6hdr) + off_dport);
+}
+
+static void recv_prepare_packet_bind(int fd)
+{
+       struct sockaddr_ll laddr = {0};
+
+       laddr.sll_family = AF_PACKET;
+
+       if (cfg_family == PF_INET)
+               laddr.sll_protocol = htons(ETH_P_IP);
+       else
+               laddr.sll_protocol = htons(ETH_P_IPV6);
+
+       laddr.sll_ifindex = if_nametoindex(cfg_ifname);
+       if (!laddr.sll_ifindex)
+               error(1, 0, "if_nametoindex %s", cfg_ifname);
+
+       if (bind(fd, (void *)&laddr, sizeof(laddr)))
+               error(1, errno, "bind pf_packet");
+}
+
+static int recv_prepare_packet(void)
+{
+       int fd, one = 1;
+
+       fd = socket(PF_PACKET, SOCK_DGRAM, 0);
+       if (fd == -1)
+               error(1, errno, "socket p");
+
+       if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
+                      &cfg_rcvbuf, sizeof(cfg_rcvbuf)))
+               error(1, errno, "setsockopt SO_RCVBUF p");
+
+       /* enable auxdata to recv checksum status (valid vs unknown) */
+       if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA, &one, sizeof(one)))
+               error(1, errno, "setsockopt auxdata");
+
+       /* install filter to restrict packet flow to match */
+       recv_prepare_packet_filter(fd);
+
+       /* bind to address family to start packet flow */
+       recv_prepare_packet_bind(fd);
+
+       return fd;
+}
+
+static int recv_udp(int fd)
+{
+       static char buf[MAX_PAYLOAD_LEN];
+       int ret, count = 0;
+
+       while (1) {
+               ret = recv(fd, buf, sizeof(buf), MSG_DONTWAIT);
+               if (ret == -1 && errno == EAGAIN)
+                       break;
+               if (ret == -1)
+                       error(1, errno, "recv r");
+
+               fprintf(stderr, "rx: udp: len=%u\n", ret);
+               count++;
+       }
+
+       return count;
+}
+
+static int recv_verify_csum(void *th, int len, uint16_t sport, uint16_t csum_field)
+{
+       uint16_t csum;
+
+       csum = checksum(th, cfg_proto, len);
+
+       fprintf(stderr, "rx: pkt: sport=%hu len=%u csum=0x%hx verify=0x%hx\n",
+               sport, len, csum_field, csum);
+
+       /* csum must be zero unless cfg_bad_csum indicates bad csum */
+       if (csum && !cfg_bad_csum) {
+               fprintf(stderr, "pkt: bad csum\n");
+               return 1;
+       } else if (cfg_bad_csum && !csum) {
+               fprintf(stderr, "pkt: good csum, while bad expected\n");
+               return 1;
+       }
+
+       if (cfg_zero_sum && csum_field != 0xFFFF) {
+               fprintf(stderr, "pkt: zero csum: field should be 0xFFFF, is 0x%hx\n", csum_field);
+               return 1;
+       }
+
+       return 0;
+}
+
+static int recv_verify_packet_tcp(void *th, int len)
+{
+       struct tcphdr *tcph = th;
+
+       if (len < sizeof(*tcph) || tcph->dest != htons(cfg_port_dst))
+               return -1;
+
+       return recv_verify_csum(th, len, ntohs(tcph->source), tcph->check);
+}
+
+static int recv_verify_packet_udp_encap(void *th, int len)
+{
+       struct udp_encap_hdr *eh = th;
+
+       if (len < sizeof(*eh) || eh->nexthdr != IPPROTO_TCP)
+               return -1;
+
+       return recv_verify_packet_tcp(eh + 1, len - sizeof(*eh));
+}
+
+static int recv_verify_packet_udp(void *th, int len)
+{
+       struct udphdr *udph = th;
+
+       if (len < sizeof(*udph))
+               return -1;
+
+       if (udph->dest != htons(cfg_port_dst))
+               return -1;
+
+       if (udph->source == htons(cfg_port_src_encap))
+               return recv_verify_packet_udp_encap(udph + 1,
+                                                   len - sizeof(*udph));
+
+       return recv_verify_csum(th, len, ntohs(udph->source), udph->check);
+}
+
+static int recv_verify_packet_ipv4(void *nh, int len)
+{
+       struct iphdr *iph = nh;
+       uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto;
+
+       if (len < sizeof(*iph) || iph->protocol != proto)
+               return -1;
+
+       iph_addr_p = &iph->saddr;
+       if (proto == IPPROTO_TCP)
+               return recv_verify_packet_tcp(iph + 1, len - sizeof(*iph));
+       else
+               return recv_verify_packet_udp(iph + 1, len - sizeof(*iph));
+}
+
+static int recv_verify_packet_ipv6(void *nh, int len)
+{
+       struct ipv6hdr *ip6h = nh;
+       uint16_t proto = cfg_encap ? IPPROTO_UDP : cfg_proto;
+
+       if (len < sizeof(*ip6h) || ip6h->nexthdr != proto)
+               return -1;
+
+       iph_addr_p = &ip6h->saddr;
+
+       if (proto == IPPROTO_TCP)
+               return recv_verify_packet_tcp(ip6h + 1, len - sizeof(*ip6h));
+       else
+               return recv_verify_packet_udp(ip6h + 1, len - sizeof(*ip6h));
+}
+
+/* return whether auxdata includes TP_STATUS_CSUM_VALID */
+static uint32_t recv_get_packet_csum_status(struct msghdr *msg)
+{
+       struct tpacket_auxdata *aux = NULL;
+       struct cmsghdr *cm;
+
+       if (msg->msg_flags & MSG_CTRUNC)
+               error(1, 0, "cmsg: truncated");
+
+       for (cm = CMSG_FIRSTHDR(msg); cm; cm = CMSG_NXTHDR(msg, cm)) {
+               if (cm->cmsg_level != SOL_PACKET ||
+                   cm->cmsg_type != PACKET_AUXDATA)
+                       error(1, 0, "cmsg: level=%d type=%d\n",
+                             cm->cmsg_level, cm->cmsg_type);
+
+               if (cm->cmsg_len != CMSG_LEN(sizeof(struct tpacket_auxdata)))
+                       error(1, 0, "cmsg: len=%lu expected=%lu",
+                             cm->cmsg_len, CMSG_LEN(sizeof(struct tpacket_auxdata)));
+
+               aux = (void *)CMSG_DATA(cm);
+       }
+
+       if (!aux)
+               error(1, 0, "cmsg: no auxdata");
+
+       return aux->tp_status;
+}
+
+static int recv_packet(int fd)
+{
+       static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN];
+       unsigned long total = 0, bad_csums = 0, bad_validations = 0;
+       char ctrl[CMSG_SPACE(sizeof(struct tpacket_auxdata))];
+       struct pkt *buf = (void *)_buf;
+       struct msghdr msg = {0};
+       uint32_t tp_status;
+       struct iovec iov;
+       int len, ret;
+
+       iov.iov_base = _buf;
+       iov.iov_len = sizeof(_buf);
+
+       msg.msg_iov = &iov;
+       msg.msg_iovlen = 1;
+
+       msg.msg_control = ctrl;
+       msg.msg_controllen = sizeof(ctrl);
+
+       while (1) {
+               msg.msg_flags = 0;
+
+               len = recvmsg(fd, &msg, MSG_DONTWAIT);
+               if (len == -1 && errno == EAGAIN)
+                       break;
+               if (len == -1)
+                       error(1, errno, "recv p");
+
+               tp_status = recv_get_packet_csum_status(&msg);
+
+               /* GRO might coalesce randomized packets. Such GSO packets are
+                * then reinitialized for csum offload (CHECKSUM_PARTIAL), with
+                * a pseudo csum. Do not try to validate these checksums.
+                */
+               if (tp_status & TP_STATUS_CSUMNOTREADY) {
+                       fprintf(stderr, "cmsg: GSO packet has partial csum: skip\n");
+                       continue;
+               }
+
+               if (cfg_family == PF_INET6)
+                       ret = recv_verify_packet_ipv6(buf, len);
+               else
+                       ret = recv_verify_packet_ipv4(buf, len);
+
+               if (ret == -1 /* skip: non-matching */)
+                       continue;
+
+               total++;
+               if (ret == 1)
+                       bad_csums++;
+
+               /* Fail if kernel returns valid for known bad csum.
+                * Do not fail if kernel does not validate a good csum:
+                * Absence of validation does not imply invalid.
+                */
+               if (tp_status & TP_STATUS_CSUM_VALID && cfg_bad_csum) {
+                       fprintf(stderr, "cmsg: expected bad csum, pf_packet returns valid\n");
+                       bad_validations++;
+               }
+       }
+
+       if (bad_csums || bad_validations)
+               error(1, 0, "rx: errors at pf_packet: total=%lu bad_csums=%lu bad_valids=%lu\n",
+                     total, bad_csums, bad_validations);
+
+       return total;
+}
+
+static void parse_args(int argc, char *const argv[])
+{
+       const char *daddr = NULL, *saddr = NULL;
+       int c;
+
+       while ((c = getopt(argc, argv, "46d:D:eEi:l:L:n:r:PRs:S:tTuUzZ")) != -1) {
+               switch (c) {
+               case '4':
+                       cfg_family = PF_INET;
+                       break;
+               case '6':
+                       cfg_family = PF_INET6;
+                       break;
+               case 'd':
+                       cfg_mac_dst = optarg;
+                       break;
+               case 'D':
+                       daddr = optarg;
+                       break;
+               case 'e':
+                       cfg_encap = true;
+                       break;
+               case 'E':
+                       cfg_bad_csum = true;
+                       break;
+               case 'i':
+                       cfg_ifname = optarg;
+                       break;
+               case 'l':
+                       cfg_payload_len = strtol(optarg, NULL, 0);
+                       break;
+               case 'L':
+                       cfg_timeout_ms = strtol(optarg, NULL, 0) * 1000;
+                       break;
+               case 'n':
+                       cfg_num_pkt = strtol(optarg, NULL, 0);
+                       break;
+               case 'r':
+                       cfg_random_seed = strtol(optarg, NULL, 0);
+                       break;
+               case 'P':
+                       cfg_send_pfpacket = true;
+                       break;
+               case 'R':
+                       /* only Rx: used with two machine tests */
+                       cfg_do_tx = false;
+                       break;
+               case 's':
+                       cfg_mac_src = optarg;
+                       break;
+               case 'S':
+                       saddr = optarg;
+                       break;
+               case 't':
+                       cfg_proto = IPPROTO_TCP;
+                       break;
+               case 'T':
+                       /* only Tx: used with two machine tests */
+                       cfg_do_rx = false;
+                       break;
+               case 'u':
+                       cfg_proto = IPPROTO_UDP;
+                       break;
+               case 'U':
+                       /* send using real udp socket,
+                        * to exercise tx checksum offload
+                        */
+                       cfg_send_udp = true;
+                       break;
+               case 'z':
+                       cfg_zero_disable = true;
+                       break;
+               case 'Z':
+                       cfg_zero_sum = true;
+                       break;
+               default:
+                       error(1, 0, "unknown arg %c", c);
+               }
+       }
+
+       if (!daddr || !saddr)
+               error(1, 0, "Must pass -D <daddr> and -S <saddr>");
+
+       if (cfg_do_tx && cfg_send_pfpacket && (!cfg_mac_src || !cfg_mac_dst))
+               error(1, 0, "Transmit with pf_packet requires mac addresses");
+
+       if (cfg_payload_len > MAX_PAYLOAD_LEN)
+               error(1, 0, "Payload length exceeds max");
+
+       if (cfg_proto != IPPROTO_UDP && (cfg_zero_sum || cfg_zero_disable))
+               error(1, 0, "Only UDP supports zero csum");
+
+       if (cfg_zero_sum && !cfg_send_udp)
+               error(1, 0, "Zero checksum conversion requires -U for tx csum offload");
+       if (cfg_zero_sum && cfg_bad_csum)
+               error(1, 0, "Cannot combine zero checksum conversion and invalid checksum");
+       if (cfg_zero_sum && cfg_random_seed)
+               error(1, 0, "Cannot combine zero checksum conversion with randomization");
+
+       if (cfg_family == PF_INET6) {
+               cfg_saddr6.sin6_port = htons(cfg_port_src);
+               cfg_daddr6.sin6_port = htons(cfg_port_dst);
+
+               if (inet_pton(cfg_family, daddr, &cfg_daddr6.sin6_addr) != 1)
+                       error(1, errno, "Cannot parse ipv6 -D");
+               if (inet_pton(cfg_family, saddr, &cfg_saddr6.sin6_addr) != 1)
+                       error(1, errno, "Cannot parse ipv6 -S");
+       } else {
+               cfg_saddr4.sin_port = htons(cfg_port_src);
+               cfg_daddr4.sin_port = htons(cfg_port_dst);
+
+               if (inet_pton(cfg_family, daddr, &cfg_daddr4.sin_addr) != 1)
+                       error(1, errno, "Cannot parse ipv4 -D");
+               if (inet_pton(cfg_family, saddr, &cfg_saddr4.sin_addr) != 1)
+                       error(1, errno, "Cannot parse ipv4 -S");
+       }
+
+       if (cfg_do_tx && cfg_random_seed) {
+               /* special case: time-based seed */
+               if (cfg_random_seed == 1)
+                       cfg_random_seed = (unsigned int)gettimeofday_ms();
+               srand(cfg_random_seed);
+               fprintf(stderr, "randomization seed: %u\n", cfg_random_seed);
+       }
+}
+
+static void do_tx(void)
+{
+       static char _buf[MAX_HEADER_LEN + MAX_PAYLOAD_LEN];
+       char *buf;
+       int fd, len, i;
+
+       buf = build_packet(_buf, sizeof(_buf), &len);
+
+       if (cfg_send_pfpacket)
+               fd = open_packet();
+       else if (cfg_send_udp)
+               fd = open_inet(SOCK_DGRAM, 0);
+       else
+               fd = open_inet(SOCK_RAW, IPPROTO_RAW);
+
+       for (i = 0; i < cfg_num_pkt; i++) {
+               if (cfg_send_pfpacket)
+                       send_packet(fd, buf, len);
+               else
+                       send_inet(fd, buf, len);
+
+               /* randomize each packet individually to increase coverage */
+               if (cfg_random_seed) {
+                       cfg_payload_len = rand() % MAX_PAYLOAD_LEN;
+                       buf = build_packet(_buf, sizeof(_buf), &len);
+               }
+       }
+
+       if (close(fd))
+               error(1, errno, "close tx");
+}
+
+static void do_rx(int fdp, int fdr)
+{
+       unsigned long count_udp = 0, count_pkt = 0;
+       long tleft, tstop;
+       struct pollfd pfd;
+
+       tstop = gettimeofday_ms() + cfg_timeout_ms;
+       tleft = cfg_timeout_ms;
+
+       do {
+               pfd.events = POLLIN;
+               pfd.fd = fdp;
+               if (poll(&pfd, 1, tleft) == -1)
+                       error(1, errno, "poll");
+
+               if (pfd.revents & POLLIN)
+                       count_pkt += recv_packet(fdp);
+
+               if (cfg_proto == IPPROTO_UDP)
+                       count_udp += recv_udp(fdr);
+
+               tleft = tstop - gettimeofday_ms();
+       } while (tleft > 0);
+
+       if (close(fdr))
+               error(1, errno, "close r");
+       if (close(fdp))
+               error(1, errno, "close p");
+
+       if (count_pkt < cfg_num_pkt)
+               error(1, 0, "rx: missing packets at pf_packet: %lu < %u",
+                     count_pkt, cfg_num_pkt);
+
+       if (cfg_proto == IPPROTO_UDP) {
+               if (cfg_bad_csum && count_udp)
+                       error(1, 0, "rx: unexpected packets at udp");
+               if (!cfg_bad_csum && !count_udp)
+                       error(1, 0, "rx: missing packets at udp");
+       }
+}
+
+int main(int argc, char *const argv[])
+{
+       int fdp = -1, fdr = -1;         /* -1 to silence -Wmaybe-uninitialized */
+
+       parse_args(argc, argv);
+
+       /* open receive sockets before transmitting */
+       if (cfg_do_rx) {
+               fdp = recv_prepare_packet();
+               fdr = recv_prepare_udp();
+       }
+
+       if (cfg_do_tx)
+               do_tx();
+
+       if (cfg_do_rx)
+               do_rx(fdp, fdr);
+
+       fprintf(stderr, "OK\n");
+       return 0;
+}