1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (c) 2017 Covalent IO, Inc. http://covalent.io
3 */
4 static const char *__doc__ =
5 "XDP redirect tool, using BPF_MAP_TYPE_DEVMAP\n"
6 "Usage: xdp_redirect_map <IFINDEX|IFNAME>_IN <IFINDEX|IFNAME>_OUT\n";
7
8 #include <linux/bpf.h>
9 #include <linux/if_link.h>
10 #include <assert.h>
11 #include <errno.h>
12 #include <signal.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <stdbool.h>
16 #include <string.h>
17 #include <net/if.h>
18 #include <unistd.h>
19 #include <libgen.h>
20 #include <getopt.h>
21 #include <bpf/bpf.h>
22 #include <bpf/libbpf.h>
23 #include "bpf_util.h"
24 #include "xdp_sample_user.h"
25 #include "xdp_redirect_map.skel.h"
26
27 static int mask = SAMPLE_RX_CNT | SAMPLE_REDIRECT_ERR_MAP_CNT |
28 SAMPLE_EXCEPTION_CNT | SAMPLE_DEVMAP_XMIT_CNT_MULTI;
29
30 DEFINE_SAMPLE_INIT(xdp_redirect_map);
31
32 static const struct option long_options[] = {
33 { "help", no_argument, NULL, 'h' },
34 { "skb-mode", no_argument, NULL, 'S' },
35 { "force", no_argument, NULL, 'F' },
36 { "load-egress", no_argument, NULL, 'X' },
37 { "stats", no_argument, NULL, 's' },
38 { "interval", required_argument, NULL, 'i' },
39 { "verbose", no_argument, NULL, 'v' },
40 {}
41 };
42
43 static int verbose = 0;
44
main(int argc,char ** argv)45 int main(int argc, char **argv)
46 {
47 struct bpf_devmap_val devmap_val = {};
48 bool xdp_devmap_attached = false;
49 struct xdp_redirect_map *skel;
50 char str[2 * IF_NAMESIZE + 1];
51 char ifname_out[IF_NAMESIZE];
52 struct bpf_map *tx_port_map;
53 char ifname_in[IF_NAMESIZE];
54 int ifindex_in, ifindex_out;
55 unsigned long interval = 2;
56 int ret = EXIT_FAIL_OPTION;
57 struct bpf_program *prog;
58 bool generic = false;
59 bool force = false;
60 bool tried = false;
61 bool error = true;
62 int opt, key = 0;
63
64 while ((opt = getopt_long(argc, argv, "hSFXi:vs",
65 long_options, NULL)) != -1) {
66 switch (opt) {
67 case 'S':
68 generic = true;
69 /* devmap_xmit tracepoint not available */
70 mask &= ~(SAMPLE_DEVMAP_XMIT_CNT |
71 SAMPLE_DEVMAP_XMIT_CNT_MULTI);
72 break;
73 case 'F':
74 force = true;
75 break;
76 case 'X':
77 xdp_devmap_attached = true;
78 break;
79 case 'i':
80 interval = strtoul(optarg, NULL, 0);
81 break;
82 case 'v':
83 sample_switch_mode();
84 verbose = 1;
85 break;
86 case 's':
87 mask |= SAMPLE_REDIRECT_MAP_CNT;
88 break;
89 case 'h':
90 error = false;
91 default:
92 sample_usage(argv, long_options, __doc__, mask, error);
93 return ret;
94 }
95 }
96
97 if (argc <= optind + 1) {
98 sample_usage(argv, long_options, __doc__, mask, true);
99 goto end;
100 }
101
102 ifindex_in = if_nametoindex(argv[optind]);
103 if (!ifindex_in)
104 ifindex_in = strtoul(argv[optind], NULL, 0);
105
106 ifindex_out = if_nametoindex(argv[optind + 1]);
107 if (!ifindex_out)
108 ifindex_out = strtoul(argv[optind + 1], NULL, 0);
109
110 if (!ifindex_in || !ifindex_out) {
111 fprintf(stderr, "Bad interface index or name\n");
112 sample_usage(argv, long_options, __doc__, mask, true);
113 goto end;
114 }
115
116 skel = xdp_redirect_map__open();
117 if (!skel) {
118 fprintf(stderr, "Failed to xdp_redirect_map__open: %s\n",
119 strerror(errno));
120 ret = EXIT_FAIL_BPF;
121 goto end;
122 }
123
124 ret = sample_init_pre_load(skel);
125 if (ret < 0) {
126 fprintf(stderr, "Failed to sample_init_pre_load: %s\n", strerror(-ret));
127 ret = EXIT_FAIL_BPF;
128 goto end_destroy;
129 }
130
131 /* Load 2nd xdp prog on egress. */
132 if (xdp_devmap_attached) {
133 ret = get_mac_addr(ifindex_out, skel->rodata->tx_mac_addr);
134 if (ret < 0) {
135 fprintf(stderr, "Failed to get interface %d mac address: %s\n",
136 ifindex_out, strerror(-ret));
137 ret = EXIT_FAIL;
138 goto end_destroy;
139 }
140 if (verbose)
141 printf("Egress ifindex:%d using src MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
142 ifindex_out,
143 skel->rodata->tx_mac_addr[0], skel->rodata->tx_mac_addr[1],
144 skel->rodata->tx_mac_addr[2], skel->rodata->tx_mac_addr[3],
145 skel->rodata->tx_mac_addr[4], skel->rodata->tx_mac_addr[5]);
146 }
147
148 skel->rodata->from_match[0] = ifindex_in;
149 skel->rodata->to_match[0] = ifindex_out;
150
151 ret = xdp_redirect_map__load(skel);
152 if (ret < 0) {
153 fprintf(stderr, "Failed to xdp_redirect_map__load: %s\n",
154 strerror(errno));
155 ret = EXIT_FAIL_BPF;
156 goto end_destroy;
157 }
158
159 ret = sample_init(skel, mask);
160 if (ret < 0) {
161 fprintf(stderr, "Failed to initialize sample: %s\n", strerror(-ret));
162 ret = EXIT_FAIL;
163 goto end_destroy;
164 }
165
166 prog = skel->progs.xdp_redirect_map_native;
167 tx_port_map = skel->maps.tx_port_native;
168 restart:
169 if (sample_install_xdp(prog, ifindex_in, generic, force) < 0) {
170 /* First try with struct bpf_devmap_val as value for generic
171 * mode, then fallback to sizeof(int) for older kernels.
172 */
173 fprintf(stderr,
174 "Trying fallback to sizeof(int) as value_size for devmap in generic mode\n");
175 if (generic && !tried) {
176 prog = skel->progs.xdp_redirect_map_general;
177 tx_port_map = skel->maps.tx_port_general;
178 tried = true;
179 goto restart;
180 }
181 ret = EXIT_FAIL_XDP;
182 goto end_destroy;
183 }
184
185 /* Loading dummy XDP prog on out-device */
186 sample_install_xdp(skel->progs.xdp_redirect_dummy_prog, ifindex_out, generic, force);
187
188 devmap_val.ifindex = ifindex_out;
189 if (xdp_devmap_attached)
190 devmap_val.bpf_prog.fd = bpf_program__fd(skel->progs.xdp_redirect_map_egress);
191 ret = bpf_map_update_elem(bpf_map__fd(tx_port_map), &key, &devmap_val, 0);
192 if (ret < 0) {
193 fprintf(stderr, "Failed to update devmap value: %s\n",
194 strerror(errno));
195 ret = EXIT_FAIL_BPF;
196 goto end_destroy;
197 }
198
199 ret = EXIT_FAIL;
200 if (!if_indextoname(ifindex_in, ifname_in)) {
201 fprintf(stderr, "Failed to if_indextoname for %d: %s\n", ifindex_in,
202 strerror(errno));
203 goto end_destroy;
204 }
205
206 if (!if_indextoname(ifindex_out, ifname_out)) {
207 fprintf(stderr, "Failed to if_indextoname for %d: %s\n", ifindex_out,
208 strerror(errno));
209 goto end_destroy;
210 }
211
212 safe_strncpy(str, get_driver_name(ifindex_in), sizeof(str));
213 printf("Redirecting from %s (ifindex %d; driver %s) to %s (ifindex %d; driver %s)\n",
214 ifname_in, ifindex_in, str, ifname_out, ifindex_out, get_driver_name(ifindex_out));
215 snprintf(str, sizeof(str), "%s->%s", ifname_in, ifname_out);
216
217 ret = sample_run(interval, NULL, NULL);
218 if (ret < 0) {
219 fprintf(stderr, "Failed during sample run: %s\n", strerror(-ret));
220 ret = EXIT_FAIL;
221 goto end_destroy;
222 }
223 ret = EXIT_OK;
224 end_destroy:
225 xdp_redirect_map__destroy(skel);
226 end:
227 sample_exit(ret);
228 }
229
