in bpf/xdp_redirect_cpu_user.c [306:560]
int main(int argc, char **argv)
{
const char *redir_interface = NULL, *redir_map = NULL;
const char *mprog_filename = NULL, *mprog_name = NULL;
struct xdp_redirect_cpu *skel;
struct bpf_map_info info = {};
struct bpf_cpumap_val value;
__u32 infosz = sizeof(info);
int ret = EXIT_FAIL_OPTION;
unsigned long interval = 2;
bool stress_mode = false;
struct bpf_program *prog;
const char *prog_name;
bool generic = false;
bool force = false;
int added_cpus = 0;
bool error = true;
int longindex = 0;
int add_cpu = -1;
int ifindex = -1;
int *cpu, i, opt;
__u32 qsize;
int n_cpus;
n_cpus = libbpf_num_possible_cpus();
/* Notice: Choosing the queue size is very important when CPU is
* configured with power-saving states.
*
* If deepest state take 133 usec to wakeup from (133/10^6). When link
* speed is 10Gbit/s ((10*10^9/8) in bytes/sec). How many bytes can
* arrive with in 133 usec at this speed: (10*10^9/8)*(133/10^6) =
* 166250 bytes. With MTU size packets this is 110 packets, and with
* minimum Ethernet (MAC-preamble + intergap) 84 bytes is 1979 packets.
*
* Setting default cpumap queue to 2048 as worst-case (small packet)
* should be +64 packet due kthread wakeup call (due to xdp_do_flush)
* worst-case is 2043 packets.
*
* Sysadm can configured system to avoid deep-sleep via:
* tuned-adm profile network-latency
*/
qsize = 2048;
skel = xdp_redirect_cpu__open();
if (!skel) {
fprintf(stderr, "Failed to xdp_redirect_cpu__open: %s\n",
strerror(errno));
ret = EXIT_FAIL_BPF;
goto end;
}
ret = sample_init_pre_load(skel);
if (ret < 0) {
fprintf(stderr, "Failed to sample_init_pre_load: %s\n", strerror(-ret));
ret = EXIT_FAIL_BPF;
goto end_destroy;
}
if (bpf_map__set_max_entries(skel->maps.cpu_map, n_cpus) < 0) {
fprintf(stderr, "Failed to set max entries for cpu_map map: %s",
strerror(errno));
ret = EXIT_FAIL_BPF;
goto end_destroy;
}
if (bpf_map__set_max_entries(skel->maps.cpus_available, n_cpus) < 0) {
fprintf(stderr, "Failed to set max entries for cpus_available map: %s",
strerror(errno));
ret = EXIT_FAIL_BPF;
goto end_destroy;
}
cpu = calloc(n_cpus, sizeof(int));
if (!cpu) {
fprintf(stderr, "Failed to allocate cpu array\n");
goto end_destroy;
}
prog = skel->progs.xdp_prognum5_lb_hash_ip_pairs;
while ((opt = getopt_long(argc, argv, "d:si:Sxp:f:e:r:m:c:q:Fvh",
long_options, &longindex)) != -1) {
switch (opt) {
case 'd':
if (strlen(optarg) >= IF_NAMESIZE) {
fprintf(stderr, "-d/--dev name too long\n");
usage(argv, long_options, __doc__, mask, true, skel->obj);
goto end_cpu;
}
ifindex = if_nametoindex(optarg);
if (!ifindex)
ifindex = strtoul(optarg, NULL, 0);
if (!ifindex) {
fprintf(stderr, "Bad interface index or name (%d): %s\n",
errno, strerror(errno));
usage(argv, long_options, __doc__, mask, true, skel->obj);
goto end_cpu;
}
break;
case 's':
mask |= SAMPLE_REDIRECT_MAP_CNT;
break;
case 'i':
interval = strtoul(optarg, NULL, 0);
break;
case 'S':
generic = true;
break;
case 'x':
stress_mode = true;
break;
case 'p':
/* Selecting eBPF prog to load */
prog_name = optarg;
prog = bpf_object__find_program_by_name(skel->obj,
prog_name);
if (!prog) {
fprintf(stderr,
"Failed to find program %s specified by"
" option -p/--progname\n",
prog_name);
print_avail_progs(skel->obj);
goto end_cpu;
}
break;
case 'f':
mprog_filename = optarg;
break;
case 'e':
mprog_name = optarg;
break;
case 'r':
redir_interface = optarg;
mask |= SAMPLE_DEVMAP_XMIT_CNT_MULTI;
break;
case 'm':
redir_map = optarg;
break;
case 'c':
/* Add multiple CPUs */
add_cpu = strtoul(optarg, NULL, 0);
if (add_cpu >= n_cpus) {
fprintf(stderr,
"--cpu nr too large for cpumap err (%d):%s\n",
errno, strerror(errno));
usage(argv, long_options, __doc__, mask, true, skel->obj);
goto end_cpu;
}
cpu[added_cpus++] = add_cpu;
break;
case 'q':
qsize = strtoul(optarg, NULL, 0);
break;
case 'F':
force = true;
break;
case 'v':
sample_switch_mode();
break;
case 'h':
error = false;
default:
usage(argv, long_options, __doc__, mask, error, skel->obj);
goto end_cpu;
}
}
ret = EXIT_FAIL_OPTION;
if (ifindex == -1) {
fprintf(stderr, "Required option --dev missing\n");
usage(argv, long_options, __doc__, mask, true, skel->obj);
goto end_cpu;
}
if (add_cpu == -1) {
fprintf(stderr, "Required option --cpu missing\n"
"Specify multiple --cpu option to add more\n");
usage(argv, long_options, __doc__, mask, true, skel->obj);
goto end_cpu;
}
skel->rodata->from_match[0] = ifindex;
if (redir_interface)
skel->rodata->to_match[0] = if_nametoindex(redir_interface);
ret = xdp_redirect_cpu__load(skel);
if (ret < 0) {
fprintf(stderr, "Failed to xdp_redirect_cpu__load: %s\n",
strerror(errno));
goto end_cpu;
}
ret = bpf_obj_get_info_by_fd(bpf_map__fd(skel->maps.cpu_map), &info, &infosz);
if (ret < 0) {
fprintf(stderr, "Failed bpf_obj_get_info_by_fd for cpumap: %s\n",
strerror(errno));
goto end_cpu;
}
skel->bss->cpumap_map_id = info.id;
map_fd = bpf_map__fd(skel->maps.cpu_map);
avail_fd = bpf_map__fd(skel->maps.cpus_available);
count_fd = bpf_map__fd(skel->maps.cpus_count);
ret = mark_cpus_unavailable();
if (ret < 0) {
fprintf(stderr, "Unable to mark CPUs as unavailable\n");
goto end_cpu;
}
ret = sample_init(skel, mask);
if (ret < 0) {
fprintf(stderr, "Failed to initialize sample: %s\n", strerror(-ret));
ret = EXIT_FAIL;
goto end_cpu;
}
value.bpf_prog.fd = set_cpumap_prog(skel, redir_interface, redir_map,
mprog_filename, mprog_name);
if (value.bpf_prog.fd < 0) {
fprintf(stderr, "Failed to set CPUMAP BPF program: %s\n",
strerror(-value.bpf_prog.fd));
usage(argv, long_options, __doc__, mask, true, skel->obj);
ret = EXIT_FAIL_BPF;
goto end_cpu;
}
value.qsize = qsize;
for (i = 0; i < added_cpus; i++) {
if (create_cpu_entry(cpu[i], &value, i, true) < 0) {
fprintf(stderr, "Cannot proceed, exiting\n");
usage(argv, long_options, __doc__, mask, true, skel->obj);
goto end_cpu;
}
}
ret = EXIT_FAIL_XDP;
if (sample_install_xdp(prog, ifindex, generic, force) < 0)
goto end_cpu;
ret = sample_run(interval, stress_mode ? stress_cpumap : NULL, &value);
if (ret < 0) {
fprintf(stderr, "Failed during sample run: %s\n", strerror(-ret));
ret = EXIT_FAIL;
goto end_cpu;
}
ret = EXIT_OK;
end_cpu:
free(cpu);
end_destroy:
xdp_redirect_cpu__destroy(skel);
end:
sample_exit(ret);
}