]> Git Repo - J-linux.git/blob - tools/testing/selftests/bpf/xdp_features.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / testing / selftests / bpf / xdp_features.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <uapi/linux/bpf.h>
3 #include <uapi/linux/netdev.h>
4 #include <linux/if_link.h>
5 #include <signal.h>
6 #include <argp.h>
7 #include <net/if.h>
8 #include <sys/socket.h>
9 #include <netinet/in.h>
10 #include <netinet/tcp.h>
11 #include <unistd.h>
12 #include <arpa/inet.h>
13 #include <bpf/bpf.h>
14 #include <bpf/libbpf.h>
15 #include <pthread.h>
16
17 #include <network_helpers.h>
18
19 #include "xdp_features.skel.h"
20 #include "xdp_features.h"
21
22 #define RED(str)        "\033[0;31m" str "\033[0m"
23 #define GREEN(str)      "\033[0;32m" str "\033[0m"
24 #define YELLOW(str)     "\033[0;33m" str "\033[0m"
25
26 static struct env {
27         bool verbosity;
28         char ifname[IF_NAMESIZE];
29         int ifindex;
30         bool is_tester;
31         struct {
32                 enum netdev_xdp_act drv_feature;
33                 enum xdp_action action;
34         } feature;
35         struct sockaddr_storage dut_ctrl_addr;
36         struct sockaddr_storage dut_addr;
37         struct sockaddr_storage tester_addr;
38 } env;
39
40 #define BUFSIZE         128
41
42 void test__fail(void) { /* for network_helpers.c */ }
43
44 static int libbpf_print_fn(enum libbpf_print_level level,
45                            const char *format, va_list args)
46 {
47         if (level == LIBBPF_DEBUG && !env.verbosity)
48                 return 0;
49         return vfprintf(stderr, format, args);
50 }
51
52 static volatile bool exiting;
53
54 static void sig_handler(int sig)
55 {
56         exiting = true;
57 }
58
59 const char *argp_program_version = "xdp-features 0.0";
60 const char argp_program_doc[] =
61 "XDP features detection application.\n"
62 "\n"
63 "XDP features application checks the XDP advertised features match detected ones.\n"
64 "\n"
65 "USAGE: ./xdp-features [-vt] [-f <xdp-feature>] [-D <dut-data-ip>] [-T <tester-data-ip>] [-C <dut-ctrl-ip>] <iface-name>\n"
66 "\n"
67 "dut-data-ip, tester-data-ip, dut-ctrl-ip: IPv6 or IPv4-mapped-IPv6 addresses;\n"
68 "\n"
69 "XDP features\n:"
70 "- XDP_PASS\n"
71 "- XDP_DROP\n"
72 "- XDP_ABORTED\n"
73 "- XDP_REDIRECT\n"
74 "- XDP_NDO_XMIT\n"
75 "- XDP_TX\n";
76
77 static const struct argp_option opts[] = {
78         { "verbose", 'v', NULL, 0, "Verbose debug output" },
79         { "tester", 't', NULL, 0, "Tester mode" },
80         { "feature", 'f', "XDP-FEATURE", 0, "XDP feature to test" },
81         { "dut_data_ip", 'D', "DUT-DATA-IP", 0, "DUT IP data channel" },
82         { "dut_ctrl_ip", 'C', "DUT-CTRL-IP", 0, "DUT IP control channel" },
83         { "tester_data_ip", 'T', "TESTER-DATA-IP", 0, "Tester IP data channel" },
84         {},
85 };
86
87 static int get_xdp_feature(const char *arg)
88 {
89         if (!strcmp(arg, "XDP_PASS")) {
90                 env.feature.action = XDP_PASS;
91                 env.feature.drv_feature = NETDEV_XDP_ACT_BASIC;
92         } else if (!strcmp(arg, "XDP_DROP")) {
93                 env.feature.drv_feature = NETDEV_XDP_ACT_BASIC;
94                 env.feature.action = XDP_DROP;
95         } else if (!strcmp(arg, "XDP_ABORTED")) {
96                 env.feature.drv_feature = NETDEV_XDP_ACT_BASIC;
97                 env.feature.action = XDP_ABORTED;
98         } else if (!strcmp(arg, "XDP_TX")) {
99                 env.feature.drv_feature = NETDEV_XDP_ACT_BASIC;
100                 env.feature.action = XDP_TX;
101         } else if (!strcmp(arg, "XDP_REDIRECT")) {
102                 env.feature.drv_feature = NETDEV_XDP_ACT_REDIRECT;
103                 env.feature.action = XDP_REDIRECT;
104         } else if (!strcmp(arg, "XDP_NDO_XMIT")) {
105                 env.feature.drv_feature = NETDEV_XDP_ACT_NDO_XMIT;
106         } else {
107                 return -EINVAL;
108         }
109
110         return 0;
111 }
112
113 static char *get_xdp_feature_str(void)
114 {
115         switch (env.feature.action) {
116         case XDP_PASS:
117                 return YELLOW("XDP_PASS");
118         case XDP_DROP:
119                 return YELLOW("XDP_DROP");
120         case XDP_ABORTED:
121                 return YELLOW("XDP_ABORTED");
122         case XDP_TX:
123                 return YELLOW("XDP_TX");
124         case XDP_REDIRECT:
125                 return YELLOW("XDP_REDIRECT");
126         default:
127                 break;
128         }
129
130         if (env.feature.drv_feature == NETDEV_XDP_ACT_NDO_XMIT)
131                 return YELLOW("XDP_NDO_XMIT");
132
133         return "";
134 }
135
136 static error_t parse_arg(int key, char *arg, struct argp_state *state)
137 {
138         switch (key) {
139         case 'v':
140                 env.verbosity = true;
141                 break;
142         case 't':
143                 env.is_tester = true;
144                 break;
145         case 'f':
146                 if (get_xdp_feature(arg) < 0) {
147                         fprintf(stderr, "Invalid xdp feature: %s\n", arg);
148                         argp_usage(state);
149                         return ARGP_ERR_UNKNOWN;
150                 }
151                 break;
152         case 'D':
153                 if (make_sockaddr(AF_INET6, arg, DUT_ECHO_PORT,
154                                   &env.dut_addr, NULL)) {
155                         fprintf(stderr,
156                                 "Invalid address assigned to the Device Under Test: %s\n",
157                                 arg);
158                         return ARGP_ERR_UNKNOWN;
159                 }
160                 break;
161         case 'C':
162                 if (make_sockaddr(AF_INET6, arg, DUT_CTRL_PORT,
163                                   &env.dut_ctrl_addr, NULL)) {
164                         fprintf(stderr,
165                                 "Invalid address assigned to the Device Under Test: %s\n",
166                                 arg);
167                         return ARGP_ERR_UNKNOWN;
168                 }
169                 break;
170         case 'T':
171                 if (make_sockaddr(AF_INET6, arg, 0, &env.tester_addr, NULL)) {
172                         fprintf(stderr,
173                                 "Invalid address assigned to the Tester device: %s\n",
174                                 arg);
175                         return ARGP_ERR_UNKNOWN;
176                 }
177                 break;
178         case ARGP_KEY_ARG:
179                 errno = 0;
180                 if (strlen(arg) >= IF_NAMESIZE) {
181                         fprintf(stderr, "Invalid device name: %s\n", arg);
182                         argp_usage(state);
183                         return ARGP_ERR_UNKNOWN;
184                 }
185
186                 env.ifindex = if_nametoindex(arg);
187                 if (!env.ifindex)
188                         env.ifindex = strtoul(arg, NULL, 0);
189                 if (!env.ifindex || !if_indextoname(env.ifindex, env.ifname)) {
190                         fprintf(stderr,
191                                 "Bad interface index or name (%d): %s\n",
192                                 errno, strerror(errno));
193                         argp_usage(state);
194                         return ARGP_ERR_UNKNOWN;
195                 }
196                 break;
197         default:
198                 return ARGP_ERR_UNKNOWN;
199         }
200
201         return 0;
202 }
203
204 static const struct argp argp = {
205         .options = opts,
206         .parser = parse_arg,
207         .doc = argp_program_doc,
208 };
209
210 static void set_env_default(void)
211 {
212         env.feature.drv_feature = NETDEV_XDP_ACT_NDO_XMIT;
213         env.feature.action = -EINVAL;
214         env.ifindex = -ENODEV;
215         strcpy(env.ifname, "unknown");
216         make_sockaddr(AF_INET6, "::ffff:127.0.0.1", DUT_CTRL_PORT,
217                       &env.dut_ctrl_addr, NULL);
218         make_sockaddr(AF_INET6, "::ffff:127.0.0.1", DUT_ECHO_PORT,
219                       &env.dut_addr, NULL);
220         make_sockaddr(AF_INET6, "::ffff:127.0.0.1", 0, &env.tester_addr, NULL);
221 }
222
223 static void *dut_echo_thread(void *arg)
224 {
225         unsigned char buf[sizeof(struct tlv_hdr)];
226         int sockfd = *(int *)arg;
227
228         while (!exiting) {
229                 struct tlv_hdr *tlv = (struct tlv_hdr *)buf;
230                 struct sockaddr_storage addr;
231                 socklen_t addrlen;
232                 size_t n;
233
234                 n = recvfrom(sockfd, buf, sizeof(buf), MSG_WAITALL,
235                              (struct sockaddr *)&addr, &addrlen);
236                 if (n != ntohs(tlv->len))
237                         continue;
238
239                 if (ntohs(tlv->type) != CMD_ECHO)
240                         continue;
241
242                 sendto(sockfd, buf, sizeof(buf), MSG_NOSIGNAL | MSG_CONFIRM,
243                        (struct sockaddr *)&addr, addrlen);
244         }
245
246         pthread_exit((void *)0);
247         close(sockfd);
248
249         return NULL;
250 }
251
252 static int dut_run_echo_thread(pthread_t *t, int *sockfd)
253 {
254         int err;
255
256         sockfd = start_reuseport_server(AF_INET6, SOCK_DGRAM, NULL,
257                                         DUT_ECHO_PORT, 0, 1);
258         if (!sockfd) {
259                 fprintf(stderr,
260                         "Failed creating data UDP socket on device %s\n",
261                         env.ifname);
262                 return -errno;
263         }
264
265         /* start echo channel */
266         err = pthread_create(t, NULL, dut_echo_thread, sockfd);
267         if (err) {
268                 fprintf(stderr,
269                         "Failed creating data UDP thread on device %s: %s\n",
270                         env.ifname, strerror(-err));
271                 free_fds(sockfd, 1);
272                 return -EINVAL;
273         }
274
275         return 0;
276 }
277
278 static int dut_attach_xdp_prog(struct xdp_features *skel, int flags)
279 {
280         enum xdp_action action = env.feature.action;
281         struct bpf_program *prog;
282         unsigned int key = 0;
283         int err, fd = 0;
284
285         if (env.feature.drv_feature == NETDEV_XDP_ACT_NDO_XMIT) {
286                 struct bpf_devmap_val entry = {
287                         .ifindex = env.ifindex,
288                 };
289
290                 err = bpf_map__update_elem(skel->maps.dev_map,
291                                            &key, sizeof(key),
292                                            &entry, sizeof(entry), 0);
293                 if (err < 0)
294                         return err;
295
296                 fd = bpf_program__fd(skel->progs.xdp_do_redirect_cpumap);
297                 action = XDP_REDIRECT;
298         }
299
300         switch (action) {
301         case XDP_TX:
302                 prog = skel->progs.xdp_do_tx;
303                 break;
304         case XDP_DROP:
305                 prog = skel->progs.xdp_do_drop;
306                 break;
307         case XDP_ABORTED:
308                 prog = skel->progs.xdp_do_aborted;
309                 break;
310         case XDP_PASS:
311                 prog = skel->progs.xdp_do_pass;
312                 break;
313         case XDP_REDIRECT: {
314                 struct bpf_cpumap_val entry = {
315                         .qsize = 2048,
316                         .bpf_prog.fd = fd,
317                 };
318
319                 err = bpf_map__update_elem(skel->maps.cpu_map,
320                                            &key, sizeof(key),
321                                            &entry, sizeof(entry), 0);
322                 if (err < 0)
323                         return err;
324
325                 prog = skel->progs.xdp_do_redirect;
326                 break;
327         }
328         default:
329                 return -EINVAL;
330         }
331
332         err = bpf_xdp_attach(env.ifindex, bpf_program__fd(prog), flags, NULL);
333         if (err)
334                 fprintf(stderr, "Failed attaching XDP program to device %s\n",
335                         env.ifname);
336         return err;
337 }
338
339 static int recv_msg(int sockfd, void *buf, size_t bufsize, void *val,
340                     size_t val_size)
341 {
342         struct tlv_hdr *tlv = (struct tlv_hdr *)buf;
343         size_t len;
344
345         len = recv(sockfd, buf, bufsize, 0);
346         if (len != ntohs(tlv->len) || len < sizeof(*tlv))
347                 return -EINVAL;
348
349         if (val) {
350                 len -= sizeof(*tlv);
351                 if (len > val_size)
352                         return -ENOMEM;
353
354                 memcpy(val, tlv->data, len);
355         }
356
357         return 0;
358 }
359
360 static int dut_run(struct xdp_features *skel)
361 {
362         int flags = XDP_FLAGS_UPDATE_IF_NOEXIST | XDP_FLAGS_DRV_MODE;
363         int state, err = 0, *sockfd, ctrl_sockfd, echo_sockfd;
364         struct sockaddr_storage ctrl_addr;
365         pthread_t dut_thread = 0;
366         socklen_t addrlen;
367
368         sockfd = start_reuseport_server(AF_INET6, SOCK_STREAM, NULL,
369                                         DUT_CTRL_PORT, 0, 1);
370         if (!sockfd) {
371                 fprintf(stderr,
372                         "Failed creating control socket on device %s\n", env.ifname);
373                 return -errno;
374         }
375
376         ctrl_sockfd = accept(*sockfd, (struct sockaddr *)&ctrl_addr, &addrlen);
377         if (ctrl_sockfd < 0) {
378                 fprintf(stderr,
379                         "Failed accepting connections on device %s control socket\n",
380                         env.ifname);
381                 free_fds(sockfd, 1);
382                 return -errno;
383         }
384
385         /* CTRL loop */
386         while (!exiting) {
387                 unsigned char buf[BUFSIZE] = {};
388                 struct tlv_hdr *tlv = (struct tlv_hdr *)buf;
389
390                 err = recv_msg(ctrl_sockfd, buf, BUFSIZE, NULL, 0);
391                 if (err)
392                         continue;
393
394                 switch (ntohs(tlv->type)) {
395                 case CMD_START: {
396                         if (state == CMD_START)
397                                 continue;
398
399                         state = CMD_START;
400                         /* Load the XDP program on the DUT */
401                         err = dut_attach_xdp_prog(skel, flags);
402                         if (err)
403                                 goto out;
404
405                         err = dut_run_echo_thread(&dut_thread, &echo_sockfd);
406                         if (err < 0)
407                                 goto out;
408
409                         tlv->type = htons(CMD_ACK);
410                         tlv->len = htons(sizeof(*tlv));
411                         err = send(ctrl_sockfd, buf, sizeof(*tlv), 0);
412                         if (err < 0)
413                                 goto end_thread;
414                         break;
415                 }
416                 case CMD_STOP:
417                         if (state != CMD_START)
418                                 break;
419
420                         state = CMD_STOP;
421
422                         exiting = true;
423                         bpf_xdp_detach(env.ifindex, flags, NULL);
424
425                         tlv->type = htons(CMD_ACK);
426                         tlv->len = htons(sizeof(*tlv));
427                         err = send(ctrl_sockfd, buf, sizeof(*tlv), 0);
428                         goto end_thread;
429                 case CMD_GET_XDP_CAP: {
430                         LIBBPF_OPTS(bpf_xdp_query_opts, opts);
431                         unsigned long long val;
432                         size_t n;
433
434                         err = bpf_xdp_query(env.ifindex, XDP_FLAGS_DRV_MODE,
435                                             &opts);
436                         if (err) {
437                                 fprintf(stderr,
438                                         "Failed querying XDP cap for device %s\n",
439                                         env.ifname);
440                                 goto end_thread;
441                         }
442
443                         tlv->type = htons(CMD_ACK);
444                         n = sizeof(*tlv) + sizeof(opts.feature_flags);
445                         tlv->len = htons(n);
446
447                         val = htobe64(opts.feature_flags);
448                         memcpy(tlv->data, &val, sizeof(val));
449
450                         err = send(ctrl_sockfd, buf, n, 0);
451                         if (err < 0)
452                                 goto end_thread;
453                         break;
454                 }
455                 case CMD_GET_STATS: {
456                         unsigned int key = 0, val;
457                         size_t n;
458
459                         err = bpf_map__lookup_elem(skel->maps.dut_stats,
460                                                    &key, sizeof(key),
461                                                    &val, sizeof(val), 0);
462                         if (err) {
463                                 fprintf(stderr,
464                                         "bpf_map_lookup_elem failed (%d)\n", err);
465                                 goto end_thread;
466                         }
467
468                         tlv->type = htons(CMD_ACK);
469                         n = sizeof(*tlv) + sizeof(val);
470                         tlv->len = htons(n);
471
472                         val = htonl(val);
473                         memcpy(tlv->data, &val, sizeof(val));
474
475                         err = send(ctrl_sockfd, buf, n, 0);
476                         if (err < 0)
477                                 goto end_thread;
478                         break;
479                 }
480                 default:
481                         break;
482                 }
483         }
484
485 end_thread:
486         pthread_join(dut_thread, NULL);
487 out:
488         bpf_xdp_detach(env.ifindex, flags, NULL);
489         close(ctrl_sockfd);
490         free_fds(sockfd, 1);
491
492         return err;
493 }
494
495 static bool tester_collect_detected_cap(struct xdp_features *skel,
496                                         unsigned int dut_stats)
497 {
498         unsigned int err, key = 0, val;
499
500         if (!dut_stats)
501                 return false;
502
503         err = bpf_map__lookup_elem(skel->maps.stats, &key, sizeof(key),
504                                    &val, sizeof(val), 0);
505         if (err) {
506                 fprintf(stderr, "bpf_map_lookup_elem failed (%d)\n", err);
507                 return false;
508         }
509
510         switch (env.feature.action) {
511         case XDP_PASS:
512         case XDP_TX:
513         case XDP_REDIRECT:
514                 return val > 0;
515         case XDP_DROP:
516         case XDP_ABORTED:
517                 return val == 0;
518         default:
519                 break;
520         }
521
522         if (env.feature.drv_feature == NETDEV_XDP_ACT_NDO_XMIT)
523                 return val > 0;
524
525         return false;
526 }
527
528 static int send_and_recv_msg(int sockfd, enum test_commands cmd, void *val,
529                              size_t val_size)
530 {
531         unsigned char buf[BUFSIZE] = {};
532         struct tlv_hdr *tlv = (struct tlv_hdr *)buf;
533         int err;
534
535         tlv->type = htons(cmd);
536         tlv->len = htons(sizeof(*tlv));
537
538         err = send(sockfd, buf, sizeof(*tlv), 0);
539         if (err < 0)
540                 return err;
541
542         err = recv_msg(sockfd, buf, BUFSIZE, val, val_size);
543         if (err < 0)
544                 return err;
545
546         return ntohs(tlv->type) == CMD_ACK ? 0 : -EINVAL;
547 }
548
549 static int send_echo_msg(void)
550 {
551         unsigned char buf[sizeof(struct tlv_hdr)];
552         struct tlv_hdr *tlv = (struct tlv_hdr *)buf;
553         int sockfd, n;
554
555         sockfd = socket(AF_INET6, SOCK_DGRAM, 0);
556         if (sockfd < 0) {
557                 fprintf(stderr,
558                         "Failed creating data UDP socket on device %s\n",
559                         env.ifname);
560                 return -errno;
561         }
562
563         tlv->type = htons(CMD_ECHO);
564         tlv->len = htons(sizeof(*tlv));
565
566         n = sendto(sockfd, buf, sizeof(*tlv), MSG_NOSIGNAL | MSG_CONFIRM,
567                    (struct sockaddr *)&env.dut_addr, sizeof(env.dut_addr));
568         close(sockfd);
569
570         return n == ntohs(tlv->len) ? 0 : -EINVAL;
571 }
572
573 static int tester_run(struct xdp_features *skel)
574 {
575         int flags = XDP_FLAGS_UPDATE_IF_NOEXIST | XDP_FLAGS_DRV_MODE;
576         unsigned long long advertised_feature;
577         struct bpf_program *prog;
578         unsigned int stats;
579         int i, err, sockfd;
580         bool detected_cap;
581
582         sockfd = socket(AF_INET6, SOCK_STREAM, 0);
583         if (sockfd < 0) {
584                 fprintf(stderr,
585                         "Failed creating tester service control socket\n");
586                 return -errno;
587         }
588
589         if (settimeo(sockfd, 1000) < 0)
590                 return -EINVAL;
591
592         err = connect(sockfd, (struct sockaddr *)&env.dut_ctrl_addr,
593                       sizeof(env.dut_ctrl_addr));
594         if (err) {
595                 fprintf(stderr,
596                         "Failed connecting to the Device Under Test control socket\n");
597                 return -errno;
598         }
599
600         err = send_and_recv_msg(sockfd, CMD_GET_XDP_CAP, &advertised_feature,
601                                 sizeof(advertised_feature));
602         if (err < 0) {
603                 close(sockfd);
604                 return err;
605         }
606
607         advertised_feature = be64toh(advertised_feature);
608
609         if (env.feature.drv_feature == NETDEV_XDP_ACT_NDO_XMIT ||
610             env.feature.action == XDP_TX)
611                 prog = skel->progs.xdp_tester_check_tx;
612         else
613                 prog = skel->progs.xdp_tester_check_rx;
614
615         err = bpf_xdp_attach(env.ifindex, bpf_program__fd(prog), flags, NULL);
616         if (err) {
617                 fprintf(stderr, "Failed attaching XDP program to device %s\n",
618                         env.ifname);
619                 goto out;
620         }
621
622         err = send_and_recv_msg(sockfd, CMD_START, NULL, 0);
623         if (err)
624                 goto out;
625
626         for (i = 0; i < 10 && !exiting; i++) {
627                 err = send_echo_msg();
628                 if (err < 0)
629                         goto out;
630
631                 sleep(1);
632         }
633
634         err = send_and_recv_msg(sockfd, CMD_GET_STATS, &stats, sizeof(stats));
635         if (err)
636                 goto out;
637
638         /* stop the test */
639         err = send_and_recv_msg(sockfd, CMD_STOP, NULL, 0);
640         /* send a new echo message to wake echo thread of the dut */
641         send_echo_msg();
642
643         detected_cap = tester_collect_detected_cap(skel, ntohl(stats));
644
645         fprintf(stdout, "Feature %s: [%s][%s]\n", get_xdp_feature_str(),
646                 detected_cap ? GREEN("DETECTED") : RED("NOT DETECTED"),
647                 env.feature.drv_feature & advertised_feature ? GREEN("ADVERTISED")
648                                                              : RED("NOT ADVERTISED"));
649 out:
650         bpf_xdp_detach(env.ifindex, flags, NULL);
651         close(sockfd);
652         return err < 0 ? err : 0;
653 }
654
655 int main(int argc, char **argv)
656 {
657         struct xdp_features *skel;
658         int err;
659
660         libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
661         libbpf_set_print(libbpf_print_fn);
662
663         signal(SIGINT, sig_handler);
664         signal(SIGTERM, sig_handler);
665
666         set_env_default();
667
668         /* Parse command line arguments */
669         err = argp_parse(&argp, argc, argv, 0, NULL, NULL);
670         if (err)
671                 return err;
672
673         if (env.ifindex < 0) {
674                 fprintf(stderr, "Invalid device name %s\n", env.ifname);
675                 return -ENODEV;
676         }
677
678         /* Load and verify BPF application */
679         skel = xdp_features__open();
680         if (!skel) {
681                 fprintf(stderr, "Failed to open and load BPF skeleton\n");
682                 return -EINVAL;
683         }
684
685         skel->rodata->tester_addr =
686                 ((struct sockaddr_in6 *)&env.tester_addr)->sin6_addr;
687         skel->rodata->dut_addr =
688                 ((struct sockaddr_in6 *)&env.dut_addr)->sin6_addr;
689
690         /* Load & verify BPF programs */
691         err = xdp_features__load(skel);
692         if (err) {
693                 fprintf(stderr, "Failed to load and verify BPF skeleton\n");
694                 goto cleanup;
695         }
696
697         err = xdp_features__attach(skel);
698         if (err) {
699                 fprintf(stderr, "Failed to attach BPF skeleton\n");
700                 goto cleanup;
701         }
702
703         if (env.is_tester) {
704                 /* Tester */
705                 fprintf(stdout, "Starting tester service on device %s\n",
706                         env.ifname);
707                 err = tester_run(skel);
708         } else {
709                 /* DUT */
710                 fprintf(stdout, "Starting test on device %s\n", env.ifname);
711                 err = dut_run(skel);
712         }
713
714 cleanup:
715         xdp_features__destroy(skel);
716
717         return err < 0 ? -err : 0;
718 }
This page took 0.069171 seconds and 4 git commands to generate.