1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2020 Intel Corporation. */
5 * Some functions in this program are taken from
6 * Linux kernel samples/bpf/xdpsock* and modified
9 * See test_xsk.sh for detailed information on test topology
10 * and prerequisite network setup.
12 * This test program contains two threads, each thread is single socket with
13 * a unique UMEM. It validates in-order packet delivery and packet content
14 * by sending packets to each other.
18 * These selftests test AF_XDP SKB and Native/DRV modes using veth
19 * Virtual Ethernet interfaces.
21 * For each mode, the following tests are run:
22 * a. nopoll - soft-irq processing
23 * b. poll - using poll() syscall
25 * Create a Tx and a Rx socket, Tx from one socket, Rx on another. Destroy
26 * both sockets, then repeat multiple times. Only nopoll mode is used
27 * d. Bi-directional sockets
28 * Configure sockets as bi-directional tx/rx sockets, sets up fill and
29 * completion rings on each socket, tx/rx in both directions. Only nopoll
32 * Trigger some error conditions and ensure that the appropriate statistics
33 * are incremented. Within this test, the following statistics are tested:
35 * Increase the UMEM frame headroom to a value which results in
36 * insufficient space in the rx buffer for both the packet and the headroom.
38 * Set the 'len' field of tx descriptors to an invalid value (umem frame
41 * Reduce the size of the RX ring to a fraction of the fill ring size.
42 * iv. fill queue empty
43 * Do not populate the fill queue and then try to receive pkts.
44 * f. bpf_link resource persistence
45 * Configure sockets at indexes 0 and 1, run a traffic on queue ids 0,
46 * then remove xsk sockets from queue 0 on both veth interfaces and
47 * finally run a traffic on queues ids 1
53 * - Single process spawns two threads: Tx and Rx
54 * - Each of these two threads attach to a veth interface within their assigned
56 * - Each thread Creates one AF_XDP socket connected to a unique umem for each
58 * - Tx thread Transmits 10k packets from veth<xxxx> to veth<yyyy>
59 * - Rx thread verifies if all 10k packets were received and delivered in-order,
60 * and have the right content
62 * Enable/disable packet dump mode:
63 * --------------------------
64 * To enable L2 - L4 headers and payload dump of each packet on STDOUT, add
65 * parameter -D to params array in test_xsk.sh, i.e. params=("-S" "-D")
72 #include <asm/barrier.h>
73 #include <linux/if_link.h>
74 #include <linux/if_ether.h>
76 #include <linux/udp.h>
77 #include <arpa/inet.h>
89 #include <sys/resource.h>
90 #include <sys/types.h>
91 #include <sys/queue.h>
94 #include <stdatomic.h>
96 #include "xdpxceiver.h"
97 #include "../kselftest.h"
99 static const char *MAC1 = "\x00\x0A\x56\x9E\xEE\x62";
100 static const char *MAC2 = "\x00\x0A\x56\x9E\xEE\x61";
101 static const char *IP1 = "192.168.100.162";
102 static const char *IP2 = "192.168.100.161";
103 static const u16 UDP_PORT1 = 2020;
104 static const u16 UDP_PORT2 = 2121;
106 static void __exit_with_error(int error, const char *file, const char *func, int line)
108 ksft_test_result_fail("[%s:%s:%i]: ERROR: %d/\"%s\"\n", file, func, line, error,
113 #define exit_with_error(error) __exit_with_error(error, __FILE__, __func__, __LINE__)
115 #define print_ksft_result(test)\
116 (ksft_test_result_pass("PASS: %s %s\n", configured_mode ? "DRV" : "SKB", \
119 static void memset32_htonl(void *dest, u32 val, u32 size)
121 u32 *ptr = (u32 *)dest;
126 for (i = 0; i < (size & (~0x3)); i += 4)
131 * Fold a partial checksum
132 * This function code has been taken from
133 * Linux kernel include/asm-generic/checksum.h
135 static __u16 csum_fold(__u32 csum)
137 u32 sum = (__force u32)csum;
139 sum = (sum & 0xffff) + (sum >> 16);
140 sum = (sum & 0xffff) + (sum >> 16);
141 return (__force __u16)~sum;
145 * This function code has been taken from
146 * Linux kernel lib/checksum.c
148 static u32 from64to32(u64 x)
150 /* add up 32-bit and 32-bit for 32+c bit */
151 x = (x & 0xffffffff) + (x >> 32);
153 x = (x & 0xffffffff) + (x >> 32);
158 * This function code has been taken from
159 * Linux kernel lib/checksum.c
161 static __u32 csum_tcpudp_nofold(__be32 saddr, __be32 daddr, __u32 len, __u8 proto, __u32 sum)
163 unsigned long long s = (__force u32)sum;
165 s += (__force u32)saddr;
166 s += (__force u32)daddr;
167 #ifdef __BIG_ENDIAN__
170 s += (proto + len) << 8;
172 return (__force __u32)from64to32(s);
176 * This function has been taken from
177 * Linux kernel include/asm-generic/checksum.h
179 static __u16 csum_tcpudp_magic(__be32 saddr, __be32 daddr, __u32 len, __u8 proto, __u32 sum)
181 return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
184 static u16 udp_csum(u32 saddr, u32 daddr, u32 len, u8 proto, u16 *udp_pkt)
189 /* udp hdr and data */
190 for (; cnt < len; cnt += 2)
191 csum += udp_pkt[cnt >> 1];
193 return csum_tcpudp_magic(saddr, daddr, len, proto, csum);
196 static void gen_eth_hdr(struct ifobject *ifobject, struct ethhdr *eth_hdr)
198 memcpy(eth_hdr->h_dest, ifobject->dst_mac, ETH_ALEN);
199 memcpy(eth_hdr->h_source, ifobject->src_mac, ETH_ALEN);
200 eth_hdr->h_proto = htons(ETH_P_IP);
203 static void gen_ip_hdr(struct ifobject *ifobject, struct iphdr *ip_hdr)
205 ip_hdr->version = IP_PKT_VER;
207 ip_hdr->tos = IP_PKT_TOS;
208 ip_hdr->tot_len = htons(IP_PKT_SIZE);
210 ip_hdr->frag_off = 0;
211 ip_hdr->ttl = IPDEFTTL;
212 ip_hdr->protocol = IPPROTO_UDP;
213 ip_hdr->saddr = ifobject->src_ip;
214 ip_hdr->daddr = ifobject->dst_ip;
218 static void gen_udp_hdr(u32 payload, void *pkt, struct ifobject *ifobject,
219 struct udphdr *udp_hdr)
221 udp_hdr->source = htons(ifobject->src_port);
222 udp_hdr->dest = htons(ifobject->dst_port);
223 udp_hdr->len = htons(UDP_PKT_SIZE);
224 memset32_htonl(pkt + PKT_HDR_SIZE, payload, UDP_PKT_DATA_SIZE);
227 static void gen_udp_csum(struct udphdr *udp_hdr, struct iphdr *ip_hdr)
231 udp_csum(ip_hdr->saddr, ip_hdr->daddr, UDP_PKT_SIZE, IPPROTO_UDP, (u16 *)udp_hdr);
234 static int xsk_configure_umem(struct xsk_umem_info *umem, void *buffer, u64 size, int idx)
236 struct xsk_umem_config cfg = {
237 .fill_size = XSK_RING_PROD__DEFAULT_NUM_DESCS,
238 .comp_size = XSK_RING_CONS__DEFAULT_NUM_DESCS,
239 .frame_size = umem->frame_size,
240 .frame_headroom = umem->frame_headroom,
241 .flags = XSK_UMEM__DEFAULT_FLAGS
245 ret = xsk_umem__create(&umem->umem, buffer, size,
246 &umem->fq, &umem->cq, &cfg);
250 umem->buffer = buffer;
254 static void xsk_populate_fill_ring(struct xsk_umem_info *umem)
259 ret = xsk_ring_prod__reserve(&umem->fq, XSK_RING_PROD__DEFAULT_NUM_DESCS, &idx);
260 if (ret != XSK_RING_PROD__DEFAULT_NUM_DESCS)
261 exit_with_error(-ret);
262 for (i = 0; i < XSK_RING_PROD__DEFAULT_NUM_DESCS; i++)
263 *xsk_ring_prod__fill_addr(&umem->fq, idx++) = i * umem->frame_size;
264 xsk_ring_prod__submit(&umem->fq, XSK_RING_PROD__DEFAULT_NUM_DESCS);
267 static int xsk_configure_socket(struct xsk_socket_info *xsk, struct xsk_umem_info *umem,
268 struct ifobject *ifobject, u32 qid)
270 struct xsk_socket_config cfg;
271 struct xsk_ring_cons *rxr;
272 struct xsk_ring_prod *txr;
275 cfg.rx_size = xsk->rxqsize;
276 cfg.tx_size = XSK_RING_PROD__DEFAULT_NUM_DESCS;
277 cfg.libbpf_flags = 0;
278 cfg.xdp_flags = xdp_flags;
279 cfg.bind_flags = xdp_bind_flags;
281 if (test_type != TEST_TYPE_BIDI) {
282 rxr = (ifobject->fv.vector == rx) ? &xsk->rx : NULL;
283 txr = (ifobject->fv.vector == tx) ? &xsk->tx : NULL;
289 return xsk_socket__create(&xsk->xsk, ifobject->ifname, qid, umem->umem, rxr, txr, &cfg);
292 static struct option long_options[] = {
293 {"interface", required_argument, 0, 'i'},
294 {"queue", optional_argument, 0, 'q'},
295 {"dump-pkts", optional_argument, 0, 'D'},
296 {"verbose", no_argument, 0, 'v'},
300 static void usage(const char *prog)
303 " Usage: %s [OPTIONS]\n"
305 " -i, --interface Use interface\n"
306 " -q, --queue=n Use queue n (default 0)\n"
307 " -D, --dump-pkts Dump packets L2 - L5\n"
308 " -v, --verbose Verbose output\n";
310 ksft_print_msg(str, prog);
313 static int switch_namespace(const char *nsname)
315 char fqns[26] = "/var/run/netns/";
318 if (!nsname || strlen(nsname) == 0)
321 strncat(fqns, nsname, sizeof(fqns) - strlen(fqns) - 1);
322 nsfd = open(fqns, O_RDONLY);
325 exit_with_error(errno);
327 if (setns(nsfd, 0) == -1)
328 exit_with_error(errno);
330 print_verbose("NS switched: %s\n", nsname);
335 static bool validate_interface(struct ifobject *ifobj)
337 if (!strcmp(ifobj->ifname, ""))
342 static void parse_command_line(struct test_spec *test, int argc, char **argv)
344 struct ifobject *ifobj;
345 u32 interface_nb = 0;
353 c = getopt_long(argc, argv, "i:Dv", long_options, &option_index);
359 if (interface_nb == 0)
360 ifobj = test->ifobj_tx;
361 else if (interface_nb == 1)
362 ifobj = test->ifobj_rx;
366 sptr = strndupa(optarg, strlen(optarg));
367 memcpy(ifobj->ifname, strsep(&sptr, ","), MAX_INTERFACE_NAME_CHARS);
368 token = strsep(&sptr, ",");
370 memcpy(ifobj->nsname, token, MAX_INTERFACES_NAMESPACE_CHARS);
380 usage(basename(argv[0]));
386 static void __test_spec_init(struct test_spec *test, struct ifobject *ifobj_tx,
387 struct ifobject *ifobj_rx)
391 for (i = 0; i < MAX_INTERFACES; i++) {
392 struct ifobject *ifobj = i ? ifobj_rx : ifobj_tx;
394 ifobj->umem = &ifobj->umem_arr[0];
395 ifobj->xsk = &ifobj->xsk_arr[0];
398 ifobj->fv.vector = tx;
400 ifobj->fv.vector = rx;
402 for (j = 0; j < MAX_SOCKETS; j++) {
403 memset(&ifobj->umem_arr[j], 0, sizeof(ifobj->umem_arr[j]));
404 memset(&ifobj->xsk_arr[j], 0, sizeof(ifobj->xsk_arr[j]));
405 ifobj->umem_arr[j].num_frames = DEFAULT_PKT_CNT / 4;
406 ifobj->umem_arr[j].frame_size = XSK_UMEM__DEFAULT_FRAME_SIZE;
407 ifobj->xsk_arr[j].rxqsize = XSK_RING_CONS__DEFAULT_NUM_DESCS;
411 test->ifobj_tx = ifobj_tx;
412 test->ifobj_rx = ifobj_rx;
415 static void test_spec_init(struct test_spec *test, struct ifobject *ifobj_tx,
416 struct ifobject *ifobj_rx)
418 memset(test, 0, sizeof(*test));
419 __test_spec_init(test, ifobj_tx, ifobj_rx);
422 static void test_spec_reset(struct test_spec *test)
424 __test_spec_init(test, test->ifobj_tx, test->ifobj_rx);
427 static void test_spec_set_name(struct test_spec *test, const char *name)
429 strncpy(test->name, name, MAX_TEST_NAME_SIZE);
432 static struct pkt *pkt_stream_get_pkt(struct pkt_stream *pkt_stream, u32 pkt_nb)
434 if (pkt_nb >= pkt_stream->nb_pkts)
437 return &pkt_stream->pkts[pkt_nb];
440 static struct pkt_stream *pkt_stream_generate(struct xsk_umem_info *umem, u32 nb_pkts, u32 pkt_len)
442 struct pkt_stream *pkt_stream;
445 pkt_stream = malloc(sizeof(*pkt_stream));
447 exit_with_error(ENOMEM);
449 pkt_stream->pkts = calloc(nb_pkts, sizeof(*pkt_stream->pkts));
450 if (!pkt_stream->pkts)
451 exit_with_error(ENOMEM);
453 pkt_stream->nb_pkts = nb_pkts;
454 for (i = 0; i < nb_pkts; i++) {
455 pkt_stream->pkts[i].addr = (i % umem->num_frames) * umem->frame_size;
456 pkt_stream->pkts[i].len = pkt_len;
457 pkt_stream->pkts[i].payload = i;
463 static struct pkt *pkt_generate(struct ifobject *ifobject, u32 pkt_nb)
465 struct pkt *pkt = pkt_stream_get_pkt(ifobject->pkt_stream, pkt_nb);
466 struct udphdr *udp_hdr;
467 struct ethhdr *eth_hdr;
468 struct iphdr *ip_hdr;
474 data = xsk_umem__get_data(ifobject->umem->buffer, pkt->addr);
475 udp_hdr = (struct udphdr *)(data + sizeof(struct ethhdr) + sizeof(struct iphdr));
476 ip_hdr = (struct iphdr *)(data + sizeof(struct ethhdr));
477 eth_hdr = (struct ethhdr *)data;
479 gen_udp_hdr(pkt_nb, data, ifobject, udp_hdr);
480 gen_ip_hdr(ifobject, ip_hdr);
481 gen_udp_csum(udp_hdr, ip_hdr);
482 gen_eth_hdr(ifobject, eth_hdr);
487 static void pkt_dump(void *pkt, u32 len)
489 char s[INET_ADDRSTRLEN];
490 struct ethhdr *ethhdr;
491 struct udphdr *udphdr;
496 iphdr = pkt + sizeof(*ethhdr);
497 udphdr = pkt + sizeof(*ethhdr) + sizeof(*iphdr);
499 /*extract L2 frame */
500 fprintf(stdout, "DEBUG>> L2: dst mac: ");
501 for (i = 0; i < ETH_ALEN; i++)
502 fprintf(stdout, "%02X", ethhdr->h_dest[i]);
504 fprintf(stdout, "\nDEBUG>> L2: src mac: ");
505 for (i = 0; i < ETH_ALEN; i++)
506 fprintf(stdout, "%02X", ethhdr->h_source[i]);
508 /*extract L3 frame */
509 fprintf(stdout, "\nDEBUG>> L3: ip_hdr->ihl: %02X\n", iphdr->ihl);
510 fprintf(stdout, "DEBUG>> L3: ip_hdr->saddr: %s\n",
511 inet_ntop(AF_INET, &iphdr->saddr, s, sizeof(s)));
512 fprintf(stdout, "DEBUG>> L3: ip_hdr->daddr: %s\n",
513 inet_ntop(AF_INET, &iphdr->daddr, s, sizeof(s)));
514 /*extract L4 frame */
515 fprintf(stdout, "DEBUG>> L4: udp_hdr->src: %d\n", ntohs(udphdr->source));
516 fprintf(stdout, "DEBUG>> L4: udp_hdr->dst: %d\n", ntohs(udphdr->dest));
517 /*extract L5 frame */
518 payload = *((uint32_t *)(pkt + PKT_HDR_SIZE));
520 fprintf(stdout, "DEBUG>> L5: payload: %d\n", payload);
521 fprintf(stdout, "---------------------------------------\n");
524 static bool is_pkt_valid(struct pkt *pkt, void *buffer, const struct xdp_desc *desc)
526 void *data = xsk_umem__get_data(buffer, desc->addr);
527 struct iphdr *iphdr = (struct iphdr *)(data + sizeof(struct ethhdr));
530 ksft_test_result_fail("ERROR: [%s] too many packets received\n", __func__);
534 if (iphdr->version == IP_PKT_VER && iphdr->tos == IP_PKT_TOS) {
535 u32 seqnum = ntohl(*((u32 *)(data + PKT_HDR_SIZE)));
537 if (opt_pkt_dump && test_type != TEST_TYPE_STATS)
538 pkt_dump(data, PKT_SIZE);
540 if (pkt->len != desc->len) {
541 ksft_test_result_fail
542 ("ERROR: [%s] expected length [%d], got length [%d]\n",
543 __func__, pkt->len, desc->len);
547 if (pkt->payload != seqnum) {
548 ksft_test_result_fail
549 ("ERROR: [%s] expected seqnum [%d], got seqnum [%d]\n",
550 __func__, pkt->payload, seqnum);
554 ksft_print_msg("Invalid frame received: ");
555 ksft_print_msg("[IP_PKT_VER: %02X], [IP_PKT_TOS: %02X]\n", iphdr->version,
563 static void kick_tx(struct xsk_socket_info *xsk)
567 ret = sendto(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, 0);
568 if (ret >= 0 || errno == ENOBUFS || errno == EAGAIN || errno == EBUSY || errno == ENETDOWN)
570 exit_with_error(errno);
573 static void complete_pkts(struct xsk_socket_info *xsk, int batch_size)
578 if (!xsk->outstanding_tx)
581 if (xsk_ring_prod__needs_wakeup(&xsk->tx))
584 rcvd = xsk_ring_cons__peek(&xsk->umem->cq, batch_size, &idx);
586 xsk_ring_cons__release(&xsk->umem->cq, rcvd);
587 xsk->outstanding_tx -= rcvd;
591 static void receive_pkts(struct pkt_stream *pkt_stream, struct xsk_socket_info *xsk,
594 u32 idx_rx = 0, idx_fq = 0, rcvd, i, pkt_count = 0;
598 pkt = pkt_stream_get_pkt(pkt_stream, pkt_count++);
600 rcvd = xsk_ring_cons__peek(&xsk->rx, BATCH_SIZE, &idx_rx);
602 if (xsk_ring_prod__needs_wakeup(&xsk->umem->fq)) {
603 ret = poll(fds, 1, POLL_TMOUT);
605 exit_with_error(-ret);
610 ret = xsk_ring_prod__reserve(&xsk->umem->fq, rcvd, &idx_fq);
611 while (ret != rcvd) {
613 exit_with_error(-ret);
614 if (xsk_ring_prod__needs_wakeup(&xsk->umem->fq)) {
615 ret = poll(fds, 1, POLL_TMOUT);
617 exit_with_error(-ret);
619 ret = xsk_ring_prod__reserve(&xsk->umem->fq, rcvd, &idx_fq);
622 for (i = 0; i < rcvd; i++) {
623 const struct xdp_desc *desc = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx++);
624 u64 addr = desc->addr, orig;
626 orig = xsk_umem__extract_addr(addr);
627 addr = xsk_umem__add_offset_to_addr(addr);
628 if (!is_pkt_valid(pkt, xsk->umem->buffer, desc))
631 *xsk_ring_prod__fill_addr(&xsk->umem->fq, idx_fq++) = orig;
632 pkt = pkt_stream_get_pkt(pkt_stream, pkt_count++);
635 xsk_ring_prod__submit(&xsk->umem->fq, rcvd);
636 xsk_ring_cons__release(&xsk->rx, rcvd);
640 static u32 __send_pkts(struct ifobject *ifobject, u32 pkt_nb)
642 struct xsk_socket_info *xsk = ifobject->xsk;
645 while (xsk_ring_prod__reserve(&xsk->tx, BATCH_SIZE, &idx) < BATCH_SIZE)
646 complete_pkts(xsk, BATCH_SIZE);
648 for (i = 0; i < BATCH_SIZE; i++) {
649 struct xdp_desc *tx_desc = xsk_ring_prod__tx_desc(&xsk->tx, idx + i);
650 struct pkt *pkt = pkt_generate(ifobject, pkt_nb);
655 tx_desc->addr = pkt->addr;
656 tx_desc->len = pkt->len;
660 xsk_ring_prod__submit(&xsk->tx, i);
661 if (stat_test_type != STAT_TEST_TX_INVALID)
662 xsk->outstanding_tx += i;
663 else if (xsk_ring_prod__needs_wakeup(&xsk->tx))
665 complete_pkts(xsk, i);
670 static void wait_for_tx_completion(struct xsk_socket_info *xsk)
672 while (xsk->outstanding_tx)
673 complete_pkts(xsk, BATCH_SIZE);
676 static void send_pkts(struct ifobject *ifobject)
678 struct pollfd fds[MAX_SOCKS] = { };
681 fds[0].fd = xsk_socket__fd(ifobject->xsk->xsk);
682 fds[0].events = POLLOUT;
684 while (pkt_cnt < ifobject->pkt_stream->nb_pkts) {
687 if (test_type == TEST_TYPE_POLL) {
690 ret = poll(fds, 1, POLL_TMOUT);
694 if (!(fds[0].revents & POLLOUT))
698 sent = __send_pkts(ifobject, pkt_cnt);
703 wait_for_tx_completion(ifobject->xsk);
706 static bool rx_stats_are_valid(struct ifobject *ifobject)
708 u32 xsk_stat = 0, expected_stat = ifobject->pkt_stream->nb_pkts;
709 struct xsk_socket *xsk = ifobject->xsk->xsk;
710 int fd = xsk_socket__fd(xsk);
711 struct xdp_statistics stats;
715 optlen = sizeof(stats);
716 err = getsockopt(fd, SOL_XDP, XDP_STATISTICS, &stats, &optlen);
718 ksft_test_result_fail("ERROR: [%s] getsockopt(XDP_STATISTICS) error %u %s\n",
719 __func__, -err, strerror(-err));
723 if (optlen == sizeof(struct xdp_statistics)) {
724 switch (stat_test_type) {
725 case STAT_TEST_RX_DROPPED:
726 xsk_stat = stats.rx_dropped;
728 case STAT_TEST_TX_INVALID:
730 case STAT_TEST_RX_FULL:
731 xsk_stat = stats.rx_ring_full;
732 expected_stat -= RX_FULL_RXQSIZE;
734 case STAT_TEST_RX_FILL_EMPTY:
735 xsk_stat = stats.rx_fill_ring_empty_descs;
741 if (xsk_stat == expected_stat)
748 static void tx_stats_validate(struct ifobject *ifobject)
750 struct xsk_socket *xsk = ifobject->xsk->xsk;
751 int fd = xsk_socket__fd(xsk);
752 struct xdp_statistics stats;
756 optlen = sizeof(stats);
757 err = getsockopt(fd, SOL_XDP, XDP_STATISTICS, &stats, &optlen);
759 ksft_test_result_fail("ERROR: [%s] getsockopt(XDP_STATISTICS) error %u %s\n",
760 __func__, -err, strerror(-err));
764 if (stats.tx_invalid_descs == ifobject->pkt_stream->nb_pkts)
767 ksft_test_result_fail("ERROR: [%s] tx_invalid_descs incorrect. Got [%u] expected [%u]\n",
768 __func__, stats.tx_invalid_descs, ifobject->pkt_stream->nb_pkts);
771 static void thread_common_ops(struct ifobject *ifobject, void *bufs)
773 u64 umem_sz = ifobject->umem->num_frames * ifobject->umem->frame_size;
774 int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE;
775 size_t mmap_sz = umem_sz;
778 ifobject->ns_fd = switch_namespace(ifobject->nsname);
780 if (test_type == TEST_TYPE_BPF_RES)
783 bufs = mmap(NULL, mmap_sz, PROT_READ | PROT_WRITE, mmap_flags, -1, 0);
784 if (bufs == MAP_FAILED)
785 exit_with_error(errno);
787 while (ctr++ < SOCK_RECONF_CTR) {
788 ret = xsk_configure_umem(&ifobject->umem_arr[0], bufs, umem_sz, 0);
790 exit_with_error(-ret);
792 ret = xsk_configure_socket(&ifobject->xsk_arr[0], &ifobject->umem_arr[0],
797 /* Retry Create Socket if it fails as xsk_socket__create() is asynchronous */
798 if (ctr >= SOCK_RECONF_CTR)
799 exit_with_error(-ret);
803 if (test_type == TEST_TYPE_BPF_RES) {
804 ret = xsk_configure_umem(&ifobject->umem_arr[1], (u8 *)bufs + umem_sz, umem_sz, 1);
806 exit_with_error(-ret);
808 ret = xsk_configure_socket(&ifobject->xsk_arr[1], &ifobject->umem_arr[1],
811 exit_with_error(-ret);
814 ifobject->umem = &ifobject->umem_arr[0];
815 ifobject->xsk = &ifobject->xsk_arr[0];
818 static bool testapp_is_test_two_stepped(void)
820 return (test_type != TEST_TYPE_BIDI && test_type != TEST_TYPE_BPF_RES) || second_step;
823 static void testapp_cleanup_xsk_res(struct ifobject *ifobj)
825 if (testapp_is_test_two_stepped()) {
826 xsk_socket__delete(ifobj->xsk->xsk);
827 (void)xsk_umem__delete(ifobj->umem->umem);
831 static void *worker_testapp_validate_tx(void *arg)
833 struct ifobject *ifobject = (struct ifobject *)arg;
837 thread_common_ops(ifobject, bufs);
839 print_verbose("Sending %d packets on interface %s\n", ifobject->pkt_stream->nb_pkts,
843 if (stat_test_type == STAT_TEST_TX_INVALID)
844 tx_stats_validate(ifobject);
846 testapp_cleanup_xsk_res(ifobject);
850 static void *worker_testapp_validate_rx(void *arg)
852 struct ifobject *ifobject = (struct ifobject *)arg;
853 struct pollfd fds[MAX_SOCKS] = { };
857 thread_common_ops(ifobject, bufs);
859 if (stat_test_type != STAT_TEST_RX_FILL_EMPTY)
860 xsk_populate_fill_ring(ifobject->umem);
862 fds[0].fd = xsk_socket__fd(ifobject->xsk->xsk);
863 fds[0].events = POLLIN;
865 pthread_barrier_wait(&barr);
867 if (test_type == TEST_TYPE_STATS)
868 while (!rx_stats_are_valid(ifobject))
871 receive_pkts(ifobject->pkt_stream, ifobject->xsk, fds);
873 if (test_type == TEST_TYPE_TEARDOWN)
874 print_verbose("Destroying socket\n");
876 testapp_cleanup_xsk_res(ifobject);
880 static void testapp_validate_traffic(struct test_spec *test)
882 struct ifobject *ifobj_tx = test->ifobj_tx;
883 struct ifobject *ifobj_rx = test->ifobj_rx;
884 struct pkt_stream *pkt_stream;
886 if (pthread_barrier_init(&barr, NULL, 2))
887 exit_with_error(errno);
889 if (stat_test_type == STAT_TEST_TX_INVALID)
890 pkt_stream = pkt_stream_generate(test->ifobj_tx->umem, DEFAULT_PKT_CNT,
891 XSK_UMEM__INVALID_FRAME_SIZE);
893 pkt_stream = pkt_stream_generate(test->ifobj_tx->umem, DEFAULT_PKT_CNT, PKT_SIZE);
894 ifobj_tx->pkt_stream = pkt_stream;
895 ifobj_rx->pkt_stream = pkt_stream;
898 pthread_create(&t0, NULL, ifobj_rx->func_ptr, ifobj_rx);
900 pthread_barrier_wait(&barr);
901 if (pthread_barrier_destroy(&barr))
902 exit_with_error(errno);
905 pthread_create(&t1, NULL, ifobj_tx->func_ptr, ifobj_tx);
907 pthread_join(t1, NULL);
908 pthread_join(t0, NULL);
911 static void testapp_teardown(struct test_spec *test)
915 test_spec_set_name(test, "TEARDOWN");
916 for (i = 0; i < MAX_TEARDOWN_ITER; i++) {
917 testapp_validate_traffic(test);
918 test_spec_reset(test);
922 static void swap_directions(struct ifobject **ifobj1, struct ifobject **ifobj2)
924 thread_func_t tmp_func_ptr = (*ifobj1)->func_ptr;
925 enum fvector tmp_vector = (*ifobj1)->fv.vector;
926 struct ifobject *tmp_ifobj = (*ifobj1);
928 (*ifobj1)->func_ptr = (*ifobj2)->func_ptr;
929 (*ifobj1)->fv.vector = (*ifobj2)->fv.vector;
931 (*ifobj2)->func_ptr = tmp_func_ptr;
932 (*ifobj2)->fv.vector = tmp_vector;
938 static void testapp_bidi(struct test_spec *test)
940 test_spec_set_name(test, "BIDIRECTIONAL");
941 for (int i = 0; i < MAX_BIDI_ITER; i++) {
942 print_verbose("Creating socket\n");
943 testapp_validate_traffic(test);
945 print_verbose("Switching Tx/Rx vectors\n");
946 swap_directions(&test->ifobj_rx, &test->ifobj_tx);
951 swap_directions(&test->ifobj_rx, &test->ifobj_tx);
954 static void swap_xsk_resources(struct ifobject *ifobj_tx, struct ifobject *ifobj_rx)
956 xsk_socket__delete(ifobj_tx->xsk->xsk);
957 xsk_umem__delete(ifobj_tx->umem->umem);
958 xsk_socket__delete(ifobj_rx->xsk->xsk);
959 xsk_umem__delete(ifobj_rx->umem->umem);
960 ifobj_tx->umem = &ifobj_tx->umem_arr[1];
961 ifobj_tx->xsk = &ifobj_tx->xsk_arr[1];
962 ifobj_rx->umem = &ifobj_rx->umem_arr[1];
963 ifobj_rx->xsk = &ifobj_rx->xsk_arr[1];
966 static void testapp_bpf_res(struct test_spec *test)
970 test_spec_set_name(test, "BPF_RES");
971 for (i = 0; i < MAX_BPF_ITER; i++) {
972 print_verbose("Creating socket\n");
973 testapp_validate_traffic(test);
975 swap_xsk_resources(test->ifobj_tx, test->ifobj_rx);
980 static void testapp_stats(struct test_spec *test)
982 for (int i = 0; i < STAT_TEST_TYPE_MAX; i++) {
983 test_spec_reset(test);
986 switch (stat_test_type) {
987 case STAT_TEST_RX_DROPPED:
988 test_spec_set_name(test, "STAT_RX_DROPPED");
989 test->ifobj_rx->umem->frame_headroom = test->ifobj_rx->umem->frame_size -
990 XDP_PACKET_HEADROOM - 1;
992 case STAT_TEST_RX_FULL:
993 test_spec_set_name(test, "STAT_RX_FULL");
994 test->ifobj_rx->xsk->rxqsize = RX_FULL_RXQSIZE;
996 case STAT_TEST_TX_INVALID:
997 test_spec_set_name(test, "STAT_TX_INVALID");
999 case STAT_TEST_RX_FILL_EMPTY:
1000 test_spec_set_name(test, "STAT_RX_FILL_EMPTY");
1005 testapp_validate_traffic(test);
1008 /* To only see the whole stat set being completed unless an individual test fails. */
1009 test_spec_set_name(test, "STATS");
1012 static void init_iface(struct ifobject *ifobj, const char *dst_mac, const char *src_mac,
1013 const char *dst_ip, const char *src_ip, const u16 dst_port,
1014 const u16 src_port, enum fvector vector, thread_func_t func_ptr)
1018 memcpy(ifobj->dst_mac, dst_mac, ETH_ALEN);
1019 memcpy(ifobj->src_mac, src_mac, ETH_ALEN);
1021 inet_aton(dst_ip, &ip);
1022 ifobj->dst_ip = ip.s_addr;
1024 inet_aton(src_ip, &ip);
1025 ifobj->src_ip = ip.s_addr;
1027 ifobj->dst_port = dst_port;
1028 ifobj->src_port = src_port;
1030 ifobj->fv.vector = vector;
1031 ifobj->func_ptr = func_ptr;
1034 static void run_pkt_test(struct test_spec *test, int mode, int type)
1038 /* reset defaults after potential previous test */
1039 xdp_flags = XDP_FLAGS_UPDATE_IF_NOEXIST;
1041 stat_test_type = -1;
1043 configured_mode = mode;
1046 case (TEST_MODE_SKB):
1047 xdp_flags |= XDP_FLAGS_SKB_MODE;
1049 case (TEST_MODE_DRV):
1050 xdp_flags |= XDP_FLAGS_DRV_MODE;
1056 switch (test_type) {
1057 case TEST_TYPE_STATS:
1058 testapp_stats(test);
1060 case TEST_TYPE_TEARDOWN:
1061 testapp_teardown(test);
1063 case TEST_TYPE_BIDI:
1066 case TEST_TYPE_BPF_RES:
1067 testapp_bpf_res(test);
1069 case TEST_TYPE_NOPOLL:
1070 test_spec_set_name(test, "RUN_TO_COMPLETION");
1071 testapp_validate_traffic(test);
1073 case TEST_TYPE_POLL:
1074 test_spec_set_name(test, "POLL");
1075 testapp_validate_traffic(test);
1081 print_ksft_result(test);
1084 static struct ifobject *ifobject_create(void)
1086 struct ifobject *ifobj;
1088 ifobj = calloc(1, sizeof(struct ifobject));
1092 ifobj->xsk_arr = calloc(MAX_SOCKETS, sizeof(*ifobj->xsk_arr));
1093 if (!ifobj->xsk_arr)
1096 ifobj->umem_arr = calloc(MAX_SOCKETS, sizeof(*ifobj->umem_arr));
1097 if (!ifobj->umem_arr)
1103 free(ifobj->xsk_arr);
1109 static void ifobject_delete(struct ifobject *ifobj)
1111 free(ifobj->umem_arr);
1112 free(ifobj->xsk_arr);
1116 int main(int argc, char **argv)
1118 struct rlimit _rlim = { RLIM_INFINITY, RLIM_INFINITY };
1119 struct ifobject *ifobj_tx, *ifobj_rx;
1120 struct test_spec test;
1123 if (setrlimit(RLIMIT_MEMLOCK, &_rlim))
1124 exit_with_error(errno);
1126 ifobj_tx = ifobject_create();
1128 exit_with_error(ENOMEM);
1129 ifobj_rx = ifobject_create();
1131 exit_with_error(ENOMEM);
1133 test_spec_init(&test, ifobj_tx, ifobj_rx);
1135 setlocale(LC_ALL, "");
1137 parse_command_line(&test, argc, argv);
1139 if (!validate_interface(ifobj_tx) || !validate_interface(ifobj_rx)) {
1140 usage(basename(argv[0]));
1144 init_iface(ifobj_tx, MAC1, MAC2, IP1, IP2, UDP_PORT1, UDP_PORT2, tx,
1145 worker_testapp_validate_tx);
1146 init_iface(ifobj_rx, MAC2, MAC1, IP2, IP1, UDP_PORT2, UDP_PORT1, rx,
1147 worker_testapp_validate_rx);
1149 ksft_set_plan(TEST_MODE_MAX * TEST_TYPE_MAX);
1151 for (i = 0; i < TEST_MODE_MAX; i++)
1152 for (j = 0; j < TEST_TYPE_MAX; j++) {
1153 test_spec_init(&test, ifobj_tx, ifobj_rx);
1154 run_pkt_test(&test, i, j);
1158 ifobject_delete(ifobj_tx);
1159 ifobject_delete(ifobj_rx);