0001
0002
0003 #define _GNU_SOURCE
0004
0005 #include <arpa/inet.h>
0006 #include <errno.h>
0007 #include <error.h>
0008 #include <linux/errqueue.h>
0009 #include <linux/net_tstamp.h>
0010 #include <netinet/if_ether.h>
0011 #include <netinet/in.h>
0012 #include <netinet/ip.h>
0013 #include <netinet/ip6.h>
0014 #include <netinet/udp.h>
0015 #include <poll.h>
0016 #include <sched.h>
0017 #include <signal.h>
0018 #include <stdbool.h>
0019 #include <stdio.h>
0020 #include <stdlib.h>
0021 #include <string.h>
0022 #include <sys/socket.h>
0023 #include <sys/time.h>
0024 #include <sys/poll.h>
0025 #include <sys/types.h>
0026 #include <unistd.h>
0027
0028 #include "../kselftest.h"
0029
0030 #ifndef ETH_MAX_MTU
0031 #define ETH_MAX_MTU 0xFFFFU
0032 #endif
0033
0034 #ifndef UDP_SEGMENT
0035 #define UDP_SEGMENT 103
0036 #endif
0037
0038 #ifndef SO_ZEROCOPY
0039 #define SO_ZEROCOPY 60
0040 #endif
0041
0042 #ifndef SO_EE_ORIGIN_ZEROCOPY
0043 #define SO_EE_ORIGIN_ZEROCOPY 5
0044 #endif
0045
0046 #ifndef MSG_ZEROCOPY
0047 #define MSG_ZEROCOPY 0x4000000
0048 #endif
0049
0050 #ifndef ENOTSUPP
0051 #define ENOTSUPP 524
0052 #endif
0053
0054 #define NUM_PKT 100
0055
0056 static bool cfg_cache_trash;
0057 static int cfg_cpu = -1;
0058 static int cfg_connected = true;
0059 static int cfg_family = PF_UNSPEC;
0060 static uint16_t cfg_mss;
0061 static int cfg_payload_len = (1472 * 42);
0062 static int cfg_port = 8000;
0063 static int cfg_runtime_ms = -1;
0064 static bool cfg_poll;
0065 static bool cfg_segment;
0066 static bool cfg_sendmmsg;
0067 static bool cfg_tcp;
0068 static uint32_t cfg_tx_ts = SOF_TIMESTAMPING_TX_SOFTWARE;
0069 static bool cfg_tx_tstamp;
0070 static bool cfg_audit;
0071 static bool cfg_verbose;
0072 static bool cfg_zerocopy;
0073 static int cfg_msg_nr;
0074 static uint16_t cfg_gso_size;
0075 static unsigned long total_num_msgs;
0076 static unsigned long total_num_sends;
0077 static unsigned long stat_tx_ts;
0078 static unsigned long stat_tx_ts_errors;
0079 static unsigned long tstart;
0080 static unsigned long tend;
0081 static unsigned long stat_zcopies;
0082
0083 static socklen_t cfg_alen;
0084 static struct sockaddr_storage cfg_dst_addr;
0085
0086 static bool interrupted;
0087 static char buf[NUM_PKT][ETH_MAX_MTU];
0088
0089 static void sigint_handler(int signum)
0090 {
0091 if (signum == SIGINT)
0092 interrupted = true;
0093 }
0094
0095 static unsigned long gettimeofday_ms(void)
0096 {
0097 struct timeval tv;
0098
0099 gettimeofday(&tv, NULL);
0100 return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
0101 }
0102
0103 static int set_cpu(int cpu)
0104 {
0105 cpu_set_t mask;
0106
0107 CPU_ZERO(&mask);
0108 CPU_SET(cpu, &mask);
0109 if (sched_setaffinity(0, sizeof(mask), &mask))
0110 error(1, 0, "setaffinity %d", cpu);
0111
0112 return 0;
0113 }
0114
0115 static void setup_sockaddr(int domain, const char *str_addr, void *sockaddr)
0116 {
0117 struct sockaddr_in6 *addr6 = (void *) sockaddr;
0118 struct sockaddr_in *addr4 = (void *) sockaddr;
0119
0120 switch (domain) {
0121 case PF_INET:
0122 addr4->sin_family = AF_INET;
0123 addr4->sin_port = htons(cfg_port);
0124 if (inet_pton(AF_INET, str_addr, &(addr4->sin_addr)) != 1)
0125 error(1, 0, "ipv4 parse error: %s", str_addr);
0126 break;
0127 case PF_INET6:
0128 addr6->sin6_family = AF_INET6;
0129 addr6->sin6_port = htons(cfg_port);
0130 if (inet_pton(AF_INET6, str_addr, &(addr6->sin6_addr)) != 1)
0131 error(1, 0, "ipv6 parse error: %s", str_addr);
0132 break;
0133 default:
0134 error(1, 0, "illegal domain");
0135 }
0136 }
0137
0138 static void flush_cmsg(struct cmsghdr *cmsg)
0139 {
0140 struct sock_extended_err *err;
0141 struct scm_timestamping *tss;
0142 __u32 lo;
0143 __u32 hi;
0144 int i;
0145
0146 switch (cmsg->cmsg_level) {
0147 case SOL_SOCKET:
0148 if (cmsg->cmsg_type == SO_TIMESTAMPING) {
0149 i = (cfg_tx_ts == SOF_TIMESTAMPING_TX_HARDWARE) ? 2 : 0;
0150 tss = (struct scm_timestamping *)CMSG_DATA(cmsg);
0151 if (tss->ts[i].tv_sec == 0)
0152 stat_tx_ts_errors++;
0153 } else {
0154 error(1, 0, "unknown SOL_SOCKET cmsg type=%u\n",
0155 cmsg->cmsg_type);
0156 }
0157 break;
0158 case SOL_IP:
0159 case SOL_IPV6:
0160 switch (cmsg->cmsg_type) {
0161 case IP_RECVERR:
0162 case IPV6_RECVERR:
0163 {
0164 err = (struct sock_extended_err *)CMSG_DATA(cmsg);
0165 switch (err->ee_origin) {
0166 case SO_EE_ORIGIN_TIMESTAMPING:
0167
0168 stat_tx_ts++;
0169 break;
0170 case SO_EE_ORIGIN_ICMP:
0171 case SO_EE_ORIGIN_ICMP6:
0172 if (cfg_verbose)
0173 fprintf(stderr,
0174 "received ICMP error: type=%u, code=%u\n",
0175 err->ee_type, err->ee_code);
0176 break;
0177 case SO_EE_ORIGIN_ZEROCOPY:
0178 {
0179 lo = err->ee_info;
0180 hi = err->ee_data;
0181
0182 stat_zcopies += hi - lo + 1;
0183 break;
0184 }
0185 case SO_EE_ORIGIN_LOCAL:
0186 if (cfg_verbose)
0187 fprintf(stderr,
0188 "received packet with local origin: %u\n",
0189 err->ee_origin);
0190 break;
0191 default:
0192 error(0, 1, "received packet with origin: %u",
0193 err->ee_origin);
0194 }
0195 break;
0196 }
0197 default:
0198 error(0, 1, "unknown IP msg type=%u\n",
0199 cmsg->cmsg_type);
0200 break;
0201 }
0202 break;
0203 default:
0204 error(0, 1, "unknown cmsg level=%u\n",
0205 cmsg->cmsg_level);
0206 }
0207 }
0208
0209 static void flush_errqueue_recv(int fd)
0210 {
0211 char control[CMSG_SPACE(sizeof(struct scm_timestamping)) +
0212 CMSG_SPACE(sizeof(struct sock_extended_err)) +
0213 CMSG_SPACE(sizeof(struct sockaddr_in6))] = {0};
0214 struct msghdr msg = {0};
0215 struct cmsghdr *cmsg;
0216 int ret;
0217
0218 while (1) {
0219 msg.msg_control = control;
0220 msg.msg_controllen = sizeof(control);
0221 ret = recvmsg(fd, &msg, MSG_ERRQUEUE);
0222 if (ret == -1 && errno == EAGAIN)
0223 break;
0224 if (ret == -1)
0225 error(1, errno, "errqueue");
0226 if (msg.msg_flags != MSG_ERRQUEUE)
0227 error(1, 0, "errqueue: flags 0x%x\n", msg.msg_flags);
0228 if (cfg_audit) {
0229 for (cmsg = CMSG_FIRSTHDR(&msg);
0230 cmsg;
0231 cmsg = CMSG_NXTHDR(&msg, cmsg))
0232 flush_cmsg(cmsg);
0233 }
0234 msg.msg_flags = 0;
0235 }
0236 }
0237
0238 static void flush_errqueue(int fd, const bool do_poll)
0239 {
0240 if (do_poll) {
0241 struct pollfd fds = {0};
0242 int ret;
0243
0244 fds.fd = fd;
0245 ret = poll(&fds, 1, 500);
0246 if (ret == 0) {
0247 if (cfg_verbose)
0248 fprintf(stderr, "poll timeout\n");
0249 } else if (ret < 0) {
0250 error(1, errno, "poll");
0251 }
0252 }
0253
0254 flush_errqueue_recv(fd);
0255 }
0256
0257 static int send_tcp(int fd, char *data)
0258 {
0259 int ret, done = 0, count = 0;
0260
0261 while (done < cfg_payload_len) {
0262 ret = send(fd, data + done, cfg_payload_len - done,
0263 cfg_zerocopy ? MSG_ZEROCOPY : 0);
0264 if (ret == -1)
0265 error(1, errno, "write");
0266
0267 done += ret;
0268 count++;
0269 }
0270
0271 return count;
0272 }
0273
0274 static int send_udp(int fd, char *data)
0275 {
0276 int ret, total_len, len, count = 0;
0277
0278 total_len = cfg_payload_len;
0279
0280 while (total_len) {
0281 len = total_len < cfg_mss ? total_len : cfg_mss;
0282
0283 ret = sendto(fd, data, len, cfg_zerocopy ? MSG_ZEROCOPY : 0,
0284 cfg_connected ? NULL : (void *)&cfg_dst_addr,
0285 cfg_connected ? 0 : cfg_alen);
0286 if (ret == -1)
0287 error(1, errno, "write");
0288 if (ret != len)
0289 error(1, errno, "write: %uB != %uB\n", ret, len);
0290
0291 total_len -= len;
0292 count++;
0293 }
0294
0295 return count;
0296 }
0297
0298 static void send_ts_cmsg(struct cmsghdr *cm)
0299 {
0300 uint32_t *valp;
0301
0302 cm->cmsg_level = SOL_SOCKET;
0303 cm->cmsg_type = SO_TIMESTAMPING;
0304 cm->cmsg_len = CMSG_LEN(sizeof(cfg_tx_ts));
0305 valp = (void *)CMSG_DATA(cm);
0306 *valp = cfg_tx_ts;
0307 }
0308
0309 static int send_udp_sendmmsg(int fd, char *data)
0310 {
0311 char control[CMSG_SPACE(sizeof(cfg_tx_ts))] = {0};
0312 const int max_nr_msg = ETH_MAX_MTU / ETH_DATA_LEN;
0313 struct mmsghdr mmsgs[max_nr_msg];
0314 struct iovec iov[max_nr_msg];
0315 unsigned int off = 0, left;
0316 size_t msg_controllen = 0;
0317 int i = 0, ret;
0318
0319 memset(mmsgs, 0, sizeof(mmsgs));
0320
0321 if (cfg_tx_tstamp) {
0322 struct msghdr msg = {0};
0323 struct cmsghdr *cmsg;
0324
0325 msg.msg_control = control;
0326 msg.msg_controllen = sizeof(control);
0327 cmsg = CMSG_FIRSTHDR(&msg);
0328 send_ts_cmsg(cmsg);
0329 msg_controllen += CMSG_SPACE(sizeof(cfg_tx_ts));
0330 }
0331
0332 left = cfg_payload_len;
0333 while (left) {
0334 if (i == max_nr_msg)
0335 error(1, 0, "sendmmsg: exceeds max_nr_msg");
0336
0337 iov[i].iov_base = data + off;
0338 iov[i].iov_len = cfg_mss < left ? cfg_mss : left;
0339
0340 mmsgs[i].msg_hdr.msg_iov = iov + i;
0341 mmsgs[i].msg_hdr.msg_iovlen = 1;
0342
0343 mmsgs[i].msg_hdr.msg_name = (void *)&cfg_dst_addr;
0344 mmsgs[i].msg_hdr.msg_namelen = cfg_alen;
0345 if (msg_controllen) {
0346 mmsgs[i].msg_hdr.msg_control = control;
0347 mmsgs[i].msg_hdr.msg_controllen = msg_controllen;
0348 }
0349
0350 off += iov[i].iov_len;
0351 left -= iov[i].iov_len;
0352 i++;
0353 }
0354
0355 ret = sendmmsg(fd, mmsgs, i, cfg_zerocopy ? MSG_ZEROCOPY : 0);
0356 if (ret == -1)
0357 error(1, errno, "sendmmsg");
0358
0359 return ret;
0360 }
0361
0362 static void send_udp_segment_cmsg(struct cmsghdr *cm)
0363 {
0364 uint16_t *valp;
0365
0366 cm->cmsg_level = SOL_UDP;
0367 cm->cmsg_type = UDP_SEGMENT;
0368 cm->cmsg_len = CMSG_LEN(sizeof(cfg_gso_size));
0369 valp = (void *)CMSG_DATA(cm);
0370 *valp = cfg_gso_size;
0371 }
0372
0373 static int send_udp_segment(int fd, char *data)
0374 {
0375 char control[CMSG_SPACE(sizeof(cfg_gso_size)) +
0376 CMSG_SPACE(sizeof(cfg_tx_ts))] = {0};
0377 struct msghdr msg = {0};
0378 struct iovec iov = {0};
0379 size_t msg_controllen;
0380 struct cmsghdr *cmsg;
0381 int ret;
0382
0383 iov.iov_base = data;
0384 iov.iov_len = cfg_payload_len;
0385
0386 msg.msg_iov = &iov;
0387 msg.msg_iovlen = 1;
0388
0389 msg.msg_control = control;
0390 msg.msg_controllen = sizeof(control);
0391 cmsg = CMSG_FIRSTHDR(&msg);
0392 send_udp_segment_cmsg(cmsg);
0393 msg_controllen = CMSG_SPACE(sizeof(cfg_mss));
0394 if (cfg_tx_tstamp) {
0395 cmsg = CMSG_NXTHDR(&msg, cmsg);
0396 send_ts_cmsg(cmsg);
0397 msg_controllen += CMSG_SPACE(sizeof(cfg_tx_ts));
0398 }
0399
0400 msg.msg_controllen = msg_controllen;
0401 msg.msg_name = (void *)&cfg_dst_addr;
0402 msg.msg_namelen = cfg_alen;
0403
0404 ret = sendmsg(fd, &msg, cfg_zerocopy ? MSG_ZEROCOPY : 0);
0405 if (ret == -1)
0406 error(1, errno, "sendmsg");
0407 if (ret != iov.iov_len)
0408 error(1, 0, "sendmsg: %u != %llu\n", ret,
0409 (unsigned long long)iov.iov_len);
0410
0411 return 1;
0412 }
0413
0414 static void usage(const char *filepath)
0415 {
0416 error(1, 0, "Usage: %s [-46acmHPtTuvz] [-C cpu] [-D dst ip] [-l secs] [-M messagenr] [-p port] [-s sendsize] [-S gsosize]",
0417 filepath);
0418 }
0419
0420 static void parse_opts(int argc, char **argv)
0421 {
0422 const char *bind_addr = NULL;
0423 int max_len, hdrlen;
0424 int c;
0425
0426 while ((c = getopt(argc, argv, "46acC:D:Hl:mM:p:s:PS:tTuvz")) != -1) {
0427 switch (c) {
0428 case '4':
0429 if (cfg_family != PF_UNSPEC)
0430 error(1, 0, "Pass one of -4 or -6");
0431 cfg_family = PF_INET;
0432 cfg_alen = sizeof(struct sockaddr_in);
0433 break;
0434 case '6':
0435 if (cfg_family != PF_UNSPEC)
0436 error(1, 0, "Pass one of -4 or -6");
0437 cfg_family = PF_INET6;
0438 cfg_alen = sizeof(struct sockaddr_in6);
0439 break;
0440 case 'a':
0441 cfg_audit = true;
0442 break;
0443 case 'c':
0444 cfg_cache_trash = true;
0445 break;
0446 case 'C':
0447 cfg_cpu = strtol(optarg, NULL, 0);
0448 break;
0449 case 'D':
0450 bind_addr = optarg;
0451 break;
0452 case 'l':
0453 cfg_runtime_ms = strtoul(optarg, NULL, 10) * 1000;
0454 break;
0455 case 'm':
0456 cfg_sendmmsg = true;
0457 break;
0458 case 'M':
0459 cfg_msg_nr = strtoul(optarg, NULL, 10);
0460 break;
0461 case 'p':
0462 cfg_port = strtoul(optarg, NULL, 0);
0463 break;
0464 case 'P':
0465 cfg_poll = true;
0466 break;
0467 case 's':
0468 cfg_payload_len = strtoul(optarg, NULL, 0);
0469 break;
0470 case 'S':
0471 cfg_gso_size = strtoul(optarg, NULL, 0);
0472 cfg_segment = true;
0473 break;
0474 case 'H':
0475 cfg_tx_ts = SOF_TIMESTAMPING_TX_HARDWARE;
0476 cfg_tx_tstamp = true;
0477 break;
0478 case 't':
0479 cfg_tcp = true;
0480 break;
0481 case 'T':
0482 cfg_tx_tstamp = true;
0483 break;
0484 case 'u':
0485 cfg_connected = false;
0486 break;
0487 case 'v':
0488 cfg_verbose = true;
0489 break;
0490 case 'z':
0491 cfg_zerocopy = true;
0492 break;
0493 }
0494 }
0495
0496 if (!bind_addr)
0497 bind_addr = cfg_family == PF_INET6 ? "::" : "0.0.0.0";
0498
0499 setup_sockaddr(cfg_family, bind_addr, &cfg_dst_addr);
0500
0501 if (optind != argc)
0502 usage(argv[0]);
0503
0504 if (cfg_family == PF_UNSPEC)
0505 error(1, 0, "must pass one of -4 or -6");
0506 if (cfg_tcp && !cfg_connected)
0507 error(1, 0, "connectionless tcp makes no sense");
0508 if (cfg_segment && cfg_sendmmsg)
0509 error(1, 0, "cannot combine segment offload and sendmmsg");
0510 if (cfg_tx_tstamp && !(cfg_segment || cfg_sendmmsg))
0511 error(1, 0, "Options -T and -H require either -S or -m option");
0512
0513 if (cfg_family == PF_INET)
0514 hdrlen = sizeof(struct iphdr) + sizeof(struct udphdr);
0515 else
0516 hdrlen = sizeof(struct ip6_hdr) + sizeof(struct udphdr);
0517
0518 cfg_mss = ETH_DATA_LEN - hdrlen;
0519 max_len = ETH_MAX_MTU - hdrlen;
0520 if (!cfg_gso_size)
0521 cfg_gso_size = cfg_mss;
0522
0523 if (cfg_payload_len > max_len)
0524 error(1, 0, "payload length %u exceeds max %u",
0525 cfg_payload_len, max_len);
0526 }
0527
0528 static void set_pmtu_discover(int fd, bool is_ipv4)
0529 {
0530 int level, name, val;
0531
0532 if (is_ipv4) {
0533 level = SOL_IP;
0534 name = IP_MTU_DISCOVER;
0535 val = IP_PMTUDISC_DO;
0536 } else {
0537 level = SOL_IPV6;
0538 name = IPV6_MTU_DISCOVER;
0539 val = IPV6_PMTUDISC_DO;
0540 }
0541
0542 if (setsockopt(fd, level, name, &val, sizeof(val)))
0543 error(1, errno, "setsockopt path mtu");
0544 }
0545
0546 static void set_tx_timestamping(int fd)
0547 {
0548 int val = SOF_TIMESTAMPING_OPT_CMSG | SOF_TIMESTAMPING_OPT_ID |
0549 SOF_TIMESTAMPING_OPT_TSONLY;
0550
0551 if (cfg_tx_ts == SOF_TIMESTAMPING_TX_SOFTWARE)
0552 val |= SOF_TIMESTAMPING_SOFTWARE;
0553 else
0554 val |= SOF_TIMESTAMPING_RAW_HARDWARE;
0555
0556 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &val, sizeof(val)))
0557 error(1, errno, "setsockopt tx timestamping");
0558 }
0559
0560 static void print_audit_report(unsigned long num_msgs, unsigned long num_sends)
0561 {
0562 unsigned long tdelta;
0563
0564 tdelta = tend - tstart;
0565 if (!tdelta)
0566 return;
0567
0568 fprintf(stderr, "Summary over %lu.%03lu seconds...\n",
0569 tdelta / 1000, tdelta % 1000);
0570 fprintf(stderr,
0571 "sum %s tx: %6lu MB/s %10lu calls (%lu/s) %10lu msgs (%lu/s)\n",
0572 cfg_tcp ? "tcp" : "udp",
0573 ((num_msgs * cfg_payload_len) >> 10) / tdelta,
0574 num_sends, num_sends * 1000 / tdelta,
0575 num_msgs, num_msgs * 1000 / tdelta);
0576
0577 if (cfg_tx_tstamp) {
0578 if (stat_tx_ts_errors)
0579 error(1, 0,
0580 "Expected clean TX Timestamps: %9lu msgs received %6lu errors",
0581 stat_tx_ts, stat_tx_ts_errors);
0582 if (stat_tx_ts != num_sends)
0583 error(1, 0,
0584 "Unexpected number of TX Timestamps: %9lu expected %9lu received",
0585 num_sends, stat_tx_ts);
0586 fprintf(stderr,
0587 "Tx Timestamps: %19lu received %17lu errors\n",
0588 stat_tx_ts, stat_tx_ts_errors);
0589 }
0590
0591 if (cfg_zerocopy) {
0592 if (stat_zcopies != num_sends)
0593 error(1, 0, "Unexpected number of Zerocopy completions: %9lu expected %9lu received",
0594 num_sends, stat_zcopies);
0595 fprintf(stderr,
0596 "Zerocopy acks: %19lu\n",
0597 stat_zcopies);
0598 }
0599 }
0600
0601 static void print_report(unsigned long num_msgs, unsigned long num_sends)
0602 {
0603 fprintf(stderr,
0604 "%s tx: %6lu MB/s %8lu calls/s %6lu msg/s\n",
0605 cfg_tcp ? "tcp" : "udp",
0606 (num_msgs * cfg_payload_len) >> 20,
0607 num_sends, num_msgs);
0608
0609 if (cfg_audit) {
0610 total_num_msgs += num_msgs;
0611 total_num_sends += num_sends;
0612 }
0613 }
0614
0615 int main(int argc, char **argv)
0616 {
0617 unsigned long num_msgs, num_sends;
0618 unsigned long tnow, treport, tstop;
0619 int fd, i, val, ret;
0620
0621 parse_opts(argc, argv);
0622
0623 if (cfg_cpu > 0)
0624 set_cpu(cfg_cpu);
0625
0626 for (i = 0; i < sizeof(buf[0]); i++)
0627 buf[0][i] = 'a' + (i % 26);
0628 for (i = 1; i < NUM_PKT; i++)
0629 memcpy(buf[i], buf[0], sizeof(buf[0]));
0630
0631 signal(SIGINT, sigint_handler);
0632
0633 fd = socket(cfg_family, cfg_tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
0634 if (fd == -1)
0635 error(1, errno, "socket");
0636
0637 if (cfg_zerocopy) {
0638 val = 1;
0639
0640 ret = setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY,
0641 &val, sizeof(val));
0642 if (ret) {
0643 if (errno == ENOPROTOOPT || errno == ENOTSUPP) {
0644 fprintf(stderr, "SO_ZEROCOPY not supported");
0645 exit(KSFT_SKIP);
0646 }
0647 error(1, errno, "setsockopt zerocopy");
0648 }
0649 }
0650
0651 if (cfg_connected &&
0652 connect(fd, (void *)&cfg_dst_addr, cfg_alen))
0653 error(1, errno, "connect");
0654
0655 if (cfg_segment)
0656 set_pmtu_discover(fd, cfg_family == PF_INET);
0657
0658 if (cfg_tx_tstamp)
0659 set_tx_timestamping(fd);
0660
0661 num_msgs = num_sends = 0;
0662 tnow = gettimeofday_ms();
0663 tstart = tnow;
0664 tend = tnow;
0665 tstop = tnow + cfg_runtime_ms;
0666 treport = tnow + 1000;
0667
0668 i = 0;
0669 do {
0670 if (cfg_tcp)
0671 num_sends += send_tcp(fd, buf[i]);
0672 else if (cfg_segment)
0673 num_sends += send_udp_segment(fd, buf[i]);
0674 else if (cfg_sendmmsg)
0675 num_sends += send_udp_sendmmsg(fd, buf[i]);
0676 else
0677 num_sends += send_udp(fd, buf[i]);
0678 num_msgs++;
0679 if ((cfg_zerocopy && ((num_msgs & 0xF) == 0)) || cfg_tx_tstamp)
0680 flush_errqueue(fd, cfg_poll);
0681
0682 if (cfg_msg_nr && num_msgs >= cfg_msg_nr)
0683 break;
0684
0685 tnow = gettimeofday_ms();
0686 if (tnow >= treport) {
0687 print_report(num_msgs, num_sends);
0688 num_msgs = num_sends = 0;
0689 treport = tnow + 1000;
0690 }
0691
0692
0693 if (cfg_cache_trash)
0694 i = ++i < NUM_PKT ? i : 0;
0695
0696 } while (!interrupted && (cfg_runtime_ms == -1 || tnow < tstop));
0697
0698 if (cfg_zerocopy || cfg_tx_tstamp)
0699 flush_errqueue(fd, true);
0700
0701 if (close(fd))
0702 error(1, errno, "close");
0703
0704 if (cfg_audit) {
0705 tend = tnow;
0706 total_num_msgs += num_msgs;
0707 total_num_sends += num_sends;
0708 print_audit_report(total_num_msgs, total_num_sends);
0709 }
0710
0711 return 0;
0712 }
