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(basename(argv[0])); 138 return 1; 139 } 140 } 141 142 if (!ifname) { 143 show_usage(basename(argv[0])); 144 return 1; 145 } 146 if (!server && optind == argc) { 147 show_usage(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(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(filename, sizeof(filename), "%s_kern.bpf.o", argv[0]); 172 173 if (bpf_prog_test_load(filename, BPF_PROG_TYPE_XDP, &obj, &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(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(map_fd, count, raddr); 244 245 cleanup(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