1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. */ |
3 | |
4 | #include <linux/bpf.h> |
5 | #include <linux/if_link.h> |
6 | #include <arpa/inet.h> |
7 | #include <assert.h> |
8 | #include <errno.h> |
9 | #include <signal.h> |
10 | #include <stdio.h> |
11 | #include <stdlib.h> |
12 | #include <string.h> |
13 | #include <unistd.h> |
14 | #include <libgen.h> |
15 | #include <net/if.h> |
16 | #include <sys/types.h> |
17 | #include <sys/socket.h> |
18 | #include <netdb.h> |
19 | |
20 | #include "bpf/bpf.h" |
21 | #include "bpf/libbpf.h" |
22 | |
23 | #include "xdping.h" |
24 | #include "testing_helpers.h" |
25 | |
26 | static int ifindex; |
27 | static __u32 xdp_flags = XDP_FLAGS_UPDATE_IF_NOEXIST; |
28 | |
29 | static void cleanup(int sig) |
30 | { |
31 | bpf_xdp_detach(ifindex, xdp_flags, NULL); |
32 | if (sig) |
33 | exit(1); |
34 | } |
35 | |
36 | static int get_stats(int fd, __u16 count, __u32 raddr) |
37 | { |
38 | struct pinginfo pinginfo = { 0 }; |
39 | char inaddrbuf[INET_ADDRSTRLEN]; |
40 | struct in_addr inaddr; |
41 | __u16 i; |
42 | |
43 | inaddr.s_addr = raddr; |
44 | |
45 | printf("\nXDP RTT data:\n" ); |
46 | |
47 | if (bpf_map_lookup_elem(fd, &raddr, &pinginfo)) { |
48 | perror("bpf_map_lookup elem" ); |
49 | return 1; |
50 | } |
51 | |
52 | for (i = 0; i < count; i++) { |
53 | if (pinginfo.times[i] == 0) |
54 | break; |
55 | |
56 | printf("64 bytes from %s: icmp_seq=%d ttl=64 time=%#.5f ms\n" , |
57 | inet_ntop(AF_INET, &inaddr, inaddrbuf, |
58 | sizeof(inaddrbuf)), |
59 | count + i + 1, |
60 | (double)pinginfo.times[i]/1000000); |
61 | } |
62 | |
63 | if (i < count) { |
64 | fprintf(stderr, "Expected %d samples, got %d.\n" , count, i); |
65 | return 1; |
66 | } |
67 | |
68 | bpf_map_delete_elem(fd, &raddr); |
69 | |
70 | return 0; |
71 | } |
72 | |
73 | static void show_usage(const char *prog) |
74 | { |
75 | fprintf(stderr, |
76 | "usage: %s [OPTS] -I interface destination\n\n" |
77 | "OPTS:\n" |
78 | " -c count Stop after sending count requests\n" |
79 | " (default %d, max %d)\n" |
80 | " -I interface interface name\n" |
81 | " -N Run in driver mode\n" |
82 | " -s Server mode\n" |
83 | " -S Run in skb mode\n" , |
84 | prog, XDPING_DEFAULT_COUNT, XDPING_MAX_COUNT); |
85 | } |
86 | |
87 | int main(int argc, char **argv) |
88 | { |
89 | __u32 mode_flags = XDP_FLAGS_DRV_MODE | XDP_FLAGS_SKB_MODE; |
90 | struct addrinfo *a, hints = { .ai_family = AF_INET }; |
91 | __u16 count = XDPING_DEFAULT_COUNT; |
92 | struct pinginfo pinginfo = { 0 }; |
93 | const char *optstr = "c:I:NsS" ; |
94 | struct bpf_program *main_prog; |
95 | int prog_fd = -1, map_fd = -1; |
96 | struct sockaddr_in rin; |
97 | struct bpf_object *obj; |
98 | struct bpf_map *map; |
99 | char *ifname = NULL; |
100 | char filename[256]; |
101 | int opt, ret = 1; |
102 | __u32 raddr = 0; |
103 | int server = 0; |
104 | char cmd[256]; |
105 | |
106 | while ((opt = getopt(argc, argv, optstr)) != -1) { |
107 | switch (opt) { |
108 | case 'c': |
109 | count = atoi(optarg); |
110 | if (count < 1 || count > XDPING_MAX_COUNT) { |
111 | fprintf(stderr, |
112 | "min count is 1, max count is %d\n" , |
113 | XDPING_MAX_COUNT); |
114 | return 1; |
115 | } |
116 | break; |
117 | case 'I': |
118 | ifname = optarg; |
119 | ifindex = if_nametoindex(ifname); |
120 | if (!ifindex) { |
121 | fprintf(stderr, "Could not get interface %s\n" , |
122 | ifname); |
123 | return 1; |
124 | } |
125 | break; |
126 | case 'N': |
127 | xdp_flags |= XDP_FLAGS_DRV_MODE; |
128 | break; |
129 | case 's': |
130 | /* use server program */ |
131 | server = 1; |
132 | break; |
133 | case 'S': |
134 | xdp_flags |= XDP_FLAGS_SKB_MODE; |
135 | break; |
136 | default: |
137 | show_usage(prog: basename(argv[0])); |
138 | return 1; |
139 | } |
140 | } |
141 | |
142 | if (!ifname) { |
143 | show_usage(prog: basename(argv[0])); |
144 | return 1; |
145 | } |
146 | if (!server && optind == argc) { |
147 | show_usage(prog: basename(argv[0])); |
148 | return 1; |
149 | } |
150 | |
151 | if ((xdp_flags & mode_flags) == mode_flags) { |
152 | fprintf(stderr, "-N or -S can be specified, not both.\n" ); |
153 | show_usage(prog: basename(argv[0])); |
154 | return 1; |
155 | } |
156 | |
157 | if (!server) { |
158 | /* Only supports IPv4; see hints initiailization above. */ |
159 | if (getaddrinfo(argv[optind], NULL, &hints, &a) || !a) { |
160 | fprintf(stderr, "Could not resolve %s\n" , argv[optind]); |
161 | return 1; |
162 | } |
163 | memcpy(&rin, a->ai_addr, sizeof(rin)); |
164 | raddr = rin.sin_addr.s_addr; |
165 | freeaddrinfo(a); |
166 | } |
167 | |
168 | /* Use libbpf 1.0 API mode */ |
169 | libbpf_set_strict_mode(LIBBPF_STRICT_ALL); |
170 | |
171 | snprintf(buf: filename, size: sizeof(filename), fmt: "%s_kern.bpf.o" , argv[0]); |
172 | |
173 | if (bpf_prog_test_load(file: filename, type: BPF_PROG_TYPE_XDP, pobj: &obj, prog_fd: &prog_fd)) { |
174 | fprintf(stderr, "load of %s failed\n" , filename); |
175 | return 1; |
176 | } |
177 | |
178 | main_prog = bpf_object__find_program_by_name(obj, |
179 | server ? "xdping_server" : "xdping_client" ); |
180 | if (main_prog) |
181 | prog_fd = bpf_program__fd(main_prog); |
182 | if (!main_prog || prog_fd < 0) { |
183 | fprintf(stderr, "could not find xdping program" ); |
184 | return 1; |
185 | } |
186 | |
187 | map = bpf_object__next_map(obj, NULL); |
188 | if (map) |
189 | map_fd = bpf_map__fd(map); |
190 | if (!map || map_fd < 0) { |
191 | fprintf(stderr, "Could not find ping map" ); |
192 | goto done; |
193 | } |
194 | |
195 | signal(SIGINT, cleanup); |
196 | signal(SIGTERM, cleanup); |
197 | |
198 | printf("Setting up XDP for %s, please wait...\n" , ifname); |
199 | |
200 | printf("XDP setup disrupts network connectivity, hit Ctrl+C to quit\n" ); |
201 | |
202 | if (bpf_xdp_attach(ifindex, prog_fd, xdp_flags, NULL) < 0) { |
203 | fprintf(stderr, "Link set xdp fd failed for %s\n" , ifname); |
204 | goto done; |
205 | } |
206 | |
207 | if (server) { |
208 | close(prog_fd); |
209 | close(map_fd); |
210 | printf("Running server on %s; press Ctrl+C to exit...\n" , |
211 | ifname); |
212 | do { } while (1); |
213 | } |
214 | |
215 | /* Start xdping-ing from last regular ping reply, e.g. for a count |
216 | * of 10 ICMP requests, we start xdping-ing using reply with seq number |
217 | * 10. The reason the last "real" ping RTT is much higher is that |
218 | * the ping program sees the ICMP reply associated with the last |
219 | * XDP-generated packet, so ping doesn't get a reply until XDP is done. |
220 | */ |
221 | pinginfo.seq = htons(count); |
222 | pinginfo.count = count; |
223 | |
224 | if (bpf_map_update_elem(map_fd, &raddr, &pinginfo, BPF_ANY)) { |
225 | fprintf(stderr, "could not communicate with BPF map: %s\n" , |
226 | strerror(errno)); |
227 | cleanup(sig: 0); |
228 | goto done; |
229 | } |
230 | |
231 | /* We need to wait for XDP setup to complete. */ |
232 | sleep(10); |
233 | |
234 | snprintf(cmd, sizeof(cmd), "ping -c %d -I %s %s" , |
235 | count, ifname, argv[optind]); |
236 | |
237 | printf("\nNormal ping RTT data\n" ); |
238 | printf("[Ignore final RTT; it is distorted by XDP using the reply]\n" ); |
239 | |
240 | ret = system(cmd); |
241 | |
242 | if (!ret) |
243 | ret = get_stats(fd: map_fd, count, raddr); |
244 | |
245 | cleanup(sig: 0); |
246 | |
247 | done: |
248 | if (prog_fd > 0) |
249 | close(prog_fd); |
250 | if (map_fd > 0) |
251 | close(map_fd); |
252 | |
253 | return ret; |
254 | } |
255 | |