2018-05-02 11:01:36 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2018-05-18 12:00:21 +00:00
|
|
|
/* Copyright(c) 2017 - 2018 Intel Corporation. */
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
#include <libgen.h>
|
|
|
|
#include <linux/bpf.h>
|
|
|
|
#include <linux/if_link.h>
|
|
|
|
#include <linux/if_xdp.h>
|
|
|
|
#include <linux/if_ether.h>
|
2019-12-20 08:55:29 +00:00
|
|
|
#include <linux/ip.h>
|
2020-10-02 13:36:12 +00:00
|
|
|
#include <linux/limits.h>
|
2019-12-20 08:55:29 +00:00
|
|
|
#include <linux/udp.h>
|
|
|
|
#include <arpa/inet.h>
|
2019-02-21 09:21:27 +00:00
|
|
|
#include <locale.h>
|
|
|
|
#include <net/ethernet.h>
|
2021-12-30 03:54:42 +00:00
|
|
|
#include <netinet/ether.h>
|
2018-05-02 11:01:36 +00:00
|
|
|
#include <net/if.h>
|
2019-02-21 09:21:27 +00:00
|
|
|
#include <poll.h>
|
|
|
|
#include <pthread.h>
|
2018-05-02 11:01:36 +00:00
|
|
|
#include <signal.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2020-12-03 09:05:46 +00:00
|
|
|
#include <sys/capability.h>
|
2019-02-21 09:21:27 +00:00
|
|
|
#include <sys/mman.h>
|
2018-05-02 11:01:36 +00:00
|
|
|
#include <sys/socket.h>
|
2019-02-21 09:21:27 +00:00
|
|
|
#include <sys/types.h>
|
2020-12-03 09:05:46 +00:00
|
|
|
#include <sys/un.h>
|
2018-05-02 11:01:36 +00:00
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
2021-12-30 03:54:45 +00:00
|
|
|
#include <sched.h>
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-01-20 13:06:49 +00:00
|
|
|
#include <bpf/libbpf.h>
|
|
|
|
#include <bpf/xsk.h>
|
2018-05-15 05:35:02 +00:00
|
|
|
#include <bpf/bpf.h>
|
2020-01-20 13:06:49 +00:00
|
|
|
#include "xdpsock.h"
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-01 23:28:23 +00:00
|
|
|
/* libbpf APIs for AF_XDP are deprecated starting from v0.7 */
|
|
|
|
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
#ifndef SOL_XDP
|
|
|
|
#define SOL_XDP 283
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef AF_XDP
|
|
|
|
#define AF_XDP 44
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef PF_XDP
|
|
|
|
#define PF_XDP AF_XDP
|
|
|
|
#endif
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
#define NUM_FRAMES (4 * 1024)
|
2019-12-20 08:55:29 +00:00
|
|
|
#define MIN_PKT_SIZE 64
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
#define DEBUG_HEXDUMP 0
|
|
|
|
|
2021-12-30 03:54:41 +00:00
|
|
|
#define VLAN_PRIO_MASK 0xe000 /* Priority Code Point */
|
|
|
|
#define VLAN_PRIO_SHIFT 13
|
|
|
|
#define VLAN_VID_MASK 0x0fff /* VLAN Identifier */
|
|
|
|
#define VLAN_VID__DEFAULT 1
|
|
|
|
#define VLAN_PRI__DEFAULT 0
|
|
|
|
|
2021-12-30 03:54:44 +00:00
|
|
|
#define NSEC_PER_SEC 1000000000UL
|
|
|
|
#define NSEC_PER_USEC 1000
|
|
|
|
|
2021-12-30 03:54:45 +00:00
|
|
|
#define SCHED_PRI__DEFAULT 0
|
|
|
|
|
2018-06-04 11:57:14 +00:00
|
|
|
typedef __u64 u64;
|
2018-05-02 11:01:36 +00:00
|
|
|
typedef __u32 u32;
|
2019-12-20 08:55:29 +00:00
|
|
|
typedef __u16 u16;
|
|
|
|
typedef __u8 u8;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
static unsigned long prev_time;
|
2021-12-30 03:54:44 +00:00
|
|
|
static long tx_cycle_diff_min;
|
|
|
|
static long tx_cycle_diff_max;
|
|
|
|
static double tx_cycle_diff_ave;
|
|
|
|
static long tx_cycle_cnt;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
enum benchmark_type {
|
|
|
|
BENCH_RXDROP = 0,
|
|
|
|
BENCH_TXONLY = 1,
|
|
|
|
BENCH_L2FWD = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum benchmark_type opt_bench = BENCH_RXDROP;
|
2019-02-01 21:42:28 +00:00
|
|
|
static u32 opt_xdp_flags = XDP_FLAGS_UPDATE_IF_NOEXIST;
|
2018-05-02 11:01:36 +00:00
|
|
|
static const char *opt_if = "";
|
|
|
|
static int opt_ifindex;
|
|
|
|
static int opt_queue;
|
2019-12-20 08:55:25 +00:00
|
|
|
static unsigned long opt_duration;
|
|
|
|
static unsigned long start_time;
|
|
|
|
static bool benchmark_done;
|
2019-12-20 08:55:27 +00:00
|
|
|
static u32 opt_batch_size = 64;
|
2019-12-20 08:55:28 +00:00
|
|
|
static int opt_pkt_count;
|
2019-12-20 08:55:29 +00:00
|
|
|
static u16 opt_pkt_size = MIN_PKT_SIZE;
|
2019-12-20 08:55:30 +00:00
|
|
|
static u32 opt_pkt_fill_pattern = 0x12345678;
|
2021-12-30 03:54:41 +00:00
|
|
|
static bool opt_vlan_tag;
|
|
|
|
static u16 opt_pkt_vlan_id = VLAN_VID__DEFAULT;
|
|
|
|
static u16 opt_pkt_vlan_pri = VLAN_PRI__DEFAULT;
|
2021-12-30 03:54:42 +00:00
|
|
|
static struct ether_addr opt_txdmac = {{ 0x3c, 0xfd, 0xfe,
|
|
|
|
0x9e, 0x7f, 0x71 }};
|
|
|
|
static struct ether_addr opt_txsmac = {{ 0xec, 0xb1, 0xd7,
|
|
|
|
0x98, 0x3a, 0xc0 }};
|
2020-07-08 07:28:34 +00:00
|
|
|
static bool opt_extra_stats;
|
2020-09-10 08:31:06 +00:00
|
|
|
static bool opt_quiet;
|
2020-10-02 13:36:11 +00:00
|
|
|
static bool opt_app_stats;
|
2020-10-02 13:36:12 +00:00
|
|
|
static const char *opt_irq_str = "";
|
|
|
|
static u32 irq_no;
|
|
|
|
static int irqs_at_init = -1;
|
2021-12-30 03:54:47 +00:00
|
|
|
static u32 sequence;
|
2018-05-02 11:01:36 +00:00
|
|
|
static int opt_poll;
|
|
|
|
static int opt_interval = 1;
|
2021-12-30 03:54:46 +00:00
|
|
|
static int opt_retries = 3;
|
2019-08-14 07:27:21 +00:00
|
|
|
static u32 opt_xdp_bind_flags = XDP_USE_NEED_WAKEUP;
|
2019-08-27 02:25:28 +00:00
|
|
|
static u32 opt_umem_flags;
|
|
|
|
static int opt_unaligned_chunks;
|
2019-08-27 02:25:30 +00:00
|
|
|
static int opt_mmap_flags;
|
2019-06-26 14:35:27 +00:00
|
|
|
static int opt_xsk_frame_size = XSK_UMEM__DEFAULT_FRAME_SIZE;
|
2019-08-14 07:27:21 +00:00
|
|
|
static int opt_timeout = 1000;
|
|
|
|
static bool opt_need_wakeup = true;
|
2019-11-07 17:47:37 +00:00
|
|
|
static u32 opt_num_xsks = 1;
|
2021-06-28 09:18:15 +00:00
|
|
|
static u32 prog_id;
|
2020-11-30 18:52:04 +00:00
|
|
|
static bool opt_busy_poll;
|
2020-12-03 09:05:46 +00:00
|
|
|
static bool opt_reduced_cap;
|
2021-12-30 03:54:43 +00:00
|
|
|
static clockid_t opt_clock = CLOCK_MONOTONIC;
|
2021-12-30 03:54:44 +00:00
|
|
|
static unsigned long opt_tx_cycle_ns;
|
2021-12-30 03:54:45 +00:00
|
|
|
static int opt_schpolicy = SCHED_OTHER;
|
|
|
|
static int opt_schprio = SCHED_PRI__DEFAULT;
|
2021-12-30 03:54:47 +00:00
|
|
|
static bool opt_tstamp;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-30 03:54:41 +00:00
|
|
|
struct vlan_ethhdr {
|
|
|
|
unsigned char h_dest[6];
|
|
|
|
unsigned char h_source[6];
|
|
|
|
__be16 h_vlan_proto;
|
|
|
|
__be16 h_vlan_TCI;
|
|
|
|
__be16 h_vlan_encapsulated_proto;
|
|
|
|
};
|
|
|
|
|
2021-12-30 03:54:47 +00:00
|
|
|
#define PKTGEN_MAGIC 0xbe9be955
|
|
|
|
struct pktgen_hdr {
|
|
|
|
__be32 pgh_magic;
|
|
|
|
__be32 seq_num;
|
|
|
|
__be32 tv_sec;
|
|
|
|
__be32 tv_usec;
|
|
|
|
};
|
|
|
|
|
2020-10-02 13:36:10 +00:00
|
|
|
struct xsk_ring_stats {
|
2018-05-02 11:01:36 +00:00
|
|
|
unsigned long rx_npkts;
|
|
|
|
unsigned long tx_npkts;
|
2020-07-08 07:28:34 +00:00
|
|
|
unsigned long rx_dropped_npkts;
|
|
|
|
unsigned long rx_invalid_npkts;
|
|
|
|
unsigned long tx_invalid_npkts;
|
|
|
|
unsigned long rx_full_npkts;
|
|
|
|
unsigned long rx_fill_empty_npkts;
|
|
|
|
unsigned long tx_empty_npkts;
|
2018-05-02 11:01:36 +00:00
|
|
|
unsigned long prev_rx_npkts;
|
|
|
|
unsigned long prev_tx_npkts;
|
2020-07-08 07:28:34 +00:00
|
|
|
unsigned long prev_rx_dropped_npkts;
|
|
|
|
unsigned long prev_rx_invalid_npkts;
|
|
|
|
unsigned long prev_tx_invalid_npkts;
|
|
|
|
unsigned long prev_rx_full_npkts;
|
|
|
|
unsigned long prev_rx_fill_empty_npkts;
|
|
|
|
unsigned long prev_tx_empty_npkts;
|
2020-10-02 13:36:10 +00:00
|
|
|
};
|
|
|
|
|
2020-10-02 13:36:12 +00:00
|
|
|
struct xsk_driver_stats {
|
|
|
|
unsigned long intrs;
|
|
|
|
unsigned long prev_intrs;
|
|
|
|
};
|
|
|
|
|
2020-10-02 13:36:11 +00:00
|
|
|
struct xsk_app_stats {
|
|
|
|
unsigned long rx_empty_polls;
|
|
|
|
unsigned long fill_fail_polls;
|
|
|
|
unsigned long copy_tx_sendtos;
|
|
|
|
unsigned long tx_wakeup_sendtos;
|
|
|
|
unsigned long opt_polls;
|
|
|
|
unsigned long prev_rx_empty_polls;
|
|
|
|
unsigned long prev_fill_fail_polls;
|
|
|
|
unsigned long prev_copy_tx_sendtos;
|
|
|
|
unsigned long prev_tx_wakeup_sendtos;
|
|
|
|
unsigned long prev_opt_polls;
|
|
|
|
};
|
|
|
|
|
2020-10-02 13:36:10 +00:00
|
|
|
struct xsk_umem_info {
|
|
|
|
struct xsk_ring_prod fq;
|
|
|
|
struct xsk_ring_cons cq;
|
|
|
|
struct xsk_umem *umem;
|
|
|
|
void *buffer;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct xsk_socket_info {
|
|
|
|
struct xsk_ring_cons rx;
|
|
|
|
struct xsk_ring_prod tx;
|
|
|
|
struct xsk_umem_info *umem;
|
|
|
|
struct xsk_socket *xsk;
|
|
|
|
struct xsk_ring_stats ring_stats;
|
2020-10-02 13:36:11 +00:00
|
|
|
struct xsk_app_stats app_stats;
|
2020-10-02 13:36:12 +00:00
|
|
|
struct xsk_driver_stats drv_stats;
|
2019-02-21 09:21:27 +00:00
|
|
|
u32 outstanding_tx;
|
2018-05-02 11:01:36 +00:00
|
|
|
};
|
|
|
|
|
2021-12-30 03:54:43 +00:00
|
|
|
static const struct clockid_map {
|
|
|
|
const char *name;
|
|
|
|
clockid_t clockid;
|
|
|
|
} clockids_map[] = {
|
|
|
|
{ "REALTIME", CLOCK_REALTIME },
|
|
|
|
{ "TAI", CLOCK_TAI },
|
|
|
|
{ "BOOTTIME", CLOCK_BOOTTIME },
|
|
|
|
{ "MONOTONIC", CLOCK_MONOTONIC },
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
2021-12-30 03:54:45 +00:00
|
|
|
static const struct sched_map {
|
|
|
|
const char *name;
|
|
|
|
int policy;
|
|
|
|
} schmap[] = {
|
|
|
|
{ "OTHER", SCHED_OTHER },
|
|
|
|
{ "FIFO", SCHED_FIFO },
|
|
|
|
{ NULL }
|
|
|
|
};
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
static int num_socks;
|
2019-02-21 09:21:27 +00:00
|
|
|
struct xsk_socket_info *xsks[MAX_SOCKS];
|
2020-12-03 09:05:46 +00:00
|
|
|
int sock;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-30 03:54:43 +00:00
|
|
|
static int get_clockid(clockid_t *id, const char *name)
|
|
|
|
{
|
|
|
|
const struct clockid_map *clk;
|
|
|
|
|
|
|
|
for (clk = clockids_map; clk->name; clk++) {
|
|
|
|
if (strcasecmp(clk->name, name) == 0) {
|
|
|
|
*id = clk->clockid;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2021-12-30 03:54:45 +00:00
|
|
|
static int get_schpolicy(int *policy, const char *name)
|
|
|
|
{
|
|
|
|
const struct sched_map *sch;
|
|
|
|
|
|
|
|
for (sch = schmap; sch->name; sch++) {
|
|
|
|
if (strcasecmp(sch->name, name) == 0) {
|
|
|
|
*policy = sch->policy;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
static unsigned long get_nsecs(void)
|
|
|
|
{
|
|
|
|
struct timespec ts;
|
|
|
|
|
2021-12-30 03:54:43 +00:00
|
|
|
clock_gettime(opt_clock, &ts);
|
2018-05-02 11:01:36 +00:00
|
|
|
return ts.tv_sec * 1000000000UL + ts.tv_nsec;
|
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
static void print_benchmark(bool running)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
const char *bench_str = "INVALID";
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
if (opt_bench == BENCH_RXDROP)
|
|
|
|
bench_str = "rxdrop";
|
|
|
|
else if (opt_bench == BENCH_TXONLY)
|
|
|
|
bench_str = "txonly";
|
|
|
|
else if (opt_bench == BENCH_L2FWD)
|
|
|
|
bench_str = "l2fwd";
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
printf("%s:%d %s ", opt_if, opt_queue, bench_str);
|
|
|
|
if (opt_xdp_flags & XDP_FLAGS_SKB_MODE)
|
|
|
|
printf("xdp-skb ");
|
|
|
|
else if (opt_xdp_flags & XDP_FLAGS_DRV_MODE)
|
|
|
|
printf("xdp-drv ");
|
|
|
|
else
|
|
|
|
printf(" ");
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
if (opt_poll)
|
|
|
|
printf("poll() ");
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
if (running) {
|
|
|
|
printf("running...");
|
|
|
|
fflush(stdout);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-08 07:28:34 +00:00
|
|
|
static int xsk_get_xdp_stats(int fd, struct xsk_socket_info *xsk)
|
|
|
|
{
|
|
|
|
struct xdp_statistics stats;
|
|
|
|
socklen_t optlen;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
optlen = sizeof(stats);
|
|
|
|
err = getsockopt(fd, SOL_XDP, XDP_STATISTICS, &stats, &optlen);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (optlen == sizeof(struct xdp_statistics)) {
|
2020-10-02 13:36:10 +00:00
|
|
|
xsk->ring_stats.rx_dropped_npkts = stats.rx_dropped;
|
|
|
|
xsk->ring_stats.rx_invalid_npkts = stats.rx_invalid_descs;
|
|
|
|
xsk->ring_stats.tx_invalid_npkts = stats.tx_invalid_descs;
|
|
|
|
xsk->ring_stats.rx_full_npkts = stats.rx_ring_full;
|
|
|
|
xsk->ring_stats.rx_fill_empty_npkts = stats.rx_fill_ring_empty_descs;
|
|
|
|
xsk->ring_stats.tx_empty_npkts = stats.tx_ring_empty_descs;
|
2020-07-08 07:28:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2020-10-02 13:36:11 +00:00
|
|
|
static void dump_app_stats(long dt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_socks && xsks[i]; i++) {
|
|
|
|
char *fmt = "%-18s %'-14.0f %'-14lu\n";
|
|
|
|
double rx_empty_polls_ps, fill_fail_polls_ps, copy_tx_sendtos_ps,
|
|
|
|
tx_wakeup_sendtos_ps, opt_polls_ps;
|
|
|
|
|
|
|
|
rx_empty_polls_ps = (xsks[i]->app_stats.rx_empty_polls -
|
|
|
|
xsks[i]->app_stats.prev_rx_empty_polls) * 1000000000. / dt;
|
|
|
|
fill_fail_polls_ps = (xsks[i]->app_stats.fill_fail_polls -
|
|
|
|
xsks[i]->app_stats.prev_fill_fail_polls) * 1000000000. / dt;
|
|
|
|
copy_tx_sendtos_ps = (xsks[i]->app_stats.copy_tx_sendtos -
|
|
|
|
xsks[i]->app_stats.prev_copy_tx_sendtos) * 1000000000. / dt;
|
|
|
|
tx_wakeup_sendtos_ps = (xsks[i]->app_stats.tx_wakeup_sendtos -
|
|
|
|
xsks[i]->app_stats.prev_tx_wakeup_sendtos)
|
|
|
|
* 1000000000. / dt;
|
|
|
|
opt_polls_ps = (xsks[i]->app_stats.opt_polls -
|
|
|
|
xsks[i]->app_stats.prev_opt_polls) * 1000000000. / dt;
|
|
|
|
|
|
|
|
printf("\n%-18s %-14s %-14s\n", "", "calls/s", "count");
|
|
|
|
printf(fmt, "rx empty polls", rx_empty_polls_ps, xsks[i]->app_stats.rx_empty_polls);
|
|
|
|
printf(fmt, "fill fail polls", fill_fail_polls_ps,
|
|
|
|
xsks[i]->app_stats.fill_fail_polls);
|
|
|
|
printf(fmt, "copy tx sendtos", copy_tx_sendtos_ps,
|
|
|
|
xsks[i]->app_stats.copy_tx_sendtos);
|
|
|
|
printf(fmt, "tx wakeup sendtos", tx_wakeup_sendtos_ps,
|
|
|
|
xsks[i]->app_stats.tx_wakeup_sendtos);
|
|
|
|
printf(fmt, "opt polls", opt_polls_ps, xsks[i]->app_stats.opt_polls);
|
|
|
|
|
|
|
|
xsks[i]->app_stats.prev_rx_empty_polls = xsks[i]->app_stats.rx_empty_polls;
|
|
|
|
xsks[i]->app_stats.prev_fill_fail_polls = xsks[i]->app_stats.fill_fail_polls;
|
|
|
|
xsks[i]->app_stats.prev_copy_tx_sendtos = xsks[i]->app_stats.copy_tx_sendtos;
|
|
|
|
xsks[i]->app_stats.prev_tx_wakeup_sendtos = xsks[i]->app_stats.tx_wakeup_sendtos;
|
|
|
|
xsks[i]->app_stats.prev_opt_polls = xsks[i]->app_stats.opt_polls;
|
|
|
|
}
|
2021-12-30 03:54:44 +00:00
|
|
|
|
|
|
|
if (opt_tx_cycle_ns) {
|
|
|
|
printf("\n%-18s %-10s %-10s %-10s %-10s %-10s\n",
|
|
|
|
"", "period", "min", "ave", "max", "cycle");
|
|
|
|
printf("%-18s %-10lu %-10lu %-10lu %-10lu %-10lu\n",
|
|
|
|
"Cyclic TX", opt_tx_cycle_ns, tx_cycle_diff_min,
|
|
|
|
(long)(tx_cycle_diff_ave / tx_cycle_cnt),
|
|
|
|
tx_cycle_diff_max, tx_cycle_cnt);
|
|
|
|
}
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
|
|
|
|
2020-10-02 13:36:12 +00:00
|
|
|
static bool get_interrupt_number(void)
|
|
|
|
{
|
|
|
|
FILE *f_int_proc;
|
|
|
|
char line[4096];
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
f_int_proc = fopen("/proc/interrupts", "r");
|
|
|
|
if (f_int_proc == NULL) {
|
|
|
|
printf("Failed to open /proc/interrupts.\n");
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!feof(f_int_proc) && !found) {
|
|
|
|
/* Make sure to read a full line at a time */
|
|
|
|
if (fgets(line, sizeof(line), f_int_proc) == NULL ||
|
|
|
|
line[strlen(line) - 1] != '\n') {
|
|
|
|
printf("Error reading from interrupts file\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Extract interrupt number from line */
|
|
|
|
if (strstr(line, opt_irq_str) != NULL) {
|
|
|
|
irq_no = atoi(line);
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(f_int_proc);
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_irqs(void)
|
|
|
|
{
|
|
|
|
char count_path[PATH_MAX];
|
|
|
|
int total_intrs = -1;
|
|
|
|
FILE *f_count_proc;
|
|
|
|
char line[4096];
|
|
|
|
|
|
|
|
snprintf(count_path, sizeof(count_path),
|
|
|
|
"/sys/kernel/irq/%i/per_cpu_count", irq_no);
|
|
|
|
f_count_proc = fopen(count_path, "r");
|
|
|
|
if (f_count_proc == NULL) {
|
|
|
|
printf("Failed to open %s\n", count_path);
|
|
|
|
return total_intrs;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fgets(line, sizeof(line), f_count_proc) == NULL ||
|
|
|
|
line[strlen(line) - 1] != '\n') {
|
|
|
|
printf("Error reading from %s\n", count_path);
|
|
|
|
} else {
|
|
|
|
static const char com[2] = ",";
|
|
|
|
char *token;
|
|
|
|
|
|
|
|
total_intrs = 0;
|
|
|
|
token = strtok(line, com);
|
|
|
|
while (token != NULL) {
|
|
|
|
/* sum up interrupts across all cores */
|
|
|
|
total_intrs += atoi(token);
|
|
|
|
token = strtok(NULL, com);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(f_count_proc);
|
|
|
|
|
|
|
|
return total_intrs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dump_driver_stats(long dt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_socks && xsks[i]; i++) {
|
|
|
|
char *fmt = "%-18s %'-14.0f %'-14lu\n";
|
|
|
|
double intrs_ps;
|
|
|
|
int n_ints = get_irqs();
|
|
|
|
|
|
|
|
if (n_ints < 0) {
|
|
|
|
printf("error getting intr info for intr %i\n", irq_no);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
xsks[i]->drv_stats.intrs = n_ints - irqs_at_init;
|
|
|
|
|
|
|
|
intrs_ps = (xsks[i]->drv_stats.intrs - xsks[i]->drv_stats.prev_intrs) *
|
|
|
|
1000000000. / dt;
|
|
|
|
|
|
|
|
printf("\n%-18s %-14s %-14s\n", "", "intrs/s", "count");
|
|
|
|
printf(fmt, "irqs", intrs_ps, xsks[i]->drv_stats.intrs);
|
|
|
|
|
|
|
|
xsks[i]->drv_stats.prev_intrs = xsks[i]->drv_stats.intrs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
static void dump_stats(void)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
unsigned long now = get_nsecs();
|
|
|
|
long dt = now - prev_time;
|
|
|
|
int i;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
prev_time = now;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
for (i = 0; i < num_socks && xsks[i]; i++) {
|
2020-10-02 13:36:11 +00:00
|
|
|
char *fmt = "%-18s %'-14.0f %'-14lu\n";
|
2020-07-08 07:28:34 +00:00
|
|
|
double rx_pps, tx_pps, dropped_pps, rx_invalid_pps, full_pps, fill_empty_pps,
|
|
|
|
tx_invalid_pps, tx_empty_pps;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-10-02 13:36:10 +00:00
|
|
|
rx_pps = (xsks[i]->ring_stats.rx_npkts - xsks[i]->ring_stats.prev_rx_npkts) *
|
2019-02-21 09:21:27 +00:00
|
|
|
1000000000. / dt;
|
2020-10-02 13:36:10 +00:00
|
|
|
tx_pps = (xsks[i]->ring_stats.tx_npkts - xsks[i]->ring_stats.prev_tx_npkts) *
|
2019-02-21 09:21:27 +00:00
|
|
|
1000000000. / dt;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
printf("\n sock%d@", i);
|
|
|
|
print_benchmark(false);
|
|
|
|
printf("\n");
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-10-02 13:36:11 +00:00
|
|
|
printf("%-18s %-14s %-14s %-14.2f\n", "", "pps", "pkts",
|
2019-02-21 09:21:27 +00:00
|
|
|
dt / 1000000000.);
|
2020-10-02 13:36:10 +00:00
|
|
|
printf(fmt, "rx", rx_pps, xsks[i]->ring_stats.rx_npkts);
|
|
|
|
printf(fmt, "tx", tx_pps, xsks[i]->ring_stats.tx_npkts);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.prev_rx_npkts = xsks[i]->ring_stats.rx_npkts;
|
|
|
|
xsks[i]->ring_stats.prev_tx_npkts = xsks[i]->ring_stats.tx_npkts;
|
2020-07-08 07:28:34 +00:00
|
|
|
|
|
|
|
if (opt_extra_stats) {
|
|
|
|
if (!xsk_get_xdp_stats(xsk_socket__fd(xsks[i]->xsk), xsks[i])) {
|
2020-10-02 13:36:10 +00:00
|
|
|
dropped_pps = (xsks[i]->ring_stats.rx_dropped_npkts -
|
|
|
|
xsks[i]->ring_stats.prev_rx_dropped_npkts) *
|
|
|
|
1000000000. / dt;
|
|
|
|
rx_invalid_pps = (xsks[i]->ring_stats.rx_invalid_npkts -
|
|
|
|
xsks[i]->ring_stats.prev_rx_invalid_npkts) *
|
|
|
|
1000000000. / dt;
|
|
|
|
tx_invalid_pps = (xsks[i]->ring_stats.tx_invalid_npkts -
|
|
|
|
xsks[i]->ring_stats.prev_tx_invalid_npkts) *
|
|
|
|
1000000000. / dt;
|
|
|
|
full_pps = (xsks[i]->ring_stats.rx_full_npkts -
|
|
|
|
xsks[i]->ring_stats.prev_rx_full_npkts) *
|
|
|
|
1000000000. / dt;
|
|
|
|
fill_empty_pps = (xsks[i]->ring_stats.rx_fill_empty_npkts -
|
|
|
|
xsks[i]->ring_stats.prev_rx_fill_empty_npkts) *
|
|
|
|
1000000000. / dt;
|
|
|
|
tx_empty_pps = (xsks[i]->ring_stats.tx_empty_npkts -
|
|
|
|
xsks[i]->ring_stats.prev_tx_empty_npkts) *
|
|
|
|
1000000000. / dt;
|
2020-07-08 07:28:34 +00:00
|
|
|
|
|
|
|
printf(fmt, "rx dropped", dropped_pps,
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.rx_dropped_npkts);
|
2020-07-08 07:28:34 +00:00
|
|
|
printf(fmt, "rx invalid", rx_invalid_pps,
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.rx_invalid_npkts);
|
2020-07-08 07:28:34 +00:00
|
|
|
printf(fmt, "tx invalid", tx_invalid_pps,
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.tx_invalid_npkts);
|
2020-07-08 07:28:34 +00:00
|
|
|
printf(fmt, "rx queue full", full_pps,
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.rx_full_npkts);
|
2020-07-08 07:28:34 +00:00
|
|
|
printf(fmt, "fill ring empty", fill_empty_pps,
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.rx_fill_empty_npkts);
|
2020-07-08 07:28:34 +00:00
|
|
|
printf(fmt, "tx ring empty", tx_empty_pps,
|
2020-10-02 13:36:10 +00:00
|
|
|
xsks[i]->ring_stats.tx_empty_npkts);
|
|
|
|
|
|
|
|
xsks[i]->ring_stats.prev_rx_dropped_npkts =
|
|
|
|
xsks[i]->ring_stats.rx_dropped_npkts;
|
|
|
|
xsks[i]->ring_stats.prev_rx_invalid_npkts =
|
|
|
|
xsks[i]->ring_stats.rx_invalid_npkts;
|
|
|
|
xsks[i]->ring_stats.prev_tx_invalid_npkts =
|
|
|
|
xsks[i]->ring_stats.tx_invalid_npkts;
|
|
|
|
xsks[i]->ring_stats.prev_rx_full_npkts =
|
|
|
|
xsks[i]->ring_stats.rx_full_npkts;
|
|
|
|
xsks[i]->ring_stats.prev_rx_fill_empty_npkts =
|
|
|
|
xsks[i]->ring_stats.rx_fill_empty_npkts;
|
|
|
|
xsks[i]->ring_stats.prev_tx_empty_npkts =
|
|
|
|
xsks[i]->ring_stats.tx_empty_npkts;
|
2020-07-08 07:28:34 +00:00
|
|
|
} else {
|
|
|
|
printf("%-15s\n", "Error retrieving extra stats");
|
|
|
|
}
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
2020-10-02 13:36:11 +00:00
|
|
|
|
|
|
|
if (opt_app_stats)
|
|
|
|
dump_app_stats(dt);
|
2020-10-02 13:36:12 +00:00
|
|
|
if (irq_no)
|
|
|
|
dump_driver_stats(dt);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:25 +00:00
|
|
|
static bool is_benchmark_done(void)
|
|
|
|
{
|
|
|
|
if (opt_duration > 0) {
|
|
|
|
unsigned long dt = (get_nsecs() - start_time);
|
|
|
|
|
|
|
|
if (dt >= opt_duration)
|
|
|
|
benchmark_done = true;
|
|
|
|
}
|
|
|
|
return benchmark_done;
|
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
static void *poller(void *arg)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
(void)arg;
|
2019-12-20 08:55:25 +00:00
|
|
|
while (!is_benchmark_done()) {
|
2019-02-21 09:21:27 +00:00
|
|
|
sleep(opt_interval);
|
|
|
|
dump_stats();
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
return NULL;
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2021-06-28 09:18:15 +00:00
|
|
|
static void remove_xdp_program(void)
|
|
|
|
{
|
|
|
|
u32 curr_prog_id = 0;
|
|
|
|
|
2022-01-20 06:14:22 +00:00
|
|
|
if (bpf_xdp_query_id(opt_ifindex, opt_xdp_flags, &curr_prog_id)) {
|
|
|
|
printf("bpf_xdp_query_id failed\n");
|
2021-06-28 09:18:15 +00:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prog_id == curr_prog_id)
|
2022-01-20 06:14:22 +00:00
|
|
|
bpf_xdp_detach(opt_ifindex, opt_xdp_flags, NULL);
|
2021-06-28 09:18:15 +00:00
|
|
|
else if (!curr_prog_id)
|
|
|
|
printf("couldn't find a prog id on a given interface\n");
|
|
|
|
else
|
|
|
|
printf("program on interface changed, not removing\n");
|
|
|
|
}
|
|
|
|
|
2021-03-29 22:43:06 +00:00
|
|
|
static void int_exit(int sig)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2021-03-29 22:43:06 +00:00
|
|
|
benchmark_done = true;
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2021-03-29 22:43:06 +00:00
|
|
|
static void __exit_with_error(int error, const char *file, const char *func,
|
|
|
|
int line)
|
2019-12-20 08:55:26 +00:00
|
|
|
{
|
2021-03-29 22:43:06 +00:00
|
|
|
fprintf(stderr, "%s:%s:%i: errno: %d/\"%s\"\n", file, func,
|
|
|
|
line, error, strerror(error));
|
2021-06-28 09:18:15 +00:00
|
|
|
|
|
|
|
if (opt_num_xsks > 1)
|
|
|
|
remove_xdp_program();
|
2021-03-29 22:43:06 +00:00
|
|
|
exit(EXIT_FAILURE);
|
2019-12-20 08:55:26 +00:00
|
|
|
}
|
|
|
|
|
2021-03-29 22:43:06 +00:00
|
|
|
#define exit_with_error(error) __exit_with_error(error, __FILE__, __func__, __LINE__)
|
|
|
|
|
2019-12-20 08:55:26 +00:00
|
|
|
static void xdpsock_cleanup(void)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
struct xsk_umem *umem = xsks[0]->umem->umem;
|
2021-03-29 22:43:06 +00:00
|
|
|
int i, cmd = CLOSE_CONN;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
dump_stats();
|
2019-11-07 17:47:37 +00:00
|
|
|
for (i = 0; i < num_socks; i++)
|
|
|
|
xsk_socket__delete(xsks[i]->xsk);
|
2019-02-21 09:21:27 +00:00
|
|
|
(void)xsk_umem__delete(umem);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-03-29 22:43:06 +00:00
|
|
|
if (opt_reduced_cap) {
|
|
|
|
if (write(sock, &cmd, sizeof(int)) < 0)
|
|
|
|
exit_with_error(errno);
|
|
|
|
}
|
2021-06-28 09:18:15 +00:00
|
|
|
|
|
|
|
if (opt_num_xsks > 1)
|
|
|
|
remove_xdp_program();
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void swap_mac_addresses(void *data)
|
|
|
|
{
|
|
|
|
struct ether_header *eth = (struct ether_header *)data;
|
|
|
|
struct ether_addr *src_addr = (struct ether_addr *)ð->ether_shost;
|
|
|
|
struct ether_addr *dst_addr = (struct ether_addr *)ð->ether_dhost;
|
|
|
|
struct ether_addr tmp;
|
|
|
|
|
|
|
|
tmp = *src_addr;
|
|
|
|
*src_addr = *dst_addr;
|
|
|
|
*dst_addr = tmp;
|
|
|
|
}
|
|
|
|
|
2018-06-04 11:57:14 +00:00
|
|
|
static void hex_dump(void *pkt, size_t length, u64 addr)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
|
|
|
const unsigned char *address = (unsigned char *)pkt;
|
|
|
|
const unsigned char *line = address;
|
|
|
|
size_t line_size = 32;
|
|
|
|
unsigned char c;
|
2018-06-04 11:57:14 +00:00
|
|
|
char buf[32];
|
|
|
|
int i = 0;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2018-06-04 11:57:14 +00:00
|
|
|
if (!DEBUG_HEXDUMP)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sprintf(buf, "addr=%llu", addr);
|
2018-05-02 11:01:36 +00:00
|
|
|
printf("length = %zu\n", length);
|
2018-06-04 11:57:14 +00:00
|
|
|
printf("%s | ", buf);
|
2018-05-02 11:01:36 +00:00
|
|
|
while (length-- > 0) {
|
|
|
|
printf("%02X ", *address++);
|
|
|
|
if (!(++i % line_size) || (length == 0 && i % line_size)) {
|
|
|
|
if (length == 0) {
|
|
|
|
while (i++ % line_size)
|
|
|
|
printf("__ ");
|
|
|
|
}
|
|
|
|
printf(" | "); /* right close */
|
|
|
|
while (line < address) {
|
|
|
|
c = *line++;
|
|
|
|
printf("%c", (c < 33 || c == 255) ? 0x2E : c);
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
if (length > 0)
|
2018-06-04 11:57:14 +00:00
|
|
|
printf("%s | ", buf);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:29 +00:00
|
|
|
static void *memset32_htonl(void *dest, u32 val, u32 size)
|
|
|
|
{
|
|
|
|
u32 *ptr = (u32 *)dest;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
val = htonl(val);
|
|
|
|
|
|
|
|
for (i = 0; i < (size & (~0x3)); i += 4)
|
|
|
|
ptr[i >> 2] = val;
|
|
|
|
|
|
|
|
for (; i < size; i++)
|
|
|
|
((char *)dest)[i] = ((char *)&val)[i & 3];
|
|
|
|
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function code has been taken from
|
|
|
|
* Linux kernel lib/checksum.c
|
|
|
|
*/
|
|
|
|
static inline unsigned short from32to16(unsigned int x)
|
|
|
|
{
|
|
|
|
/* add up 16-bit and 16-bit for 16+c bit */
|
|
|
|
x = (x & 0xffff) + (x >> 16);
|
|
|
|
/* add up carry.. */
|
|
|
|
x = (x & 0xffff) + (x >> 16);
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function code has been taken from
|
|
|
|
* Linux kernel lib/checksum.c
|
|
|
|
*/
|
|
|
|
static unsigned int do_csum(const unsigned char *buff, int len)
|
|
|
|
{
|
|
|
|
unsigned int result = 0;
|
|
|
|
int odd;
|
|
|
|
|
|
|
|
if (len <= 0)
|
|
|
|
goto out;
|
|
|
|
odd = 1 & (unsigned long)buff;
|
|
|
|
if (odd) {
|
|
|
|
#ifdef __LITTLE_ENDIAN
|
|
|
|
result += (*buff << 8);
|
|
|
|
#else
|
|
|
|
result = *buff;
|
|
|
|
#endif
|
|
|
|
len--;
|
|
|
|
buff++;
|
|
|
|
}
|
|
|
|
if (len >= 2) {
|
|
|
|
if (2 & (unsigned long)buff) {
|
|
|
|
result += *(unsigned short *)buff;
|
|
|
|
len -= 2;
|
|
|
|
buff += 2;
|
|
|
|
}
|
|
|
|
if (len >= 4) {
|
|
|
|
const unsigned char *end = buff +
|
|
|
|
((unsigned int)len & ~3);
|
|
|
|
unsigned int carry = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
unsigned int w = *(unsigned int *)buff;
|
|
|
|
|
|
|
|
buff += 4;
|
|
|
|
result += carry;
|
|
|
|
result += w;
|
|
|
|
carry = (w > result);
|
|
|
|
} while (buff < end);
|
|
|
|
result += carry;
|
|
|
|
result = (result & 0xffff) + (result >> 16);
|
|
|
|
}
|
|
|
|
if (len & 2) {
|
|
|
|
result += *(unsigned short *)buff;
|
|
|
|
buff += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (len & 1)
|
|
|
|
#ifdef __LITTLE_ENDIAN
|
|
|
|
result += *buff;
|
|
|
|
#else
|
|
|
|
result += (*buff << 8);
|
|
|
|
#endif
|
|
|
|
result = from32to16(result);
|
|
|
|
if (odd)
|
|
|
|
result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
|
|
|
|
out:
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a version of ip_compute_csum() optimized for IP headers,
|
|
|
|
* which always checksum on 4 octet boundaries.
|
|
|
|
* This function code has been taken from
|
|
|
|
* Linux kernel lib/checksum.c
|
|
|
|
*/
|
2021-08-06 12:28:55 +00:00
|
|
|
static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
|
2019-12-20 08:55:29 +00:00
|
|
|
{
|
2021-08-06 12:28:54 +00:00
|
|
|
return (__sum16)~do_csum(iph, ihl * 4);
|
2019-12-20 08:55:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fold a partial checksum
|
|
|
|
* This function code has been taken from
|
|
|
|
* Linux kernel include/asm-generic/checksum.h
|
|
|
|
*/
|
|
|
|
static inline __sum16 csum_fold(__wsum csum)
|
|
|
|
{
|
2021-08-06 12:28:54 +00:00
|
|
|
u32 sum = (u32)csum;
|
2019-12-20 08:55:29 +00:00
|
|
|
|
|
|
|
sum = (sum & 0xffff) + (sum >> 16);
|
|
|
|
sum = (sum & 0xffff) + (sum >> 16);
|
2021-08-06 12:28:54 +00:00
|
|
|
return (__sum16)~sum;
|
2019-12-20 08:55:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function code has been taken from
|
|
|
|
* Linux kernel lib/checksum.c
|
|
|
|
*/
|
|
|
|
static inline u32 from64to32(u64 x)
|
|
|
|
{
|
|
|
|
/* add up 32-bit and 32-bit for 32+c bit */
|
|
|
|
x = (x & 0xffffffff) + (x >> 32);
|
|
|
|
/* add up carry.. */
|
|
|
|
x = (x & 0xffffffff) + (x >> 32);
|
|
|
|
return (u32)x;
|
|
|
|
}
|
|
|
|
|
|
|
|
__wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
|
|
|
|
__u32 len, __u8 proto, __wsum sum);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function code has been taken from
|
|
|
|
* Linux kernel lib/checksum.c
|
|
|
|
*/
|
|
|
|
__wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr,
|
|
|
|
__u32 len, __u8 proto, __wsum sum)
|
|
|
|
{
|
2021-08-06 12:28:54 +00:00
|
|
|
unsigned long long s = (u32)sum;
|
2019-12-20 08:55:29 +00:00
|
|
|
|
2021-08-06 12:28:54 +00:00
|
|
|
s += (u32)saddr;
|
|
|
|
s += (u32)daddr;
|
2019-12-20 08:55:29 +00:00
|
|
|
#ifdef __BIG_ENDIAN__
|
|
|
|
s += proto + len;
|
|
|
|
#else
|
|
|
|
s += (proto + len) << 8;
|
|
|
|
#endif
|
2021-08-06 12:28:54 +00:00
|
|
|
return (__wsum)from64to32(s);
|
2019-12-20 08:55:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function has been taken from
|
|
|
|
* Linux kernel include/asm-generic/checksum.h
|
|
|
|
*/
|
|
|
|
static inline __sum16
|
|
|
|
csum_tcpudp_magic(__be32 saddr, __be32 daddr, __u32 len,
|
|
|
|
__u8 proto, __wsum sum)
|
|
|
|
{
|
|
|
|
return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 udp_csum(u32 saddr, u32 daddr, u32 len,
|
|
|
|
u8 proto, u16 *udp_pkt)
|
|
|
|
{
|
|
|
|
u32 csum = 0;
|
|
|
|
u32 cnt = 0;
|
|
|
|
|
|
|
|
/* udp hdr and data */
|
|
|
|
for (; cnt < len; cnt += 2)
|
|
|
|
csum += udp_pkt[cnt >> 1];
|
|
|
|
|
|
|
|
return csum_tcpudp_magic(saddr, daddr, len, proto, csum);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ETH_FCS_SIZE 4
|
|
|
|
|
2021-12-30 03:54:41 +00:00
|
|
|
#define ETH_HDR_SIZE (opt_vlan_tag ? sizeof(struct vlan_ethhdr) : \
|
|
|
|
sizeof(struct ethhdr))
|
2021-12-30 03:54:47 +00:00
|
|
|
#define PKTGEN_HDR_SIZE (opt_tstamp ? sizeof(struct pktgen_hdr) : 0)
|
2021-12-30 03:54:41 +00:00
|
|
|
#define PKT_HDR_SIZE (ETH_HDR_SIZE + sizeof(struct iphdr) + \
|
2021-12-30 03:54:47 +00:00
|
|
|
sizeof(struct udphdr) + PKTGEN_HDR_SIZE)
|
|
|
|
#define PKTGEN_HDR_OFFSET (ETH_HDR_SIZE + sizeof(struct iphdr) + \
|
|
|
|
sizeof(struct udphdr))
|
|
|
|
#define PKTGEN_SIZE_MIN (PKTGEN_HDR_OFFSET + sizeof(struct pktgen_hdr) + \
|
|
|
|
ETH_FCS_SIZE)
|
2019-12-20 08:55:29 +00:00
|
|
|
|
|
|
|
#define PKT_SIZE (opt_pkt_size - ETH_FCS_SIZE)
|
2021-12-30 03:54:41 +00:00
|
|
|
#define IP_PKT_SIZE (PKT_SIZE - ETH_HDR_SIZE)
|
2019-12-20 08:55:29 +00:00
|
|
|
#define UDP_PKT_SIZE (IP_PKT_SIZE - sizeof(struct iphdr))
|
2021-12-30 03:54:47 +00:00
|
|
|
#define UDP_PKT_DATA_SIZE (UDP_PKT_SIZE - \
|
|
|
|
(sizeof(struct udphdr) + PKTGEN_HDR_SIZE))
|
2019-12-20 08:55:29 +00:00
|
|
|
|
|
|
|
static u8 pkt_data[XSK_UMEM__DEFAULT_FRAME_SIZE];
|
|
|
|
|
|
|
|
static void gen_eth_hdr_data(void)
|
|
|
|
{
|
2021-12-30 03:54:47 +00:00
|
|
|
struct pktgen_hdr *pktgen_hdr;
|
2021-12-30 03:54:41 +00:00
|
|
|
struct udphdr *udp_hdr;
|
|
|
|
struct iphdr *ip_hdr;
|
|
|
|
|
|
|
|
if (opt_vlan_tag) {
|
|
|
|
struct vlan_ethhdr *veth_hdr = (struct vlan_ethhdr *)pkt_data;
|
|
|
|
u16 vlan_tci = 0;
|
|
|
|
|
|
|
|
udp_hdr = (struct udphdr *)(pkt_data +
|
|
|
|
sizeof(struct vlan_ethhdr) +
|
|
|
|
sizeof(struct iphdr));
|
|
|
|
ip_hdr = (struct iphdr *)(pkt_data +
|
|
|
|
sizeof(struct vlan_ethhdr));
|
2021-12-30 03:54:47 +00:00
|
|
|
pktgen_hdr = (struct pktgen_hdr *)(pkt_data +
|
|
|
|
sizeof(struct vlan_ethhdr) +
|
|
|
|
sizeof(struct iphdr) +
|
|
|
|
sizeof(struct udphdr));
|
2021-12-30 03:54:41 +00:00
|
|
|
/* ethernet & VLAN header */
|
2021-12-30 03:54:42 +00:00
|
|
|
memcpy(veth_hdr->h_dest, &opt_txdmac, ETH_ALEN);
|
|
|
|
memcpy(veth_hdr->h_source, &opt_txsmac, ETH_ALEN);
|
2021-12-30 03:54:41 +00:00
|
|
|
veth_hdr->h_vlan_proto = htons(ETH_P_8021Q);
|
|
|
|
vlan_tci = opt_pkt_vlan_id & VLAN_VID_MASK;
|
|
|
|
vlan_tci |= (opt_pkt_vlan_pri << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;
|
|
|
|
veth_hdr->h_vlan_TCI = htons(vlan_tci);
|
|
|
|
veth_hdr->h_vlan_encapsulated_proto = htons(ETH_P_IP);
|
|
|
|
} else {
|
|
|
|
struct ethhdr *eth_hdr = (struct ethhdr *)pkt_data;
|
|
|
|
|
|
|
|
udp_hdr = (struct udphdr *)(pkt_data +
|
|
|
|
sizeof(struct ethhdr) +
|
|
|
|
sizeof(struct iphdr));
|
|
|
|
ip_hdr = (struct iphdr *)(pkt_data +
|
|
|
|
sizeof(struct ethhdr));
|
2021-12-30 03:54:47 +00:00
|
|
|
pktgen_hdr = (struct pktgen_hdr *)(pkt_data +
|
|
|
|
sizeof(struct ethhdr) +
|
|
|
|
sizeof(struct iphdr) +
|
|
|
|
sizeof(struct udphdr));
|
2021-12-30 03:54:41 +00:00
|
|
|
/* ethernet header */
|
2021-12-30 03:54:42 +00:00
|
|
|
memcpy(eth_hdr->h_dest, &opt_txdmac, ETH_ALEN);
|
|
|
|
memcpy(eth_hdr->h_source, &opt_txsmac, ETH_ALEN);
|
2021-12-30 03:54:41 +00:00
|
|
|
eth_hdr->h_proto = htons(ETH_P_IP);
|
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:29 +00:00
|
|
|
|
|
|
|
/* IP header */
|
|
|
|
ip_hdr->version = IPVERSION;
|
|
|
|
ip_hdr->ihl = 0x5; /* 20 byte header */
|
|
|
|
ip_hdr->tos = 0x0;
|
|
|
|
ip_hdr->tot_len = htons(IP_PKT_SIZE);
|
|
|
|
ip_hdr->id = 0;
|
|
|
|
ip_hdr->frag_off = 0;
|
|
|
|
ip_hdr->ttl = IPDEFTTL;
|
|
|
|
ip_hdr->protocol = IPPROTO_UDP;
|
|
|
|
ip_hdr->saddr = htonl(0x0a0a0a10);
|
|
|
|
ip_hdr->daddr = htonl(0x0a0a0a20);
|
|
|
|
|
|
|
|
/* IP header checksum */
|
|
|
|
ip_hdr->check = 0;
|
|
|
|
ip_hdr->check = ip_fast_csum((const void *)ip_hdr, ip_hdr->ihl);
|
|
|
|
|
|
|
|
/* UDP header */
|
|
|
|
udp_hdr->source = htons(0x1000);
|
|
|
|
udp_hdr->dest = htons(0x1000);
|
|
|
|
udp_hdr->len = htons(UDP_PKT_SIZE);
|
|
|
|
|
2021-12-30 03:54:47 +00:00
|
|
|
if (opt_tstamp)
|
|
|
|
pktgen_hdr->pgh_magic = htonl(PKTGEN_MAGIC);
|
|
|
|
|
2019-12-20 08:55:29 +00:00
|
|
|
/* UDP data */
|
2019-12-20 08:55:30 +00:00
|
|
|
memset32_htonl(pkt_data + PKT_HDR_SIZE, opt_pkt_fill_pattern,
|
2019-12-20 08:55:29 +00:00
|
|
|
UDP_PKT_DATA_SIZE);
|
|
|
|
|
|
|
|
/* UDP header checksum */
|
|
|
|
udp_hdr->check = 0;
|
|
|
|
udp_hdr->check = udp_csum(ip_hdr->saddr, ip_hdr->daddr, UDP_PKT_SIZE,
|
|
|
|
IPPROTO_UDP, (u16 *)udp_hdr);
|
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:27 +00:00
|
|
|
static void gen_eth_frame(struct xsk_umem_info *umem, u64 addr)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
memcpy(xsk_umem__get_data(umem->buffer, addr), pkt_data,
|
2019-12-20 08:55:29 +00:00
|
|
|
PKT_SIZE);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
static struct xsk_umem_info *xsk_configure_umem(void *buffer, u64 size)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
struct xsk_umem_info *umem;
|
2019-06-26 14:35:27 +00:00
|
|
|
struct xsk_umem_config cfg = {
|
2020-08-28 12:51:05 +00:00
|
|
|
/* We recommend that you set the fill ring size >= HW RX ring size +
|
|
|
|
* AF_XDP RX ring size. Make sure you fill up the fill ring
|
|
|
|
* with buffers at regular intervals, and you will with this setting
|
|
|
|
* avoid allocation failures in the driver. These are usually quite
|
|
|
|
* expensive since drivers have not been written to assume that
|
|
|
|
* allocation failures are common. For regular sockets, kernel
|
|
|
|
* allocated memory is used that only runs out in OOM situations
|
|
|
|
* that should be rare.
|
|
|
|
*/
|
|
|
|
.fill_size = XSK_RING_PROD__DEFAULT_NUM_DESCS * 2,
|
2019-06-26 14:35:27 +00:00
|
|
|
.comp_size = XSK_RING_CONS__DEFAULT_NUM_DESCS,
|
|
|
|
.frame_size = opt_xsk_frame_size,
|
|
|
|
.frame_headroom = XSK_UMEM__DEFAULT_FRAME_HEADROOM,
|
2019-08-27 02:25:28 +00:00
|
|
|
.flags = opt_umem_flags
|
2019-06-26 14:35:27 +00:00
|
|
|
};
|
2019-11-07 17:47:39 +00:00
|
|
|
int ret;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
umem = calloc(1, sizeof(*umem));
|
2019-02-21 09:21:27 +00:00
|
|
|
if (!umem)
|
|
|
|
exit_with_error(errno);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
ret = xsk_umem__create(&umem->umem, buffer, size, &umem->fq, &umem->cq,
|
2019-06-26 14:35:27 +00:00
|
|
|
&cfg);
|
2019-02-21 09:21:27 +00:00
|
|
|
if (ret)
|
|
|
|
exit_with_error(-ret);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-11-07 17:47:39 +00:00
|
|
|
umem->buffer = buffer;
|
|
|
|
return umem;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xsk_populate_fill_ring(struct xsk_umem_info *umem)
|
|
|
|
{
|
|
|
|
int ret, i;
|
|
|
|
u32 idx;
|
|
|
|
|
2019-11-07 17:47:37 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&umem->fq,
|
2020-08-28 12:51:05 +00:00
|
|
|
XSK_RING_PROD__DEFAULT_NUM_DESCS * 2, &idx);
|
|
|
|
if (ret != XSK_RING_PROD__DEFAULT_NUM_DESCS * 2)
|
2019-11-07 17:47:37 +00:00
|
|
|
exit_with_error(-ret);
|
2020-08-28 12:51:05 +00:00
|
|
|
for (i = 0; i < XSK_RING_PROD__DEFAULT_NUM_DESCS * 2; i++)
|
2019-11-07 17:47:37 +00:00
|
|
|
*xsk_ring_prod__fill_addr(&umem->fq, idx++) =
|
|
|
|
i * opt_xsk_frame_size;
|
2020-08-28 12:51:05 +00:00
|
|
|
xsk_ring_prod__submit(&umem->fq, XSK_RING_PROD__DEFAULT_NUM_DESCS * 2);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-11-07 17:47:39 +00:00
|
|
|
static struct xsk_socket_info *xsk_configure_socket(struct xsk_umem_info *umem,
|
|
|
|
bool rx, bool tx)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-02-21 09:21:27 +00:00
|
|
|
struct xsk_socket_config cfg;
|
|
|
|
struct xsk_socket_info *xsk;
|
2019-11-07 17:47:39 +00:00
|
|
|
struct xsk_ring_cons *rxr;
|
|
|
|
struct xsk_ring_prod *txr;
|
2019-02-21 09:21:27 +00:00
|
|
|
int ret;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
xsk = calloc(1, sizeof(*xsk));
|
2019-02-21 09:21:27 +00:00
|
|
|
if (!xsk)
|
|
|
|
exit_with_error(errno);
|
|
|
|
|
|
|
|
xsk->umem = umem;
|
|
|
|
cfg.rx_size = XSK_RING_CONS__DEFAULT_NUM_DESCS;
|
|
|
|
cfg.tx_size = XSK_RING_PROD__DEFAULT_NUM_DESCS;
|
2020-12-03 09:05:46 +00:00
|
|
|
if (opt_num_xsks > 1 || opt_reduced_cap)
|
2019-11-07 17:47:37 +00:00
|
|
|
cfg.libbpf_flags = XSK_LIBBPF_FLAGS__INHIBIT_PROG_LOAD;
|
|
|
|
else
|
|
|
|
cfg.libbpf_flags = 0;
|
2019-02-21 09:21:27 +00:00
|
|
|
cfg.xdp_flags = opt_xdp_flags;
|
|
|
|
cfg.bind_flags = opt_xdp_bind_flags;
|
2019-11-07 17:47:37 +00:00
|
|
|
|
2019-11-07 17:47:39 +00:00
|
|
|
rxr = rx ? &xsk->rx : NULL;
|
|
|
|
txr = tx ? &xsk->tx : NULL;
|
|
|
|
ret = xsk_socket__create(&xsk->xsk, opt_if, opt_queue, umem->umem,
|
|
|
|
rxr, txr, &cfg);
|
2019-02-21 09:21:27 +00:00
|
|
|
if (ret)
|
|
|
|
exit_with_error(-ret);
|
|
|
|
|
2022-01-20 06:14:22 +00:00
|
|
|
ret = bpf_xdp_query_id(opt_ifindex, opt_xdp_flags, &prog_id);
|
2021-06-28 09:18:15 +00:00
|
|
|
if (ret)
|
|
|
|
exit_with_error(-ret);
|
|
|
|
|
2020-10-02 13:36:11 +00:00
|
|
|
xsk->app_stats.rx_empty_polls = 0;
|
|
|
|
xsk->app_stats.fill_fail_polls = 0;
|
|
|
|
xsk->app_stats.copy_tx_sendtos = 0;
|
|
|
|
xsk->app_stats.tx_wakeup_sendtos = 0;
|
|
|
|
xsk->app_stats.opt_polls = 0;
|
|
|
|
xsk->app_stats.prev_rx_empty_polls = 0;
|
|
|
|
xsk->app_stats.prev_fill_fail_polls = 0;
|
|
|
|
xsk->app_stats.prev_copy_tx_sendtos = 0;
|
|
|
|
xsk->app_stats.prev_tx_wakeup_sendtos = 0;
|
|
|
|
xsk->app_stats.prev_opt_polls = 0;
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
return xsk;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct option long_options[] = {
|
|
|
|
{"rxdrop", no_argument, 0, 'r'},
|
|
|
|
{"txonly", no_argument, 0, 't'},
|
|
|
|
{"l2fwd", no_argument, 0, 'l'},
|
|
|
|
{"interface", required_argument, 0, 'i'},
|
|
|
|
{"queue", required_argument, 0, 'q'},
|
|
|
|
{"poll", no_argument, 0, 'p'},
|
|
|
|
{"xdp-skb", no_argument, 0, 'S'},
|
|
|
|
{"xdp-native", no_argument, 0, 'N'},
|
|
|
|
{"interval", required_argument, 0, 'n'},
|
2021-12-30 03:54:46 +00:00
|
|
|
{"retries", required_argument, 0, 'O'},
|
2018-08-28 12:44:35 +00:00
|
|
|
{"zero-copy", no_argument, 0, 'z'},
|
|
|
|
{"copy", no_argument, 0, 'c'},
|
2019-06-26 14:35:27 +00:00
|
|
|
{"frame-size", required_argument, 0, 'f'},
|
2019-08-14 07:27:21 +00:00
|
|
|
{"no-need-wakeup", no_argument, 0, 'm'},
|
2019-08-27 02:25:28 +00:00
|
|
|
{"unaligned", no_argument, 0, 'u'},
|
2019-11-07 17:47:37 +00:00
|
|
|
{"shared-umem", no_argument, 0, 'M'},
|
2019-11-14 16:28:47 +00:00
|
|
|
{"force", no_argument, 0, 'F'},
|
2019-12-20 08:55:25 +00:00
|
|
|
{"duration", required_argument, 0, 'd'},
|
2021-12-30 03:54:43 +00:00
|
|
|
{"clock", required_argument, 0, 'w'},
|
2019-12-20 08:55:27 +00:00
|
|
|
{"batch-size", required_argument, 0, 'b'},
|
2019-12-20 08:55:28 +00:00
|
|
|
{"tx-pkt-count", required_argument, 0, 'C'},
|
2019-12-20 08:55:29 +00:00
|
|
|
{"tx-pkt-size", required_argument, 0, 's'},
|
2019-12-20 08:55:30 +00:00
|
|
|
{"tx-pkt-pattern", required_argument, 0, 'P'},
|
2021-12-30 03:54:41 +00:00
|
|
|
{"tx-vlan", no_argument, 0, 'V'},
|
|
|
|
{"tx-vlan-id", required_argument, 0, 'J'},
|
|
|
|
{"tx-vlan-pri", required_argument, 0, 'K'},
|
2021-12-30 03:54:42 +00:00
|
|
|
{"tx-dmac", required_argument, 0, 'G'},
|
|
|
|
{"tx-smac", required_argument, 0, 'H'},
|
2021-12-30 03:54:44 +00:00
|
|
|
{"tx-cycle", required_argument, 0, 'T'},
|
2021-12-30 03:54:47 +00:00
|
|
|
{"tstamp", no_argument, 0, 'y'},
|
2021-12-30 03:54:45 +00:00
|
|
|
{"policy", required_argument, 0, 'W'},
|
|
|
|
{"schpri", required_argument, 0, 'U'},
|
2020-07-08 07:28:34 +00:00
|
|
|
{"extra-stats", no_argument, 0, 'x'},
|
2020-09-10 08:31:06 +00:00
|
|
|
{"quiet", no_argument, 0, 'Q'},
|
2020-10-02 13:36:11 +00:00
|
|
|
{"app-stats", no_argument, 0, 'a'},
|
2020-10-02 13:36:12 +00:00
|
|
|
{"irq-string", no_argument, 0, 'I'},
|
2020-11-30 18:52:04 +00:00
|
|
|
{"busy-poll", no_argument, 0, 'B'},
|
2020-12-03 09:05:46 +00:00
|
|
|
{"reduce-cap", no_argument, 0, 'R'},
|
2018-05-02 11:01:36 +00:00
|
|
|
{0, 0, 0, 0}
|
|
|
|
};
|
|
|
|
|
|
|
|
static void usage(const char *prog)
|
|
|
|
{
|
|
|
|
const char *str =
|
|
|
|
" Usage: %s [OPTIONS]\n"
|
|
|
|
" Options:\n"
|
|
|
|
" -r, --rxdrop Discard all incoming packets (default)\n"
|
|
|
|
" -t, --txonly Only send packets\n"
|
|
|
|
" -l, --l2fwd MAC swap L2 forwarding\n"
|
|
|
|
" -i, --interface=n Run on interface n\n"
|
|
|
|
" -q, --queue=n Use queue n (default 0)\n"
|
|
|
|
" -p, --poll Use poll syscall\n"
|
|
|
|
" -S, --xdp-skb=n Use XDP skb-mod\n"
|
2019-10-07 08:26:36 +00:00
|
|
|
" -N, --xdp-native=n Enforce XDP native mode\n"
|
2018-05-02 11:01:36 +00:00
|
|
|
" -n, --interval=n Specify statistics update interval (default 1 sec).\n"
|
2021-12-30 03:54:46 +00:00
|
|
|
" -O, --retries=n Specify time-out retries (1s interval) attempt (default 3).\n"
|
2018-08-28 12:44:35 +00:00
|
|
|
" -z, --zero-copy Force zero-copy mode.\n"
|
|
|
|
" -c, --copy Force copy mode.\n"
|
2019-08-14 07:27:21 +00:00
|
|
|
" -m, --no-need-wakeup Turn off use of driver need wakeup flag.\n"
|
2019-08-27 02:25:28 +00:00
|
|
|
" -f, --frame-size=n Set the frame size (must be a power of two in aligned mode, default is %d).\n"
|
|
|
|
" -u, --unaligned Enable unaligned chunk placement\n"
|
2020-12-03 09:05:46 +00:00
|
|
|
" -M, --shared-umem Enable XDP_SHARED_UMEM (cannot be used with -R)\n"
|
2019-11-14 16:28:47 +00:00
|
|
|
" -F, --force Force loading the XDP prog\n"
|
2019-12-20 08:55:25 +00:00
|
|
|
" -d, --duration=n Duration in secs to run command.\n"
|
|
|
|
" Default: forever.\n"
|
2021-12-30 03:54:43 +00:00
|
|
|
" -w, --clock=CLOCK Clock NAME (default MONOTONIC).\n"
|
2019-12-20 08:55:27 +00:00
|
|
|
" -b, --batch-size=n Batch size for sending or receiving\n"
|
|
|
|
" packets. Default: %d\n"
|
2019-12-20 08:55:28 +00:00
|
|
|
" -C, --tx-pkt-count=n Number of packets to send.\n"
|
|
|
|
" Default: Continuous packets.\n"
|
2019-12-20 08:55:29 +00:00
|
|
|
" -s, --tx-pkt-size=n Transmit packet size.\n"
|
|
|
|
" (Default: %d bytes)\n"
|
|
|
|
" Min size: %d, Max size %d.\n"
|
2019-12-20 08:55:30 +00:00
|
|
|
" -P, --tx-pkt-pattern=nPacket fill pattern. Default: 0x%x\n"
|
2021-12-30 03:54:41 +00:00
|
|
|
" -V, --tx-vlan Send VLAN tagged packets (For -t|--txonly)\n"
|
|
|
|
" -J, --tx-vlan-id=n Tx VLAN ID [1-4095]. Default: %d (For -V|--tx-vlan)\n"
|
|
|
|
" -K, --tx-vlan-pri=n Tx VLAN Priority [0-7]. Default: %d (For -V|--tx-vlan)\n"
|
2021-12-30 03:54:42 +00:00
|
|
|
" -G, --tx-dmac=<MAC> Dest MAC addr of TX frame in aa:bb:cc:dd:ee:ff format (For -V|--tx-vlan)\n"
|
|
|
|
" -H, --tx-smac=<MAC> Src MAC addr of TX frame in aa:bb:cc:dd:ee:ff format (For -V|--tx-vlan)\n"
|
2021-12-30 03:54:44 +00:00
|
|
|
" -T, --tx-cycle=n Tx cycle time in micro-seconds (For -t|--txonly).\n"
|
2021-12-30 03:54:47 +00:00
|
|
|
" -y, --tstamp Add time-stamp to packet (For -t|--txonly).\n"
|
2021-12-30 03:54:45 +00:00
|
|
|
" -W, --policy=POLICY Schedule policy. Default: SCHED_OTHER\n"
|
|
|
|
" -U, --schpri=n Schedule priority. Default: %d\n"
|
2020-07-08 07:28:34 +00:00
|
|
|
" -x, --extra-stats Display extra statistics.\n"
|
2020-09-10 08:31:06 +00:00
|
|
|
" -Q, --quiet Do not display any stats.\n"
|
2020-10-02 13:36:11 +00:00
|
|
|
" -a, --app-stats Display application (syscall) statistics.\n"
|
2020-10-02 13:36:12 +00:00
|
|
|
" -I, --irq-string Display driver interrupt statistics for interface associated with irq-string.\n"
|
2020-11-30 18:52:04 +00:00
|
|
|
" -B, --busy-poll Busy poll.\n"
|
2020-12-03 09:05:46 +00:00
|
|
|
" -R, --reduce-cap Use reduced capabilities (cannot be used with -M)\n"
|
2018-05-02 11:01:36 +00:00
|
|
|
"\n";
|
2019-12-20 08:55:27 +00:00
|
|
|
fprintf(stderr, str, prog, XSK_UMEM__DEFAULT_FRAME_SIZE,
|
2019-12-20 08:55:29 +00:00
|
|
|
opt_batch_size, MIN_PKT_SIZE, MIN_PKT_SIZE,
|
2021-12-30 03:54:41 +00:00
|
|
|
XSK_UMEM__DEFAULT_FRAME_SIZE, opt_pkt_fill_pattern,
|
2021-12-30 03:54:45 +00:00
|
|
|
VLAN_VID__DEFAULT, VLAN_PRI__DEFAULT,
|
|
|
|
SCHED_PRI__DEFAULT);
|
2019-12-20 08:55:29 +00:00
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_command_line(int argc, char **argv)
|
|
|
|
{
|
|
|
|
int option_index, c;
|
|
|
|
|
|
|
|
opterr = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
2021-12-30 03:54:45 +00:00
|
|
|
c = getopt_long(argc, argv,
|
2021-12-30 03:54:47 +00:00
|
|
|
"Frtli:q:pSNn:w:O:czf:muMd:b:C:s:P:VJ:K:G:H:T:yW:U:xQaI:BR",
|
2019-08-14 07:27:21 +00:00
|
|
|
long_options, &option_index);
|
2018-05-02 11:01:36 +00:00
|
|
|
if (c == -1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (c) {
|
|
|
|
case 'r':
|
|
|
|
opt_bench = BENCH_RXDROP;
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
opt_bench = BENCH_TXONLY;
|
|
|
|
break;
|
|
|
|
case 'l':
|
|
|
|
opt_bench = BENCH_L2FWD;
|
|
|
|
break;
|
|
|
|
case 'i':
|
|
|
|
opt_if = optarg;
|
|
|
|
break;
|
|
|
|
case 'q':
|
|
|
|
opt_queue = atoi(optarg);
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
opt_poll = 1;
|
|
|
|
break;
|
|
|
|
case 'S':
|
|
|
|
opt_xdp_flags |= XDP_FLAGS_SKB_MODE;
|
2018-06-04 12:06:01 +00:00
|
|
|
opt_xdp_bind_flags |= XDP_COPY;
|
2018-05-02 11:01:36 +00:00
|
|
|
break;
|
|
|
|
case 'N':
|
samples/bpf: Attach XDP programs in driver mode by default
When attaching XDP programs, userspace can set flags to request the attach
mode (generic/SKB mode, driver mode or hw offloaded mode). If no such flags
are requested, the kernel will attempt to attach in driver mode, and then
silently fall back to SKB mode if this fails.
The silent fallback is a major source of user confusion, as users will try
to load a program on a device without XDP support, and instead of an error
they will get the silent fallback behaviour, not notice, and then wonder
why performance is not what they were expecting.
In an attempt to combat this, let's switch all the samples to default to
explicitly requesting driver-mode attach. As part of this, ensure that all
the userspace utilities have a switch to enable SKB mode. For those that
have a switch to request driver mode, keep it but turn it into a no-op.
Signed-off-by: Toke Høiland-Jørgensen <toke@redhat.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Jesper Dangaard Brouer <brouer@redhat.com>
Acked-by: David Ahern <dsahern@gmail.com>
Link: https://lore.kernel.org/bpf/20191216110742.364456-1-toke@redhat.com
2019-12-16 11:07:42 +00:00
|
|
|
/* default, set below */
|
2018-05-02 11:01:36 +00:00
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
opt_interval = atoi(optarg);
|
|
|
|
break;
|
2021-12-30 03:54:43 +00:00
|
|
|
case 'w':
|
|
|
|
if (get_clockid(&opt_clock, optarg)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"ERROR: Invalid clock %s. Default to CLOCK_MONOTONIC.\n",
|
|
|
|
optarg);
|
|
|
|
opt_clock = CLOCK_MONOTONIC;
|
|
|
|
}
|
|
|
|
break;
|
2021-12-30 03:54:46 +00:00
|
|
|
case 'O':
|
|
|
|
opt_retries = atoi(optarg);
|
|
|
|
break;
|
2018-08-28 12:44:35 +00:00
|
|
|
case 'z':
|
|
|
|
opt_xdp_bind_flags |= XDP_ZEROCOPY;
|
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
opt_xdp_bind_flags |= XDP_COPY;
|
|
|
|
break;
|
2019-08-27 02:25:28 +00:00
|
|
|
case 'u':
|
|
|
|
opt_umem_flags |= XDP_UMEM_UNALIGNED_CHUNK_FLAG;
|
|
|
|
opt_unaligned_chunks = 1;
|
2019-08-27 02:25:30 +00:00
|
|
|
opt_mmap_flags = MAP_HUGETLB;
|
2019-08-27 02:25:28 +00:00
|
|
|
break;
|
2019-02-01 21:42:28 +00:00
|
|
|
case 'F':
|
|
|
|
opt_xdp_flags &= ~XDP_FLAGS_UPDATE_IF_NOEXIST;
|
|
|
|
break;
|
2019-06-26 14:35:27 +00:00
|
|
|
case 'f':
|
|
|
|
opt_xsk_frame_size = atoi(optarg);
|
2019-11-07 17:47:37 +00:00
|
|
|
break;
|
2019-08-14 07:27:21 +00:00
|
|
|
case 'm':
|
|
|
|
opt_need_wakeup = false;
|
|
|
|
opt_xdp_bind_flags &= ~XDP_USE_NEED_WAKEUP;
|
2019-06-26 14:35:27 +00:00
|
|
|
break;
|
2019-11-07 17:47:37 +00:00
|
|
|
case 'M':
|
|
|
|
opt_num_xsks = MAX_SOCKS;
|
|
|
|
break;
|
2019-12-20 08:55:25 +00:00
|
|
|
case 'd':
|
|
|
|
opt_duration = atoi(optarg);
|
|
|
|
opt_duration *= 1000000000;
|
|
|
|
break;
|
2019-12-20 08:55:27 +00:00
|
|
|
case 'b':
|
|
|
|
opt_batch_size = atoi(optarg);
|
|
|
|
break;
|
2019-12-20 08:55:28 +00:00
|
|
|
case 'C':
|
|
|
|
opt_pkt_count = atoi(optarg);
|
|
|
|
break;
|
2019-12-20 08:55:29 +00:00
|
|
|
case 's':
|
|
|
|
opt_pkt_size = atoi(optarg);
|
|
|
|
if (opt_pkt_size > (XSK_UMEM__DEFAULT_FRAME_SIZE) ||
|
|
|
|
opt_pkt_size < MIN_PKT_SIZE) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"ERROR: Invalid frame size %d\n",
|
|
|
|
opt_pkt_size);
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
|
|
|
break;
|
2019-12-20 08:55:30 +00:00
|
|
|
case 'P':
|
|
|
|
opt_pkt_fill_pattern = strtol(optarg, NULL, 16);
|
|
|
|
break;
|
2021-12-30 03:54:41 +00:00
|
|
|
case 'V':
|
|
|
|
opt_vlan_tag = true;
|
|
|
|
break;
|
|
|
|
case 'J':
|
|
|
|
opt_pkt_vlan_id = atoi(optarg);
|
|
|
|
break;
|
|
|
|
case 'K':
|
|
|
|
opt_pkt_vlan_pri = atoi(optarg);
|
|
|
|
break;
|
2021-12-30 03:54:42 +00:00
|
|
|
case 'G':
|
|
|
|
if (!ether_aton_r(optarg,
|
|
|
|
(struct ether_addr *)&opt_txdmac)) {
|
|
|
|
fprintf(stderr, "Invalid dmac address:%s\n",
|
|
|
|
optarg);
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'H':
|
|
|
|
if (!ether_aton_r(optarg,
|
|
|
|
(struct ether_addr *)&opt_txsmac)) {
|
|
|
|
fprintf(stderr, "Invalid smac address:%s\n",
|
|
|
|
optarg);
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
|
|
|
break;
|
2021-12-30 03:54:44 +00:00
|
|
|
case 'T':
|
|
|
|
opt_tx_cycle_ns = atoi(optarg);
|
|
|
|
opt_tx_cycle_ns *= NSEC_PER_USEC;
|
|
|
|
break;
|
2021-12-30 03:54:47 +00:00
|
|
|
case 'y':
|
|
|
|
opt_tstamp = 1;
|
|
|
|
break;
|
2021-12-30 03:54:45 +00:00
|
|
|
case 'W':
|
|
|
|
if (get_schpolicy(&opt_schpolicy, optarg)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"ERROR: Invalid policy %s. Default to SCHED_OTHER.\n",
|
|
|
|
optarg);
|
|
|
|
opt_schpolicy = SCHED_OTHER;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'U':
|
|
|
|
opt_schprio = atoi(optarg);
|
|
|
|
break;
|
2020-07-08 07:28:34 +00:00
|
|
|
case 'x':
|
|
|
|
opt_extra_stats = 1;
|
|
|
|
break;
|
2020-09-10 08:31:06 +00:00
|
|
|
case 'Q':
|
|
|
|
opt_quiet = 1;
|
|
|
|
break;
|
2020-10-02 13:36:11 +00:00
|
|
|
case 'a':
|
|
|
|
opt_app_stats = 1;
|
2020-10-02 13:36:12 +00:00
|
|
|
break;
|
|
|
|
case 'I':
|
|
|
|
opt_irq_str = optarg;
|
|
|
|
if (get_interrupt_number())
|
|
|
|
irqs_at_init = get_irqs();
|
|
|
|
if (irqs_at_init < 0) {
|
|
|
|
fprintf(stderr, "ERROR: Failed to get irqs for %s\n", opt_irq_str);
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
2020-11-30 18:52:04 +00:00
|
|
|
break;
|
|
|
|
case 'B':
|
|
|
|
opt_busy_poll = 1;
|
2020-10-02 13:36:11 +00:00
|
|
|
break;
|
2020-12-03 09:05:46 +00:00
|
|
|
case 'R':
|
|
|
|
opt_reduced_cap = true;
|
|
|
|
break;
|
2018-05-02 11:01:36 +00:00
|
|
|
default:
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
samples/bpf: Attach XDP programs in driver mode by default
When attaching XDP programs, userspace can set flags to request the attach
mode (generic/SKB mode, driver mode or hw offloaded mode). If no such flags
are requested, the kernel will attempt to attach in driver mode, and then
silently fall back to SKB mode if this fails.
The silent fallback is a major source of user confusion, as users will try
to load a program on a device without XDP support, and instead of an error
they will get the silent fallback behaviour, not notice, and then wonder
why performance is not what they were expecting.
In an attempt to combat this, let's switch all the samples to default to
explicitly requesting driver-mode attach. As part of this, ensure that all
the userspace utilities have a switch to enable SKB mode. For those that
have a switch to request driver mode, keep it but turn it into a no-op.
Signed-off-by: Toke Høiland-Jørgensen <toke@redhat.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Jesper Dangaard Brouer <brouer@redhat.com>
Acked-by: David Ahern <dsahern@gmail.com>
Link: https://lore.kernel.org/bpf/20191216110742.364456-1-toke@redhat.com
2019-12-16 11:07:42 +00:00
|
|
|
if (!(opt_xdp_flags & XDP_FLAGS_SKB_MODE))
|
|
|
|
opt_xdp_flags |= XDP_FLAGS_DRV_MODE;
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
opt_ifindex = if_nametoindex(opt_if);
|
|
|
|
if (!opt_ifindex) {
|
|
|
|
fprintf(stderr, "ERROR: interface \"%s\" does not exist\n",
|
|
|
|
opt_if);
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
2019-02-21 09:21:27 +00:00
|
|
|
|
2019-08-27 02:25:28 +00:00
|
|
|
if ((opt_xsk_frame_size & (opt_xsk_frame_size - 1)) &&
|
|
|
|
!opt_unaligned_chunks) {
|
2019-06-26 14:35:27 +00:00
|
|
|
fprintf(stderr, "--frame-size=%d is not a power of two\n",
|
|
|
|
opt_xsk_frame_size);
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
2020-12-03 09:05:46 +00:00
|
|
|
|
|
|
|
if (opt_reduced_cap && opt_num_xsks > 1) {
|
|
|
|
fprintf(stderr, "ERROR: -M and -R cannot be used together\n");
|
|
|
|
usage(basename(argv[0]));
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
static void kick_tx(struct xsk_socket_info *xsk)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
ret = sendto(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, 0);
|
2020-02-05 04:58:34 +00:00
|
|
|
if (ret >= 0 || errno == ENOBUFS || errno == EAGAIN ||
|
|
|
|
errno == EBUSY || errno == ENETDOWN)
|
2018-05-02 11:01:36 +00:00
|
|
|
return;
|
2019-02-21 09:21:27 +00:00
|
|
|
exit_with_error(errno);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2020-11-30 18:52:03 +00:00
|
|
|
static inline void complete_tx_l2fwd(struct xsk_socket_info *xsk)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-08-27 02:25:29 +00:00
|
|
|
struct xsk_umem_info *umem = xsk->umem;
|
2019-03-01 06:19:41 +00:00
|
|
|
u32 idx_cq = 0, idx_fq = 0;
|
2018-05-02 11:01:36 +00:00
|
|
|
unsigned int rcvd;
|
|
|
|
size_t ndescs;
|
|
|
|
|
|
|
|
if (!xsk->outstanding_tx)
|
|
|
|
return;
|
|
|
|
|
2020-09-10 08:31:04 +00:00
|
|
|
/* In copy mode, Tx is driven by a syscall so we need to use e.g. sendto() to
|
|
|
|
* really send the packets. In zero-copy mode we do not have to do this, since Tx
|
|
|
|
* is driven by the NAPI loop. So as an optimization, we do not have to call
|
|
|
|
* sendto() all the time in zero-copy mode for l2fwd.
|
|
|
|
*/
|
2020-10-02 13:36:11 +00:00
|
|
|
if (opt_xdp_bind_flags & XDP_COPY) {
|
|
|
|
xsk->app_stats.copy_tx_sendtos++;
|
2020-09-10 08:31:04 +00:00
|
|
|
kick_tx(xsk);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2020-09-10 08:31:04 +00:00
|
|
|
|
2019-12-20 08:55:27 +00:00
|
|
|
ndescs = (xsk->outstanding_tx > opt_batch_size) ? opt_batch_size :
|
2019-02-21 09:21:27 +00:00
|
|
|
xsk->outstanding_tx;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
/* re-add completed Tx buffers */
|
2019-08-27 02:25:29 +00:00
|
|
|
rcvd = xsk_ring_cons__peek(&umem->cq, ndescs, &idx_cq);
|
2018-05-02 11:01:36 +00:00
|
|
|
if (rcvd > 0) {
|
2019-02-21 09:21:27 +00:00
|
|
|
unsigned int i;
|
|
|
|
int ret;
|
|
|
|
|
2019-08-27 02:25:29 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&umem->fq, rcvd, &idx_fq);
|
2019-02-21 09:21:27 +00:00
|
|
|
while (ret != rcvd) {
|
|
|
|
if (ret < 0)
|
|
|
|
exit_with_error(-ret);
|
2020-11-30 18:52:04 +00:00
|
|
|
if (opt_busy_poll || xsk_ring_prod__needs_wakeup(&umem->fq)) {
|
2020-10-02 13:36:11 +00:00
|
|
|
xsk->app_stats.fill_fail_polls++;
|
2020-11-30 18:52:03 +00:00
|
|
|
recvfrom(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL,
|
|
|
|
NULL);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2019-08-27 02:25:29 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&umem->fq, rcvd, &idx_fq);
|
2019-02-21 09:21:27 +00:00
|
|
|
}
|
2019-08-27 02:25:29 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
for (i = 0; i < rcvd; i++)
|
2019-08-27 02:25:29 +00:00
|
|
|
*xsk_ring_prod__fill_addr(&umem->fq, idx_fq++) =
|
|
|
|
*xsk_ring_cons__comp_addr(&umem->cq, idx_cq++);
|
2019-02-21 09:21:27 +00:00
|
|
|
|
|
|
|
xsk_ring_prod__submit(&xsk->umem->fq, rcvd);
|
|
|
|
xsk_ring_cons__release(&xsk->umem->cq, rcvd);
|
2018-05-02 11:01:36 +00:00
|
|
|
xsk->outstanding_tx -= rcvd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:28 +00:00
|
|
|
static inline void complete_tx_only(struct xsk_socket_info *xsk,
|
|
|
|
int batch_size)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
|
|
|
unsigned int rcvd;
|
2019-02-21 09:21:27 +00:00
|
|
|
u32 idx;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
if (!xsk->outstanding_tx)
|
|
|
|
return;
|
|
|
|
|
2020-10-02 13:36:11 +00:00
|
|
|
if (!opt_need_wakeup || xsk_ring_prod__needs_wakeup(&xsk->tx)) {
|
|
|
|
xsk->app_stats.tx_wakeup_sendtos++;
|
2019-08-14 07:27:21 +00:00
|
|
|
kick_tx(xsk);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-12-20 08:55:28 +00:00
|
|
|
rcvd = xsk_ring_cons__peek(&xsk->umem->cq, batch_size, &idx);
|
2018-05-02 11:01:36 +00:00
|
|
|
if (rcvd > 0) {
|
2019-02-21 09:21:27 +00:00
|
|
|
xsk_ring_cons__release(&xsk->umem->cq, rcvd);
|
2018-05-02 11:01:36 +00:00
|
|
|
xsk->outstanding_tx -= rcvd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-30 18:52:02 +00:00
|
|
|
static void rx_drop(struct xsk_socket_info *xsk)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
|
|
|
unsigned int rcvd, i;
|
2019-03-01 06:19:41 +00:00
|
|
|
u32 idx_rx = 0, idx_fq = 0;
|
2019-02-21 09:21:27 +00:00
|
|
|
int ret;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-12-20 08:55:27 +00:00
|
|
|
rcvd = xsk_ring_cons__peek(&xsk->rx, opt_batch_size, &idx_rx);
|
2019-08-14 07:27:21 +00:00
|
|
|
if (!rcvd) {
|
2020-11-30 18:52:04 +00:00
|
|
|
if (opt_busy_poll || xsk_ring_prod__needs_wakeup(&xsk->umem->fq)) {
|
2020-10-02 13:36:11 +00:00
|
|
|
xsk->app_stats.rx_empty_polls++;
|
2020-11-30 18:52:02 +00:00
|
|
|
recvfrom(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, NULL);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
return;
|
2019-08-14 07:27:21 +00:00
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&xsk->umem->fq, rcvd, &idx_fq);
|
|
|
|
while (ret != rcvd) {
|
|
|
|
if (ret < 0)
|
|
|
|
exit_with_error(-ret);
|
2020-11-30 18:52:04 +00:00
|
|
|
if (opt_busy_poll || xsk_ring_prod__needs_wakeup(&xsk->umem->fq)) {
|
2020-10-02 13:36:11 +00:00
|
|
|
xsk->app_stats.fill_fail_polls++;
|
2020-11-30 18:52:02 +00:00
|
|
|
recvfrom(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, NULL);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2019-02-21 09:21:27 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&xsk->umem->fq, rcvd, &idx_fq);
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
for (i = 0; i < rcvd; i++) {
|
2019-02-21 09:21:27 +00:00
|
|
|
u64 addr = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx)->addr;
|
|
|
|
u32 len = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx++)->len;
|
2019-08-27 02:25:29 +00:00
|
|
|
u64 orig = xsk_umem__extract_addr(addr);
|
|
|
|
|
|
|
|
addr = xsk_umem__add_offset_to_addr(addr);
|
2019-02-21 09:21:27 +00:00
|
|
|
char *pkt = xsk_umem__get_data(xsk->umem->buffer, addr);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
hex_dump(pkt, len, addr);
|
2019-08-27 02:25:29 +00:00
|
|
|
*xsk_ring_prod__fill_addr(&xsk->umem->fq, idx_fq++) = orig;
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
xsk_ring_prod__submit(&xsk->umem->fq, rcvd);
|
|
|
|
xsk_ring_cons__release(&xsk->rx, rcvd);
|
2020-10-02 13:36:10 +00:00
|
|
|
xsk->ring_stats.rx_npkts += rcvd;
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rx_drop_all(void)
|
|
|
|
{
|
2019-11-07 17:47:37 +00:00
|
|
|
struct pollfd fds[MAX_SOCKS] = {};
|
2019-08-14 07:27:21 +00:00
|
|
|
int i, ret;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
for (i = 0; i < num_socks; i++) {
|
2019-02-21 09:21:27 +00:00
|
|
|
fds[i].fd = xsk_socket__fd(xsks[i]->xsk);
|
2018-05-02 11:01:36 +00:00
|
|
|
fds[i].events = POLLIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
if (opt_poll) {
|
2020-10-02 13:36:11 +00:00
|
|
|
for (i = 0; i < num_socks; i++)
|
|
|
|
xsks[i]->app_stats.opt_polls++;
|
2019-08-14 07:27:21 +00:00
|
|
|
ret = poll(fds, num_socks, opt_timeout);
|
2018-05-02 11:01:36 +00:00
|
|
|
if (ret <= 0)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_socks; i++)
|
2020-11-30 18:52:02 +00:00
|
|
|
rx_drop(xsks[i]);
|
2019-12-20 08:55:25 +00:00
|
|
|
|
|
|
|
if (benchmark_done)
|
|
|
|
break;
|
2019-08-14 07:27:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-30 03:54:47 +00:00
|
|
|
static int tx_only(struct xsk_socket_info *xsk, u32 *frame_nb,
|
|
|
|
int batch_size, unsigned long tx_ns)
|
2019-08-14 07:27:21 +00:00
|
|
|
{
|
2021-12-30 03:54:47 +00:00
|
|
|
u32 idx, tv_sec, tv_usec;
|
2019-12-20 08:55:27 +00:00
|
|
|
unsigned int i;
|
2019-08-14 07:27:21 +00:00
|
|
|
|
2019-12-20 08:55:28 +00:00
|
|
|
while (xsk_ring_prod__reserve(&xsk->tx, batch_size, &idx) <
|
|
|
|
batch_size) {
|
|
|
|
complete_tx_only(xsk, batch_size);
|
2020-12-10 16:34:07 +00:00
|
|
|
if (benchmark_done)
|
2021-12-30 03:54:44 +00:00
|
|
|
return 0;
|
2019-12-20 08:55:27 +00:00
|
|
|
}
|
2019-08-14 07:27:21 +00:00
|
|
|
|
2021-12-30 03:54:47 +00:00
|
|
|
if (opt_tstamp) {
|
|
|
|
tv_sec = (u32)(tx_ns / NSEC_PER_SEC);
|
|
|
|
tv_usec = (u32)((tx_ns % NSEC_PER_SEC) / 1000);
|
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:28 +00:00
|
|
|
for (i = 0; i < batch_size; i++) {
|
2019-12-20 08:55:27 +00:00
|
|
|
struct xdp_desc *tx_desc = xsk_ring_prod__tx_desc(&xsk->tx,
|
|
|
|
idx + i);
|
2021-05-06 12:43:49 +00:00
|
|
|
tx_desc->addr = (*frame_nb + i) * opt_xsk_frame_size;
|
2019-12-20 08:55:29 +00:00
|
|
|
tx_desc->len = PKT_SIZE;
|
2021-12-30 03:54:47 +00:00
|
|
|
|
|
|
|
if (opt_tstamp) {
|
|
|
|
struct pktgen_hdr *pktgen_hdr;
|
|
|
|
u64 addr = tx_desc->addr;
|
|
|
|
char *pkt;
|
|
|
|
|
|
|
|
pkt = xsk_umem__get_data(xsk->umem->buffer, addr);
|
|
|
|
pktgen_hdr = (struct pktgen_hdr *)(pkt + PKTGEN_HDR_OFFSET);
|
|
|
|
|
|
|
|
pktgen_hdr->seq_num = htonl(sequence++);
|
|
|
|
pktgen_hdr->tv_sec = htonl(tv_sec);
|
|
|
|
pktgen_hdr->tv_usec = htonl(tv_usec);
|
|
|
|
|
|
|
|
hex_dump(pkt, PKT_SIZE, addr);
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
2019-08-14 07:27:21 +00:00
|
|
|
|
2019-12-20 08:55:28 +00:00
|
|
|
xsk_ring_prod__submit(&xsk->tx, batch_size);
|
2020-11-16 11:12:43 +00:00
|
|
|
xsk->ring_stats.tx_npkts += batch_size;
|
2019-12-20 08:55:28 +00:00
|
|
|
xsk->outstanding_tx += batch_size;
|
2020-08-28 16:17:17 +00:00
|
|
|
*frame_nb += batch_size;
|
|
|
|
*frame_nb %= NUM_FRAMES;
|
2019-12-20 08:55:28 +00:00
|
|
|
complete_tx_only(xsk, batch_size);
|
2021-12-30 03:54:44 +00:00
|
|
|
|
|
|
|
return batch_size;
|
2019-12-20 08:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_batch_size(int pkt_cnt)
|
|
|
|
{
|
|
|
|
if (!opt_pkt_count)
|
|
|
|
return opt_batch_size;
|
|
|
|
|
|
|
|
if (pkt_cnt + opt_batch_size <= opt_pkt_count)
|
|
|
|
return opt_batch_size;
|
|
|
|
|
|
|
|
return opt_pkt_count - pkt_cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void complete_tx_only_all(void)
|
|
|
|
{
|
|
|
|
bool pending;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
do {
|
|
|
|
pending = false;
|
|
|
|
for (i = 0; i < num_socks; i++) {
|
|
|
|
if (xsks[i]->outstanding_tx) {
|
|
|
|
complete_tx_only(xsks[i], opt_batch_size);
|
|
|
|
pending = !!xsks[i]->outstanding_tx;
|
|
|
|
}
|
|
|
|
}
|
2021-12-30 03:54:46 +00:00
|
|
|
sleep(1);
|
|
|
|
} while (pending && opt_retries-- > 0);
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
static void tx_only_all(void)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-11-07 17:47:37 +00:00
|
|
|
struct pollfd fds[MAX_SOCKS] = {};
|
2019-08-14 07:27:21 +00:00
|
|
|
u32 frame_nb[MAX_SOCKS] = {};
|
2021-12-30 03:54:44 +00:00
|
|
|
unsigned long next_tx_ns = 0;
|
2019-12-20 08:55:28 +00:00
|
|
|
int pkt_cnt = 0;
|
2019-08-14 07:27:21 +00:00
|
|
|
int i, ret;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-30 03:54:44 +00:00
|
|
|
if (opt_poll && opt_tx_cycle_ns) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"Error: --poll and --tx-cycles are both set\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
for (i = 0; i < num_socks; i++) {
|
|
|
|
fds[0].fd = xsk_socket__fd(xsks[i]->xsk);
|
|
|
|
fds[0].events = POLLOUT;
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-30 03:54:44 +00:00
|
|
|
if (opt_tx_cycle_ns) {
|
|
|
|
/* Align Tx time to micro-second boundary */
|
|
|
|
next_tx_ns = (get_nsecs() / NSEC_PER_USEC + 1) *
|
|
|
|
NSEC_PER_USEC;
|
|
|
|
next_tx_ns += opt_tx_cycle_ns;
|
|
|
|
|
|
|
|
/* Initialize periodic Tx scheduling variance */
|
|
|
|
tx_cycle_diff_min = 1000000000;
|
|
|
|
tx_cycle_diff_max = 0;
|
|
|
|
tx_cycle_diff_ave = 0.0;
|
|
|
|
}
|
|
|
|
|
2019-12-20 08:55:28 +00:00
|
|
|
while ((opt_pkt_count && pkt_cnt < opt_pkt_count) || !opt_pkt_count) {
|
|
|
|
int batch_size = get_batch_size(pkt_cnt);
|
2021-12-30 03:54:47 +00:00
|
|
|
unsigned long tx_ns = 0;
|
2021-12-30 03:54:44 +00:00
|
|
|
struct timespec next;
|
|
|
|
int tx_cnt = 0;
|
|
|
|
long diff;
|
|
|
|
int err;
|
2019-12-20 08:55:28 +00:00
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
if (opt_poll) {
|
2020-10-02 13:36:11 +00:00
|
|
|
for (i = 0; i < num_socks; i++)
|
|
|
|
xsks[i]->app_stats.opt_polls++;
|
2019-08-14 07:27:21 +00:00
|
|
|
ret = poll(fds, num_socks, opt_timeout);
|
2018-05-02 11:01:36 +00:00
|
|
|
if (ret <= 0)
|
|
|
|
continue;
|
|
|
|
|
2019-02-21 09:21:27 +00:00
|
|
|
if (!(fds[0].revents & POLLOUT))
|
2018-05-02 11:01:36 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-12-30 03:54:44 +00:00
|
|
|
if (opt_tx_cycle_ns) {
|
|
|
|
next.tv_sec = next_tx_ns / NSEC_PER_SEC;
|
|
|
|
next.tv_nsec = next_tx_ns % NSEC_PER_SEC;
|
|
|
|
err = clock_nanosleep(opt_clock, TIMER_ABSTIME, &next, NULL);
|
|
|
|
if (err) {
|
|
|
|
if (err != EINTR)
|
|
|
|
fprintf(stderr,
|
|
|
|
"clock_nanosleep failed. Err:%d errno:%d\n",
|
|
|
|
err, errno);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Measure periodic Tx scheduling variance */
|
2021-12-30 03:54:47 +00:00
|
|
|
tx_ns = get_nsecs();
|
|
|
|
diff = tx_ns - next_tx_ns;
|
2021-12-30 03:54:44 +00:00
|
|
|
if (diff < tx_cycle_diff_min)
|
|
|
|
tx_cycle_diff_min = diff;
|
|
|
|
|
|
|
|
if (diff > tx_cycle_diff_max)
|
|
|
|
tx_cycle_diff_max = diff;
|
|
|
|
|
|
|
|
tx_cycle_diff_ave += (double)diff;
|
|
|
|
tx_cycle_cnt++;
|
2021-12-30 03:54:47 +00:00
|
|
|
} else if (opt_tstamp) {
|
|
|
|
tx_ns = get_nsecs();
|
2021-12-30 03:54:44 +00:00
|
|
|
}
|
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
for (i = 0; i < num_socks; i++)
|
2021-12-30 03:54:47 +00:00
|
|
|
tx_cnt += tx_only(xsks[i], &frame_nb[i], batch_size, tx_ns);
|
2019-12-20 08:55:28 +00:00
|
|
|
|
2021-12-30 03:54:44 +00:00
|
|
|
pkt_cnt += tx_cnt;
|
2019-12-20 08:55:25 +00:00
|
|
|
|
|
|
|
if (benchmark_done)
|
|
|
|
break;
|
2021-12-30 03:54:44 +00:00
|
|
|
|
|
|
|
if (opt_tx_cycle_ns)
|
|
|
|
next_tx_ns += opt_tx_cycle_ns;
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
2019-12-20 08:55:28 +00:00
|
|
|
|
|
|
|
if (opt_pkt_count)
|
|
|
|
complete_tx_only_all();
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
|
2020-11-30 18:52:03 +00:00
|
|
|
static void l2fwd(struct xsk_socket_info *xsk)
|
2018-05-02 11:01:36 +00:00
|
|
|
{
|
2019-08-14 07:27:21 +00:00
|
|
|
unsigned int rcvd, i;
|
|
|
|
u32 idx_rx = 0, idx_tx = 0;
|
|
|
|
int ret;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-11-30 18:52:03 +00:00
|
|
|
complete_tx_l2fwd(xsk);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-12-20 08:55:27 +00:00
|
|
|
rcvd = xsk_ring_cons__peek(&xsk->rx, opt_batch_size, &idx_rx);
|
2019-08-14 07:27:21 +00:00
|
|
|
if (!rcvd) {
|
2020-11-30 18:52:04 +00:00
|
|
|
if (opt_busy_poll || xsk_ring_prod__needs_wakeup(&xsk->umem->fq)) {
|
2020-10-02 13:36:11 +00:00
|
|
|
xsk->app_stats.rx_empty_polls++;
|
2020-11-30 18:52:03 +00:00
|
|
|
recvfrom(xsk_socket__fd(xsk->xsk), NULL, 0, MSG_DONTWAIT, NULL, NULL);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2019-08-14 07:27:21 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-11-16 11:12:43 +00:00
|
|
|
xsk->ring_stats.rx_npkts += rcvd;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&xsk->tx, rcvd, &idx_tx);
|
|
|
|
while (ret != rcvd) {
|
|
|
|
if (ret < 0)
|
|
|
|
exit_with_error(-ret);
|
2020-11-30 18:52:03 +00:00
|
|
|
complete_tx_l2fwd(xsk);
|
2020-11-30 18:52:04 +00:00
|
|
|
if (opt_busy_poll || xsk_ring_prod__needs_wakeup(&xsk->tx)) {
|
2020-10-02 13:36:11 +00:00
|
|
|
xsk->app_stats.tx_wakeup_sendtos++;
|
2019-08-14 07:27:21 +00:00
|
|
|
kick_tx(xsk);
|
2020-10-02 13:36:11 +00:00
|
|
|
}
|
2019-02-21 09:21:27 +00:00
|
|
|
ret = xsk_ring_prod__reserve(&xsk->tx, rcvd, &idx_tx);
|
2019-08-14 07:27:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < rcvd; i++) {
|
|
|
|
u64 addr = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx)->addr;
|
|
|
|
u32 len = xsk_ring_cons__rx_desc(&xsk->rx, idx_rx++)->len;
|
2019-09-13 10:39:48 +00:00
|
|
|
u64 orig = addr;
|
2019-08-27 02:25:29 +00:00
|
|
|
|
|
|
|
addr = xsk_umem__add_offset_to_addr(addr);
|
2019-08-14 07:27:21 +00:00
|
|
|
char *pkt = xsk_umem__get_data(xsk->umem->buffer, addr);
|
|
|
|
|
|
|
|
swap_mac_addresses(pkt);
|
2019-02-21 09:21:27 +00:00
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
hex_dump(pkt, len, addr);
|
2019-08-27 02:25:29 +00:00
|
|
|
xsk_ring_prod__tx_desc(&xsk->tx, idx_tx)->addr = orig;
|
2019-08-14 07:27:21 +00:00
|
|
|
xsk_ring_prod__tx_desc(&xsk->tx, idx_tx++)->len = len;
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
xsk_ring_prod__submit(&xsk->tx, rcvd);
|
|
|
|
xsk_ring_cons__release(&xsk->rx, rcvd);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-11-16 11:12:43 +00:00
|
|
|
xsk->ring_stats.tx_npkts += rcvd;
|
2019-08-14 07:27:21 +00:00
|
|
|
xsk->outstanding_tx += rcvd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void l2fwd_all(void)
|
|
|
|
{
|
2019-11-07 17:47:37 +00:00
|
|
|
struct pollfd fds[MAX_SOCKS] = {};
|
2019-08-14 07:27:21 +00:00
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
if (opt_poll) {
|
2020-11-30 18:52:03 +00:00
|
|
|
for (i = 0; i < num_socks; i++) {
|
|
|
|
fds[i].fd = xsk_socket__fd(xsks[i]->xsk);
|
|
|
|
fds[i].events = POLLOUT | POLLIN;
|
2020-10-02 13:36:11 +00:00
|
|
|
xsks[i]->app_stats.opt_polls++;
|
2020-11-30 18:52:03 +00:00
|
|
|
}
|
2019-08-14 07:27:21 +00:00
|
|
|
ret = poll(fds, num_socks, opt_timeout);
|
|
|
|
if (ret <= 0)
|
|
|
|
continue;
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-08-14 07:27:21 +00:00
|
|
|
for (i = 0; i < num_socks; i++)
|
2020-11-30 18:52:03 +00:00
|
|
|
l2fwd(xsks[i]);
|
2019-12-20 08:55:25 +00:00
|
|
|
|
|
|
|
if (benchmark_done)
|
|
|
|
break;
|
2018-05-02 11:01:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-07 17:47:37 +00:00
|
|
|
static void load_xdp_program(char **argv, struct bpf_object **obj)
|
|
|
|
{
|
|
|
|
struct bpf_prog_load_attr prog_load_attr = {
|
|
|
|
.prog_type = BPF_PROG_TYPE_XDP,
|
|
|
|
};
|
|
|
|
char xdp_filename[256];
|
|
|
|
int prog_fd;
|
|
|
|
|
|
|
|
snprintf(xdp_filename, sizeof(xdp_filename), "%s_kern.o", argv[0]);
|
|
|
|
prog_load_attr.file = xdp_filename;
|
|
|
|
|
|
|
|
if (bpf_prog_load_xattr(&prog_load_attr, obj, &prog_fd))
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
if (prog_fd < 0) {
|
|
|
|
fprintf(stderr, "ERROR: no program found: %s\n",
|
|
|
|
strerror(prog_fd));
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2022-01-20 06:14:22 +00:00
|
|
|
if (bpf_xdp_attach(opt_ifindex, prog_fd, opt_xdp_flags, NULL) < 0) {
|
2019-11-07 17:47:37 +00:00
|
|
|
fprintf(stderr, "ERROR: link set xdp fd failed\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void enter_xsks_into_map(struct bpf_object *obj)
|
|
|
|
{
|
|
|
|
struct bpf_map *map;
|
|
|
|
int i, xsks_map;
|
|
|
|
|
|
|
|
map = bpf_object__find_map_by_name(obj, "xsks_map");
|
|
|
|
xsks_map = bpf_map__fd(map);
|
|
|
|
if (xsks_map < 0) {
|
|
|
|
fprintf(stderr, "ERROR: no xsks map found: %s\n",
|
|
|
|
strerror(xsks_map));
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < num_socks; i++) {
|
|
|
|
int fd = xsk_socket__fd(xsks[i]->xsk);
|
|
|
|
int key, ret;
|
|
|
|
|
|
|
|
key = i;
|
|
|
|
ret = bpf_map_update_elem(xsks_map, &key, &fd, 0);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "ERROR: bpf_map_update_elem %d\n", i);
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-30 18:52:04 +00:00
|
|
|
static void apply_setsockopt(struct xsk_socket_info *xsk)
|
|
|
|
{
|
|
|
|
int sock_opt;
|
|
|
|
|
|
|
|
if (!opt_busy_poll)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sock_opt = 1;
|
|
|
|
if (setsockopt(xsk_socket__fd(xsk->xsk), SOL_SOCKET, SO_PREFER_BUSY_POLL,
|
|
|
|
(void *)&sock_opt, sizeof(sock_opt)) < 0)
|
|
|
|
exit_with_error(errno);
|
|
|
|
|
|
|
|
sock_opt = 20;
|
|
|
|
if (setsockopt(xsk_socket__fd(xsk->xsk), SOL_SOCKET, SO_BUSY_POLL,
|
|
|
|
(void *)&sock_opt, sizeof(sock_opt)) < 0)
|
|
|
|
exit_with_error(errno);
|
2020-11-30 18:52:05 +00:00
|
|
|
|
|
|
|
sock_opt = opt_batch_size;
|
|
|
|
if (setsockopt(xsk_socket__fd(xsk->xsk), SOL_SOCKET, SO_BUSY_POLL_BUDGET,
|
|
|
|
(void *)&sock_opt, sizeof(sock_opt)) < 0)
|
|
|
|
exit_with_error(errno);
|
2020-11-30 18:52:04 +00:00
|
|
|
}
|
|
|
|
|
2020-12-03 09:05:46 +00:00
|
|
|
static int recv_xsks_map_fd_from_ctrl_node(int sock, int *_fd)
|
|
|
|
{
|
|
|
|
char cms[CMSG_SPACE(sizeof(int))];
|
|
|
|
struct cmsghdr *cmsg;
|
|
|
|
struct msghdr msg;
|
|
|
|
struct iovec iov;
|
|
|
|
int value;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
iov.iov_base = &value;
|
|
|
|
iov.iov_len = sizeof(int);
|
|
|
|
|
|
|
|
msg.msg_name = 0;
|
|
|
|
msg.msg_namelen = 0;
|
|
|
|
msg.msg_iov = &iov;
|
|
|
|
msg.msg_iovlen = 1;
|
|
|
|
msg.msg_flags = 0;
|
|
|
|
msg.msg_control = (caddr_t)cms;
|
|
|
|
msg.msg_controllen = sizeof(cms);
|
|
|
|
|
|
|
|
len = recvmsg(sock, &msg, 0);
|
|
|
|
|
|
|
|
if (len < 0) {
|
|
|
|
fprintf(stderr, "Recvmsg failed length incorrect.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
fprintf(stderr, "Recvmsg failed no data\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmsg = CMSG_FIRSTHDR(&msg);
|
|
|
|
*_fd = *(int *)CMSG_DATA(cmsg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
recv_xsks_map_fd(int *xsks_map_fd)
|
|
|
|
{
|
|
|
|
struct sockaddr_un server;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
sock = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
|
|
if (sock < 0) {
|
|
|
|
fprintf(stderr, "Error opening socket stream: %s", strerror(errno));
|
|
|
|
return errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
server.sun_family = AF_UNIX;
|
|
|
|
strcpy(server.sun_path, SOCKET_NAME);
|
|
|
|
|
|
|
|
if (connect(sock, (struct sockaddr *)&server, sizeof(struct sockaddr_un)) < 0) {
|
|
|
|
close(sock);
|
|
|
|
fprintf(stderr, "Error connecting stream socket: %s", strerror(errno));
|
|
|
|
return errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = recv_xsks_map_fd_from_ctrl_node(sock, xsks_map_fd);
|
|
|
|
if (err) {
|
2020-12-03 11:44:52 +00:00
|
|
|
fprintf(stderr, "Error %d receiving fd\n", err);
|
2020-12-03 09:05:46 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2020-12-03 09:05:46 +00:00
|
|
|
struct __user_cap_header_struct hdr = { _LINUX_CAPABILITY_VERSION_3, 0 };
|
|
|
|
struct __user_cap_data_struct data[2] = { { 0 } };
|
2019-11-07 17:47:39 +00:00
|
|
|
bool rx = false, tx = false;
|
2021-12-30 03:54:45 +00:00
|
|
|
struct sched_param schparam;
|
2019-02-21 09:21:27 +00:00
|
|
|
struct xsk_umem_info *umem;
|
2019-11-07 17:47:37 +00:00
|
|
|
struct bpf_object *obj;
|
2020-12-03 09:05:46 +00:00
|
|
|
int xsks_map_fd = 0;
|
2018-05-02 11:01:36 +00:00
|
|
|
pthread_t pt;
|
2019-11-07 17:47:37 +00:00
|
|
|
int i, ret;
|
2019-02-21 09:21:27 +00:00
|
|
|
void *bufs;
|
2018-05-02 11:01:36 +00:00
|
|
|
|
|
|
|
parse_command_line(argc, argv);
|
|
|
|
|
2020-12-03 09:05:46 +00:00
|
|
|
if (opt_reduced_cap) {
|
|
|
|
if (capget(&hdr, data) < 0)
|
|
|
|
fprintf(stderr, "Error getting capabilities\n");
|
|
|
|
|
|
|
|
data->effective &= CAP_TO_MASK(CAP_NET_RAW);
|
|
|
|
data->permitted &= CAP_TO_MASK(CAP_NET_RAW);
|
|
|
|
|
|
|
|
if (capset(&hdr, data) < 0)
|
|
|
|
fprintf(stderr, "Setting capabilities failed\n");
|
|
|
|
|
|
|
|
if (capget(&hdr, data) < 0) {
|
|
|
|
fprintf(stderr, "Error getting capabilities\n");
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "Capabilities EFF %x Caps INH %x Caps Per %x\n",
|
|
|
|
data[0].effective, data[0].inheritable, data[0].permitted);
|
|
|
|
fprintf(stderr, "Capabilities EFF %x Caps INH %x Caps Per %x\n",
|
|
|
|
data[1].effective, data[1].inheritable, data[1].permitted);
|
|
|
|
}
|
|
|
|
} else {
|
2022-04-09 12:59:55 +00:00
|
|
|
/* Use libbpf 1.0 API mode */
|
|
|
|
libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
|
2020-12-03 09:05:46 +00:00
|
|
|
|
|
|
|
if (opt_num_xsks > 1)
|
|
|
|
load_xdp_program(argv, &obj);
|
|
|
|
}
|
2019-11-07 17:47:37 +00:00
|
|
|
|
2019-08-27 02:25:30 +00:00
|
|
|
/* Reserve memory for the umem. Use hugepages if unaligned chunk mode */
|
|
|
|
bufs = mmap(NULL, NUM_FRAMES * opt_xsk_frame_size,
|
|
|
|
PROT_READ | PROT_WRITE,
|
|
|
|
MAP_PRIVATE | MAP_ANONYMOUS | opt_mmap_flags, -1, 0);
|
|
|
|
if (bufs == MAP_FAILED) {
|
|
|
|
printf("ERROR: mmap failed\n");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2019-11-07 17:47:37 +00:00
|
|
|
|
|
|
|
/* Create sockets... */
|
2019-06-26 14:35:27 +00:00
|
|
|
umem = xsk_configure_umem(bufs, NUM_FRAMES * opt_xsk_frame_size);
|
2019-11-07 17:47:39 +00:00
|
|
|
if (opt_bench == BENCH_RXDROP || opt_bench == BENCH_L2FWD) {
|
|
|
|
rx = true;
|
|
|
|
xsk_populate_fill_ring(umem);
|
|
|
|
}
|
|
|
|
if (opt_bench == BENCH_L2FWD || opt_bench == BENCH_TXONLY)
|
|
|
|
tx = true;
|
2019-11-07 17:47:37 +00:00
|
|
|
for (i = 0; i < opt_num_xsks; i++)
|
2019-11-07 17:47:39 +00:00
|
|
|
xsks[num_socks++] = xsk_configure_socket(umem, rx, tx);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-11-30 18:52:04 +00:00
|
|
|
for (i = 0; i < opt_num_xsks; i++)
|
|
|
|
apply_setsockopt(xsks[i]);
|
|
|
|
|
2019-12-20 08:55:29 +00:00
|
|
|
if (opt_bench == BENCH_TXONLY) {
|
2021-12-30 03:54:47 +00:00
|
|
|
if (opt_tstamp && opt_pkt_size < PKTGEN_SIZE_MIN)
|
|
|
|
opt_pkt_size = PKTGEN_SIZE_MIN;
|
|
|
|
|
2019-12-20 08:55:29 +00:00
|
|
|
gen_eth_hdr_data();
|
|
|
|
|
2019-11-07 17:47:39 +00:00
|
|
|
for (i = 0; i < NUM_FRAMES; i++)
|
|
|
|
gen_eth_frame(umem, i * opt_xsk_frame_size);
|
2019-12-20 08:55:29 +00:00
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2019-11-07 17:47:37 +00:00
|
|
|
if (opt_num_xsks > 1 && opt_bench != BENCH_TXONLY)
|
|
|
|
enter_xsks_into_map(obj);
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2020-12-03 09:05:46 +00:00
|
|
|
if (opt_reduced_cap) {
|
|
|
|
ret = recv_xsks_map_fd(&xsks_map_fd);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "Error %d receiving xsks_map_fd\n", ret);
|
|
|
|
exit_with_error(ret);
|
|
|
|
}
|
|
|
|
if (xsks[0]->xsk) {
|
|
|
|
ret = xsk_socket__update_xskmap(xsks[0]->xsk, xsks_map_fd);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "Update of BPF map failed(%d)\n", ret);
|
|
|
|
exit_with_error(ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
signal(SIGINT, int_exit);
|
|
|
|
signal(SIGTERM, int_exit);
|
|
|
|
signal(SIGABRT, int_exit);
|
|
|
|
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
|
2022-03-15 10:29:48 +00:00
|
|
|
prev_time = get_nsecs();
|
|
|
|
start_time = prev_time;
|
|
|
|
|
2020-09-10 08:31:06 +00:00
|
|
|
if (!opt_quiet) {
|
|
|
|
ret = pthread_create(&pt, NULL, poller, NULL);
|
|
|
|
if (ret)
|
|
|
|
exit_with_error(ret);
|
|
|
|
}
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-30 03:54:45 +00:00
|
|
|
/* Configure sched priority for better wake-up accuracy */
|
|
|
|
memset(&schparam, 0, sizeof(schparam));
|
|
|
|
schparam.sched_priority = opt_schprio;
|
|
|
|
ret = sched_setscheduler(0, opt_schpolicy, &schparam);
|
|
|
|
if (ret) {
|
|
|
|
fprintf(stderr, "Error(%d) in setting priority(%d): %s\n",
|
|
|
|
errno, opt_schprio, strerror(errno));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
if (opt_bench == BENCH_RXDROP)
|
|
|
|
rx_drop_all();
|
|
|
|
else if (opt_bench == BENCH_TXONLY)
|
2019-08-14 07:27:21 +00:00
|
|
|
tx_only_all();
|
2018-05-02 11:01:36 +00:00
|
|
|
else
|
2019-08-14 07:27:21 +00:00
|
|
|
l2fwd_all();
|
2018-05-02 11:01:36 +00:00
|
|
|
|
2021-12-30 03:54:45 +00:00
|
|
|
out:
|
2019-12-20 08:55:28 +00:00
|
|
|
benchmark_done = true;
|
|
|
|
|
2020-09-10 08:31:06 +00:00
|
|
|
if (!opt_quiet)
|
|
|
|
pthread_join(pt, NULL);
|
2019-12-20 08:55:25 +00:00
|
|
|
|
2019-12-20 08:55:26 +00:00
|
|
|
xdpsock_cleanup();
|
|
|
|
|
2021-03-03 18:56:35 +00:00
|
|
|
munmap(bufs, NUM_FRAMES * opt_xsk_frame_size);
|
|
|
|
|
2018-05-02 11:01:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|