1 // SPDX-License-Identifier: GPL-2.0
2
3 #define _GNU_SOURCE
4
5 #include <arpa/inet.h>
6 #include <errno.h>
7 #include <error.h>
8 #include <linux/errqueue.h>
9 #include <linux/net_tstamp.h>
10 #include <netinet/if_ether.h>
11 #include <netinet/in.h>
12 #include <netinet/ip.h>
13 #include <netinet/ip6.h>
14 #include <netinet/udp.h>
15 #include <poll.h>
16 #include <sched.h>
17 #include <signal.h>
18 #include <stdbool.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <sys/socket.h>
23 #include <sys/time.h>
24 #include <sys/poll.h>
25 #include <sys/types.h>
26 #include <unistd.h>
27
28 #include "../kselftest.h"
29
30 #ifndef ETH_MAX_MTU
31 #define ETH_MAX_MTU 0xFFFFU
32 #endif
33
34 #ifndef UDP_SEGMENT
35 #define UDP_SEGMENT 103
36 #endif
37
38 #ifndef SO_ZEROCOPY
39 #define SO_ZEROCOPY 60
40 #endif
41
42 #ifndef SO_EE_ORIGIN_ZEROCOPY
43 #define SO_EE_ORIGIN_ZEROCOPY 5
44 #endif
45
46 #ifndef MSG_ZEROCOPY
47 #define MSG_ZEROCOPY 0x4000000
48 #endif
49
50 #ifndef ENOTSUPP
51 #define ENOTSUPP 524
52 #endif
53
54 #define NUM_PKT 100
55
56 static bool cfg_cache_trash;
57 static int cfg_cpu = -1;
58 static int cfg_connected = true;
59 static int cfg_family = PF_UNSPEC;
60 static uint16_t cfg_mss;
61 static int cfg_payload_len = (1472 * 42);
62 static int cfg_port = 8000;
63 static int cfg_runtime_ms = -1;
64 static bool cfg_poll;
65 static int cfg_poll_loop_timeout_ms = 2000;
66 static bool cfg_segment;
67 static bool cfg_sendmmsg;
68 static bool cfg_tcp;
69 static uint32_t cfg_tx_ts = SOF_TIMESTAMPING_TX_SOFTWARE;
70 static bool cfg_tx_tstamp;
71 static bool cfg_audit;
72 static bool cfg_verbose;
73 static bool cfg_zerocopy;
74 static int cfg_msg_nr;
75 static uint16_t cfg_gso_size;
76 static unsigned long total_num_msgs;
77 static unsigned long total_num_sends;
78 static unsigned long stat_tx_ts;
79 static unsigned long stat_tx_ts_errors;
80 static unsigned long tstart;
81 static unsigned long tend;
82 static unsigned long stat_zcopies;
83
84 static socklen_t cfg_alen;
85 static struct sockaddr_storage cfg_dst_addr;
86
87 static bool interrupted;
88 static char buf[NUM_PKT][ETH_MAX_MTU];
89
90 static void sigint_handler(int signum)
91 {
92 if (signum == SIGINT)
93 interrupted = true;
94 }
95
96 static unsigned long gettimeofday_ms(void)
97 {
98 struct timeval tv;
99
100 gettimeofday(&tv, NULL);
101 return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
102 }
103
104 static int set_cpu(int cpu)
105 {
106 cpu_set_t mask;
107
108 CPU_ZERO(&mask);
109 CPU_SET(cpu, &mask);
110 if (sched_setaffinity(0, sizeof(mask), &mask))
111 error(1, 0, "setaffinity %d", cpu);
112
113 return 0;
114 }
115
116 static void setup_sockaddr(int domain, const char *str_addr, void *sockaddr)
117 {
118 struct sockaddr_in6 *addr6 = (void *) sockaddr;
119 struct sockaddr_in *addr4 = (void *) sockaddr;
120
121 switch (domain) {
122 case PF_INET:
123 addr4->sin_family = AF_INET;
124 addr4->sin_port = htons(cfg_port);
125 if (inet_pton(AF_INET, str_addr, &(addr4->sin_addr)) != 1)
126 error(1, 0, "ipv4 parse error: %s", str_addr);
127 break;
128 case PF_INET6:
129 addr6->sin6_family = AF_INET6;
130 addr6->sin6_port = htons(cfg_port);
131 if (inet_pton(AF_INET6, str_addr, &(addr6->sin6_addr)) != 1)
132 error(1, 0, "ipv6 parse error: %s", str_addr);
133 break;
134 default:
135 error(1, 0, "illegal domain");
136 }
137 }
138
139 static void flush_cmsg(struct cmsghdr *cmsg)
140 {
141 struct sock_extended_err *err;
142 struct scm_timestamping *tss;
143 __u32 lo;
144 __u32 hi;
145 int i;
146
147 switch (cmsg->cmsg_level) {
148 case SOL_SOCKET:
149 if (cmsg->cmsg_type == SO_TIMESTAMPING) {
150 i = (cfg_tx_ts == SOF_TIMESTAMPING_TX_HARDWARE) ? 2 : 0;
151 tss = (struct scm_timestamping *)CMSG_DATA(cmsg);
152 if (tss->ts[i].tv_sec == 0)
153 stat_tx_ts_errors++;
154 } else {
155 error(1, 0, "unknown SOL_SOCKET cmsg type=%u\n",
156 cmsg->cmsg_type);
157 }
158 break;
159 case SOL_IP:
160 case SOL_IPV6:
161 switch (cmsg->cmsg_type) {
162 case IP_RECVERR:
163 case IPV6_RECVERR:
164 {
165 err = (struct sock_extended_err *)CMSG_DATA(cmsg);
166 switch (err->ee_origin) {
167 case SO_EE_ORIGIN_TIMESTAMPING:
168 /* Got a TX timestamp from error queue */
169 stat_tx_ts++;
170 break;
171 case SO_EE_ORIGIN_ICMP:
172 case SO_EE_ORIGIN_ICMP6:
173 if (cfg_verbose)
174 fprintf(stderr,
175 "received ICMP error: type=%u, code=%u\n",
176 err->ee_type, err->ee_code);
177 break;
178 case SO_EE_ORIGIN_ZEROCOPY:
179 {
180 lo = err->ee_info;
181 hi = err->ee_data;
182 /* range of IDs acknowledged */
183 stat_zcopies += hi - lo + 1;
184 break;
185 }
186 case SO_EE_ORIGIN_LOCAL:
187 if (cfg_verbose)
188 fprintf(stderr,
189 "received packet with local origin: %u\n",
190 err->ee_origin);
191 break;
192 default:
193 error(0, 1, "received packet with origin: %u",
194 err->ee_origin);
195 }
196 break;
197 }
198 default:
199 error(0, 1, "unknown IP msg type=%u\n",
200 cmsg->cmsg_type);
201 break;
202 }
203 break;
204 default:
205 error(0, 1, "unknown cmsg level=%u\n",
206 cmsg->cmsg_level);
207 }
208 }
209
210 static void flush_errqueue_recv(int fd)
211 {
212 char control[CMSG_SPACE(sizeof(struct scm_timestamping)) +
213 CMSG_SPACE(sizeof(struct sock_extended_err)) +
214 CMSG_SPACE(sizeof(struct sockaddr_in6))] = {0};
215 struct msghdr msg = {0};
216 struct cmsghdr *cmsg;
217 int ret;
218
219 while (1) {
220 msg.msg_control = control;
221 msg.msg_controllen = sizeof(control);
222 ret = recvmsg(fd, &msg, MSG_ERRQUEUE);
223 if (ret == -1 && errno == EAGAIN)
224 break;
225 if (ret == -1)
226 error(1, errno, "errqueue");
227 if (msg.msg_flags != MSG_ERRQUEUE)
228 error(1, 0, "errqueue: flags 0x%x\n", msg.msg_flags);
229 if (cfg_audit) {
230 for (cmsg = CMSG_FIRSTHDR(&msg);
231 cmsg;
232 cmsg = CMSG_NXTHDR(&msg, cmsg))
233 flush_cmsg(cmsg);
234 }
235 msg.msg_flags = 0;
236 }
237 }
238
239 static void flush_errqueue(int fd, const bool do_poll,
240 unsigned long poll_timeout, const bool poll_err)
241 {
242 if (do_poll) {
243 struct pollfd fds = {0};
244 int ret;
245
246 fds.fd = fd;
247 ret = poll(&fds, 1, poll_timeout);
248 if (ret == 0) {
249 if ((cfg_verbose) && (poll_err))
250 fprintf(stderr, "poll timeout\n");
251 } else if (ret < 0) {
252 error(1, errno, "poll");
253 }
254 }
255
256 flush_errqueue_recv(fd);
257 }
258
259 static void flush_errqueue_retry(int fd, unsigned long num_sends)
260 {
261 unsigned long tnow, tstop;
262 bool first_try = true;
263
264 tnow = gettimeofday_ms();
265 tstop = tnow + cfg_poll_loop_timeout_ms;
266 do {
267 flush_errqueue(fd, true, tstop - tnow, first_try);
268 first_try = false;
269 tnow = gettimeofday_ms();
270 } while ((stat_zcopies != num_sends) && (tnow < tstop));
271 }
272
273 static int send_tcp(int fd, char *data)
274 {
275 int ret, done = 0, count = 0;
276
277 while (done < cfg_payload_len) {
278 ret = send(fd, data + done, cfg_payload_len - done,
279 cfg_zerocopy ? MSG_ZEROCOPY : 0);
280 if (ret == -1)
281 error(1, errno, "write");
282
283 done += ret;
284 count++;
285 }
286
287 return count;
288 }
289
290 static int send_udp(int fd, char *data)
291 {
292 int ret, total_len, len, count = 0;
293
294 total_len = cfg_payload_len;
295
296 while (total_len) {
297 len = total_len < cfg_mss ? total_len : cfg_mss;
298
299 ret = sendto(fd, data, len, cfg_zerocopy ? MSG_ZEROCOPY : 0,
300 cfg_connected ? NULL : (void *)&cfg_dst_addr,
301 cfg_connected ? 0 : cfg_alen);
302 if (ret == -1)
303 error(1, errno, "write");
304 if (ret != len)
305 error(1, errno, "write: %uB != %uB\n", ret, len);
306
307 total_len -= len;
308 count++;
309 }
310
311 return count;
312 }
313
314 static void send_ts_cmsg(struct cmsghdr *cm)
315 {
316 uint32_t *valp;
317
318 cm->cmsg_level = SOL_SOCKET;
319 cm->cmsg_type = SO_TIMESTAMPING;
320 cm->cmsg_len = CMSG_LEN(sizeof(cfg_tx_ts));
321 valp = (void *)CMSG_DATA(cm);
322 *valp = cfg_tx_ts;
323 }
324
325 static int send_udp_sendmmsg(int fd, char *data)
326 {
327 char control[CMSG_SPACE(sizeof(cfg_tx_ts))] = {0};
328 const int max_nr_msg = ETH_MAX_MTU / ETH_DATA_LEN;
329 struct mmsghdr mmsgs[max_nr_msg];
330 struct iovec iov[max_nr_msg];
331 unsigned int off = 0, left;
332 size_t msg_controllen = 0;
333 int i = 0, ret;
334
335 memset(mmsgs, 0, sizeof(mmsgs));
336
337 if (cfg_tx_tstamp) {
338 struct msghdr msg = {0};
339 struct cmsghdr *cmsg;
340
341 msg.msg_control = control;
342 msg.msg_controllen = sizeof(control);
343 cmsg = CMSG_FIRSTHDR(&msg);
344 send_ts_cmsg(cmsg);
345 msg_controllen += CMSG_SPACE(sizeof(cfg_tx_ts));
346 }
347
348 left = cfg_payload_len;
349 while (left) {
350 if (i == max_nr_msg)
351 error(1, 0, "sendmmsg: exceeds max_nr_msg");
352
353 iov[i].iov_base = data + off;
354 iov[i].iov_len = cfg_mss < left ? cfg_mss : left;
355
356 mmsgs[i].msg_hdr.msg_iov = iov + i;
357 mmsgs[i].msg_hdr.msg_iovlen = 1;
358
359 mmsgs[i].msg_hdr.msg_name = (void *)&cfg_dst_addr;
360 mmsgs[i].msg_hdr.msg_namelen = cfg_alen;
361 if (msg_controllen) {
362 mmsgs[i].msg_hdr.msg_control = control;
363 mmsgs[i].msg_hdr.msg_controllen = msg_controllen;
364 }
365
366 off += iov[i].iov_len;
367 left -= iov[i].iov_len;
368 i++;
369 }
370
371 ret = sendmmsg(fd, mmsgs, i, cfg_zerocopy ? MSG_ZEROCOPY : 0);
372 if (ret == -1)
373 error(1, errno, "sendmmsg");
374
375 return ret;
376 }
377
378 static void send_udp_segment_cmsg(struct cmsghdr *cm)
379 {
380 uint16_t *valp;
381
382 cm->cmsg_level = SOL_UDP;
383 cm->cmsg_type = UDP_SEGMENT;
384 cm->cmsg_len = CMSG_LEN(sizeof(cfg_gso_size));
385 valp = (void *)CMSG_DATA(cm);
386 *valp = cfg_gso_size;
387 }
388
389 static int send_udp_segment(int fd, char *data)
390 {
391 char control[CMSG_SPACE(sizeof(cfg_gso_size)) +
392 CMSG_SPACE(sizeof(cfg_tx_ts))] = {0};
393 struct msghdr msg = {0};
394 struct iovec iov = {0};
395 size_t msg_controllen;
396 struct cmsghdr *cmsg;
397 int ret;
398
399 iov.iov_base = data;
400 iov.iov_len = cfg_payload_len;
401
402 msg.msg_iov = &iov;
403 msg.msg_iovlen = 1;
404
405 msg.msg_control = control;
406 msg.msg_controllen = sizeof(control);
407 cmsg = CMSG_FIRSTHDR(&msg);
408 send_udp_segment_cmsg(cmsg);
409 msg_controllen = CMSG_SPACE(sizeof(cfg_mss));
410 if (cfg_tx_tstamp) {
411 cmsg = CMSG_NXTHDR(&msg, cmsg);
412 send_ts_cmsg(cmsg);
413 msg_controllen += CMSG_SPACE(sizeof(cfg_tx_ts));
414 }
415
416 msg.msg_controllen = msg_controllen;
417 msg.msg_name = (void *)&cfg_dst_addr;
418 msg.msg_namelen = cfg_alen;
419
420 ret = sendmsg(fd, &msg, cfg_zerocopy ? MSG_ZEROCOPY : 0);
421 if (ret == -1)
422 error(1, errno, "sendmsg");
423 if (ret != iov.iov_len)
424 error(1, 0, "sendmsg: %u != %llu\n", ret,
425 (unsigned long long)iov.iov_len);
426
427 return 1;
428 }
429
430 static void usage(const char *filepath)
431 {
432 error(1, 0, "Usage: %s [-46acmHPtTuvz] [-C cpu] [-D dst ip] [-l secs] "
433 "[-L secs] [-M messagenr] [-p port] [-s sendsize] [-S gsosize]",
434 filepath);
435 }
436
437 static void parse_opts(int argc, char **argv)
438 {
439 const char *bind_addr = NULL;
440 int max_len, hdrlen;
441 int c;
442
443 while ((c = getopt(argc, argv, "46acC:D:Hl:L:mM:p:s:PS:tTuvz")) != -1) {
444 switch (c) {
445 case '4':
446 if (cfg_family != PF_UNSPEC)
447 error(1, 0, "Pass one of -4 or -6");
448 cfg_family = PF_INET;
449 cfg_alen = sizeof(struct sockaddr_in);
450 break;
451 case '6':
452 if (cfg_family != PF_UNSPEC)
453 error(1, 0, "Pass one of -4 or -6");
454 cfg_family = PF_INET6;
455 cfg_alen = sizeof(struct sockaddr_in6);
456 break;
457 case 'a':
458 cfg_audit = true;
459 break;
460 case 'c':
461 cfg_cache_trash = true;
462 break;
463 case 'C':
464 cfg_cpu = strtol(optarg, NULL, 0);
465 break;
466 case 'D':
467 bind_addr = optarg;
468 break;
469 case 'l':
470 cfg_runtime_ms = strtoul(optarg, NULL, 10) * 1000;
471 break;
472 case 'L':
473 cfg_poll_loop_timeout_ms = strtoul(optarg, NULL, 10) * 1000;
474 break;
475 case 'm':
476 cfg_sendmmsg = true;
477 break;
478 case 'M':
479 cfg_msg_nr = strtoul(optarg, NULL, 10);
480 break;
481 case 'p':
482 cfg_port = strtoul(optarg, NULL, 0);
483 break;
484 case 'P':
485 cfg_poll = true;
486 break;
487 case 's':
488 cfg_payload_len = strtoul(optarg, NULL, 0);
489 break;
490 case 'S':
491 cfg_gso_size = strtoul(optarg, NULL, 0);
492 cfg_segment = true;
493 break;
494 case 'H':
495 cfg_tx_ts = SOF_TIMESTAMPING_TX_HARDWARE;
496 cfg_tx_tstamp = true;
497 break;
498 case 't':
499 cfg_tcp = true;
500 break;
501 case 'T':
502 cfg_tx_tstamp = true;
503 break;
504 case 'u':
505 cfg_connected = false;
506 break;
507 case 'v':
508 cfg_verbose = true;
509 break;
510 case 'z':
511 cfg_zerocopy = true;
512 break;
513 default:
514 exit(1);
515 }
516 }
517
518 if (!bind_addr)
519 bind_addr = cfg_family == PF_INET6 ? "::" : "0.0.0.0";
520
521 setup_sockaddr(cfg_family, bind_addr, &cfg_dst_addr);
522
523 if (optind != argc)
524 usage(argv[0]);
525
526 if (cfg_family == PF_UNSPEC)
527 error(1, 0, "must pass one of -4 or -6");
528 if (cfg_tcp && !cfg_connected)
529 error(1, 0, "connectionless tcp makes no sense");
530 if (cfg_segment && cfg_sendmmsg)
531 error(1, 0, "cannot combine segment offload and sendmmsg");
532 if (cfg_tx_tstamp && !(cfg_segment || cfg_sendmmsg))
533 error(1, 0, "Options -T and -H require either -S or -m option");
534
535 if (cfg_family == PF_INET)
536 hdrlen = sizeof(struct iphdr) + sizeof(struct udphdr);
537 else
538 hdrlen = sizeof(struct ip6_hdr) + sizeof(struct udphdr);
539
540 cfg_mss = ETH_DATA_LEN - hdrlen;
541 max_len = ETH_MAX_MTU - hdrlen;
542 if (!cfg_gso_size)
543 cfg_gso_size = cfg_mss;
544
545 if (cfg_payload_len > max_len)
546 error(1, 0, "payload length %u exceeds max %u",
547 cfg_payload_len, max_len);
548 }
549
550 static void set_pmtu_discover(int fd, bool is_ipv4)
551 {
552 int level, name, val;
553
554 if (is_ipv4) {
555 level = SOL_IP;
556 name = IP_MTU_DISCOVER;
557 val = IP_PMTUDISC_DO;
558 } else {
559 level = SOL_IPV6;
560 name = IPV6_MTU_DISCOVER;
561 val = IPV6_PMTUDISC_DO;
562 }
563
564 if (setsockopt(fd, level, name, &val, sizeof(val)))
565 error(1, errno, "setsockopt path mtu");
566 }
567
568 static void set_tx_timestamping(int fd)
569 {
570 int val = SOF_TIMESTAMPING_OPT_CMSG | SOF_TIMESTAMPING_OPT_ID |
571 SOF_TIMESTAMPING_OPT_TSONLY;
572
573 if (cfg_tx_ts == SOF_TIMESTAMPING_TX_SOFTWARE)
574 val |= SOF_TIMESTAMPING_SOFTWARE;
575 else
576 val |= SOF_TIMESTAMPING_RAW_HARDWARE;
577
578 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &val, sizeof(val)))
579 error(1, errno, "setsockopt tx timestamping");
580 }
581
582 static void print_audit_report(unsigned long num_msgs, unsigned long num_sends)
583 {
584 unsigned long tdelta;
585
586 tdelta = tend - tstart;
587 if (!tdelta)
588 return;
589
590 fprintf(stderr, "Summary over %lu.%03lu seconds...\n",
591 tdelta / 1000, tdelta % 1000);
592 fprintf(stderr,
593 "sum %s tx: %6lu MB/s %10lu calls (%lu/s) %10lu msgs (%lu/s)\n",
594 cfg_tcp ? "tcp" : "udp",
595 ((num_msgs * cfg_payload_len) >> 10) / tdelta,
596 num_sends, num_sends * 1000 / tdelta,
597 num_msgs, num_msgs * 1000 / tdelta);
598
599 if (cfg_tx_tstamp) {
600 if (stat_tx_ts_errors)
601 error(1, 0,
602 "Expected clean TX Timestamps: %9lu msgs received %6lu errors",
603 stat_tx_ts, stat_tx_ts_errors);
604 if (stat_tx_ts != num_sends)
605 error(1, 0,
606 "Unexpected number of TX Timestamps: %9lu expected %9lu received",
607 num_sends, stat_tx_ts);
608 fprintf(stderr,
609 "Tx Timestamps: %19lu received %17lu errors\n",
610 stat_tx_ts, stat_tx_ts_errors);
611 }
612
613 if (cfg_zerocopy) {
614 if (stat_zcopies != num_sends)
615 error(1, 0, "Unexpected number of Zerocopy completions: %9lu expected %9lu received",
616 num_sends, stat_zcopies);
617 fprintf(stderr,
618 "Zerocopy acks: %19lu\n",
619 stat_zcopies);
620 }
621 }
622
623 static void print_report(unsigned long num_msgs, unsigned long num_sends)
624 {
625 fprintf(stderr,
626 "%s tx: %6lu MB/s %8lu calls/s %6lu msg/s\n",
627 cfg_tcp ? "tcp" : "udp",
628 (num_msgs * cfg_payload_len) >> 20,
629 num_sends, num_msgs);
630
631 if (cfg_audit) {
632 total_num_msgs += num_msgs;
633 total_num_sends += num_sends;
634 }
635 }
636
637 int main(int argc, char **argv)
638 {
639 unsigned long num_msgs, num_sends;
640 unsigned long tnow, treport, tstop;
641 int fd, i, val, ret;
642
643 parse_opts(argc, argv);
644
645 if (cfg_cpu > 0)
646 set_cpu(cfg_cpu);
647
648 for (i = 0; i < sizeof(buf[0]); i++)
649 buf[0][i] = 'a' + (i % 26);
650 for (i = 1; i < NUM_PKT; i++)
651 memcpy(buf[i], buf[0], sizeof(buf[0]));
652
653 signal(SIGINT, sigint_handler);
654
655 fd = socket(cfg_family, cfg_tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
656 if (fd == -1)
657 error(1, errno, "socket");
658
659 if (cfg_zerocopy) {
660 val = 1;
661
662 ret = setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY,
663 &val, sizeof(val));
664 if (ret) {
665 if (errno == ENOPROTOOPT || errno == ENOTSUPP) {
666 fprintf(stderr, "SO_ZEROCOPY not supported");
667 exit(KSFT_SKIP);
668 }
669 error(1, errno, "setsockopt zerocopy");
670 }
671 }
672
673 if (cfg_connected &&
674 connect(fd, (void *)&cfg_dst_addr, cfg_alen))
675 error(1, errno, "connect");
676
677 if (cfg_segment)
678 set_pmtu_discover(fd, cfg_family == PF_INET);
679
680 if (cfg_tx_tstamp)
681 set_tx_timestamping(fd);
682
683 num_msgs = num_sends = 0;
684 tnow = gettimeofday_ms();
685 tstart = tnow;
686 tend = tnow;
687 tstop = tnow + cfg_runtime_ms;
688 treport = tnow + 1000;
689
690 i = 0;
691 do {
692 if (cfg_tcp)
693 num_sends += send_tcp(fd, buf[i]);
694 else if (cfg_segment)
695 num_sends += send_udp_segment(fd, buf[i]);
696 else if (cfg_sendmmsg)
697 num_sends += send_udp_sendmmsg(fd, buf[i]);
698 else
699 num_sends += send_udp(fd, buf[i]);
700 num_msgs++;
701 if ((cfg_zerocopy && ((num_msgs & 0xF) == 0)) || cfg_tx_tstamp)
702 flush_errqueue(fd, cfg_poll, 500, true);
703
704 if (cfg_msg_nr && num_msgs >= cfg_msg_nr)
705 break;
706
707 tnow = gettimeofday_ms();
708 if (tnow >= treport) {
709 print_report(num_msgs, num_sends);
710 num_msgs = num_sends = 0;
711 treport = tnow + 1000;
712 }
713
714 /* cold cache when writing buffer */
715 if (cfg_cache_trash)
716 i = ++i < NUM_PKT ? i : 0;
717
718 } while (!interrupted && (cfg_runtime_ms == -1 || tnow < tstop));
719
720 if (cfg_zerocopy || cfg_tx_tstamp)
721 flush_errqueue_retry(fd, num_sends);
722
723 if (close(fd))
724 error(1, errno, "close");
725
726 if (cfg_audit) {
727 tend = tnow;
728 total_num_msgs += num_msgs;
729 total_num_sends += num_sends;
730 print_audit_report(total_num_msgs, total_num_sends);
731 }
732
733 return 0;
734 }
735
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.