1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2020 Intel Corporation. */ 3 4 /* 5 * Some functions in this program are taken from 6 * Linux kernel samples/bpf/xdpsock* and modified 7 * for use. 8 * 9 * See test_xsk.sh for detailed information on test topology 10 * and prerequisite network setup. 11 * 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. 15 * 16 * Tests Information: 17 * ------------------ 18 * These selftests test AF_XDP SKB and Native/DRV modes using veth 19 * Virtual Ethernet interfaces. 20 * 21 * For each mode, the following tests are run: 22 * a. nopoll - soft-irq processing in run-to-completion mode 23 * b. poll - using poll() syscall 24 * c. Socket Teardown 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 30 * mode is used 31 * e. Statistics 32 * Trigger some error conditions and ensure that the appropriate statistics 33 * are incremented. Within this test, the following statistics are tested: 34 * i. rx dropped 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. 37 * ii. tx invalid 38 * Set the 'len' field of tx descriptors to an invalid value (umem frame 39 * size + 1). 40 * iii. rx ring full 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 48 * g. unaligned mode 49 * h. tests for invalid and corner case Tx descriptors so that the correct ones 50 * are discarded and let through, respectively. 51 * i. 2K frame size tests 52 * j. If multi-buffer is supported, send 9k packets divided into 3 frames 53 * k. If multi-buffer and huge pages are supported, send 9k packets in a single frame 54 * using unaligned mode 55 * l. If multi-buffer is supported, try various nasty combinations of descriptors to 56 * check if they pass the validation or not 57 * 58 * Flow: 59 * ----- 60 * - Single process spawns two threads: Tx and Rx 61 * - Each of these two threads attach to a veth interface 62 * - Each thread creates one AF_XDP socket connected to a unique umem for each 63 * veth interface 64 * - Tx thread Transmits a number of packets from veth<xxxx> to veth<yyyy> 65 * - Rx thread verifies if all packets were received and delivered in-order, 66 * and have the right content 67 * 68 * Enable/disable packet dump mode: 69 * -------------------------- 70 * To enable L2 - L4 headers and payload dump of each packet on STDOUT, add 71 * parameter -D to params array in test_xsk.sh, i.e. params=("-S" "-D") 72 */ 73 74 #define _GNU_SOURCE 75 #include <assert.h> 76 #include <fcntl.h> 77 #include <errno.h> 78 #include <getopt.h> 79 #include <linux/if_link.h> 80 #include <linux/if_ether.h> 81 #include <linux/mman.h> 82 #include <linux/netdev.h> 83 #include <linux/bitmap.h> 84 #include <arpa/inet.h> 85 #include <net/if.h> 86 #include <locale.h> 87 #include <poll.h> 88 #include <pthread.h> 89 #include <signal.h> 90 #include <stdio.h> 91 #include <stdlib.h> 92 #include <string.h> 93 #include <stddef.h> 94 #include <sys/mman.h> 95 #include <sys/socket.h> 96 #include <sys/time.h> 97 #include <sys/types.h> 98 #include <unistd.h> 99 100 #include "xsk_xdp_progs.skel.h" 101 #include "xsk.h" 102 #include "xskxceiver.h" 103 #include <bpf/bpf.h> 104 #include <linux/filter.h> 105 #include "../kselftest.h" 106 #include "xsk_xdp_common.h" 107 108 static bool opt_verbose; 109 static bool opt_print_tests; 110 static enum test_mode opt_mode = TEST_MODE_ALL; 111 static u32 opt_run_test = RUN_ALL_TESTS; 112 113 static void __exit_with_error(int error, const char *file, const char *func, int line) 114 { 115 ksft_test_result_fail("[%s:%s:%i]: ERROR: %d/\"%s\"\n", file, func, line, error, 116 strerror(error)); 117 ksft_exit_xfail(); 118 } 119 120 #define exit_with_error(error) __exit_with_error(error, __FILE__, __func__, __LINE__) 121 #define busy_poll_string(test) (test)->ifobj_tx->busy_poll ? "BUSY-POLL " : "" 122 static char *mode_string(struct test_spec *test) 123 { 124 switch (test->mode) { 125 case TEST_MODE_SKB: 126 return "SKB"; 127 case TEST_MODE_DRV: 128 return "DRV"; 129 case TEST_MODE_ZC: 130 return "ZC"; 131 default: 132 return "BOGUS"; 133 } 134 } 135 136 static void report_failure(struct test_spec *test) 137 { 138 if (test->fail) 139 return; 140 141 ksft_test_result_fail("FAIL: %s %s%s\n", mode_string(test), busy_poll_string(test), 142 test->name); 143 test->fail = true; 144 } 145 146 /* The payload is a word consisting of a packet sequence number in the upper 147 * 16-bits and a intra packet data sequence number in the lower 16 bits. So the 3rd packet's 148 * 5th word of data will contain the number (2<<16) | 4 as they are numbered from 0. 149 */ 150 static void write_payload(void *dest, u32 pkt_nb, u32 start, u32 size) 151 { 152 u32 *ptr = (u32 *)dest, i; 153 154 start /= sizeof(*ptr); 155 size /= sizeof(*ptr); 156 for (i = 0; i < size; i++) 157 ptr[i] = htonl(pkt_nb << 16 | (i + start)); 158 } 159 160 static void gen_eth_hdr(struct xsk_socket_info *xsk, struct ethhdr *eth_hdr) 161 { 162 memcpy(eth_hdr->h_dest, xsk->dst_mac, ETH_ALEN); 163 memcpy(eth_hdr->h_source, xsk->src_mac, ETH_ALEN); 164 eth_hdr->h_proto = htons(ETH_P_LOOPBACK); 165 } 166 167 static bool is_umem_valid(struct ifobject *ifobj) 168 { 169 return !!ifobj->umem->umem; 170 } 171 172 static u32 mode_to_xdp_flags(enum test_mode mode) 173 { 174 return (mode == TEST_MODE_SKB) ? XDP_FLAGS_SKB_MODE : XDP_FLAGS_DRV_MODE; 175 } 176 177 static u64 umem_size(struct xsk_umem_info *umem) 178 { 179 return umem->num_frames * umem->frame_size; 180 } 181 182 static int xsk_configure_umem(struct ifobject *ifobj, struct xsk_umem_info *umem, void *buffer, 183 u64 size) 184 { 185 struct xsk_umem_config cfg = { 186 .fill_size = XSK_RING_PROD__DEFAULT_NUM_DESCS, 187 .comp_size = XSK_RING_CONS__DEFAULT_NUM_DESCS, 188 .frame_size = umem->frame_size, 189 .frame_headroom = umem->frame_headroom, 190 .flags = XSK_UMEM__DEFAULT_FLAGS 191 }; 192 int ret; 193 194 if (umem->unaligned_mode) 195 cfg.flags |= XDP_UMEM_UNALIGNED_CHUNK_FLAG; 196 197 ret = xsk_umem__create(&umem->umem, buffer, size, 198 &umem->fq, &umem->cq, &cfg); 199 if (ret) 200 return ret; 201 202 umem->buffer = buffer; 203 if (ifobj->shared_umem && ifobj->rx_on) { 204 umem->base_addr = umem_size(umem); 205 umem->next_buffer = umem_size(umem); 206 } 207 208 return 0; 209 } 210 211 static u64 umem_alloc_buffer(struct xsk_umem_info *umem) 212 { 213 u64 addr; 214 215 addr = umem->next_buffer; 216 umem->next_buffer += umem->frame_size; 217 if (umem->next_buffer >= umem->base_addr + umem_size(umem)) 218 umem->next_buffer = umem->base_addr; 219 220 return addr; 221 } 222 223 static void umem_reset_alloc(struct xsk_umem_info *umem) 224 { 225 umem->next_buffer = 0; 226 } 227 228 static void enable_busy_poll(struct xsk_socket_info *xsk) 229 { 230 int sock_opt; 231 232 sock_opt = 1; 233 if (setsockopt(xsk_socket__fd(xsk->xsk), SOL_SOCKET, SO_PREFER_BUSY_POLL, 234 (void *)&sock_opt, sizeof(sock_opt)) < 0) 235 exit_with_error(errno); 236 237 sock_opt = 20; 238 if (setsockopt(xsk_socket__fd(xsk->xsk), SOL_SOCKET, SO_BUSY_POLL, 239 (void *)&sock_opt, sizeof(sock_opt)) < 0) 240 exit_with_error(errno); 241 242 sock_opt = BATCH_SIZE; 243 if (setsockopt(xsk_socket__fd(xsk->xsk), SOL_SOCKET, SO_BUSY_POLL_BUDGET, 244 (void *)&sock_opt, sizeof(sock_opt)) < 0) 245 exit_with_error(errno); 246 } 247 248 static int __xsk_configure_socket(struct xsk_socket_info *xsk, struct xsk_umem_info *umem, 249 struct ifobject *ifobject, bool shared) 250 { 251 struct xsk_socket_config cfg = {}; 252 struct xsk_ring_cons *rxr; 253 struct xsk_ring_prod *txr; 254 255 xsk->umem = umem; 256 cfg.rx_size = xsk->rxqsize; 257 cfg.tx_size = XSK_RING_PROD__DEFAULT_NUM_DESCS; 258 cfg.bind_flags = ifobject->bind_flags; 259 if (shared) 260 cfg.bind_flags |= XDP_SHARED_UMEM; 261 if (ifobject->mtu > MAX_ETH_PKT_SIZE) 262 cfg.bind_flags |= XDP_USE_SG; 263 264 txr = ifobject->tx_on ? &xsk->tx : NULL; 265 rxr = ifobject->rx_on ? &xsk->rx : NULL; 266 return xsk_socket__create(&xsk->xsk, ifobject->ifindex, 0, umem->umem, rxr, txr, &cfg); 267 } 268 269 static bool ifobj_zc_avail(struct ifobject *ifobject) 270 { 271 size_t umem_sz = DEFAULT_UMEM_BUFFERS * XSK_UMEM__DEFAULT_FRAME_SIZE; 272 int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE; 273 struct xsk_socket_info *xsk; 274 struct xsk_umem_info *umem; 275 bool zc_avail = false; 276 void *bufs; 277 int ret; 278 279 bufs = mmap(NULL, umem_sz, PROT_READ | PROT_WRITE, mmap_flags, -1, 0); 280 if (bufs == MAP_FAILED) 281 exit_with_error(errno); 282 283 umem = calloc(1, sizeof(struct xsk_umem_info)); 284 if (!umem) { 285 munmap(bufs, umem_sz); 286 exit_with_error(ENOMEM); 287 } 288 umem->frame_size = XSK_UMEM__DEFAULT_FRAME_SIZE; 289 ret = xsk_configure_umem(ifobject, umem, bufs, umem_sz); 290 if (ret) 291 exit_with_error(-ret); 292 293 xsk = calloc(1, sizeof(struct xsk_socket_info)); 294 if (!xsk) 295 goto out; 296 ifobject->bind_flags = XDP_USE_NEED_WAKEUP | XDP_ZEROCOPY; 297 ifobject->rx_on = true; 298 xsk->rxqsize = XSK_RING_CONS__DEFAULT_NUM_DESCS; 299 ret = __xsk_configure_socket(xsk, umem, ifobject, false); 300 if (!ret) 301 zc_avail = true; 302 303 xsk_socket__delete(xsk->xsk); 304 free(xsk); 305 out: 306 munmap(umem->buffer, umem_sz); 307 xsk_umem__delete(umem->umem); 308 free(umem); 309 return zc_avail; 310 } 311 312 static struct option long_options[] = { 313 {"interface", required_argument, 0, 'i'}, 314 {"busy-poll", no_argument, 0, 'b'}, 315 {"verbose", no_argument, 0, 'v'}, 316 {"mode", required_argument, 0, 'm'}, 317 {"list", no_argument, 0, 'l'}, 318 {"test", required_argument, 0, 't'}, 319 {"help", no_argument, 0, 'h'}, 320 {0, 0, 0, 0} 321 }; 322 323 static void print_usage(char **argv) 324 { 325 const char *str = 326 " Usage: xskxceiver [OPTIONS]\n" 327 " Options:\n" 328 " -i, --interface Use interface\n" 329 " -v, --verbose Verbose output\n" 330 " -b, --busy-poll Enable busy poll\n" 331 " -m, --mode Run only mode skb, drv, or zc\n" 332 " -l, --list List all available tests\n" 333 " -t, --test Run a specific test. Enter number from -l option.\n" 334 " -h, --help Display this help and exit\n"; 335 336 ksft_print_msg(str, basename(argv[0])); 337 ksft_exit_xfail(); 338 } 339 340 static bool validate_interface(struct ifobject *ifobj) 341 { 342 if (!strcmp(ifobj->ifname, "")) 343 return false; 344 return true; 345 } 346 347 static void parse_command_line(struct ifobject *ifobj_tx, struct ifobject *ifobj_rx, int argc, 348 char **argv) 349 { 350 struct ifobject *ifobj; 351 u32 interface_nb = 0; 352 int option_index, c; 353 354 opterr = 0; 355 356 for (;;) { 357 c = getopt_long(argc, argv, "i:vbm:lt:", long_options, &option_index); 358 if (c == -1) 359 break; 360 361 switch (c) { 362 case 'i': 363 if (interface_nb == 0) 364 ifobj = ifobj_tx; 365 else if (interface_nb == 1) 366 ifobj = ifobj_rx; 367 else 368 break; 369 370 memcpy(ifobj->ifname, optarg, 371 min_t(size_t, MAX_INTERFACE_NAME_CHARS, strlen(optarg))); 372 373 ifobj->ifindex = if_nametoindex(ifobj->ifname); 374 if (!ifobj->ifindex) 375 exit_with_error(errno); 376 377 interface_nb++; 378 break; 379 case 'v': 380 opt_verbose = true; 381 break; 382 case 'b': 383 ifobj_tx->busy_poll = true; 384 ifobj_rx->busy_poll = true; 385 break; 386 case 'm': 387 if (!strncmp("skb", optarg, strlen(optarg))) 388 opt_mode = TEST_MODE_SKB; 389 else if (!strncmp("drv", optarg, strlen(optarg))) 390 opt_mode = TEST_MODE_DRV; 391 else if (!strncmp("zc", optarg, strlen(optarg))) 392 opt_mode = TEST_MODE_ZC; 393 else 394 print_usage(argv); 395 break; 396 case 'l': 397 opt_print_tests = true; 398 break; 399 case 't': 400 errno = 0; 401 opt_run_test = strtol(optarg, NULL, 0); 402 if (errno) 403 print_usage(argv); 404 break; 405 case 'h': 406 default: 407 print_usage(argv); 408 } 409 } 410 } 411 412 static void __test_spec_init(struct test_spec *test, struct ifobject *ifobj_tx, 413 struct ifobject *ifobj_rx) 414 { 415 u32 i, j; 416 417 for (i = 0; i < MAX_INTERFACES; i++) { 418 struct ifobject *ifobj = i ? ifobj_rx : ifobj_tx; 419 420 ifobj->xsk = &ifobj->xsk_arr[0]; 421 ifobj->use_poll = false; 422 ifobj->use_fill_ring = true; 423 ifobj->release_rx = true; 424 ifobj->validation_func = NULL; 425 ifobj->use_metadata = false; 426 427 if (i == 0) { 428 ifobj->rx_on = false; 429 ifobj->tx_on = true; 430 } else { 431 ifobj->rx_on = true; 432 ifobj->tx_on = false; 433 } 434 435 memset(ifobj->umem, 0, sizeof(*ifobj->umem)); 436 ifobj->umem->num_frames = DEFAULT_UMEM_BUFFERS; 437 ifobj->umem->frame_size = XSK_UMEM__DEFAULT_FRAME_SIZE; 438 439 for (j = 0; j < MAX_SOCKETS; j++) { 440 memset(&ifobj->xsk_arr[j], 0, sizeof(ifobj->xsk_arr[j])); 441 ifobj->xsk_arr[j].rxqsize = XSK_RING_CONS__DEFAULT_NUM_DESCS; 442 if (i == 0) 443 ifobj->xsk_arr[j].pkt_stream = test->tx_pkt_stream_default; 444 else 445 ifobj->xsk_arr[j].pkt_stream = test->rx_pkt_stream_default; 446 447 memcpy(ifobj->xsk_arr[j].src_mac, g_mac, ETH_ALEN); 448 memcpy(ifobj->xsk_arr[j].dst_mac, g_mac, ETH_ALEN); 449 ifobj->xsk_arr[j].src_mac[5] += ((j * 2) + 0); 450 ifobj->xsk_arr[j].dst_mac[5] += ((j * 2) + 1); 451 } 452 } 453 454 test->ifobj_tx = ifobj_tx; 455 test->ifobj_rx = ifobj_rx; 456 test->current_step = 0; 457 test->total_steps = 1; 458 test->nb_sockets = 1; 459 test->fail = false; 460 test->mtu = MAX_ETH_PKT_SIZE; 461 test->xdp_prog_rx = ifobj_rx->xdp_progs->progs.xsk_def_prog; 462 test->xskmap_rx = ifobj_rx->xdp_progs->maps.xsk; 463 test->xdp_prog_tx = ifobj_tx->xdp_progs->progs.xsk_def_prog; 464 test->xskmap_tx = ifobj_tx->xdp_progs->maps.xsk; 465 } 466 467 static void test_spec_init(struct test_spec *test, struct ifobject *ifobj_tx, 468 struct ifobject *ifobj_rx, enum test_mode mode, 469 const struct test_spec *test_to_run) 470 { 471 struct pkt_stream *tx_pkt_stream; 472 struct pkt_stream *rx_pkt_stream; 473 u32 i; 474 475 tx_pkt_stream = test->tx_pkt_stream_default; 476 rx_pkt_stream = test->rx_pkt_stream_default; 477 memset(test, 0, sizeof(*test)); 478 test->tx_pkt_stream_default = tx_pkt_stream; 479 test->rx_pkt_stream_default = rx_pkt_stream; 480 481 for (i = 0; i < MAX_INTERFACES; i++) { 482 struct ifobject *ifobj = i ? ifobj_rx : ifobj_tx; 483 484 ifobj->bind_flags = XDP_USE_NEED_WAKEUP; 485 if (mode == TEST_MODE_ZC) 486 ifobj->bind_flags |= XDP_ZEROCOPY; 487 else 488 ifobj->bind_flags |= XDP_COPY; 489 } 490 491 strncpy(test->name, test_to_run->name, MAX_TEST_NAME_SIZE); 492 test->test_func = test_to_run->test_func; 493 test->mode = mode; 494 __test_spec_init(test, ifobj_tx, ifobj_rx); 495 } 496 497 static void test_spec_reset(struct test_spec *test) 498 { 499 __test_spec_init(test, test->ifobj_tx, test->ifobj_rx); 500 } 501 502 static void test_spec_set_xdp_prog(struct test_spec *test, struct bpf_program *xdp_prog_rx, 503 struct bpf_program *xdp_prog_tx, struct bpf_map *xskmap_rx, 504 struct bpf_map *xskmap_tx) 505 { 506 test->xdp_prog_rx = xdp_prog_rx; 507 test->xdp_prog_tx = xdp_prog_tx; 508 test->xskmap_rx = xskmap_rx; 509 test->xskmap_tx = xskmap_tx; 510 } 511 512 static int test_spec_set_mtu(struct test_spec *test, int mtu) 513 { 514 int err; 515 516 if (test->ifobj_rx->mtu != mtu) { 517 err = xsk_set_mtu(test->ifobj_rx->ifindex, mtu); 518 if (err) 519 return err; 520 test->ifobj_rx->mtu = mtu; 521 } 522 if (test->ifobj_tx->mtu != mtu) { 523 err = xsk_set_mtu(test->ifobj_tx->ifindex, mtu); 524 if (err) 525 return err; 526 test->ifobj_tx->mtu = mtu; 527 } 528 529 return 0; 530 } 531 532 static void pkt_stream_reset(struct pkt_stream *pkt_stream) 533 { 534 if (pkt_stream) { 535 pkt_stream->current_pkt_nb = 0; 536 pkt_stream->nb_rx_pkts = 0; 537 } 538 } 539 540 static struct pkt *pkt_stream_get_next_tx_pkt(struct pkt_stream *pkt_stream) 541 { 542 if (pkt_stream->current_pkt_nb >= pkt_stream->nb_pkts) 543 return NULL; 544 545 return &pkt_stream->pkts[pkt_stream->current_pkt_nb++]; 546 } 547 548 static struct pkt *pkt_stream_get_next_rx_pkt(struct pkt_stream *pkt_stream, u32 *pkts_sent) 549 { 550 while (pkt_stream->current_pkt_nb < pkt_stream->nb_pkts) { 551 (*pkts_sent)++; 552 if (pkt_stream->pkts[pkt_stream->current_pkt_nb].valid) 553 return &pkt_stream->pkts[pkt_stream->current_pkt_nb++]; 554 pkt_stream->current_pkt_nb++; 555 } 556 return NULL; 557 } 558 559 static void pkt_stream_delete(struct pkt_stream *pkt_stream) 560 { 561 free(pkt_stream->pkts); 562 free(pkt_stream); 563 } 564 565 static void pkt_stream_restore_default(struct test_spec *test) 566 { 567 struct pkt_stream *tx_pkt_stream = test->ifobj_tx->xsk->pkt_stream; 568 struct pkt_stream *rx_pkt_stream = test->ifobj_rx->xsk->pkt_stream; 569 570 if (tx_pkt_stream != test->tx_pkt_stream_default) { 571 pkt_stream_delete(test->ifobj_tx->xsk->pkt_stream); 572 test->ifobj_tx->xsk->pkt_stream = test->tx_pkt_stream_default; 573 } 574 575 if (rx_pkt_stream != test->rx_pkt_stream_default) { 576 pkt_stream_delete(test->ifobj_rx->xsk->pkt_stream); 577 test->ifobj_rx->xsk->pkt_stream = test->rx_pkt_stream_default; 578 } 579 } 580 581 static struct pkt_stream *__pkt_stream_alloc(u32 nb_pkts) 582 { 583 struct pkt_stream *pkt_stream; 584 585 pkt_stream = calloc(1, sizeof(*pkt_stream)); 586 if (!pkt_stream) 587 return NULL; 588 589 pkt_stream->pkts = calloc(nb_pkts, sizeof(*pkt_stream->pkts)); 590 if (!pkt_stream->pkts) { 591 free(pkt_stream); 592 return NULL; 593 } 594 595 pkt_stream->nb_pkts = nb_pkts; 596 return pkt_stream; 597 } 598 599 static bool pkt_continues(u32 options) 600 { 601 return options & XDP_PKT_CONTD; 602 } 603 604 static u32 ceil_u32(u32 a, u32 b) 605 { 606 return (a + b - 1) / b; 607 } 608 609 static u32 pkt_nb_frags(u32 frame_size, struct pkt_stream *pkt_stream, struct pkt *pkt) 610 { 611 u32 nb_frags = 1, next_frag; 612 613 if (!pkt) 614 return 1; 615 616 if (!pkt_stream->verbatim) { 617 if (!pkt->valid || !pkt->len) 618 return 1; 619 return ceil_u32(pkt->len, frame_size); 620 } 621 622 /* Search for the end of the packet in verbatim mode */ 623 if (!pkt_continues(pkt->options)) 624 return nb_frags; 625 626 next_frag = pkt_stream->current_pkt_nb; 627 pkt++; 628 while (next_frag++ < pkt_stream->nb_pkts) { 629 nb_frags++; 630 if (!pkt_continues(pkt->options) || !pkt->valid) 631 break; 632 pkt++; 633 } 634 return nb_frags; 635 } 636 637 static void pkt_set(struct pkt_stream *pkt_stream, struct pkt *pkt, int offset, u32 len) 638 { 639 pkt->offset = offset; 640 pkt->len = len; 641 if (len > MAX_ETH_JUMBO_SIZE) { 642 pkt->valid = false; 643 } else { 644 pkt->valid = true; 645 pkt_stream->nb_valid_entries++; 646 } 647 } 648 649 static u32 pkt_get_buffer_len(struct xsk_umem_info *umem, u32 len) 650 { 651 return ceil_u32(len, umem->frame_size) * umem->frame_size; 652 } 653 654 static struct pkt_stream *__pkt_stream_generate(u32 nb_pkts, u32 pkt_len, u32 nb_start, u32 nb_off) 655 { 656 struct pkt_stream *pkt_stream; 657 u32 i; 658 659 pkt_stream = __pkt_stream_alloc(nb_pkts); 660 if (!pkt_stream) 661 exit_with_error(ENOMEM); 662 663 pkt_stream->nb_pkts = nb_pkts; 664 pkt_stream->max_pkt_len = pkt_len; 665 for (i = 0; i < nb_pkts; i++) { 666 struct pkt *pkt = &pkt_stream->pkts[i]; 667 668 pkt_set(pkt_stream, pkt, 0, pkt_len); 669 pkt->pkt_nb = nb_start + i * nb_off; 670 } 671 672 return pkt_stream; 673 } 674 675 static struct pkt_stream *pkt_stream_generate(u32 nb_pkts, u32 pkt_len) 676 { 677 return __pkt_stream_generate(nb_pkts, pkt_len, 0, 1); 678 } 679 680 static struct pkt_stream *pkt_stream_clone(struct pkt_stream *pkt_stream) 681 { 682 return pkt_stream_generate(pkt_stream->nb_pkts, pkt_stream->pkts[0].len); 683 } 684 685 static void pkt_stream_replace(struct test_spec *test, u32 nb_pkts, u32 pkt_len) 686 { 687 struct pkt_stream *pkt_stream; 688 689 pkt_stream = pkt_stream_generate(nb_pkts, pkt_len); 690 test->ifobj_tx->xsk->pkt_stream = pkt_stream; 691 pkt_stream = pkt_stream_generate(nb_pkts, pkt_len); 692 test->ifobj_rx->xsk->pkt_stream = pkt_stream; 693 } 694 695 static void __pkt_stream_replace_half(struct ifobject *ifobj, u32 pkt_len, 696 int offset) 697 { 698 struct pkt_stream *pkt_stream; 699 u32 i; 700 701 pkt_stream = pkt_stream_clone(ifobj->xsk->pkt_stream); 702 for (i = 1; i < ifobj->xsk->pkt_stream->nb_pkts; i += 2) 703 pkt_set(pkt_stream, &pkt_stream->pkts[i], offset, pkt_len); 704 705 ifobj->xsk->pkt_stream = pkt_stream; 706 pkt_stream->nb_valid_entries /= 2; 707 } 708 709 static void pkt_stream_replace_half(struct test_spec *test, u32 pkt_len, int offset) 710 { 711 __pkt_stream_replace_half(test->ifobj_tx, pkt_len, offset); 712 __pkt_stream_replace_half(test->ifobj_rx, pkt_len, offset); 713 } 714 715 static void pkt_stream_receive_half(struct test_spec *test) 716 { 717 struct pkt_stream *pkt_stream = test->ifobj_tx->xsk->pkt_stream; 718 u32 i; 719 720 test->ifobj_rx->xsk->pkt_stream = pkt_stream_generate(pkt_stream->nb_pkts, 721 pkt_stream->pkts[0].len); 722 pkt_stream = test->ifobj_rx->xsk->pkt_stream; 723 for (i = 1; i < pkt_stream->nb_pkts; i += 2) 724 pkt_stream->pkts[i].valid = false; 725 726 pkt_stream->nb_valid_entries /= 2; 727 } 728 729 static void pkt_stream_even_odd_sequence(struct test_spec *test) 730 { 731 struct pkt_stream *pkt_stream; 732 u32 i; 733 734 for (i = 0; i < test->nb_sockets; i++) { 735 pkt_stream = test->ifobj_tx->xsk_arr[i].pkt_stream; 736 pkt_stream = __pkt_stream_generate(pkt_stream->nb_pkts / 2, 737 pkt_stream->pkts[0].len, i, 2); 738 test->ifobj_tx->xsk_arr[i].pkt_stream = pkt_stream; 739 740 pkt_stream = test->ifobj_rx->xsk_arr[i].pkt_stream; 741 pkt_stream = __pkt_stream_generate(pkt_stream->nb_pkts / 2, 742 pkt_stream->pkts[0].len, i, 2); 743 test->ifobj_rx->xsk_arr[i].pkt_stream = pkt_stream; 744 } 745 } 746 747 static u64 pkt_get_addr(struct pkt *pkt, struct xsk_umem_info *umem) 748 { 749 if (!pkt->valid) 750 return pkt->offset; 751 return pkt->offset + umem_alloc_buffer(umem); 752 } 753 754 static void pkt_stream_cancel(struct pkt_stream *pkt_stream) 755 { 756 pkt_stream->current_pkt_nb--; 757 } 758 759 static void pkt_generate(struct xsk_socket_info *xsk, struct xsk_umem_info *umem, u64 addr, u32 len, 760 u32 pkt_nb, u32 bytes_written) 761 { 762 void *data = xsk_umem__get_data(umem->buffer, addr); 763 764 if (len < MIN_PKT_SIZE) 765 return; 766 767 if (!bytes_written) { 768 gen_eth_hdr(xsk, data); 769 770 len -= PKT_HDR_SIZE; 771 data += PKT_HDR_SIZE; 772 } else { 773 bytes_written -= PKT_HDR_SIZE; 774 } 775 776 write_payload(data, pkt_nb, bytes_written, len); 777 } 778 779 static struct pkt_stream *__pkt_stream_generate_custom(struct ifobject *ifobj, struct pkt *frames, 780 u32 nb_frames, bool verbatim) 781 { 782 u32 i, len = 0, pkt_nb = 0, payload = 0; 783 struct pkt_stream *pkt_stream; 784 785 pkt_stream = __pkt_stream_alloc(nb_frames); 786 if (!pkt_stream) 787 exit_with_error(ENOMEM); 788 789 for (i = 0; i < nb_frames; i++) { 790 struct pkt *pkt = &pkt_stream->pkts[pkt_nb]; 791 struct pkt *frame = &frames[i]; 792 793 pkt->offset = frame->offset; 794 if (verbatim) { 795 *pkt = *frame; 796 pkt->pkt_nb = payload; 797 if (!frame->valid || !pkt_continues(frame->options)) 798 payload++; 799 } else { 800 if (frame->valid) 801 len += frame->len; 802 if (frame->valid && pkt_continues(frame->options)) 803 continue; 804 805 pkt->pkt_nb = pkt_nb; 806 pkt->len = len; 807 pkt->valid = frame->valid; 808 pkt->options = 0; 809 810 len = 0; 811 } 812 813 print_verbose("offset: %d len: %u valid: %u options: %u pkt_nb: %u\n", 814 pkt->offset, pkt->len, pkt->valid, pkt->options, pkt->pkt_nb); 815 816 if (pkt->valid && pkt->len > pkt_stream->max_pkt_len) 817 pkt_stream->max_pkt_len = pkt->len; 818 819 if (pkt->valid) 820 pkt_stream->nb_valid_entries++; 821 822 pkt_nb++; 823 } 824 825 pkt_stream->nb_pkts = pkt_nb; 826 pkt_stream->verbatim = verbatim; 827 return pkt_stream; 828 } 829 830 static void pkt_stream_generate_custom(struct test_spec *test, struct pkt *pkts, u32 nb_pkts) 831 { 832 struct pkt_stream *pkt_stream; 833 834 pkt_stream = __pkt_stream_generate_custom(test->ifobj_tx, pkts, nb_pkts, true); 835 test->ifobj_tx->xsk->pkt_stream = pkt_stream; 836 837 pkt_stream = __pkt_stream_generate_custom(test->ifobj_rx, pkts, nb_pkts, false); 838 test->ifobj_rx->xsk->pkt_stream = pkt_stream; 839 } 840 841 static void pkt_print_data(u32 *data, u32 cnt) 842 { 843 u32 i; 844 845 for (i = 0; i < cnt; i++) { 846 u32 seqnum, pkt_nb; 847 848 seqnum = ntohl(*data) & 0xffff; 849 pkt_nb = ntohl(*data) >> 16; 850 ksft_print_msg("%u:%u ", pkt_nb, seqnum); 851 data++; 852 } 853 } 854 855 static void pkt_dump(void *pkt, u32 len, bool eth_header) 856 { 857 struct ethhdr *ethhdr = pkt; 858 u32 i, *data; 859 860 if (eth_header) { 861 /*extract L2 frame */ 862 ksft_print_msg("DEBUG>> L2: dst mac: "); 863 for (i = 0; i < ETH_ALEN; i++) 864 ksft_print_msg("%02X", ethhdr->h_dest[i]); 865 866 ksft_print_msg("\nDEBUG>> L2: src mac: "); 867 for (i = 0; i < ETH_ALEN; i++) 868 ksft_print_msg("%02X", ethhdr->h_source[i]); 869 870 data = pkt + PKT_HDR_SIZE; 871 } else { 872 data = pkt; 873 } 874 875 /*extract L5 frame */ 876 ksft_print_msg("\nDEBUG>> L5: seqnum: "); 877 pkt_print_data(data, PKT_DUMP_NB_TO_PRINT); 878 ksft_print_msg("...."); 879 if (len > PKT_DUMP_NB_TO_PRINT * sizeof(u32)) { 880 ksft_print_msg("\n.... "); 881 pkt_print_data(data + len / sizeof(u32) - PKT_DUMP_NB_TO_PRINT, 882 PKT_DUMP_NB_TO_PRINT); 883 } 884 ksft_print_msg("\n---------------------------------------\n"); 885 } 886 887 static bool is_offset_correct(struct xsk_umem_info *umem, struct pkt *pkt, u64 addr) 888 { 889 u32 headroom = umem->unaligned_mode ? 0 : umem->frame_headroom; 890 u32 offset = addr % umem->frame_size, expected_offset; 891 int pkt_offset = pkt->valid ? pkt->offset : 0; 892 893 if (!umem->unaligned_mode) 894 pkt_offset = 0; 895 896 expected_offset = (pkt_offset + headroom + XDP_PACKET_HEADROOM) % umem->frame_size; 897 898 if (offset == expected_offset) 899 return true; 900 901 ksft_print_msg("[%s] expected [%u], got [%u]\n", __func__, expected_offset, offset); 902 return false; 903 } 904 905 static bool is_metadata_correct(struct pkt *pkt, void *buffer, u64 addr) 906 { 907 void *data = xsk_umem__get_data(buffer, addr); 908 struct xdp_info *meta = data - sizeof(struct xdp_info); 909 910 if (meta->count != pkt->pkt_nb) { 911 ksft_print_msg("[%s] expected meta_count [%d], got meta_count [%d]\n", 912 __func__, pkt->pkt_nb, meta->count); 913 return false; 914 } 915 916 return true; 917 } 918 919 static bool is_frag_valid(struct xsk_umem_info *umem, u64 addr, u32 len, u32 expected_pkt_nb, 920 u32 bytes_processed) 921 { 922 u32 seqnum, pkt_nb, *pkt_data, words_to_end, expected_seqnum; 923 void *data = xsk_umem__get_data(umem->buffer, addr); 924 925 addr -= umem->base_addr; 926 927 if (addr >= umem->num_frames * umem->frame_size || 928 addr + len > umem->num_frames * umem->frame_size) { 929 ksft_print_msg("Frag invalid addr: %llx len: %u\n", addr, len); 930 return false; 931 } 932 if (!umem->unaligned_mode && addr % umem->frame_size + len > umem->frame_size) { 933 ksft_print_msg("Frag crosses frame boundary addr: %llx len: %u\n", addr, len); 934 return false; 935 } 936 937 pkt_data = data; 938 if (!bytes_processed) { 939 pkt_data += PKT_HDR_SIZE / sizeof(*pkt_data); 940 len -= PKT_HDR_SIZE; 941 } else { 942 bytes_processed -= PKT_HDR_SIZE; 943 } 944 945 expected_seqnum = bytes_processed / sizeof(*pkt_data); 946 seqnum = ntohl(*pkt_data) & 0xffff; 947 pkt_nb = ntohl(*pkt_data) >> 16; 948 949 if (expected_pkt_nb != pkt_nb) { 950 ksft_print_msg("[%s] expected pkt_nb [%u], got pkt_nb [%u]\n", 951 __func__, expected_pkt_nb, pkt_nb); 952 goto error; 953 } 954 if (expected_seqnum != seqnum) { 955 ksft_print_msg("[%s] expected seqnum at start [%u], got seqnum [%u]\n", 956 __func__, expected_seqnum, seqnum); 957 goto error; 958 } 959 960 words_to_end = len / sizeof(*pkt_data) - 1; 961 pkt_data += words_to_end; 962 seqnum = ntohl(*pkt_data) & 0xffff; 963 expected_seqnum += words_to_end; 964 if (expected_seqnum != seqnum) { 965 ksft_print_msg("[%s] expected seqnum at end [%u], got seqnum [%u]\n", 966 __func__, expected_seqnum, seqnum); 967 goto error; 968 } 969 970 return true; 971 972 error: 973 pkt_dump(data, len, !bytes_processed); 974 return false; 975 } 976 977 static bool is_pkt_valid(struct pkt *pkt, void *buffer, u64 addr, u32 len) 978 { 979 if (pkt->len != len) { 980 ksft_print_msg("[%s] expected packet length [%d], got length [%d]\n", 981 __func__, pkt->len, len); 982 pkt_dump(xsk_umem__get_data(buffer, addr), len, true); 983 return false; 984 } 985 986 return true; 987 } 988 989 static int kick_tx(struct xsk_socket_info *xsk) 990 { 991 int ret; 992 993 ret = sendto(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, 0); 994 if (ret >= 0) 995 return TEST_PASS; 996 if (errno == ENOBUFS || errno == EAGAIN || errno == EBUSY || errno == ENETDOWN) { 997 usleep(100); 998 return TEST_PASS; 999 } 1000 return TEST_FAILURE; 1001 } 1002 1003 static int kick_rx(struct xsk_socket_info *xsk) 1004 { 1005 int ret; 1006 1007 ret = recvfrom(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, NULL); 1008 if (ret < 0) 1009 return TEST_FAILURE; 1010 1011 return TEST_PASS; 1012 } 1013 1014 static int complete_pkts(struct xsk_socket_info *xsk, int batch_size) 1015 { 1016 unsigned int rcvd; 1017 u32 idx; 1018 int ret; 1019 1020 if (xsk_ring_prod__needs_wakeup(&xsk->tx)) { 1021 ret = kick_tx(xsk); 1022 if (ret) 1023 return TEST_FAILURE; 1024 } 1025 1026 rcvd = xsk_ring_cons__peek(&xsk->umem->cq, batch_size, &idx); 1027 if (rcvd) { 1028 if (rcvd > xsk->outstanding_tx) { 1029 u64 addr = *xsk_ring_cons__comp_addr(&xsk->umem->cq, idx + rcvd - 1); 1030 1031 ksft_print_msg("[%s] Too many packets completed\n", __func__); 1032 ksft_print_msg("Last completion address: %llx\n", addr); 1033 return TEST_FAILURE; 1034 } 1035 1036 xsk_ring_cons__release(&xsk->umem->cq, rcvd); 1037 xsk->outstanding_tx -= rcvd; 1038 } 1039 1040 return TEST_PASS; 1041 } 1042 1043 static int __receive_pkts(struct test_spec *test, struct xsk_socket_info *xsk) 1044 { 1045 u32 frags_processed = 0, nb_frags = 0, pkt_len = 0; 1046 u32 idx_rx = 0, idx_fq = 0, rcvd, pkts_sent = 0; 1047 struct pkt_stream *pkt_stream = xsk->pkt_stream; 1048 struct ifobject *ifobj = test->ifobj_rx; 1049 struct xsk_umem_info *umem = xsk->umem; 1050 struct pollfd fds = { }; 1051 struct pkt *pkt; 1052 u64 first_addr = 0; 1053 int ret; 1054 1055 fds.fd = xsk_socket__fd(xsk->xsk); 1056 fds.events = POLLIN; 1057 1058 ret = kick_rx(xsk); 1059 if (ret) 1060 return TEST_FAILURE; 1061 1062 if (ifobj->use_poll) { 1063 ret = poll(&fds, 1, POLL_TMOUT); 1064 if (ret < 0) 1065 return TEST_FAILURE; 1066 1067 if (!ret) { 1068 if (!is_umem_valid(test->ifobj_tx)) 1069 return TEST_PASS; 1070 1071 ksft_print_msg("ERROR: [%s] Poll timed out\n", __func__); 1072 return TEST_CONTINUE; 1073 } 1074 1075 if (!(fds.revents & POLLIN)) 1076 return TEST_CONTINUE; 1077 } 1078 1079 rcvd = xsk_ring_cons__peek(&xsk->rx, BATCH_SIZE, &idx_rx); 1080 if (!rcvd) 1081 return TEST_CONTINUE; 1082 1083 if (ifobj->use_fill_ring) { 1084 ret = xsk_ring_prod__reserve(&umem->fq, rcvd, &idx_fq); 1085 while (ret != rcvd) { 1086 if (xsk_ring_prod__needs_wakeup(&umem->fq)) { 1087 ret = poll(&fds, 1, POLL_TMOUT); 1088 if (ret < 0) 1089 return TEST_FAILURE; 1090 } 1091 ret = xsk_ring_prod__reserve(&umem->fq, rcvd, &idx_fq); 1092 } 1093 } 1094 1095 while (frags_processed < rcvd) { 1096 const struct xdp_desc *desc = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx++); 1097 u64 addr = desc->addr, orig; 1098 1099 orig = xsk_umem__extract_addr(addr); 1100 addr = xsk_umem__add_offset_to_addr(addr); 1101 1102 if (!nb_frags) { 1103 pkt = pkt_stream_get_next_rx_pkt(pkt_stream, &pkts_sent); 1104 if (!pkt) { 1105 ksft_print_msg("[%s] received too many packets addr: %lx len %u\n", 1106 __func__, addr, desc->len); 1107 return TEST_FAILURE; 1108 } 1109 } 1110 1111 print_verbose("Rx: addr: %lx len: %u options: %u pkt_nb: %u valid: %u\n", 1112 addr, desc->len, desc->options, pkt->pkt_nb, pkt->valid); 1113 1114 if (!is_frag_valid(umem, addr, desc->len, pkt->pkt_nb, pkt_len) || 1115 !is_offset_correct(umem, pkt, addr) || (ifobj->use_metadata && 1116 !is_metadata_correct(pkt, umem->buffer, addr))) 1117 return TEST_FAILURE; 1118 1119 if (!nb_frags++) 1120 first_addr = addr; 1121 frags_processed++; 1122 pkt_len += desc->len; 1123 if (ifobj->use_fill_ring) 1124 *xsk_ring_prod__fill_addr(&umem->fq, idx_fq++) = orig; 1125 1126 if (pkt_continues(desc->options)) 1127 continue; 1128 1129 /* The complete packet has been received */ 1130 if (!is_pkt_valid(pkt, umem->buffer, first_addr, pkt_len) || 1131 !is_offset_correct(umem, pkt, addr)) 1132 return TEST_FAILURE; 1133 1134 pkt_stream->nb_rx_pkts++; 1135 nb_frags = 0; 1136 pkt_len = 0; 1137 } 1138 1139 if (nb_frags) { 1140 /* In the middle of a packet. Start over from beginning of packet. */ 1141 idx_rx -= nb_frags; 1142 xsk_ring_cons__cancel(&xsk->rx, nb_frags); 1143 if (ifobj->use_fill_ring) { 1144 idx_fq -= nb_frags; 1145 xsk_ring_prod__cancel(&umem->fq, nb_frags); 1146 } 1147 frags_processed -= nb_frags; 1148 } 1149 1150 if (ifobj->use_fill_ring) 1151 xsk_ring_prod__submit(&umem->fq, frags_processed); 1152 if (ifobj->release_rx) 1153 xsk_ring_cons__release(&xsk->rx, frags_processed); 1154 1155 pthread_mutex_lock(&pacing_mutex); 1156 pkts_in_flight -= pkts_sent; 1157 pthread_mutex_unlock(&pacing_mutex); 1158 pkts_sent = 0; 1159 1160 return TEST_CONTINUE; 1161 } 1162 1163 bool all_packets_received(struct test_spec *test, struct xsk_socket_info *xsk, u32 sock_num, 1164 unsigned long *bitmap) 1165 { 1166 struct pkt_stream *pkt_stream = xsk->pkt_stream; 1167 1168 if (!pkt_stream) { 1169 __set_bit(sock_num, bitmap); 1170 return false; 1171 } 1172 1173 if (pkt_stream->nb_rx_pkts == pkt_stream->nb_valid_entries) { 1174 __set_bit(sock_num, bitmap); 1175 if (bitmap_full(bitmap, test->nb_sockets)) 1176 return true; 1177 } 1178 1179 return false; 1180 } 1181 1182 static int receive_pkts(struct test_spec *test) 1183 { 1184 struct timeval tv_end, tv_now, tv_timeout = {THREAD_TMOUT, 0}; 1185 DECLARE_BITMAP(bitmap, test->nb_sockets); 1186 struct xsk_socket_info *xsk; 1187 u32 sock_num = 0; 1188 int res, ret; 1189 1190 ret = gettimeofday(&tv_now, NULL); 1191 if (ret) 1192 exit_with_error(errno); 1193 1194 timeradd(&tv_now, &tv_timeout, &tv_end); 1195 1196 while (1) { 1197 xsk = &test->ifobj_rx->xsk_arr[sock_num]; 1198 1199 if ((all_packets_received(test, xsk, sock_num, bitmap))) 1200 break; 1201 1202 res = __receive_pkts(test, xsk); 1203 if (!(res == TEST_PASS || res == TEST_CONTINUE)) 1204 return res; 1205 1206 ret = gettimeofday(&tv_now, NULL); 1207 if (ret) 1208 exit_with_error(errno); 1209 1210 if (timercmp(&tv_now, &tv_end, >)) { 1211 ksft_print_msg("ERROR: [%s] Receive loop timed out\n", __func__); 1212 return TEST_FAILURE; 1213 } 1214 sock_num = (sock_num + 1) % test->nb_sockets; 1215 } 1216 1217 return TEST_PASS; 1218 } 1219 1220 static int __send_pkts(struct ifobject *ifobject, struct xsk_socket_info *xsk, bool timeout) 1221 { 1222 u32 i, idx = 0, valid_pkts = 0, valid_frags = 0, buffer_len; 1223 struct pkt_stream *pkt_stream = xsk->pkt_stream; 1224 struct xsk_umem_info *umem = ifobject->umem; 1225 bool use_poll = ifobject->use_poll; 1226 struct pollfd fds = { }; 1227 int ret; 1228 1229 buffer_len = pkt_get_buffer_len(umem, pkt_stream->max_pkt_len); 1230 /* pkts_in_flight might be negative if many invalid packets are sent */ 1231 if (pkts_in_flight >= (int)((umem_size(umem) - BATCH_SIZE * buffer_len) / buffer_len)) { 1232 ret = kick_tx(xsk); 1233 if (ret) 1234 return TEST_FAILURE; 1235 return TEST_CONTINUE; 1236 } 1237 1238 fds.fd = xsk_socket__fd(xsk->xsk); 1239 fds.events = POLLOUT; 1240 1241 while (xsk_ring_prod__reserve(&xsk->tx, BATCH_SIZE, &idx) < BATCH_SIZE) { 1242 if (use_poll) { 1243 ret = poll(&fds, 1, POLL_TMOUT); 1244 if (timeout) { 1245 if (ret < 0) { 1246 ksft_print_msg("ERROR: [%s] Poll error %d\n", 1247 __func__, errno); 1248 return TEST_FAILURE; 1249 } 1250 if (ret == 0) 1251 return TEST_PASS; 1252 break; 1253 } 1254 if (ret <= 0) { 1255 ksft_print_msg("ERROR: [%s] Poll error %d\n", 1256 __func__, errno); 1257 return TEST_FAILURE; 1258 } 1259 } 1260 1261 complete_pkts(xsk, BATCH_SIZE); 1262 } 1263 1264 for (i = 0; i < BATCH_SIZE; i++) { 1265 struct pkt *pkt = pkt_stream_get_next_tx_pkt(pkt_stream); 1266 u32 nb_frags_left, nb_frags, bytes_written = 0; 1267 1268 if (!pkt) 1269 break; 1270 1271 nb_frags = pkt_nb_frags(umem->frame_size, pkt_stream, pkt); 1272 if (nb_frags > BATCH_SIZE - i) { 1273 pkt_stream_cancel(pkt_stream); 1274 xsk_ring_prod__cancel(&xsk->tx, BATCH_SIZE - i); 1275 break; 1276 } 1277 nb_frags_left = nb_frags; 1278 1279 while (nb_frags_left--) { 1280 struct xdp_desc *tx_desc = xsk_ring_prod__tx_desc(&xsk->tx, idx + i); 1281 1282 tx_desc->addr = pkt_get_addr(pkt, ifobject->umem); 1283 if (pkt_stream->verbatim) { 1284 tx_desc->len = pkt->len; 1285 tx_desc->options = pkt->options; 1286 } else if (nb_frags_left) { 1287 tx_desc->len = umem->frame_size; 1288 tx_desc->options = XDP_PKT_CONTD; 1289 } else { 1290 tx_desc->len = pkt->len - bytes_written; 1291 tx_desc->options = 0; 1292 } 1293 if (pkt->valid) 1294 pkt_generate(xsk, umem, tx_desc->addr, tx_desc->len, pkt->pkt_nb, 1295 bytes_written); 1296 bytes_written += tx_desc->len; 1297 1298 print_verbose("Tx addr: %llx len: %u options: %u pkt_nb: %u\n", 1299 tx_desc->addr, tx_desc->len, tx_desc->options, pkt->pkt_nb); 1300 1301 if (nb_frags_left) { 1302 i++; 1303 if (pkt_stream->verbatim) 1304 pkt = pkt_stream_get_next_tx_pkt(pkt_stream); 1305 } 1306 } 1307 1308 if (pkt && pkt->valid) { 1309 valid_pkts++; 1310 valid_frags += nb_frags; 1311 } 1312 } 1313 1314 pthread_mutex_lock(&pacing_mutex); 1315 pkts_in_flight += valid_pkts; 1316 pthread_mutex_unlock(&pacing_mutex); 1317 1318 xsk_ring_prod__submit(&xsk->tx, i); 1319 xsk->outstanding_tx += valid_frags; 1320 1321 if (use_poll) { 1322 ret = poll(&fds, 1, POLL_TMOUT); 1323 if (ret <= 0) { 1324 if (ret == 0 && timeout) 1325 return TEST_PASS; 1326 1327 ksft_print_msg("ERROR: [%s] Poll error %d\n", __func__, ret); 1328 return TEST_FAILURE; 1329 } 1330 } 1331 1332 if (!timeout) { 1333 if (complete_pkts(xsk, i)) 1334 return TEST_FAILURE; 1335 1336 usleep(10); 1337 return TEST_PASS; 1338 } 1339 1340 return TEST_CONTINUE; 1341 } 1342 1343 static int wait_for_tx_completion(struct xsk_socket_info *xsk) 1344 { 1345 struct timeval tv_end, tv_now, tv_timeout = {THREAD_TMOUT, 0}; 1346 int ret; 1347 1348 ret = gettimeofday(&tv_now, NULL); 1349 if (ret) 1350 exit_with_error(errno); 1351 timeradd(&tv_now, &tv_timeout, &tv_end); 1352 1353 while (xsk->outstanding_tx) { 1354 ret = gettimeofday(&tv_now, NULL); 1355 if (ret) 1356 exit_with_error(errno); 1357 if (timercmp(&tv_now, &tv_end, >)) { 1358 ksft_print_msg("ERROR: [%s] Transmission loop timed out\n", __func__); 1359 return TEST_FAILURE; 1360 } 1361 1362 complete_pkts(xsk, BATCH_SIZE); 1363 } 1364 1365 return TEST_PASS; 1366 } 1367 1368 bool all_packets_sent(struct test_spec *test, unsigned long *bitmap) 1369 { 1370 return bitmap_full(bitmap, test->nb_sockets); 1371 } 1372 1373 static int send_pkts(struct test_spec *test, struct ifobject *ifobject) 1374 { 1375 bool timeout = !is_umem_valid(test->ifobj_rx); 1376 DECLARE_BITMAP(bitmap, test->nb_sockets); 1377 u32 i, ret; 1378 1379 while (!(all_packets_sent(test, bitmap))) { 1380 for (i = 0; i < test->nb_sockets; i++) { 1381 struct pkt_stream *pkt_stream; 1382 1383 pkt_stream = ifobject->xsk_arr[i].pkt_stream; 1384 if (!pkt_stream || pkt_stream->current_pkt_nb >= pkt_stream->nb_pkts) { 1385 __set_bit(i, bitmap); 1386 continue; 1387 } 1388 ret = __send_pkts(ifobject, &ifobject->xsk_arr[i], timeout); 1389 if (ret == TEST_CONTINUE && !test->fail) 1390 continue; 1391 1392 if ((ret || test->fail) && !timeout) 1393 return TEST_FAILURE; 1394 1395 if (ret == TEST_PASS && timeout) 1396 return ret; 1397 1398 ret = wait_for_tx_completion(&ifobject->xsk_arr[i]); 1399 if (ret) 1400 return TEST_FAILURE; 1401 } 1402 } 1403 1404 return TEST_PASS; 1405 } 1406 1407 static int get_xsk_stats(struct xsk_socket *xsk, struct xdp_statistics *stats) 1408 { 1409 int fd = xsk_socket__fd(xsk), err; 1410 socklen_t optlen, expected_len; 1411 1412 optlen = sizeof(*stats); 1413 err = getsockopt(fd, SOL_XDP, XDP_STATISTICS, stats, &optlen); 1414 if (err) { 1415 ksft_print_msg("[%s] getsockopt(XDP_STATISTICS) error %u %s\n", 1416 __func__, -err, strerror(-err)); 1417 return TEST_FAILURE; 1418 } 1419 1420 expected_len = sizeof(struct xdp_statistics); 1421 if (optlen != expected_len) { 1422 ksft_print_msg("[%s] getsockopt optlen error. Expected: %u got: %u\n", 1423 __func__, expected_len, optlen); 1424 return TEST_FAILURE; 1425 } 1426 1427 return TEST_PASS; 1428 } 1429 1430 static int validate_rx_dropped(struct ifobject *ifobject) 1431 { 1432 struct xsk_socket *xsk = ifobject->xsk->xsk; 1433 struct xdp_statistics stats; 1434 int err; 1435 1436 err = kick_rx(ifobject->xsk); 1437 if (err) 1438 return TEST_FAILURE; 1439 1440 err = get_xsk_stats(xsk, &stats); 1441 if (err) 1442 return TEST_FAILURE; 1443 1444 /* The receiver calls getsockopt after receiving the last (valid) 1445 * packet which is not the final packet sent in this test (valid and 1446 * invalid packets are sent in alternating fashion with the final 1447 * packet being invalid). Since the last packet may or may not have 1448 * been dropped already, both outcomes must be allowed. 1449 */ 1450 if (stats.rx_dropped == ifobject->xsk->pkt_stream->nb_pkts / 2 || 1451 stats.rx_dropped == ifobject->xsk->pkt_stream->nb_pkts / 2 - 1) 1452 return TEST_PASS; 1453 1454 return TEST_FAILURE; 1455 } 1456 1457 static int validate_rx_full(struct ifobject *ifobject) 1458 { 1459 struct xsk_socket *xsk = ifobject->xsk->xsk; 1460 struct xdp_statistics stats; 1461 int err; 1462 1463 usleep(1000); 1464 err = kick_rx(ifobject->xsk); 1465 if (err) 1466 return TEST_FAILURE; 1467 1468 err = get_xsk_stats(xsk, &stats); 1469 if (err) 1470 return TEST_FAILURE; 1471 1472 if (stats.rx_ring_full) 1473 return TEST_PASS; 1474 1475 return TEST_FAILURE; 1476 } 1477 1478 static int validate_fill_empty(struct ifobject *ifobject) 1479 { 1480 struct xsk_socket *xsk = ifobject->xsk->xsk; 1481 struct xdp_statistics stats; 1482 int err; 1483 1484 usleep(1000); 1485 err = kick_rx(ifobject->xsk); 1486 if (err) 1487 return TEST_FAILURE; 1488 1489 err = get_xsk_stats(xsk, &stats); 1490 if (err) 1491 return TEST_FAILURE; 1492 1493 if (stats.rx_fill_ring_empty_descs) 1494 return TEST_PASS; 1495 1496 return TEST_FAILURE; 1497 } 1498 1499 static int validate_tx_invalid_descs(struct ifobject *ifobject) 1500 { 1501 struct xsk_socket *xsk = ifobject->xsk->xsk; 1502 int fd = xsk_socket__fd(xsk); 1503 struct xdp_statistics stats; 1504 socklen_t optlen; 1505 int err; 1506 1507 optlen = sizeof(stats); 1508 err = getsockopt(fd, SOL_XDP, XDP_STATISTICS, &stats, &optlen); 1509 if (err) { 1510 ksft_print_msg("[%s] getsockopt(XDP_STATISTICS) error %u %s\n", 1511 __func__, -err, strerror(-err)); 1512 return TEST_FAILURE; 1513 } 1514 1515 if (stats.tx_invalid_descs != ifobject->xsk->pkt_stream->nb_pkts / 2) { 1516 ksft_print_msg("[%s] tx_invalid_descs incorrect. Got [%u] expected [%u]\n", 1517 __func__, stats.tx_invalid_descs, 1518 ifobject->xsk->pkt_stream->nb_pkts); 1519 return TEST_FAILURE; 1520 } 1521 1522 return TEST_PASS; 1523 } 1524 1525 static void xsk_configure_socket(struct test_spec *test, struct ifobject *ifobject, 1526 struct xsk_umem_info *umem, bool tx) 1527 { 1528 int i, ret; 1529 1530 for (i = 0; i < test->nb_sockets; i++) { 1531 bool shared = (ifobject->shared_umem && tx) ? true : !!i; 1532 u32 ctr = 0; 1533 1534 while (ctr++ < SOCK_RECONF_CTR) { 1535 ret = __xsk_configure_socket(&ifobject->xsk_arr[i], umem, 1536 ifobject, shared); 1537 if (!ret) 1538 break; 1539 1540 /* Retry if it fails as xsk_socket__create() is asynchronous */ 1541 if (ctr >= SOCK_RECONF_CTR) 1542 exit_with_error(-ret); 1543 usleep(USLEEP_MAX); 1544 } 1545 if (ifobject->busy_poll) 1546 enable_busy_poll(&ifobject->xsk_arr[i]); 1547 } 1548 } 1549 1550 static void thread_common_ops_tx(struct test_spec *test, struct ifobject *ifobject) 1551 { 1552 xsk_configure_socket(test, ifobject, test->ifobj_rx->umem, true); 1553 ifobject->xsk = &ifobject->xsk_arr[0]; 1554 ifobject->xskmap = test->ifobj_rx->xskmap; 1555 memcpy(ifobject->umem, test->ifobj_rx->umem, sizeof(struct xsk_umem_info)); 1556 ifobject->umem->base_addr = 0; 1557 } 1558 1559 static void xsk_populate_fill_ring(struct xsk_umem_info *umem, struct pkt_stream *pkt_stream, 1560 bool fill_up) 1561 { 1562 u32 rx_frame_size = umem->frame_size - XDP_PACKET_HEADROOM; 1563 u32 idx = 0, filled = 0, buffers_to_fill, nb_pkts; 1564 int ret; 1565 1566 if (umem->num_frames < XSK_RING_PROD__DEFAULT_NUM_DESCS) 1567 buffers_to_fill = umem->num_frames; 1568 else 1569 buffers_to_fill = XSK_RING_PROD__DEFAULT_NUM_DESCS; 1570 1571 ret = xsk_ring_prod__reserve(&umem->fq, buffers_to_fill, &idx); 1572 if (ret != buffers_to_fill) 1573 exit_with_error(ENOSPC); 1574 1575 while (filled < buffers_to_fill) { 1576 struct pkt *pkt = pkt_stream_get_next_rx_pkt(pkt_stream, &nb_pkts); 1577 u64 addr; 1578 u32 i; 1579 1580 for (i = 0; i < pkt_nb_frags(rx_frame_size, pkt_stream, pkt); i++) { 1581 if (!pkt) { 1582 if (!fill_up) 1583 break; 1584 addr = filled * umem->frame_size + umem->base_addr; 1585 } else if (pkt->offset >= 0) { 1586 addr = pkt->offset % umem->frame_size + umem_alloc_buffer(umem); 1587 } else { 1588 addr = pkt->offset + umem_alloc_buffer(umem); 1589 } 1590 1591 *xsk_ring_prod__fill_addr(&umem->fq, idx++) = addr; 1592 if (++filled >= buffers_to_fill) 1593 break; 1594 } 1595 } 1596 xsk_ring_prod__submit(&umem->fq, filled); 1597 xsk_ring_prod__cancel(&umem->fq, buffers_to_fill - filled); 1598 1599 pkt_stream_reset(pkt_stream); 1600 umem_reset_alloc(umem); 1601 } 1602 1603 static void thread_common_ops(struct test_spec *test, struct ifobject *ifobject) 1604 { 1605 u64 umem_sz = ifobject->umem->num_frames * ifobject->umem->frame_size; 1606 int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE; 1607 LIBBPF_OPTS(bpf_xdp_query_opts, opts); 1608 void *bufs; 1609 int ret; 1610 u32 i; 1611 1612 if (ifobject->umem->unaligned_mode) 1613 mmap_flags |= MAP_HUGETLB | MAP_HUGE_2MB; 1614 1615 if (ifobject->shared_umem) 1616 umem_sz *= 2; 1617 1618 bufs = mmap(NULL, umem_sz, PROT_READ | PROT_WRITE, mmap_flags, -1, 0); 1619 if (bufs == MAP_FAILED) 1620 exit_with_error(errno); 1621 1622 ret = xsk_configure_umem(ifobject, ifobject->umem, bufs, umem_sz); 1623 if (ret) 1624 exit_with_error(-ret); 1625 1626 xsk_configure_socket(test, ifobject, ifobject->umem, false); 1627 1628 ifobject->xsk = &ifobject->xsk_arr[0]; 1629 1630 if (!ifobject->rx_on) 1631 return; 1632 1633 xsk_populate_fill_ring(ifobject->umem, ifobject->xsk->pkt_stream, ifobject->use_fill_ring); 1634 1635 for (i = 0; i < test->nb_sockets; i++) { 1636 ifobject->xsk = &ifobject->xsk_arr[i]; 1637 ret = xsk_update_xskmap(ifobject->xskmap, ifobject->xsk->xsk, i); 1638 if (ret) 1639 exit_with_error(errno); 1640 } 1641 } 1642 1643 static void *worker_testapp_validate_tx(void *arg) 1644 { 1645 struct test_spec *test = (struct test_spec *)arg; 1646 struct ifobject *ifobject = test->ifobj_tx; 1647 int err; 1648 1649 if (test->current_step == 1) { 1650 if (!ifobject->shared_umem) 1651 thread_common_ops(test, ifobject); 1652 else 1653 thread_common_ops_tx(test, ifobject); 1654 } 1655 1656 err = send_pkts(test, ifobject); 1657 1658 if (!err && ifobject->validation_func) 1659 err = ifobject->validation_func(ifobject); 1660 if (err) 1661 report_failure(test); 1662 1663 pthread_exit(NULL); 1664 } 1665 1666 static void *worker_testapp_validate_rx(void *arg) 1667 { 1668 struct test_spec *test = (struct test_spec *)arg; 1669 struct ifobject *ifobject = test->ifobj_rx; 1670 int err; 1671 1672 if (test->current_step == 1) { 1673 thread_common_ops(test, ifobject); 1674 } else { 1675 xsk_clear_xskmap(ifobject->xskmap); 1676 err = xsk_update_xskmap(ifobject->xskmap, ifobject->xsk->xsk, 0); 1677 if (err) { 1678 ksft_print_msg("Error: Failed to update xskmap, error %s\n", 1679 strerror(-err)); 1680 exit_with_error(-err); 1681 } 1682 } 1683 1684 pthread_barrier_wait(&barr); 1685 1686 err = receive_pkts(test); 1687 1688 if (!err && ifobject->validation_func) 1689 err = ifobject->validation_func(ifobject); 1690 if (err) 1691 report_failure(test); 1692 1693 pthread_exit(NULL); 1694 } 1695 1696 static u64 ceil_u64(u64 a, u64 b) 1697 { 1698 return (a + b - 1) / b; 1699 } 1700 1701 static void testapp_clean_xsk_umem(struct ifobject *ifobj) 1702 { 1703 u64 umem_sz = ifobj->umem->num_frames * ifobj->umem->frame_size; 1704 1705 if (ifobj->shared_umem) 1706 umem_sz *= 2; 1707 1708 umem_sz = ceil_u64(umem_sz, HUGEPAGE_SIZE) * HUGEPAGE_SIZE; 1709 xsk_umem__delete(ifobj->umem->umem); 1710 munmap(ifobj->umem->buffer, umem_sz); 1711 } 1712 1713 static void handler(int signum) 1714 { 1715 pthread_exit(NULL); 1716 } 1717 1718 static bool xdp_prog_changed_rx(struct test_spec *test) 1719 { 1720 struct ifobject *ifobj = test->ifobj_rx; 1721 1722 return ifobj->xdp_prog != test->xdp_prog_rx || ifobj->mode != test->mode; 1723 } 1724 1725 static bool xdp_prog_changed_tx(struct test_spec *test) 1726 { 1727 struct ifobject *ifobj = test->ifobj_tx; 1728 1729 return ifobj->xdp_prog != test->xdp_prog_tx || ifobj->mode != test->mode; 1730 } 1731 1732 static void xsk_reattach_xdp(struct ifobject *ifobj, struct bpf_program *xdp_prog, 1733 struct bpf_map *xskmap, enum test_mode mode) 1734 { 1735 int err; 1736 1737 xsk_detach_xdp_program(ifobj->ifindex, mode_to_xdp_flags(ifobj->mode)); 1738 err = xsk_attach_xdp_program(xdp_prog, ifobj->ifindex, mode_to_xdp_flags(mode)); 1739 if (err) { 1740 ksft_print_msg("Error attaching XDP program\n"); 1741 exit_with_error(-err); 1742 } 1743 1744 if (ifobj->mode != mode && (mode == TEST_MODE_DRV || mode == TEST_MODE_ZC)) 1745 if (!xsk_is_in_mode(ifobj->ifindex, XDP_FLAGS_DRV_MODE)) { 1746 ksft_print_msg("ERROR: XDP prog not in DRV mode\n"); 1747 exit_with_error(EINVAL); 1748 } 1749 1750 ifobj->xdp_prog = xdp_prog; 1751 ifobj->xskmap = xskmap; 1752 ifobj->mode = mode; 1753 } 1754 1755 static void xsk_attach_xdp_progs(struct test_spec *test, struct ifobject *ifobj_rx, 1756 struct ifobject *ifobj_tx) 1757 { 1758 if (xdp_prog_changed_rx(test)) 1759 xsk_reattach_xdp(ifobj_rx, test->xdp_prog_rx, test->xskmap_rx, test->mode); 1760 1761 if (!ifobj_tx || ifobj_tx->shared_umem) 1762 return; 1763 1764 if (xdp_prog_changed_tx(test)) 1765 xsk_reattach_xdp(ifobj_tx, test->xdp_prog_tx, test->xskmap_tx, test->mode); 1766 } 1767 1768 static int __testapp_validate_traffic(struct test_spec *test, struct ifobject *ifobj1, 1769 struct ifobject *ifobj2) 1770 { 1771 pthread_t t0, t1; 1772 int err; 1773 1774 if (test->mtu > MAX_ETH_PKT_SIZE) { 1775 if (test->mode == TEST_MODE_ZC && (!ifobj1->multi_buff_zc_supp || 1776 (ifobj2 && !ifobj2->multi_buff_zc_supp))) { 1777 ksft_test_result_skip("Multi buffer for zero-copy not supported.\n"); 1778 return TEST_SKIP; 1779 } 1780 if (test->mode != TEST_MODE_ZC && (!ifobj1->multi_buff_supp || 1781 (ifobj2 && !ifobj2->multi_buff_supp))) { 1782 ksft_test_result_skip("Multi buffer not supported.\n"); 1783 return TEST_SKIP; 1784 } 1785 } 1786 err = test_spec_set_mtu(test, test->mtu); 1787 if (err) { 1788 ksft_print_msg("Error, could not set mtu.\n"); 1789 exit_with_error(err); 1790 } 1791 1792 if (ifobj2) { 1793 if (pthread_barrier_init(&barr, NULL, 2)) 1794 exit_with_error(errno); 1795 pkt_stream_reset(ifobj2->xsk->pkt_stream); 1796 } 1797 1798 test->current_step++; 1799 pkt_stream_reset(ifobj1->xsk->pkt_stream); 1800 pkts_in_flight = 0; 1801 1802 signal(SIGUSR1, handler); 1803 /*Spawn RX thread */ 1804 pthread_create(&t0, NULL, ifobj1->func_ptr, test); 1805 1806 if (ifobj2) { 1807 pthread_barrier_wait(&barr); 1808 if (pthread_barrier_destroy(&barr)) 1809 exit_with_error(errno); 1810 1811 /*Spawn TX thread */ 1812 pthread_create(&t1, NULL, ifobj2->func_ptr, test); 1813 1814 pthread_join(t1, NULL); 1815 } 1816 1817 if (!ifobj2) 1818 pthread_kill(t0, SIGUSR1); 1819 else 1820 pthread_join(t0, NULL); 1821 1822 if (test->total_steps == test->current_step || test->fail) { 1823 u32 i; 1824 1825 if (ifobj2) 1826 for (i = 0; i < test->nb_sockets; i++) 1827 xsk_socket__delete(ifobj2->xsk_arr[i].xsk); 1828 1829 for (i = 0; i < test->nb_sockets; i++) 1830 xsk_socket__delete(ifobj1->xsk_arr[i].xsk); 1831 1832 testapp_clean_xsk_umem(ifobj1); 1833 if (ifobj2 && !ifobj2->shared_umem) 1834 testapp_clean_xsk_umem(ifobj2); 1835 } 1836 1837 return !!test->fail; 1838 } 1839 1840 static int testapp_validate_traffic(struct test_spec *test) 1841 { 1842 struct ifobject *ifobj_rx = test->ifobj_rx; 1843 struct ifobject *ifobj_tx = test->ifobj_tx; 1844 1845 if ((ifobj_rx->umem->unaligned_mode && !ifobj_rx->unaligned_supp) || 1846 (ifobj_tx->umem->unaligned_mode && !ifobj_tx->unaligned_supp)) { 1847 ksft_test_result_skip("No huge pages present.\n"); 1848 return TEST_SKIP; 1849 } 1850 1851 xsk_attach_xdp_progs(test, ifobj_rx, ifobj_tx); 1852 return __testapp_validate_traffic(test, ifobj_rx, ifobj_tx); 1853 } 1854 1855 static int testapp_validate_traffic_single_thread(struct test_spec *test, struct ifobject *ifobj) 1856 { 1857 return __testapp_validate_traffic(test, ifobj, NULL); 1858 } 1859 1860 static int testapp_teardown(struct test_spec *test) 1861 { 1862 int i; 1863 1864 for (i = 0; i < MAX_TEARDOWN_ITER; i++) { 1865 if (testapp_validate_traffic(test)) 1866 return TEST_FAILURE; 1867 test_spec_reset(test); 1868 } 1869 1870 return TEST_PASS; 1871 } 1872 1873 static void swap_directions(struct ifobject **ifobj1, struct ifobject **ifobj2) 1874 { 1875 thread_func_t tmp_func_ptr = (*ifobj1)->func_ptr; 1876 struct ifobject *tmp_ifobj = (*ifobj1); 1877 1878 (*ifobj1)->func_ptr = (*ifobj2)->func_ptr; 1879 (*ifobj2)->func_ptr = tmp_func_ptr; 1880 1881 *ifobj1 = *ifobj2; 1882 *ifobj2 = tmp_ifobj; 1883 } 1884 1885 static int testapp_bidirectional(struct test_spec *test) 1886 { 1887 int res; 1888 1889 test->ifobj_tx->rx_on = true; 1890 test->ifobj_rx->tx_on = true; 1891 test->total_steps = 2; 1892 if (testapp_validate_traffic(test)) 1893 return TEST_FAILURE; 1894 1895 print_verbose("Switching Tx/Rx direction\n"); 1896 swap_directions(&test->ifobj_rx, &test->ifobj_tx); 1897 res = __testapp_validate_traffic(test, test->ifobj_rx, test->ifobj_tx); 1898 1899 swap_directions(&test->ifobj_rx, &test->ifobj_tx); 1900 return res; 1901 } 1902 1903 static int swap_xsk_resources(struct test_spec *test) 1904 { 1905 int ret; 1906 1907 test->ifobj_tx->xsk_arr[0].pkt_stream = NULL; 1908 test->ifobj_rx->xsk_arr[0].pkt_stream = NULL; 1909 test->ifobj_tx->xsk_arr[1].pkt_stream = test->tx_pkt_stream_default; 1910 test->ifobj_rx->xsk_arr[1].pkt_stream = test->rx_pkt_stream_default; 1911 test->ifobj_tx->xsk = &test->ifobj_tx->xsk_arr[1]; 1912 test->ifobj_rx->xsk = &test->ifobj_rx->xsk_arr[1]; 1913 1914 ret = xsk_update_xskmap(test->ifobj_rx->xskmap, test->ifobj_rx->xsk->xsk, 0); 1915 if (ret) 1916 return TEST_FAILURE; 1917 1918 return TEST_PASS; 1919 } 1920 1921 static int testapp_xdp_prog_cleanup(struct test_spec *test) 1922 { 1923 test->total_steps = 2; 1924 test->nb_sockets = 2; 1925 if (testapp_validate_traffic(test)) 1926 return TEST_FAILURE; 1927 1928 if (swap_xsk_resources(test)) 1929 return TEST_FAILURE; 1930 return testapp_validate_traffic(test); 1931 } 1932 1933 static int testapp_headroom(struct test_spec *test) 1934 { 1935 test->ifobj_rx->umem->frame_headroom = UMEM_HEADROOM_TEST_SIZE; 1936 return testapp_validate_traffic(test); 1937 } 1938 1939 static int testapp_stats_rx_dropped(struct test_spec *test) 1940 { 1941 if (test->mode == TEST_MODE_ZC) { 1942 ksft_test_result_skip("Can not run RX_DROPPED test for ZC mode\n"); 1943 return TEST_SKIP; 1944 } 1945 1946 pkt_stream_replace_half(test, MIN_PKT_SIZE * 4, 0); 1947 test->ifobj_rx->umem->frame_headroom = test->ifobj_rx->umem->frame_size - 1948 XDP_PACKET_HEADROOM - MIN_PKT_SIZE * 3; 1949 pkt_stream_receive_half(test); 1950 test->ifobj_rx->validation_func = validate_rx_dropped; 1951 return testapp_validate_traffic(test); 1952 } 1953 1954 static int testapp_stats_tx_invalid_descs(struct test_spec *test) 1955 { 1956 pkt_stream_replace_half(test, XSK_UMEM__INVALID_FRAME_SIZE, 0); 1957 test->ifobj_tx->validation_func = validate_tx_invalid_descs; 1958 return testapp_validate_traffic(test); 1959 } 1960 1961 static int testapp_stats_rx_full(struct test_spec *test) 1962 { 1963 pkt_stream_replace(test, DEFAULT_UMEM_BUFFERS + DEFAULT_UMEM_BUFFERS / 2, MIN_PKT_SIZE); 1964 test->ifobj_rx->xsk->pkt_stream = pkt_stream_generate(DEFAULT_UMEM_BUFFERS, MIN_PKT_SIZE); 1965 1966 test->ifobj_rx->xsk->rxqsize = DEFAULT_UMEM_BUFFERS; 1967 test->ifobj_rx->release_rx = false; 1968 test->ifobj_rx->validation_func = validate_rx_full; 1969 return testapp_validate_traffic(test); 1970 } 1971 1972 static int testapp_stats_fill_empty(struct test_spec *test) 1973 { 1974 pkt_stream_replace(test, DEFAULT_UMEM_BUFFERS + DEFAULT_UMEM_BUFFERS / 2, MIN_PKT_SIZE); 1975 test->ifobj_rx->xsk->pkt_stream = pkt_stream_generate(DEFAULT_UMEM_BUFFERS, MIN_PKT_SIZE); 1976 1977 test->ifobj_rx->use_fill_ring = false; 1978 test->ifobj_rx->validation_func = validate_fill_empty; 1979 return testapp_validate_traffic(test); 1980 } 1981 1982 static int testapp_send_receive_unaligned(struct test_spec *test) 1983 { 1984 test->ifobj_tx->umem->unaligned_mode = true; 1985 test->ifobj_rx->umem->unaligned_mode = true; 1986 /* Let half of the packets straddle a 4K buffer boundary */ 1987 pkt_stream_replace_half(test, MIN_PKT_SIZE, -MIN_PKT_SIZE / 2); 1988 1989 return testapp_validate_traffic(test); 1990 } 1991 1992 static int testapp_send_receive_unaligned_mb(struct test_spec *test) 1993 { 1994 test->mtu = MAX_ETH_JUMBO_SIZE; 1995 test->ifobj_tx->umem->unaligned_mode = true; 1996 test->ifobj_rx->umem->unaligned_mode = true; 1997 pkt_stream_replace(test, DEFAULT_PKT_CNT, MAX_ETH_JUMBO_SIZE); 1998 return testapp_validate_traffic(test); 1999 } 2000 2001 static int testapp_single_pkt(struct test_spec *test) 2002 { 2003 struct pkt pkts[] = {{0, MIN_PKT_SIZE, 0, true}}; 2004 2005 pkt_stream_generate_custom(test, pkts, ARRAY_SIZE(pkts)); 2006 return testapp_validate_traffic(test); 2007 } 2008 2009 static int testapp_send_receive_mb(struct test_spec *test) 2010 { 2011 test->mtu = MAX_ETH_JUMBO_SIZE; 2012 pkt_stream_replace(test, DEFAULT_PKT_CNT, MAX_ETH_JUMBO_SIZE); 2013 2014 return testapp_validate_traffic(test); 2015 } 2016 2017 static int testapp_invalid_desc_mb(struct test_spec *test) 2018 { 2019 struct xsk_umem_info *umem = test->ifobj_tx->umem; 2020 u64 umem_size = umem->num_frames * umem->frame_size; 2021 struct pkt pkts[] = { 2022 /* Valid packet for synch to start with */ 2023 {0, MIN_PKT_SIZE, 0, true, 0}, 2024 /* Zero frame len is not legal */ 2025 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2026 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2027 {0, 0, 0, false, 0}, 2028 /* Invalid address in the second frame */ 2029 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2030 {umem_size, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2031 /* Invalid len in the middle */ 2032 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2033 {0, XSK_UMEM__INVALID_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2034 /* Invalid options in the middle */ 2035 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2036 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XSK_DESC__INVALID_OPTION}, 2037 /* Transmit 2 frags, receive 3 */ 2038 {0, XSK_UMEM__MAX_FRAME_SIZE, 0, true, XDP_PKT_CONTD}, 2039 {0, XSK_UMEM__MAX_FRAME_SIZE, 0, true, 0}, 2040 /* Middle frame crosses chunk boundary with small length */ 2041 {0, XSK_UMEM__LARGE_FRAME_SIZE, 0, false, XDP_PKT_CONTD}, 2042 {-MIN_PKT_SIZE / 2, MIN_PKT_SIZE, 0, false, 0}, 2043 /* Valid packet for synch so that something is received */ 2044 {0, MIN_PKT_SIZE, 0, true, 0}}; 2045 2046 if (umem->unaligned_mode) { 2047 /* Crossing a chunk boundary allowed */ 2048 pkts[12].valid = true; 2049 pkts[13].valid = true; 2050 } 2051 2052 test->mtu = MAX_ETH_JUMBO_SIZE; 2053 pkt_stream_generate_custom(test, pkts, ARRAY_SIZE(pkts)); 2054 return testapp_validate_traffic(test); 2055 } 2056 2057 static int testapp_invalid_desc(struct test_spec *test) 2058 { 2059 struct xsk_umem_info *umem = test->ifobj_tx->umem; 2060 u64 umem_size = umem->num_frames * umem->frame_size; 2061 struct pkt pkts[] = { 2062 /* Zero packet address allowed */ 2063 {0, MIN_PKT_SIZE, 0, true}, 2064 /* Allowed packet */ 2065 {0, MIN_PKT_SIZE, 0, true}, 2066 /* Straddling the start of umem */ 2067 {-2, MIN_PKT_SIZE, 0, false}, 2068 /* Packet too large */ 2069 {0, XSK_UMEM__INVALID_FRAME_SIZE, 0, false}, 2070 /* Up to end of umem allowed */ 2071 {umem_size - MIN_PKT_SIZE - 2 * umem->frame_size, MIN_PKT_SIZE, 0, true}, 2072 /* After umem ends */ 2073 {umem_size, MIN_PKT_SIZE, 0, false}, 2074 /* Straddle the end of umem */ 2075 {umem_size - MIN_PKT_SIZE / 2, MIN_PKT_SIZE, 0, false}, 2076 /* Straddle a 4K boundary */ 2077 {0x1000 - MIN_PKT_SIZE / 2, MIN_PKT_SIZE, 0, false}, 2078 /* Straddle a 2K boundary */ 2079 {0x800 - MIN_PKT_SIZE / 2, MIN_PKT_SIZE, 0, true}, 2080 /* Valid packet for synch so that something is received */ 2081 {0, MIN_PKT_SIZE, 0, true}}; 2082 2083 if (umem->unaligned_mode) { 2084 /* Crossing a page boundary allowed */ 2085 pkts[7].valid = true; 2086 } 2087 if (umem->frame_size == XSK_UMEM__DEFAULT_FRAME_SIZE / 2) { 2088 /* Crossing a 2K frame size boundary not allowed */ 2089 pkts[8].valid = false; 2090 } 2091 2092 if (test->ifobj_tx->shared_umem) { 2093 pkts[4].offset += umem_size; 2094 pkts[5].offset += umem_size; 2095 pkts[6].offset += umem_size; 2096 } 2097 2098 pkt_stream_generate_custom(test, pkts, ARRAY_SIZE(pkts)); 2099 return testapp_validate_traffic(test); 2100 } 2101 2102 static int testapp_xdp_drop(struct test_spec *test) 2103 { 2104 struct xsk_xdp_progs *skel_rx = test->ifobj_rx->xdp_progs; 2105 struct xsk_xdp_progs *skel_tx = test->ifobj_tx->xdp_progs; 2106 2107 test_spec_set_xdp_prog(test, skel_rx->progs.xsk_xdp_drop, skel_tx->progs.xsk_xdp_drop, 2108 skel_rx->maps.xsk, skel_tx->maps.xsk); 2109 2110 pkt_stream_receive_half(test); 2111 return testapp_validate_traffic(test); 2112 } 2113 2114 static int testapp_xdp_metadata_copy(struct test_spec *test) 2115 { 2116 struct xsk_xdp_progs *skel_rx = test->ifobj_rx->xdp_progs; 2117 struct xsk_xdp_progs *skel_tx = test->ifobj_tx->xdp_progs; 2118 struct bpf_map *data_map; 2119 int count = 0; 2120 int key = 0; 2121 2122 test_spec_set_xdp_prog(test, skel_rx->progs.xsk_xdp_populate_metadata, 2123 skel_tx->progs.xsk_xdp_populate_metadata, 2124 skel_rx->maps.xsk, skel_tx->maps.xsk); 2125 test->ifobj_rx->use_metadata = true; 2126 2127 data_map = bpf_object__find_map_by_name(skel_rx->obj, "xsk_xdp_.bss"); 2128 if (!data_map || !bpf_map__is_internal(data_map)) { 2129 ksft_print_msg("Error: could not find bss section of XDP program\n"); 2130 return TEST_FAILURE; 2131 } 2132 2133 if (bpf_map_update_elem(bpf_map__fd(data_map), &key, &count, BPF_ANY)) { 2134 ksft_print_msg("Error: could not update count element\n"); 2135 return TEST_FAILURE; 2136 } 2137 2138 return testapp_validate_traffic(test); 2139 } 2140 2141 static int testapp_xdp_shared_umem(struct test_spec *test) 2142 { 2143 struct xsk_xdp_progs *skel_rx = test->ifobj_rx->xdp_progs; 2144 struct xsk_xdp_progs *skel_tx = test->ifobj_tx->xdp_progs; 2145 2146 test->total_steps = 1; 2147 test->nb_sockets = 2; 2148 2149 test_spec_set_xdp_prog(test, skel_rx->progs.xsk_xdp_shared_umem, 2150 skel_tx->progs.xsk_xdp_shared_umem, 2151 skel_rx->maps.xsk, skel_tx->maps.xsk); 2152 2153 pkt_stream_even_odd_sequence(test); 2154 2155 return testapp_validate_traffic(test); 2156 } 2157 2158 static int testapp_poll_txq_tmout(struct test_spec *test) 2159 { 2160 test->ifobj_tx->use_poll = true; 2161 /* create invalid frame by set umem frame_size and pkt length equal to 2048 */ 2162 test->ifobj_tx->umem->frame_size = 2048; 2163 pkt_stream_replace(test, 2 * DEFAULT_PKT_CNT, 2048); 2164 return testapp_validate_traffic_single_thread(test, test->ifobj_tx); 2165 } 2166 2167 static int testapp_poll_rxq_tmout(struct test_spec *test) 2168 { 2169 test->ifobj_rx->use_poll = true; 2170 return testapp_validate_traffic_single_thread(test, test->ifobj_rx); 2171 } 2172 2173 static int testapp_too_many_frags(struct test_spec *test) 2174 { 2175 struct pkt pkts[2 * XSK_DESC__MAX_SKB_FRAGS + 2] = {}; 2176 u32 max_frags, i; 2177 2178 if (test->mode == TEST_MODE_ZC) 2179 max_frags = test->ifobj_tx->xdp_zc_max_segs; 2180 else 2181 max_frags = XSK_DESC__MAX_SKB_FRAGS; 2182 2183 test->mtu = MAX_ETH_JUMBO_SIZE; 2184 2185 /* Valid packet for synch */ 2186 pkts[0].len = MIN_PKT_SIZE; 2187 pkts[0].valid = true; 2188 2189 /* One valid packet with the max amount of frags */ 2190 for (i = 1; i < max_frags + 1; i++) { 2191 pkts[i].len = MIN_PKT_SIZE; 2192 pkts[i].options = XDP_PKT_CONTD; 2193 pkts[i].valid = true; 2194 } 2195 pkts[max_frags].options = 0; 2196 2197 /* An invalid packet with the max amount of frags but signals packet 2198 * continues on the last frag 2199 */ 2200 for (i = max_frags + 1; i < 2 * max_frags + 1; i++) { 2201 pkts[i].len = MIN_PKT_SIZE; 2202 pkts[i].options = XDP_PKT_CONTD; 2203 pkts[i].valid = false; 2204 } 2205 2206 /* Valid packet for synch */ 2207 pkts[2 * max_frags + 1].len = MIN_PKT_SIZE; 2208 pkts[2 * max_frags + 1].valid = true; 2209 2210 pkt_stream_generate_custom(test, pkts, 2 * max_frags + 2); 2211 return testapp_validate_traffic(test); 2212 } 2213 2214 static int xsk_load_xdp_programs(struct ifobject *ifobj) 2215 { 2216 ifobj->xdp_progs = xsk_xdp_progs__open_and_load(); 2217 if (libbpf_get_error(ifobj->xdp_progs)) 2218 return libbpf_get_error(ifobj->xdp_progs); 2219 2220 return 0; 2221 } 2222 2223 static void xsk_unload_xdp_programs(struct ifobject *ifobj) 2224 { 2225 xsk_xdp_progs__destroy(ifobj->xdp_progs); 2226 } 2227 2228 /* Simple test */ 2229 static bool hugepages_present(void) 2230 { 2231 size_t mmap_sz = 2 * DEFAULT_UMEM_BUFFERS * XSK_UMEM__DEFAULT_FRAME_SIZE; 2232 void *bufs; 2233 2234 bufs = mmap(NULL, mmap_sz, PROT_READ | PROT_WRITE, 2235 MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, MAP_HUGE_2MB); 2236 if (bufs == MAP_FAILED) 2237 return false; 2238 2239 mmap_sz = ceil_u64(mmap_sz, HUGEPAGE_SIZE) * HUGEPAGE_SIZE; 2240 munmap(bufs, mmap_sz); 2241 return true; 2242 } 2243 2244 static void init_iface(struct ifobject *ifobj, thread_func_t func_ptr) 2245 { 2246 LIBBPF_OPTS(bpf_xdp_query_opts, query_opts); 2247 int err; 2248 2249 ifobj->func_ptr = func_ptr; 2250 2251 err = xsk_load_xdp_programs(ifobj); 2252 if (err) { 2253 ksft_print_msg("Error loading XDP program\n"); 2254 exit_with_error(err); 2255 } 2256 2257 if (hugepages_present()) 2258 ifobj->unaligned_supp = true; 2259 2260 err = bpf_xdp_query(ifobj->ifindex, XDP_FLAGS_DRV_MODE, &query_opts); 2261 if (err) { 2262 ksft_print_msg("Error querying XDP capabilities\n"); 2263 exit_with_error(-err); 2264 } 2265 if (query_opts.feature_flags & NETDEV_XDP_ACT_RX_SG) 2266 ifobj->multi_buff_supp = true; 2267 if (query_opts.feature_flags & NETDEV_XDP_ACT_XSK_ZEROCOPY) { 2268 if (query_opts.xdp_zc_max_segs > 1) { 2269 ifobj->multi_buff_zc_supp = true; 2270 ifobj->xdp_zc_max_segs = query_opts.xdp_zc_max_segs; 2271 } else { 2272 ifobj->xdp_zc_max_segs = 0; 2273 } 2274 } 2275 } 2276 2277 static int testapp_send_receive(struct test_spec *test) 2278 { 2279 return testapp_validate_traffic(test); 2280 } 2281 2282 static int testapp_send_receive_2k_frame(struct test_spec *test) 2283 { 2284 test->ifobj_tx->umem->frame_size = 2048; 2285 test->ifobj_rx->umem->frame_size = 2048; 2286 pkt_stream_replace(test, DEFAULT_PKT_CNT, MIN_PKT_SIZE); 2287 return testapp_validate_traffic(test); 2288 } 2289 2290 static int testapp_poll_rx(struct test_spec *test) 2291 { 2292 test->ifobj_rx->use_poll = true; 2293 return testapp_validate_traffic(test); 2294 } 2295 2296 static int testapp_poll_tx(struct test_spec *test) 2297 { 2298 test->ifobj_tx->use_poll = true; 2299 return testapp_validate_traffic(test); 2300 } 2301 2302 static int testapp_aligned_inv_desc(struct test_spec *test) 2303 { 2304 return testapp_invalid_desc(test); 2305 } 2306 2307 static int testapp_aligned_inv_desc_2k_frame(struct test_spec *test) 2308 { 2309 test->ifobj_tx->umem->frame_size = 2048; 2310 test->ifobj_rx->umem->frame_size = 2048; 2311 return testapp_invalid_desc(test); 2312 } 2313 2314 static int testapp_unaligned_inv_desc(struct test_spec *test) 2315 { 2316 test->ifobj_tx->umem->unaligned_mode = true; 2317 test->ifobj_rx->umem->unaligned_mode = true; 2318 return testapp_invalid_desc(test); 2319 } 2320 2321 static int testapp_unaligned_inv_desc_4001_frame(struct test_spec *test) 2322 { 2323 u64 page_size, umem_size; 2324 2325 /* Odd frame size so the UMEM doesn't end near a page boundary. */ 2326 test->ifobj_tx->umem->frame_size = 4001; 2327 test->ifobj_rx->umem->frame_size = 4001; 2328 test->ifobj_tx->umem->unaligned_mode = true; 2329 test->ifobj_rx->umem->unaligned_mode = true; 2330 /* This test exists to test descriptors that staddle the end of 2331 * the UMEM but not a page. 2332 */ 2333 page_size = sysconf(_SC_PAGESIZE); 2334 umem_size = test->ifobj_tx->umem->num_frames * test->ifobj_tx->umem->frame_size; 2335 assert(umem_size % page_size > MIN_PKT_SIZE); 2336 assert(umem_size % page_size < page_size - MIN_PKT_SIZE); 2337 2338 return testapp_invalid_desc(test); 2339 } 2340 2341 static int testapp_aligned_inv_desc_mb(struct test_spec *test) 2342 { 2343 return testapp_invalid_desc_mb(test); 2344 } 2345 2346 static int testapp_unaligned_inv_desc_mb(struct test_spec *test) 2347 { 2348 test->ifobj_tx->umem->unaligned_mode = true; 2349 test->ifobj_rx->umem->unaligned_mode = true; 2350 return testapp_invalid_desc_mb(test); 2351 } 2352 2353 static int testapp_xdp_metadata(struct test_spec *test) 2354 { 2355 return testapp_xdp_metadata_copy(test); 2356 } 2357 2358 static int testapp_xdp_metadata_mb(struct test_spec *test) 2359 { 2360 test->mtu = MAX_ETH_JUMBO_SIZE; 2361 return testapp_xdp_metadata_copy(test); 2362 } 2363 2364 static void run_pkt_test(struct test_spec *test) 2365 { 2366 int ret; 2367 2368 ret = test->test_func(test); 2369 2370 if (ret == TEST_PASS) 2371 ksft_test_result_pass("PASS: %s %s%s\n", mode_string(test), busy_poll_string(test), 2372 test->name); 2373 pkt_stream_restore_default(test); 2374 } 2375 2376 static struct ifobject *ifobject_create(void) 2377 { 2378 struct ifobject *ifobj; 2379 2380 ifobj = calloc(1, sizeof(struct ifobject)); 2381 if (!ifobj) 2382 return NULL; 2383 2384 ifobj->xsk_arr = calloc(MAX_SOCKETS, sizeof(*ifobj->xsk_arr)); 2385 if (!ifobj->xsk_arr) 2386 goto out_xsk_arr; 2387 2388 ifobj->umem = calloc(1, sizeof(*ifobj->umem)); 2389 if (!ifobj->umem) 2390 goto out_umem; 2391 2392 return ifobj; 2393 2394 out_umem: 2395 free(ifobj->xsk_arr); 2396 out_xsk_arr: 2397 free(ifobj); 2398 return NULL; 2399 } 2400 2401 static void ifobject_delete(struct ifobject *ifobj) 2402 { 2403 free(ifobj->umem); 2404 free(ifobj->xsk_arr); 2405 free(ifobj); 2406 } 2407 2408 static bool is_xdp_supported(int ifindex) 2409 { 2410 int flags = XDP_FLAGS_DRV_MODE; 2411 2412 LIBBPF_OPTS(bpf_link_create_opts, opts, .flags = flags); 2413 struct bpf_insn insns[2] = { 2414 BPF_MOV64_IMM(BPF_REG_0, XDP_PASS), 2415 BPF_EXIT_INSN() 2416 }; 2417 int prog_fd, insn_cnt = ARRAY_SIZE(insns); 2418 int err; 2419 2420 prog_fd = bpf_prog_load(BPF_PROG_TYPE_XDP, NULL, "GPL", insns, insn_cnt, NULL); 2421 if (prog_fd < 0) 2422 return false; 2423 2424 err = bpf_xdp_attach(ifindex, prog_fd, flags, NULL); 2425 if (err) { 2426 close(prog_fd); 2427 return false; 2428 } 2429 2430 bpf_xdp_detach(ifindex, flags, NULL); 2431 close(prog_fd); 2432 2433 return true; 2434 } 2435 2436 static const struct test_spec tests[] = { 2437 {.name = "SEND_RECEIVE", .test_func = testapp_send_receive}, 2438 {.name = "SEND_RECEIVE_2K_FRAME", .test_func = testapp_send_receive_2k_frame}, 2439 {.name = "SEND_RECEIVE_SINGLE_PKT", .test_func = testapp_single_pkt}, 2440 {.name = "POLL_RX", .test_func = testapp_poll_rx}, 2441 {.name = "POLL_TX", .test_func = testapp_poll_tx}, 2442 {.name = "POLL_RXQ_FULL", .test_func = testapp_poll_rxq_tmout}, 2443 {.name = "POLL_TXQ_FULL", .test_func = testapp_poll_txq_tmout}, 2444 {.name = "SEND_RECEIVE_UNALIGNED", .test_func = testapp_send_receive_unaligned}, 2445 {.name = "ALIGNED_INV_DESC", .test_func = testapp_aligned_inv_desc}, 2446 {.name = "ALIGNED_INV_DESC_2K_FRAME_SIZE", .test_func = testapp_aligned_inv_desc_2k_frame}, 2447 {.name = "UNALIGNED_INV_DESC", .test_func = testapp_unaligned_inv_desc}, 2448 {.name = "UNALIGNED_INV_DESC_4001_FRAME_SIZE", 2449 .test_func = testapp_unaligned_inv_desc_4001_frame}, 2450 {.name = "UMEM_HEADROOM", .test_func = testapp_headroom}, 2451 {.name = "TEARDOWN", .test_func = testapp_teardown}, 2452 {.name = "BIDIRECTIONAL", .test_func = testapp_bidirectional}, 2453 {.name = "STAT_RX_DROPPED", .test_func = testapp_stats_rx_dropped}, 2454 {.name = "STAT_TX_INVALID", .test_func = testapp_stats_tx_invalid_descs}, 2455 {.name = "STAT_RX_FULL", .test_func = testapp_stats_rx_full}, 2456 {.name = "STAT_FILL_EMPTY", .test_func = testapp_stats_fill_empty}, 2457 {.name = "XDP_PROG_CLEANUP", .test_func = testapp_xdp_prog_cleanup}, 2458 {.name = "XDP_DROP_HALF", .test_func = testapp_xdp_drop}, 2459 {.name = "XDP_SHARED_UMEM", .test_func = testapp_xdp_shared_umem}, 2460 {.name = "XDP_METADATA_COPY", .test_func = testapp_xdp_metadata}, 2461 {.name = "XDP_METADATA_COPY_MULTI_BUFF", .test_func = testapp_xdp_metadata_mb}, 2462 {.name = "SEND_RECEIVE_9K_PACKETS", .test_func = testapp_send_receive_mb}, 2463 {.name = "SEND_RECEIVE_UNALIGNED_9K_PACKETS", 2464 .test_func = testapp_send_receive_unaligned_mb}, 2465 {.name = "ALIGNED_INV_DESC_MULTI_BUFF", .test_func = testapp_aligned_inv_desc_mb}, 2466 {.name = "UNALIGNED_INV_DESC_MULTI_BUFF", .test_func = testapp_unaligned_inv_desc_mb}, 2467 {.name = "TOO_MANY_FRAGS", .test_func = testapp_too_many_frags}, 2468 }; 2469 2470 static void print_tests(void) 2471 { 2472 u32 i; 2473 2474 printf("Tests:\n"); 2475 for (i = 0; i < ARRAY_SIZE(tests); i++) 2476 printf("%u: %s\n", i, tests[i].name); 2477 } 2478 2479 int main(int argc, char **argv) 2480 { 2481 struct pkt_stream *rx_pkt_stream_default; 2482 struct pkt_stream *tx_pkt_stream_default; 2483 struct ifobject *ifobj_tx, *ifobj_rx; 2484 u32 i, j, failed_tests = 0, nb_tests; 2485 int modes = TEST_MODE_SKB + 1; 2486 struct test_spec test; 2487 bool shared_netdev; 2488 2489 /* Use libbpf 1.0 API mode */ 2490 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 2491 2492 ifobj_tx = ifobject_create(); 2493 if (!ifobj_tx) 2494 exit_with_error(ENOMEM); 2495 ifobj_rx = ifobject_create(); 2496 if (!ifobj_rx) 2497 exit_with_error(ENOMEM); 2498 2499 setlocale(LC_ALL, ""); 2500 2501 parse_command_line(ifobj_tx, ifobj_rx, argc, argv); 2502 2503 if (opt_print_tests) { 2504 print_tests(); 2505 ksft_exit_xpass(); 2506 } 2507 if (opt_run_test != RUN_ALL_TESTS && opt_run_test >= ARRAY_SIZE(tests)) { 2508 ksft_print_msg("Error: test %u does not exist.\n", opt_run_test); 2509 ksft_exit_xfail(); 2510 } 2511 2512 shared_netdev = (ifobj_tx->ifindex == ifobj_rx->ifindex); 2513 ifobj_tx->shared_umem = shared_netdev; 2514 ifobj_rx->shared_umem = shared_netdev; 2515 2516 if (!validate_interface(ifobj_tx) || !validate_interface(ifobj_rx)) 2517 print_usage(argv); 2518 2519 if (is_xdp_supported(ifobj_tx->ifindex)) { 2520 modes++; 2521 if (ifobj_zc_avail(ifobj_tx)) 2522 modes++; 2523 } 2524 2525 init_iface(ifobj_rx, worker_testapp_validate_rx); 2526 init_iface(ifobj_tx, worker_testapp_validate_tx); 2527 2528 test_spec_init(&test, ifobj_tx, ifobj_rx, 0, &tests[0]); 2529 tx_pkt_stream_default = pkt_stream_generate(DEFAULT_PKT_CNT, MIN_PKT_SIZE); 2530 rx_pkt_stream_default = pkt_stream_generate(DEFAULT_PKT_CNT, MIN_PKT_SIZE); 2531 if (!tx_pkt_stream_default || !rx_pkt_stream_default) 2532 exit_with_error(ENOMEM); 2533 test.tx_pkt_stream_default = tx_pkt_stream_default; 2534 test.rx_pkt_stream_default = rx_pkt_stream_default; 2535 2536 if (opt_run_test == RUN_ALL_TESTS) 2537 nb_tests = ARRAY_SIZE(tests); 2538 else 2539 nb_tests = 1; 2540 if (opt_mode == TEST_MODE_ALL) { 2541 ksft_set_plan(modes * nb_tests); 2542 } else { 2543 if (opt_mode == TEST_MODE_DRV && modes <= TEST_MODE_DRV) { 2544 ksft_print_msg("Error: XDP_DRV mode not supported.\n"); 2545 ksft_exit_xfail(); 2546 } 2547 if (opt_mode == TEST_MODE_ZC && modes <= TEST_MODE_ZC) { 2548 ksft_print_msg("Error: zero-copy mode not supported.\n"); 2549 ksft_exit_xfail(); 2550 } 2551 2552 ksft_set_plan(nb_tests); 2553 } 2554 2555 for (i = 0; i < modes; i++) { 2556 if (opt_mode != TEST_MODE_ALL && i != opt_mode) 2557 continue; 2558 2559 for (j = 0; j < ARRAY_SIZE(tests); j++) { 2560 if (opt_run_test != RUN_ALL_TESTS && j != opt_run_test) 2561 continue; 2562 2563 test_spec_init(&test, ifobj_tx, ifobj_rx, i, &tests[j]); 2564 run_pkt_test(&test); 2565 usleep(USLEEP_MAX); 2566 2567 if (test.fail) 2568 failed_tests++; 2569 } 2570 } 2571 2572 pkt_stream_delete(tx_pkt_stream_default); 2573 pkt_stream_delete(rx_pkt_stream_default); 2574 xsk_unload_xdp_programs(ifobj_tx); 2575 xsk_unload_xdp_programs(ifobj_rx); 2576 ifobject_delete(ifobj_tx); 2577 ifobject_delete(ifobj_rx); 2578 2579 if (failed_tests) 2580 ksft_exit_fail(); 2581 else 2582 ksft_exit_pass(); 2583 } 2584