1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright(c) 2017 Jesper Dangaard Brouer, Red Hat, Inc.
4 static const char *__doc__ =
5 "XDP CPU redirect tool, using BPF_MAP_TYPE_CPUMAP\n"
6 "Usage: xdp_redirect_cpu -d <IFINDEX|IFNAME> -c 0 ... -c N\n"
7 "Valid specification for CPUMAP BPF program:\n"
8 " --mprog-name/-e pass (use built-in XDP_PASS program)\n"
9 " --mprog-name/-e drop (use built-in XDP_DROP program)\n"
10 " --redirect-device/-r <ifindex|ifname> (use built-in DEVMAP redirect program)\n"
11 " Custom CPUMAP BPF program:\n"
12 " --mprog-filename/-f <filename> --mprog-name/-e <program>\n"
13 " Optionally, also pass --redirect-map/-m and --redirect-device/-r together\n"
14 " to configure DEVMAP in BPF object <filename>\n";
24 #include <sys/resource.h>
25 #include <sys/sysinfo.h>
29 #include <linux/limits.h>
30 #include <arpa/inet.h>
31 #include <linux/if_link.h>
33 #include <bpf/libbpf.h>
35 #include "xdp_sample_user.h"
36 #include "xdp_redirect_cpu.skel.h"
42 static int mask = SAMPLE_RX_CNT | SAMPLE_REDIRECT_ERR_MAP_CNT |
43 SAMPLE_CPUMAP_ENQUEUE_CNT | SAMPLE_CPUMAP_KTHREAD_CNT |
46 DEFINE_SAMPLE_INIT(xdp_redirect_cpu);
48 static const struct option long_options[] = {
49 { "help", no_argument, NULL, 'h' },
50 { "dev", required_argument, NULL, 'd' },
51 { "skb-mode", no_argument, NULL, 'S' },
52 { "progname", required_argument, NULL, 'p' },
53 { "qsize", required_argument, NULL, 'q' },
54 { "cpu", required_argument, NULL, 'c' },
55 { "stress-mode", no_argument, NULL, 'x' },
56 { "force", no_argument, NULL, 'F' },
57 { "interval", required_argument, NULL, 'i' },
58 { "verbose", no_argument, NULL, 'v' },
59 { "stats", no_argument, NULL, 's' },
60 { "mprog-name", required_argument, NULL, 'e' },
61 { "mprog-filename", required_argument, NULL, 'f' },
62 { "redirect-device", required_argument, NULL, 'r' },
63 { "redirect-map", required_argument, NULL, 'm' },
67 static void print_avail_progs(struct bpf_object *obj)
69 struct bpf_program *pos;
71 printf(" Programs to be used for -p/--progname:\n");
72 bpf_object__for_each_program(pos, obj) {
73 if (bpf_program__is_xdp(pos)) {
74 if (!strncmp(bpf_program__name(pos), "xdp_prognum",
75 sizeof("xdp_prognum") - 1))
76 printf(" %s\n", bpf_program__name(pos));
81 static void usage(char *argv[], const struct option *long_options,
82 const char *doc, int mask, bool error, struct bpf_object *obj)
84 sample_usage(argv, long_options, doc, mask, error);
85 print_avail_progs(obj);
88 static int create_cpu_entry(__u32 cpu, struct bpf_cpumap_val *value,
89 __u32 avail_idx, bool new)
91 __u32 curr_cpus_count = 0;
95 /* Add a CPU entry to cpumap, as this allocate a cpu entry in
96 * the kernel for the cpu.
98 ret = bpf_map_update_elem(map_fd, &cpu, value, 0);
100 fprintf(stderr, "Create CPU entry failed: %s\n", strerror(errno));
104 /* Inform bpf_prog's that a new CPU is available to select
105 * from via some control maps.
107 ret = bpf_map_update_elem(avail_fd, &avail_idx, &cpu, 0);
109 fprintf(stderr, "Add to avail CPUs failed: %s\n", strerror(errno));
113 /* When not replacing/updating existing entry, bump the count */
114 ret = bpf_map_lookup_elem(count_fd, &key, &curr_cpus_count);
116 fprintf(stderr, "Failed reading curr cpus_count: %s\n",
122 ret = bpf_map_update_elem(count_fd, &key,
123 &curr_cpus_count, 0);
125 fprintf(stderr, "Failed write curr cpus_count: %s\n",
131 printf("%s CPU: %u as idx: %u qsize: %d cpumap_prog_fd: %d (cpus_count: %u)\n",
132 new ? "Add new" : "Replace", cpu, avail_idx,
133 value->qsize, value->bpf_prog.fd, curr_cpus_count);
138 /* CPUs are zero-indexed. Thus, add a special sentinel default value
139 * in map cpus_available to mark CPU index'es not configured
141 static int mark_cpus_unavailable(void)
143 int ret, i, n_cpus = libbpf_num_possible_cpus();
144 __u32 invalid_cpu = n_cpus;
146 for (i = 0; i < n_cpus; i++) {
147 ret = bpf_map_update_elem(avail_fd, &i,
150 fprintf(stderr, "Failed marking CPU unavailable: %s\n",
159 /* Stress cpumap management code by concurrently changing underlying cpumap */
160 static void stress_cpumap(void *ctx)
162 struct bpf_cpumap_val *value = ctx;
164 /* Changing qsize will cause kernel to free and alloc a new
165 * bpf_cpu_map_entry, with an associated/complicated tear-down
169 create_cpu_entry(1, value, 0, false);
171 create_cpu_entry(1, value, 0, false);
172 value->qsize = 16000;
173 create_cpu_entry(1, value, 0, false);
176 static int set_cpumap_prog(struct xdp_redirect_cpu *skel,
177 const char *redir_interface, const char *redir_map,
178 const char *mprog_filename, const char *mprog_name)
180 if (mprog_filename) {
181 struct bpf_program *prog;
182 struct bpf_object *obj;
186 fprintf(stderr, "BPF program not specified for file %s\n",
190 if ((redir_interface && !redir_map) || (!redir_interface && redir_map)) {
191 fprintf(stderr, "--redirect-%s specified but --redirect-%s not specified\n",
192 redir_interface ? "device" : "map", redir_interface ? "map" : "device");
196 /* Custom BPF program */
197 obj = bpf_object__open_file(mprog_filename, NULL);
200 fprintf(stderr, "Failed to bpf_prog_load_xattr: %s\n",
205 ret = bpf_object__load(obj);
208 fprintf(stderr, "Failed to bpf_object__load: %s\n",
214 int err, redir_map_fd, ifindex_out, key = 0;
216 redir_map_fd = bpf_object__find_map_fd_by_name(obj, redir_map);
217 if (redir_map_fd < 0) {
218 fprintf(stderr, "Failed to bpf_object__find_map_fd_by_name: %s\n",
223 ifindex_out = if_nametoindex(redir_interface);
225 ifindex_out = strtoul(redir_interface, NULL, 0);
227 fprintf(stderr, "Bad interface name or index\n");
231 err = bpf_map_update_elem(redir_map_fd, &key, &ifindex_out, 0);
236 prog = bpf_object__find_program_by_name(obj, mprog_name);
239 fprintf(stderr, "Failed to bpf_object__find_program_by_name: %s\n",
244 return bpf_program__fd(prog);
247 if (redir_interface || redir_map) {
248 fprintf(stderr, "Need to specify --mprog-filename/-f\n");
251 if (!strcmp(mprog_name, "pass") || !strcmp(mprog_name, "drop")) {
252 /* Use built-in pass/drop programs */
253 return *mprog_name == 'p' ? bpf_program__fd(skel->progs.xdp_redirect_cpu_pass)
254 : bpf_program__fd(skel->progs.xdp_redirect_cpu_drop);
256 fprintf(stderr, "Unknown name \"%s\" for built-in BPF program\n",
262 fprintf(stderr, "Need to specify --mprog-filename, --mprog-name and"
263 " --redirect-device with --redirect-map\n");
266 if (redir_interface) {
267 /* Use built-in devmap redirect */
268 struct bpf_devmap_val val = {};
269 int ifindex_out, err;
272 if (!redir_interface)
275 ifindex_out = if_nametoindex(redir_interface);
277 ifindex_out = strtoul(redir_interface, NULL, 0);
279 fprintf(stderr, "Bad interface name or index\n");
283 if (get_mac_addr(ifindex_out, skel->bss->tx_mac_addr) < 0) {
284 printf("Get interface %d mac failed\n", ifindex_out);
288 val.ifindex = ifindex_out;
289 val.bpf_prog.fd = bpf_program__fd(skel->progs.xdp_redirect_egress_prog);
290 err = bpf_map_update_elem(bpf_map__fd(skel->maps.tx_port), &key, &val, 0);
294 return bpf_program__fd(skel->progs.xdp_redirect_cpu_devmap);
302 fprintf(stderr, "Invalid options for CPUMAP BPF program\n");
306 int main(int argc, char **argv)
308 const char *redir_interface = NULL, *redir_map = NULL;
309 const char *mprog_filename = NULL, *mprog_name = NULL;
310 struct xdp_redirect_cpu *skel;
311 struct bpf_map_info info = {};
312 char ifname_buf[IF_NAMESIZE];
313 struct bpf_cpumap_val value;
314 __u32 infosz = sizeof(info);
315 int ret = EXIT_FAIL_OPTION;
316 unsigned long interval = 2;
317 bool stress_mode = false;
318 struct bpf_program *prog;
319 const char *prog_name;
320 bool generic = false;
332 n_cpus = libbpf_num_possible_cpus();
334 /* Notice: Choosing the queue size is very important when CPU is
335 * configured with power-saving states.
337 * If deepest state take 133 usec to wakeup from (133/10^6). When link
338 * speed is 10Gbit/s ((10*10^9/8) in bytes/sec). How many bytes can
339 * arrive with in 133 usec at this speed: (10*10^9/8)*(133/10^6) =
340 * 166250 bytes. With MTU size packets this is 110 packets, and with
341 * minimum Ethernet (MAC-preamble + intergap) 84 bytes is 1979 packets.
343 * Setting default cpumap queue to 2048 as worst-case (small packet)
344 * should be +64 packet due kthread wakeup call (due to xdp_do_flush)
345 * worst-case is 2043 packets.
347 * Sysadm can configured system to avoid deep-sleep via:
348 * tuned-adm profile network-latency
352 skel = xdp_redirect_cpu__open();
354 fprintf(stderr, "Failed to xdp_redirect_cpu__open: %s\n",
360 ret = sample_init_pre_load(skel);
362 fprintf(stderr, "Failed to sample_init_pre_load: %s\n", strerror(-ret));
367 if (bpf_map__set_max_entries(skel->maps.cpu_map, n_cpus) < 0) {
368 fprintf(stderr, "Failed to set max entries for cpu_map map: %s",
374 if (bpf_map__set_max_entries(skel->maps.cpus_available, n_cpus) < 0) {
375 fprintf(stderr, "Failed to set max entries for cpus_available map: %s",
381 cpu = calloc(n_cpus, sizeof(int));
383 fprintf(stderr, "Failed to allocate cpu array\n");
387 prog = skel->progs.xdp_prognum5_lb_hash_ip_pairs;
388 while ((opt = getopt_long(argc, argv, "d:si:Sxp:f:e:r:m:c:q:Fvh",
389 long_options, &longindex)) != -1) {
392 if (strlen(optarg) >= IF_NAMESIZE) {
393 fprintf(stderr, "-d/--dev name too long\n");
396 ifname = (char *)&ifname_buf;
397 safe_strncpy(ifname, optarg, sizeof(ifname));
398 ifindex = if_nametoindex(ifname);
400 ifindex = strtoul(optarg, NULL, 0);
402 fprintf(stderr, "Bad interface index or name (%d): %s\n",
403 errno, strerror(errno));
404 usage(argv, long_options, __doc__, mask, true, skel->obj);
409 mask |= SAMPLE_REDIRECT_MAP_CNT;
412 interval = strtoul(optarg, NULL, 0);
421 /* Selecting eBPF prog to load */
423 prog = bpf_object__find_program_by_name(skel->obj,
427 "Failed to find program %s specified by"
428 " option -p/--progname\n",
430 print_avail_progs(skel->obj);
435 mprog_filename = optarg;
441 redir_interface = optarg;
442 mask |= SAMPLE_DEVMAP_XMIT_CNT_MULTI;
448 /* Add multiple CPUs */
449 add_cpu = strtoul(optarg, NULL, 0);
450 if (add_cpu >= n_cpus) {
452 "--cpu nr too large for cpumap err (%d):%s\n",
453 errno, strerror(errno));
454 usage(argv, long_options, __doc__, mask, true, skel->obj);
457 cpu[added_cpus++] = add_cpu;
460 qsize = strtoul(optarg, NULL, 0);
466 sample_switch_mode();
471 usage(argv, long_options, __doc__, mask, error, skel->obj);
476 ret = EXIT_FAIL_OPTION;
478 fprintf(stderr, "Required option --dev missing\n");
479 usage(argv, long_options, __doc__, mask, true, skel->obj);
484 fprintf(stderr, "Required option --cpu missing\n"
485 "Specify multiple --cpu option to add more\n");
486 usage(argv, long_options, __doc__, mask, true, skel->obj);
490 skel->rodata->from_match[0] = ifindex;
492 skel->rodata->to_match[0] = if_nametoindex(redir_interface);
494 ret = xdp_redirect_cpu__load(skel);
496 fprintf(stderr, "Failed to xdp_redirect_cpu__load: %s\n",
501 ret = bpf_obj_get_info_by_fd(bpf_map__fd(skel->maps.cpu_map), &info, &infosz);
503 fprintf(stderr, "Failed bpf_obj_get_info_by_fd for cpumap: %s\n",
508 skel->bss->cpumap_map_id = info.id;
510 map_fd = bpf_map__fd(skel->maps.cpu_map);
511 avail_fd = bpf_map__fd(skel->maps.cpus_available);
512 count_fd = bpf_map__fd(skel->maps.cpus_count);
514 ret = mark_cpus_unavailable();
516 fprintf(stderr, "Unable to mark CPUs as unavailable\n");
520 ret = sample_init(skel, mask);
522 fprintf(stderr, "Failed to initialize sample: %s\n", strerror(-ret));
527 value.bpf_prog.fd = set_cpumap_prog(skel, redir_interface, redir_map,
528 mprog_filename, mprog_name);
529 if (value.bpf_prog.fd < 0) {
530 fprintf(stderr, "Failed to set CPUMAP BPF program: %s\n",
531 strerror(-value.bpf_prog.fd));
532 usage(argv, long_options, __doc__, mask, true, skel->obj);
538 for (i = 0; i < added_cpus; i++) {
539 if (create_cpu_entry(cpu[i], &value, i, true) < 0) {
540 fprintf(stderr, "Cannot proceed, exiting\n");
541 usage(argv, long_options, __doc__, mask, true, skel->obj);
547 if (sample_install_xdp(prog, ifindex, generic, force) < 0)
550 ret = sample_run(interval, stress_mode ? stress_cpumap : NULL, &value);
552 fprintf(stderr, "Failed during sample run: %s\n", strerror(-ret));
560 xdp_redirect_cpu__destroy(skel);