tools/tools/netmap/pkt-gen.c

   1 /*
   2  * Copyright (C) 2011-2014 Matteo Landi, Luigi Rizzo. All rights reserved.
   3  * Copyright (C) 2013-2014 Universita` di Pisa. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *   1. Redistributions of source code must retain the above copyright
   9  *      notice, this list of conditions and the following disclaimer.
  10  *   2. Redistributions in binary form must reproduce the above copyright
  11  *      notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * $FreeBSD$
  29  * $Id: pkt-gen.c 12346 2013-06-12 17:36:25Z luigi $
  30  *
  31  * Example program to show how to build a multithreaded packet
  32  * source/sink using the netmap device.
  33  *
  34  * In this example we create a programmable number of threads
  35  * to take care of all the queues of the interface used to
  36  * send or receive traffic.
  37  *
  38  */
  39
  40 // #define TRASH_VHOST_HDR
  41
  42 #define _GNU_SOURCE     /* for CPU_SET() */
  43 #include <stdio.h>
  44 #define NETMAP_WITH_LIBS
  45 #include <net/netmap_user.h>
  46
  47
  48 #include <ctype.h>      // isprint()
  49 #include <unistd.h>     // sysconf()
  50 #include <sys/poll.h>
  51 #include <arpa/inet.h>  /* ntohs */
  52 #include <sys/sysctl.h> /* sysctl */
  53 #include <ifaddrs.h>    /* getifaddrs */
  54 #include <net/ethernet.h>
  55 #include <netinet/in.h>
  56 #include <netinet/ip.h>
  57 #include <netinet/udp.h>
  58
  59 #include <pthread.h>
  60
  61 #ifndef NO_PCAP
  62 #include <pcap/pcap.h>
  63 #endif
  64
  65 #ifdef linux
  66
  67 #define cpuset_t        cpu_set_t
  68
  69 #define ifr_flagshigh  ifr_flags        /* only the low 16 bits here */
  70 #define IFF_PPROMISC   IFF_PROMISC      /* IFF_PPROMISC does not exist */
  71 #include <linux/ethtool.h>
  72 #include <linux/sockios.h>
  73
  74 #define CLOCK_REALTIME_PRECISE CLOCK_REALTIME
  75 #include <netinet/ether.h>      /* ether_aton */
  76 #include <linux/if_packet.h>    /* sockaddr_ll */
  77 #endif  /* linux */
  78
  79 #ifdef __FreeBSD__
  80 #include <sys/endian.h> /* le64toh */
  81 #include <machine/param.h>
  82
  83 #include <pthread_np.h> /* pthread w/ affinity */
  84 #include <sys/cpuset.h> /* cpu_set */
  85 #include <net/if_dl.h>  /* LLADDR */
  86 #endif  /* __FreeBSD__ */
  87
  88 #ifdef __APPLE__
  89
  90 #define cpuset_t        uint64_t        // XXX
  91 static inline void CPU_ZERO(cpuset_t *p)
  92 {
  93         *p = 0;
  94 }
  95
  96 static inline void CPU_SET(uint32_t i, cpuset_t *p)
  97 {
  98         *p |= 1<< (i & 0x3f);
  99 }
 100
 101 #define pthread_setaffinity_np(a, b, c) ((void)a, 0)
 102
 103 #define ifr_flagshigh  ifr_flags        // XXX
 104 #define IFF_PPROMISC   IFF_PROMISC
 105 #include <net/if_dl.h>  /* LLADDR */
 106 #define clock_gettime(a,b)      \
 107         do {struct timespec t0 = {0,0}; *(b) = t0; } while (0)
 108 #endif  /* __APPLE__ */
 109
 110 const char *default_payload="netmap pkt-gen DIRECT payload\n"
 111         "http://info.iet.unipi.it/~luigi/netmap/ ";
 112
 113 const char *indirect_payload="netmap pkt-gen indirect payload\n"
 114         "http://info.iet.unipi.it/~luigi/netmap/ ";
 115
 116 int verbose = 0;
 117
 118 #define SKIP_PAYLOAD 1 /* do not check payload. XXX unused */
 119
 120
 121 #define VIRT_HDR_1      10      /* length of a base vnet-hdr */
 122 #define VIRT_HDR_2      12      /* length of the extenede vnet-hdr */
 123 #define VIRT_HDR_MAX    VIRT_HDR_2
 124 struct virt_header {
 125         uint8_t fields[VIRT_HDR_MAX];
 126 };
 127
 128 #define MAX_BODYSIZE    16384
 129
 130 struct pkt {
 131         struct virt_header vh;
 132         struct ether_header eh;
 133         struct ip ip;
 134         struct udphdr udp;
 135         uint8_t body[MAX_BODYSIZE];     // XXX hardwired
 136 } __attribute__((__packed__));
 137
 138 struct ip_range {
 139         char *name;
 140         uint32_t start, end; /* same as struct in_addr */
 141         uint16_t port0, port1;
 142 };
 143
 144 struct mac_range {
 145         char *name;
 146         struct ether_addr start, end;
 147 };
 148
 149 /* ifname can be netmap:foo-xxxx */
 150 #define MAX_IFNAMELEN   64      /* our buffer for ifname */
 151 //#define MAX_PKTSIZE   1536
 152 #define MAX_PKTSIZE     MAX_BODYSIZE    /* XXX: + IP_HDR + ETH_HDR */
 153
 154 /* compact timestamp to fit into 60 byte packet. (enough to obtain RTT) */
 155 struct tstamp {
 156         uint32_t sec;
 157         uint32_t nsec;
 158 };
 159
 160 /*
 161  * global arguments for all threads
 162  */
 163
 164 struct glob_arg {
 165         struct ip_range src_ip;
 166         struct ip_range dst_ip;
 167         struct mac_range dst_mac;
 168         struct mac_range src_mac;
 169         int pkt_size;
 170         int burst;
 171         int forever;
 172         int npackets;   /* total packets to send */
 173         int frags;      /* fragments per packet */
 174         int nthreads;
 175         int cpus;
 176         int options;    /* testing */
 177 #define OPT_PREFETCH    1
 178 #define OPT_ACCESS      2
 179 #define OPT_COPY        4
 180 #define OPT_MEMCPY      8
 181 #define OPT_TS          16      /* add a timestamp */
 182 #define OPT_INDIRECT    32      /* use indirect buffers, tx only */
 183 #define OPT_DUMP        64      /* dump rx/tx traffic */
 184 #define OPT_MONITOR_TX  128
 185 #define OPT_MONITOR_RX  256
 186 #define OPT_RANDOM_SRC  512
 187 #define OPT_RANDOM_DST  1024
 188         int dev_type;
 189 #ifndef NO_PCAP
 190         pcap_t *p;
 191 #endif
 192
 193         int tx_rate;
 194         struct timespec tx_period;
 195
 196         int affinity;
 197         int main_fd;
 198         struct nm_desc *nmd;
 199         int report_interval;            /* milliseconds between prints */
 200         void *(*td_body)(void *);
 201         void *mmap_addr;
 202         char ifname[MAX_IFNAMELEN];
 203         char *nmr_config;
 204         int dummy_send;
 205         int virt_header;        /* send also the virt_header */
 206         int extra_bufs;         /* goes in nr_arg3 */
 207         char *packet_file;      /* -P option */
 208 };
 209 enum dev_type { DEV_NONE, DEV_NETMAP, DEV_PCAP, DEV_TAP };
 210
 211
 212 /*
 213  * Arguments for a new thread. The same structure is used by
 214  * the source and the sink
 215  */
 216 struct targ {
 217         struct glob_arg *g;
 218         int used;
 219         int completed;
 220         int cancel;
 221         int fd;
 222         struct nm_desc *nmd;
 223         volatile uint64_t count;
 224         struct timespec tic, toc;
 225         int me;
 226         pthread_t thread;
 227         int affinity;
 228
 229         struct pkt pkt;
 230         void *frame;
 231 };
 232
 233
 234 /*
 235  * extract the extremes from a range of ipv4 addresses.
 236  * addr_lo[-addr_hi][:port_lo[-port_hi]]
 237  */
 238 static void
 239 extract_ip_range(struct ip_range *r)
 240 {
 241         char *ap, *pp;
 242         struct in_addr a;
 243
 244         if (verbose)
 245                 D("extract IP range from %s", r->name);
 246         r->port0 = r->port1 = 0;
 247         r->start = r->end = 0;
 248
 249         /* the first - splits start/end of range */
 250         ap = index(r->name, '-');       /* do we have ports ? */
 251         if (ap) {
 252                 *ap++ = '\0';
 253         }
 254         /* grab the initial values (mandatory) */
 255         pp = index(r->name, ':');
 256         if (pp) {
 257                 *pp++ = '\0';
 258                 r->port0 = r->port1 = strtol(pp, NULL, 0);
 259         };
 260         inet_aton(r->name, &a);
 261         r->start = r->end = ntohl(a.s_addr);
 262         if (ap) {
 263                 pp = index(ap, ':');
 264                 if (pp) {
 265                         *pp++ = '\0';
 266                         if (*pp)
 267                                 r->port1 = strtol(pp, NULL, 0);
 268                 }
 269                 if (*ap) {
 270                         inet_aton(ap, &a);
 271                         r->end = ntohl(a.s_addr);
 272                 }
 273         }
 274         if (r->port0 > r->port1) {
 275                 uint16_t tmp = r->port0;
 276                 r->port0 = r->port1;
 277                 r->port1 = tmp;
 278         }
 279         if (r->start > r->end) {
 280                 uint32_t tmp = r->start;
 281                 r->start = r->end;
 282                 r->end = tmp;
 283         }
 284         {
 285                 struct in_addr a;
 286                 char buf1[16]; // one ip address
 287
 288                 a.s_addr = htonl(r->end);
 289                 strncpy(buf1, inet_ntoa(a), sizeof(buf1));
 290                 a.s_addr = htonl(r->start);
 291                 if (1)
 292                     D("range is %s:%d to %s:%d",
 293                         inet_ntoa(a), r->port0, buf1, r->port1);
 294         }
 295 }
 296
 297 static void
 298 extract_mac_range(struct mac_range *r)
 299 {
 300         if (verbose)
 301             D("extract MAC range from %s", r->name);
 302         bcopy(ether_aton(r->name), &r->start, 6);
 303         bcopy(ether_aton(r->name), &r->end, 6);
 304 #if 0
 305         bcopy(targ->src_mac, eh->ether_shost, 6);
 306         p = index(targ->g->src_mac, '-');
 307         if (p)
 308                 targ->src_mac_range = atoi(p+1);
 309
 310         bcopy(ether_aton(targ->g->dst_mac), targ->dst_mac, 6);
 311         bcopy(targ->dst_mac, eh->ether_dhost, 6);
 312         p = index(targ->g->dst_mac, '-');
 313         if (p)
 314                 targ->dst_mac_range = atoi(p+1);
 315 #endif
 316         if (verbose)
 317                 D("%s starts at %s", r->name, ether_ntoa(&r->start));
 318 }
 319
 320 static struct targ *targs;
 321 static int global_nthreads;
 322
 323 /* control-C handler */
 324 static void
 325 sigint_h(int sig)
 326 {
 327         int i;
 328
 329         (void)sig;      /* UNUSED */
 330         D("received control-C on thread %p", pthread_self());
 331         for (i = 0; i < global_nthreads; i++) {
 332                 targs[i].cancel = 1;
 333         }
 334         signal(SIGINT, SIG_DFL);
 335 }
 336
 337 /* sysctl wrapper to return the number of active CPUs */
 338 static int
 339 system_ncpus(void)
 340 {
 341         int ncpus;
 342 #if defined (__FreeBSD__)
 343         int mib[2] = { CTL_HW, HW_NCPU };
 344         size_t len = sizeof(mib);
 345         sysctl(mib, 2, &ncpus, &len, NULL, 0);
 346 #elif defined(linux)
 347         ncpus = sysconf(_SC_NPROCESSORS_ONLN);
 348 #else /* others */
 349         ncpus = 1;
 350 #endif /* others */
 351         return (ncpus);
 352 }
 353
 354 #ifdef __linux__
 355 #define sockaddr_dl    sockaddr_ll
 356 #define sdl_family     sll_family
 357 #define AF_LINK        AF_PACKET
 358 #define LLADDR(s)      s->sll_addr;
 359 #include <linux/if_tun.h>
 360 #define TAP_CLONEDEV    "/dev/net/tun"
 361 #endif /* __linux__ */
 362
 363 #ifdef __FreeBSD__
 364 #include <net/if_tun.h>
 365 #define TAP_CLONEDEV    "/dev/tap"
 366 #endif /* __FreeBSD */
 367
 368 #ifdef __APPLE__
 369 // #warning TAP not supported on apple ?
 370 #include <net/if_utun.h>
 371 #define TAP_CLONEDEV    "/dev/tap"
 372 #endif /* __APPLE__ */
 373
 374
 375 /*
 376  * parse the vale configuration in conf and put it in nmr.
 377  * Return the flag set if necessary.
 378  * The configuration may consist of 0 to 4 numbers separated
 379  * by commas: #tx-slots,#rx-slots,#tx-rings,#rx-rings.
 380  * Missing numbers or zeroes stand for default values.
 381  * As an additional convenience, if exactly one number
 382  * is specified, then this is assigned to both #tx-slots and #rx-slots.
 383  * If there is no 4th number, then the 3rd is assigned to both #tx-rings
 384  * and #rx-rings.
 385  */
 386 int
 387 parse_nmr_config(const char* conf, struct nmreq *nmr)
 388 {
 389         char *w, *tok;
 390         int i, v;
 391
 392         nmr->nr_tx_rings = nmr->nr_rx_rings = 0;
 393         nmr->nr_tx_slots = nmr->nr_rx_slots = 0;
 394         if (conf == NULL || ! *conf)
 395                 return 0;
 396         w = strdup(conf);
 397         for (i = 0, tok = strtok(w, ","); tok; i++, tok = strtok(NULL, ",")) {
 398                 v = atoi(tok);
 399                 switch (i) {
 400                 case 0:
 401                         nmr->nr_tx_slots = nmr->nr_rx_slots = v;
 402                         break;
 403                 case 1:
 404                         nmr->nr_rx_slots = v;
 405                         break;
 406                 case 2:
 407                         nmr->nr_tx_rings = nmr->nr_rx_rings = v;
 408                         break;
 409                 case 3:
 410                         nmr->nr_rx_rings = v;
 411                         break;
 412                 default:
 413                         D("ignored config: %s", tok);
 414                         break;
 415                 }
 416         }
 417         D("txr %d txd %d rxr %d rxd %d",
 418                         nmr->nr_tx_rings, nmr->nr_tx_slots,
 419                         nmr->nr_rx_rings, nmr->nr_rx_slots);
 420         free(w);
 421         return (nmr->nr_tx_rings || nmr->nr_tx_slots ||
 422                         nmr->nr_rx_rings || nmr->nr_rx_slots) ?
 423                 NM_OPEN_RING_CFG : 0;
 424 }
 425
 426
 427 /*
 428  * locate the src mac address for our interface, put it
 429  * into the user-supplied buffer. return 0 if ok, -1 on error.
 430  */
 431 static int
 432 source_hwaddr(const char *ifname, char *buf)
 433 {
 434         struct ifaddrs *ifaphead, *ifap;
 435         int l = sizeof(ifap->ifa_name);
 436
 437         if (getifaddrs(&ifaphead) != 0) {
 438                 D("getifaddrs %s failed", ifname);
 439                 return (-1);
 440         }
 441
 442         for (ifap = ifaphead; ifap; ifap = ifap->ifa_next) {
 443                 struct sockaddr_dl *sdl =
 444                         (struct sockaddr_dl *)ifap->ifa_addr;
 445                 uint8_t *mac;
 446
 447                 if (!sdl || sdl->sdl_family != AF_LINK)
 448                         continue;
 449                 if (strncmp(ifap->ifa_name, ifname, l) != 0)
 450                         continue;
 451                 mac = (uint8_t *)LLADDR(sdl);
 452                 sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x",
 453                         mac[0], mac[1], mac[2],
 454                         mac[3], mac[4], mac[5]);
 455                 if (verbose)
 456                         D("source hwaddr %s", buf);
 457                 break;
 458         }
 459         freeifaddrs(ifaphead);
 460         return ifap ? 0 : 1;
 461 }
 462
 463
 464 /* set the thread affinity. */
 465 static int
 466 setaffinity(pthread_t me, int i)
 467 {
 468         cpuset_t cpumask;
 469
 470         if (i == -1)
 471                 return 0;
 472
 473         /* Set thread affinity affinity.*/
 474         CPU_ZERO(&cpumask);
 475         CPU_SET(i, &cpumask);
 476
 477         if (pthread_setaffinity_np(me, sizeof(cpuset_t), &cpumask) != 0) {
 478                 D("Unable to set affinity: %s", strerror(errno));
 479                 return 1;
 480         }
 481         return 0;
 482 }
 483
 484 /* Compute the checksum of the given ip header. */
 485 static uint16_t
 486 checksum(const void *data, uint16_t len, uint32_t sum)
 487 {
 488         const uint8_t *addr = data;
 489         uint32_t i;
 490
 491         /* Checksum all the pairs of bytes first... */
 492         for (i = 0; i < (len & ~1U); i += 2) {
 493                 sum += (u_int16_t)ntohs(*((u_int16_t *)(addr + i)));
 494                 if (sum > 0xFFFF)
 495                         sum -= 0xFFFF;
 496         }
 497         /*
 498          * If there's a single byte left over, checksum it, too.
 499          * Network byte order is big-endian, so the remaining byte is
 500          * the high byte.
 501          */
 502         if (i < len) {
 503                 sum += addr[i] << 8;
 504                 if (sum > 0xFFFF)
 505                         sum -= 0xFFFF;
 506         }
 507         return sum;
 508 }
 509
 510 static u_int16_t
 511 wrapsum(u_int32_t sum)
 512 {
 513         sum = ~sum & 0xFFFF;
 514         return (htons(sum));
 515 }
 516
 517 /* Check the payload of the packet for errors (use it for debug).
 518  * Look for consecutive ascii representations of the size of the packet.
 519  */
 520 static void
 521 dump_payload(char *p, int len, struct netmap_ring *ring, int cur)
 522 {
 523         char buf[128];
 524         int i, j, i0;
 525
 526         /* get the length in ASCII of the length of the packet. */
 527
 528         printf("ring %p cur %5d [buf %6d flags 0x%04x len %5d]\n",
 529                 ring, cur, ring->slot[cur].buf_idx,
 530                 ring->slot[cur].flags, len);
 531         /* hexdump routine */
 532         for (i = 0; i < len; ) {
 533                 memset(buf, sizeof(buf), ' ');
 534                 sprintf(buf, "%5d: ", i);
 535                 i0 = i;
 536                 for (j=0; j < 16 && i < len; i++, j++)
 537                         sprintf(buf+7+j*3, "%02x ", (uint8_t)(p[i]));
 538                 i = i0;
 539                 for (j=0; j < 16 && i < len; i++, j++)
 540                         sprintf(buf+7+j + 48, "%c",
 541                                 isprint(p[i]) ? p[i] : '.');
 542                 printf("%s\n", buf);
 543         }
 544 }
 545
 546 /*
 547  * Fill a packet with some payload.
 548  * We create a UDP packet so the payload starts at
 549  *      14+20+8 = 42 bytes.
 550  */
 551 #ifdef __linux__
 552 #define uh_sport source
 553 #define uh_dport dest
 554 #define uh_ulen len
 555 #define uh_sum check
 556 #endif /* linux */
 557
 558 /*
 559  * increment the addressed in the packet,
 560  * starting from the least significant field.
 561  *      DST_IP DST_PORT SRC_IP SRC_PORT
 562  */
 563 static void
 564 update_addresses(struct pkt *pkt, struct glob_arg *g)
 565 {
 566         uint32_t a;
 567         uint16_t p;
 568         struct ip *ip = &pkt->ip;
 569         struct udphdr *udp = &pkt->udp;
 570
 571     do {
 572         /* XXX for now it doesn't handle non-random src, random dst */
 573         if (g->options & OPT_RANDOM_SRC) {
 574                 udp->uh_sport = random();
 575                 ip->ip_src.s_addr = random();
 576         } else {
 577                 p = ntohs(udp->uh_sport);
 578                 if (p < g->src_ip.port1) { /* just inc, no wrap */
 579                         udp->uh_sport = htons(p + 1);
 580                         break;
 581                 }
 582                 udp->uh_sport = htons(g->src_ip.port0);
 583
 584                 a = ntohl(ip->ip_src.s_addr);
 585                 if (a < g->src_ip.end) { /* just inc, no wrap */
 586                         ip->ip_src.s_addr = htonl(a + 1);
 587                         break;
 588                 }
 589                 ip->ip_src.s_addr = htonl(g->src_ip.start);
 590
 591                 udp->uh_sport = htons(g->src_ip.port0);
 592         }
 593
 594         if (g->options & OPT_RANDOM_DST) {
 595                 udp->uh_dport = random();
 596                 ip->ip_dst.s_addr = random();
 597         } else {
 598                 p = ntohs(udp->uh_dport);
 599                 if (p < g->dst_ip.port1) { /* just inc, no wrap */
 600                         udp->uh_dport = htons(p + 1);
 601                         break;
 602                 }
 603                 udp->uh_dport = htons(g->dst_ip.port0);
 604
 605                 a = ntohl(ip->ip_dst.s_addr);
 606                 if (a < g->dst_ip.end) { /* just inc, no wrap */
 607                         ip->ip_dst.s_addr = htonl(a + 1);
 608                         break;
 609                 }
 610         }
 611         ip->ip_dst.s_addr = htonl(g->dst_ip.start);
 612     } while (0);
 613     // update checksum
 614 }
 615
 616 /*
 617  * initialize one packet and prepare for the next one.
 618  * The copy could be done better instead of repeating it each time.
 619  */
 620 static void
 621 initialize_packet(struct targ *targ)
 622 {
 623         struct pkt *pkt = &targ->pkt;
 624         struct ether_header *eh;
 625         struct ip *ip;
 626         struct udphdr *udp;
 627         uint16_t paylen = targ->g->pkt_size - sizeof(*eh) - sizeof(struct ip);
 628         const char *payload = targ->g->options & OPT_INDIRECT ?
 629                 indirect_payload : default_payload;
 630         int i, l0 = strlen(payload);
 631
 632         char errbuf[PCAP_ERRBUF_SIZE];
 633         pcap_t *file;
 634         struct pcap_pkthdr *header;
 635         const unsigned char *packet;
 636
 637         /* Read a packet from a PCAP file if asked. */
 638         if (targ->g->packet_file != NULL) {
 639                 if ((file = pcap_open_offline(targ->g->packet_file,
 640                             errbuf)) == NULL)
 641                         D("failed to open pcap file %s",
 642                             targ->g->packet_file);
 643                 if (pcap_next_ex(file, &header, &packet) < 0)
 644                         D("failed to read packet from %s",
 645                             targ->g->packet_file);
 646                 if ((targ->frame = malloc(header->caplen)) == NULL)
 647                         D("out of memory");
 648                 bcopy(packet, (unsigned char *)targ->frame, header->caplen);
 649                 targ->g->pkt_size = header->caplen;
 650                 pcap_close(file);
 651                 return;
 652         }
 653
 654         /* create a nice NUL-terminated string */
 655         for (i = 0; i < paylen; i += l0) {
 656                 if (l0 > paylen - i)
 657                         l0 = paylen - i; // last round
 658                 bcopy(payload, pkt->body + i, l0);
 659         }
 660         pkt->body[i-1] = '\0';
 661         ip = &pkt->ip;
 662
 663         /* prepare the headers */
 664         ip->ip_v = IPVERSION;
 665         ip->ip_hl = 5;
 666         ip->ip_id = 0;
 667         ip->ip_tos = IPTOS_LOWDELAY;
 668         ip->ip_len = ntohs(targ->g->pkt_size - sizeof(*eh));
 669         ip->ip_id = 0;
 670         ip->ip_off = htons(IP_DF); /* Don't fragment */
 671         ip->ip_ttl = IPDEFTTL;
 672         ip->ip_p = IPPROTO_UDP;
 673         ip->ip_dst.s_addr = htonl(targ->g->dst_ip.start);
 674         ip->ip_src.s_addr = htonl(targ->g->src_ip.start);
 675         ip->ip_sum = wrapsum(checksum(ip, sizeof(*ip), 0));
 676
 677
 678         udp = &pkt->udp;
 679         udp->uh_sport = htons(targ->g->src_ip.port0);
 680         udp->uh_dport = htons(targ->g->dst_ip.port0);
 681         udp->uh_ulen = htons(paylen);
 682         /* Magic: taken from sbin/dhclient/packet.c */
 683         udp->uh_sum = wrapsum(checksum(udp, sizeof(*udp),
 684                     checksum(pkt->body,
 685                         paylen - sizeof(*udp),
 686                         checksum(&ip->ip_src, 2 * sizeof(ip->ip_src),
 687                             IPPROTO_UDP + (u_int32_t)ntohs(udp->uh_ulen)
 688                         )
 689                     )
 690                 ));
 691
 692         eh = &pkt->eh;
 693         bcopy(&targ->g->src_mac.start, eh->ether_shost, 6);
 694         bcopy(&targ->g->dst_mac.start, eh->ether_dhost, 6);
 695         eh->ether_type = htons(ETHERTYPE_IP);
 696
 697         bzero(&pkt->vh, sizeof(pkt->vh));
 698 #ifdef TRASH_VHOST_HDR
 699         /* set bogus content */
 700         pkt->vh.fields[0] = 0xff;
 701         pkt->vh.fields[1] = 0xff;
 702         pkt->vh.fields[2] = 0xff;
 703         pkt->vh.fields[3] = 0xff;
 704         pkt->vh.fields[4] = 0xff;
 705         pkt->vh.fields[5] = 0xff;
 706 #endif /* TRASH_VHOST_HDR */
 707         // dump_payload((void *)pkt, targ->g->pkt_size, NULL, 0);
 708 }
 709
 710 static void
 711 set_vnet_hdr_len(struct targ *t)
 712 {
 713         int err, l = t->g->virt_header;
 714         struct nmreq req;
 715
 716         if (l == 0)
 717                 return;
 718
 719         memset(&req, 0, sizeof(req));
 720         bcopy(t->nmd->req.nr_name, req.nr_name, sizeof(req.nr_name));
 721         req.nr_version = NETMAP_API;
 722         req.nr_cmd = NETMAP_BDG_VNET_HDR;
 723         req.nr_arg1 = l;
 724         err = ioctl(t->fd, NIOCREGIF, &req);
 725         if (err) {
 726                 D("Unable to set vnet header length %d", l);
 727         }
 728 }
 729
 730
 731 /*
 732  * create and enqueue a batch of packets on a ring.
 733  * On the last one set NS_REPORT to tell the driver to generate
 734  * an interrupt when done.
 735  */
 736 static int
 737 send_packets(struct netmap_ring *ring, struct pkt *pkt, void *frame,
 738                 int size, struct glob_arg *g, u_int count, int options,
 739                 u_int nfrags)
 740 {
 741         u_int n, sent, cur = ring->cur;
 742         u_int fcnt;
 743
 744         n = nm_ring_space(ring);
 745         if (n < count)
 746                 count = n;
 747         if (count < nfrags) {
 748                 D("truncating packet, no room for frags %d %d",
 749                                 count, nfrags);
 750         }
 751 #if 0
 752         if (options & (OPT_COPY | OPT_PREFETCH) ) {
 753                 for (sent = 0; sent < count; sent++) {
 754                         struct netmap_slot *slot = &ring->slot[cur];
 755                         char *p = NETMAP_BUF(ring, slot->buf_idx);
 756
 757                         __builtin_prefetch(p);
 758                         cur = nm_ring_next(ring, cur);
 759                 }
 760                 cur = ring->cur;
 761         }
 762 #endif
 763         for (fcnt = nfrags, sent = 0; sent < count; sent++) {
 764                 struct netmap_slot *slot = &ring->slot[cur];
 765                 char *p = NETMAP_BUF(ring, slot->buf_idx);
 766
 767                 slot->flags = 0;
 768                 if (options & OPT_INDIRECT) {
 769                         slot->flags |= NS_INDIRECT;
 770                         slot->ptr = (uint64_t)frame;
 771                 } else if (options & OPT_COPY) {
 772                         nm_pkt_copy(frame, p, size);
 773                         if (fcnt == nfrags)
 774                                 update_addresses(pkt, g);
 775                 } else if (options & OPT_MEMCPY) {
 776                         memcpy(p, frame, size);
 777                         if (fcnt == nfrags)
 778                                 update_addresses(pkt, g);
 779                 } else if (options & OPT_PREFETCH) {
 780                         __builtin_prefetch(p);
 781                 }
 782                 if (options & OPT_DUMP)
 783                         dump_payload(p, size, ring, cur);
 784                 slot->len = size;
 785                 if (--fcnt > 0)
 786                         slot->flags |= NS_MOREFRAG;
 787                 else
 788                         fcnt = nfrags;
 789                 if (sent == count - 1) {
 790                         slot->flags &= ~NS_MOREFRAG;
 791                         slot->flags |= NS_REPORT;
 792                 }
 793                 cur = nm_ring_next(ring, cur);
 794         }
 795         ring->head = ring->cur = cur;
 796
 797         return (sent);
 798 }
 799
 800 /*
 801  * Send a packet, and wait for a response.
 802  * The payload (after UDP header, ofs 42) has a 4-byte sequence
 803  * followed by a struct timeval (or bintime?)
 804  */
 805 #define PAY_OFS 42      /* where in the pkt... */
 806
 807 static void *
 808 pinger_body(void *data)
 809 {
 810         struct targ *targ = (struct targ *) data;
 811         struct pollfd pfd = { .fd = targ->fd, .events = POLLIN };
 812         struct netmap_if *nifp = targ->nmd->nifp;
 813         int i, rx = 0, n = targ->g->npackets;
 814         void *frame;
 815         int size;
 816         uint32_t sent = 0;
 817         struct timespec ts, now, last_print;
 818         uint32_t count = 0, min = 1000000000, av = 0;
 819
 820         frame = &targ->pkt;
 821         frame += sizeof(targ->pkt.vh) - targ->g->virt_header;
 822         size = targ->g->pkt_size + targ->g->virt_header;
 823
 824         if (targ->g->nthreads > 1) {
 825                 D("can only ping with 1 thread");
 826                 return NULL;
 827         }
 828
 829         clock_gettime(CLOCK_REALTIME_PRECISE, &last_print);
 830         now = last_print;
 831         while (n == 0 || (int)sent < n) {
 832                 struct netmap_ring *ring = NETMAP_TXRING(nifp, 0);
 833                 struct netmap_slot *slot;
 834                 char *p;
 835             for (i = 0; i < 1; i++) { /* XXX why the loop for 1 pkt ? */
 836                 slot = &ring->slot[ring->cur];
 837                 slot->len = size;
 838                 p = NETMAP_BUF(ring, slot->buf_idx);
 839
 840                 if (nm_ring_empty(ring)) {
 841                         D("-- ouch, cannot send");
 842                 } else {
 843                         struct tstamp *tp;
 844                         nm_pkt_copy(frame, p, size);
 845                         clock_gettime(CLOCK_REALTIME_PRECISE, &ts);
 846                         bcopy(&sent, p+42, sizeof(sent));
 847                         tp = (struct tstamp *)(p+46);
 848                         tp->sec = (uint32_t)ts.tv_sec;
 849                         tp->nsec = (uint32_t)ts.tv_nsec;
 850                         sent++;
 851                         ring->head = ring->cur = nm_ring_next(ring, ring->cur);
 852                 }
 853             }
 854                 /* should use a parameter to decide how often to send */
 855                 if (poll(&pfd, 1, 3000) <= 0) {
 856                         D("poll error/timeout on queue %d: %s", targ->me,
 857                                 strerror(errno));
 858                         continue;
 859                 }
 860                 /* see what we got back */
 861                 for (i = targ->nmd->first_tx_ring;
 862                         i <= targ->nmd->last_tx_ring; i++) {
 863                         ring = NETMAP_RXRING(nifp, i);
 864                         while (!nm_ring_empty(ring)) {
 865                                 uint32_t seq;
 866                                 struct tstamp *tp;
 867                                 slot = &ring->slot[ring->cur];
 868                                 p = NETMAP_BUF(ring, slot->buf_idx);
 869
 870                                 clock_gettime(CLOCK_REALTIME_PRECISE, &now);
 871                                 bcopy(p+42, &seq, sizeof(seq));
 872                                 tp = (struct tstamp *)(p+46);
 873                                 ts.tv_sec = (time_t)tp->sec;
 874                                 ts.tv_nsec = (long)tp->nsec;
 875                                 ts.tv_sec = now.tv_sec - ts.tv_sec;
 876                                 ts.tv_nsec = now.tv_nsec - ts.tv_nsec;
 877                                 if (ts.tv_nsec < 0) {
 878                                         ts.tv_nsec += 1000000000;
 879                                         ts.tv_sec--;
 880                                 }
 881                                 if (1) D("seq %d/%d delta %d.%09d", seq, sent,
 882                                         (int)ts.tv_sec, (int)ts.tv_nsec);
 883                                 if (ts.tv_nsec < (int)min)
 884                                         min = ts.tv_nsec;
 885                                 count ++;
 886                                 av += ts.tv_nsec;
 887                                 ring->head = ring->cur = nm_ring_next(ring, ring->cur);
 888                                 rx++;
 889                         }
 890                 }
 891                 //D("tx %d rx %d", sent, rx);
 892                 //usleep(100000);
 893                 ts.tv_sec = now.tv_sec - last_print.tv_sec;
 894                 ts.tv_nsec = now.tv_nsec - last_print.tv_nsec;
 895                 if (ts.tv_nsec < 0) {
 896                         ts.tv_nsec += 1000000000;
 897                         ts.tv_sec--;
 898                 }
 899                 if (ts.tv_sec >= 1) {
 900                         D("count %d min %d av %d",
 901                                 count, min, av/count);
 902                         count = 0;
 903                         av = 0;
 904                         min = 100000000;
 905                         last_print = now;
 906                 }
 907         }
 908         return NULL;
 909 }
 910
 911
 912 /*
 913  * reply to ping requests
 914  */
 915 static void *
 916 ponger_body(void *data)
 917 {
 918         struct targ *targ = (struct targ *) data;
 919         struct pollfd pfd = { .fd = targ->fd, .events = POLLIN };
 920         struct netmap_if *nifp = targ->nmd->nifp;
 921         struct netmap_ring *txring, *rxring;
 922         int i, rx = 0, sent = 0, n = targ->g->npackets;
 923
 924         if (targ->g->nthreads > 1) {
 925                 D("can only reply ping with 1 thread");
 926                 return NULL;
 927         }
 928         D("understood ponger %d but don't know how to do it", n);
 929         while (n == 0 || sent < n) {
 930                 uint32_t txcur, txavail;
 931 //#define BUSYWAIT
 932 #ifdef BUSYWAIT
 933                 ioctl(pfd.fd, NIOCRXSYNC, NULL);
 934 #else
 935                 if (poll(&pfd, 1, 1000) <= 0) {
 936                         D("poll error/timeout on queue %d: %s", targ->me,
 937                                 strerror(errno));
 938                         continue;
 939                 }
 940 #endif
 941                 txring = NETMAP_TXRING(nifp, 0);
 942                 txcur = txring->cur;
 943                 txavail = nm_ring_space(txring);
 944                 /* see what we got back */
 945                 for (i = targ->nmd->first_rx_ring; i <= targ->nmd->last_rx_ring; i++) {
 946                         rxring = NETMAP_RXRING(nifp, i);
 947                         while (!nm_ring_empty(rxring)) {
 948                                 uint16_t *spkt, *dpkt;
 949                                 uint32_t cur = rxring->cur;
 950                                 struct netmap_slot *slot = &rxring->slot[cur];
 951                                 char *src, *dst;
 952                                 src = NETMAP_BUF(rxring, slot->buf_idx);
 953                                 //D("got pkt %p of size %d", src, slot->len);
 954                                 rxring->head = rxring->cur = nm_ring_next(rxring, cur);
 955                                 rx++;
 956                                 if (txavail == 0)
 957                                         continue;
 958                                 dst = NETMAP_BUF(txring,
 959                                     txring->slot[txcur].buf_idx);
 960                                 /* copy... */
 961                                 dpkt = (uint16_t *)dst;
 962                                 spkt = (uint16_t *)src;
 963                                 nm_pkt_copy(src, dst, slot->len);
 964                                 dpkt[0] = spkt[3];
 965                                 dpkt[1] = spkt[4];
 966                                 dpkt[2] = spkt[5];
 967                                 dpkt[3] = spkt[0];
 968                                 dpkt[4] = spkt[1];
 969                                 dpkt[5] = spkt[2];
 970                                 txring->slot[txcur].len = slot->len;
 971                                 /* XXX swap src dst mac */
 972                                 txcur = nm_ring_next(txring, txcur);
 973                                 txavail--;
 974                                 sent++;
 975                         }
 976                 }
 977                 txring->head = txring->cur = txcur;
 978                 targ->count = sent;
 979 #ifdef BUSYWAIT
 980                 ioctl(pfd.fd, NIOCTXSYNC, NULL);
 981 #endif
 982                 //D("tx %d rx %d", sent, rx);
 983         }
 984         return NULL;
 985 }
 986
 987 static __inline int
 988 timespec_ge(const struct timespec *a, const struct timespec *b)
 989 {
 990
 991         if (a->tv_sec > b->tv_sec)
 992                 return (1);
 993         if (a->tv_sec < b->tv_sec)
 994                 return (0);
 995         if (a->tv_nsec >= b->tv_nsec)
 996                 return (1);
 997         return (0);
 998 }
 999
1000 static __inline struct timespec
1001 timeval2spec(const struct timeval *a)
1002 {
1003         struct timespec ts = {
1004                 .tv_sec = a->tv_sec,
1005                 .tv_nsec = a->tv_usec * 1000
1006         };
1007         return ts;
1008 }
1009
1010 static __inline struct timeval
1011 timespec2val(const struct timespec *a)
1012 {
1013         struct timeval tv = {
1014                 .tv_sec = a->tv_sec,
1015                 .tv_usec = a->tv_nsec / 1000
1016         };
1017         return tv;
1018 }
1019
1020
1021 static __inline struct timespec
1022 timespec_add(struct timespec a, struct timespec b)
1023 {
1024         struct timespec ret = { a.tv_sec + b.tv_sec, a.tv_nsec + b.tv_nsec };
1025         if (ret.tv_nsec >= 1000000000) {
1026                 ret.tv_sec++;
1027                 ret.tv_nsec -= 1000000000;
1028         }
1029         return ret;
1030 }
1031
1032 static __inline struct timespec
1033 timespec_sub(struct timespec a, struct timespec b)
1034 {
1035         struct timespec ret = { a.tv_sec - b.tv_sec, a.tv_nsec - b.tv_nsec };
1036         if (ret.tv_nsec < 0) {
1037                 ret.tv_sec--;
1038                 ret.tv_nsec += 1000000000;
1039         }
1040         return ret;
1041 }
1042
1043
1044 /*
1045  * wait until ts, either busy or sleeping if more than 1ms.
1046  * Return wakeup time.
1047  */
1048 static struct timespec
1049 wait_time(struct timespec ts)
1050 {
1051         for (;;) {
1052                 struct timespec w, cur;
1053                 clock_gettime(CLOCK_REALTIME_PRECISE, &cur);
1054                 w = timespec_sub(ts, cur);
1055                 if (w.tv_sec < 0)
1056                         return cur;
1057                 else if (w.tv_sec > 0 || w.tv_nsec > 1000000)
1058                         poll(NULL, 0, 1);
1059         }
1060 }
1061
1062 static void *
1063 sender_body(void *data)
1064 {
1065         struct targ *targ = (struct targ *) data;
1066         struct pollfd pfd = { .fd = targ->fd, .events = POLLOUT };
1067         struct netmap_if *nifp;
1068         struct netmap_ring *txring;
1069         int i, n = targ->g->npackets / targ->g->nthreads;
1070         int64_t sent = 0;
1071         int options = targ->g->options | OPT_COPY;
1072         struct timespec nexttime = { 0, 0}; // XXX silence compiler
1073         int rate_limit = targ->g->tx_rate;
1074         struct pkt *pkt = &targ->pkt;
1075         void *frame;
1076         int size;
1077
1078         if (targ->frame == NULL) {
1079                 frame = pkt;
1080                 frame += sizeof(pkt->vh) - targ->g->virt_header;
1081                 size = targ->g->pkt_size + targ->g->virt_header;
1082         } else {
1083                 frame = targ->frame;
1084                 size = targ->g->pkt_size;
1085         }
1086
1087         D("start, fd %d main_fd %d", targ->fd, targ->g->main_fd);
1088         if (setaffinity(targ->thread, targ->affinity))
1089                 goto quit;
1090
1091         /* main loop.*/
1092         clock_gettime(CLOCK_REALTIME_PRECISE, &targ->tic);
1093         if (rate_limit) {
1094                 targ->tic = timespec_add(targ->tic, (struct timespec){2,0});
1095                 targ->tic.tv_nsec = 0;
1096                 wait_time(targ->tic);
1097                 nexttime = targ->tic;
1098         }
1099         if (targ->g->dev_type == DEV_TAP) {
1100             D("writing to file desc %d", targ->g->main_fd);
1101
1102             for (i = 0; !targ->cancel && (n == 0 || sent < n); i++) {
1103                 if (write(targ->g->main_fd, frame, size) != -1)
1104                         sent++;
1105                 update_addresses(pkt, targ->g);
1106                 if (i > 10000) {
1107                         targ->count = sent;
1108                         i = 0;
1109                 }
1110             }
1111 #ifndef NO_PCAP
1112     } else if (targ->g->dev_type == DEV_PCAP) {
1113             pcap_t *p = targ->g->p;
1114
1115             for (i = 0; !targ->cancel && (n == 0 || sent < n); i++) {
1116                 if (pcap_inject(p, frame, size) != -1)
1117                         sent++;
1118                 update_addresses(pkt, targ->g);
1119                 if (i > 10000) {
1120                         targ->count = sent;
1121                         i = 0;
1122                 }
1123             }
1124 #endif /* NO_PCAP */
1125     } else {
1126         int tosend = 0;
1127         int frags = targ->g->frags;
1128
1129         nifp = targ->nmd->nifp;
1130         while (!targ->cancel && (n == 0 || sent < n)) {
1131
1132                 if (rate_limit && tosend <= 0) {
1133                         tosend = targ->g->burst;
1134                         nexttime = timespec_add(nexttime, targ->g->tx_period);
1135                         wait_time(nexttime);
1136                 }
1137
1138                 /*
1139                  * wait for available room in the send queue(s)
1140                  */
1141                 if (poll(&pfd, 1, 2000) <= 0) {
1142                         if (targ->cancel)
1143                                 break;
1144                         D("poll error/timeout on queue %d: %s", targ->me,
1145                                 strerror(errno));
1146                         // goto quit;
1147                 }
1148                 if (pfd.revents & POLLERR) {
1149                         D("poll error");
1150                         goto quit;
1151                 }
1152                 /*
1153                  * scan our queues and send on those with room
1154                  */
1155                 if (options & OPT_COPY && sent > 100000 && !(targ->g->options & OPT_COPY) ) {
1156                         D("drop copy");
1157                         options &= ~OPT_COPY;
1158                 }
1159                 for (i = targ->nmd->first_tx_ring; i <= targ->nmd->last_tx_ring; i++) {
1160                         int m, limit = rate_limit ?  tosend : targ->g->burst;
1161                         if (n > 0 && n - sent < limit)
1162                                 limit = n - sent;
1163                         txring = NETMAP_TXRING(nifp, i);
1164                         if (nm_ring_empty(txring))
1165                                 continue;
1166                         if (frags > 1)
1167                                 limit = ((limit + frags - 1) / frags) * frags;
1168
1169                         m = send_packets(txring, pkt, frame, size, targ->g,
1170                                          limit, options, frags);
1171                         ND("limit %d tail %d frags %d m %d",
1172                                 limit, txring->tail, frags, m);
1173                         sent += m;
1174                         targ->count = sent;
1175                         if (rate_limit) {
1176                                 tosend -= m;
1177                                 if (tosend <= 0)
1178                                         break;
1179                         }
1180                 }
1181         }
1182         /* flush any remaining packets */
1183         D("flush tail %d head %d on thread %p",
1184                 txring->tail, txring->head,
1185                 pthread_self());
1186         ioctl(pfd.fd, NIOCTXSYNC, NULL);
1187
1188         /* final part: wait all the TX queues to be empty. */
1189         for (i = targ->nmd->first_tx_ring; i <= targ->nmd->last_tx_ring; i++) {
1190                 txring = NETMAP_TXRING(nifp, i);
1191                 while (nm_tx_pending(txring)) {
1192                         RD(5, "pending tx tail %d head %d on ring %d",
1193                                 txring->tail, txring->head, i);
1194                         ioctl(pfd.fd, NIOCTXSYNC, NULL);
1195                         usleep(1); /* wait 1 tick */
1196                 }
1197         }
1198     } /* end DEV_NETMAP */
1199
1200         clock_gettime(CLOCK_REALTIME_PRECISE, &targ->toc);
1201         targ->completed = 1;
1202         targ->count = sent;
1203
1204 quit:
1205         /* reset the ``used`` flag. */
1206         targ->used = 0;
1207
1208         return (NULL);
1209 }
1210
1211
1212 #ifndef NO_PCAP
1213 static void
1214 receive_pcap(u_char *user, const struct pcap_pkthdr * h,
1215         const u_char * bytes)
1216 {
1217         int *count = (int *)user;
1218         (void)h;        /* UNUSED */
1219         (void)bytes;    /* UNUSED */
1220         (*count)++;
1221 }
1222 #endif /* !NO_PCAP */
1223
1224 static int
1225 receive_packets(struct netmap_ring *ring, u_int limit, int dump)
1226 {
1227         u_int cur, rx, n;
1228
1229         cur = ring->cur;
1230         n = nm_ring_space(ring);
1231         if (n < limit)
1232                 limit = n;
1233         for (rx = 0; rx < limit; rx++) {
1234                 struct netmap_slot *slot = &ring->slot[cur];
1235                 char *p = NETMAP_BUF(ring, slot->buf_idx);
1236
1237                 if (dump)
1238                         dump_payload(p, slot->len, ring, cur);
1239
1240                 cur = nm_ring_next(ring, cur);
1241         }
1242         ring->head = ring->cur = cur;
1243
1244         return (rx);
1245 }
1246
1247 static void *
1248 receiver_body(void *data)
1249 {
1250         struct targ *targ = (struct targ *) data;
1251         struct pollfd pfd = { .fd = targ->fd, .events = POLLIN };
1252         struct netmap_if *nifp;
1253         struct netmap_ring *rxring;
1254         int i;
1255         uint64_t received = 0;
1256
1257         if (setaffinity(targ->thread, targ->affinity))
1258                 goto quit;
1259
1260         D("reading from %s fd %d main_fd %d",
1261                 targ->g->ifname, targ->fd, targ->g->main_fd);
1262         /* unbounded wait for the first packet. */
1263         for (;!targ->cancel;) {
1264                 i = poll(&pfd, 1, 1000);
1265                 if (i > 0 && !(pfd.revents & POLLERR))
1266                         break;
1267                 RD(1, "waiting for initial packets, poll returns %d %d",
1268                         i, pfd.revents);
1269         }
1270         /* main loop, exit after 1s silence */
1271         clock_gettime(CLOCK_REALTIME_PRECISE, &targ->tic);
1272     if (targ->g->dev_type == DEV_TAP) {
1273         while (!targ->cancel) {
1274                 char buf[MAX_BODYSIZE];
1275                 /* XXX should we poll ? */
1276                 if (read(targ->g->main_fd, buf, sizeof(buf)) > 0)
1277                         targ->count++;
1278         }
1279 #ifndef NO_PCAP
1280     } else if (targ->g->dev_type == DEV_PCAP) {
1281         while (!targ->cancel) {
1282                 /* XXX should we poll ? */
1283                 pcap_dispatch(targ->g->p, targ->g->burst, receive_pcap,
1284                         (u_char *)&targ->count);
1285         }
1286 #endif /* !NO_PCAP */
1287     } else {
1288         int dump = targ->g->options & OPT_DUMP;
1289
1290         nifp = targ->nmd->nifp;
1291         while (!targ->cancel) {
1292                 /* Once we started to receive packets, wait at most 1 seconds
1293                    before quitting. */
1294                 if (poll(&pfd, 1, 1 * 1000) <= 0 && !targ->g->forever) {
1295                         clock_gettime(CLOCK_REALTIME_PRECISE, &targ->toc);
1296                         targ->toc.tv_sec -= 1; /* Subtract timeout time. */
1297                         goto out;
1298                 }
1299
1300                 if (pfd.revents & POLLERR) {
1301                         D("poll err");
1302                         goto quit;
1303                 }
1304
1305                 for (i = targ->nmd->first_rx_ring; i <= targ->nmd->last_rx_ring; i++) {
1306                         int m;
1307
1308                         rxring = NETMAP_RXRING(nifp, i);
1309                         if (nm_ring_empty(rxring))
1310                                 continue;
1311
1312                         m = receive_packets(rxring, targ->g->burst, dump);
1313                         received += m;
1314                 }
1315                 targ->count = received;
1316         }
1317     }
1318
1319         clock_gettime(CLOCK_REALTIME_PRECISE, &targ->toc);
1320
1321 out:
1322         targ->completed = 1;
1323         targ->count = received;
1324
1325 quit:
1326         /* reset the ``used`` flag. */
1327         targ->used = 0;
1328
1329         return (NULL);
1330 }
1331
1332 /* very crude code to print a number in normalized form.
1333  * Caller has to make sure that the buffer is large enough.
1334  */
1335 static const char *
1336 norm(char *buf, double val)
1337 {
1338         char *units[] = { "", "K", "M", "G", "T" };
1339         u_int i;
1340
1341         for (i = 0; val >=1000 && i < sizeof(units)/sizeof(char *) - 1; i++)
1342                 val /= 1000;
1343         sprintf(buf, "%.2f %s", val, units[i]);
1344         return buf;
1345 }
1346
1347 static void
1348 tx_output(uint64_t sent, int size, double delta)
1349 {
1350         double bw, raw_bw, pps;
1351         char b1[40], b2[80], b3[80];
1352
1353         printf("Sent %llu packets, %d bytes each, in %.2f seconds.\n",
1354                (unsigned long long)sent, size, delta);
1355         if (delta == 0)
1356                 delta = 1e-6;
1357         if (size < 60)          /* correct for min packet size */
1358                 size = 60;
1359         pps = sent / delta;
1360         bw = (8.0 * size * sent) / delta;
1361         /* raw packets have4 bytes crc + 20 bytes framing */
1362         raw_bw = (8.0 * (size + 24) * sent) / delta;
1363
1364         printf("Speed: %spps Bandwidth: %sbps (raw %sbps)\n",
1365                 norm(b1, pps), norm(b2, bw), norm(b3, raw_bw) );
1366 }
1367
1368
1369 static void
1370 rx_output(uint64_t received, double delta)
1371 {
1372         double pps;
1373         char b1[40];
1374
1375         printf("Received %llu packets, in %.2f seconds.\n",
1376                 (unsigned long long) received, delta);
1377
1378         if (delta == 0)
1379                 delta = 1e-6;
1380         pps = received / delta;
1381         printf("Speed: %spps\n", norm(b1, pps));
1382 }
1383
1384 static void
1385 usage(void)
1386 {
1387         const char *cmd = "pkt-gen";
1388         fprintf(stderr,
1389                 "Usage:\n"
1390                 "%s arguments\n"
1391                 "\t-i interface         interface name\n"
1392                 "\t-f function          tx rx ping pong\n"
1393                 "\t-n count             number of iterations (can be 0)\n"
1394                 "\t-t pkts_to_send              also forces tx mode\n"
1395                 "\t-r pkts_to_receive   also forces rx mode\n"
1396                 "\t-l pkt_size          in bytes excluding CRC\n"
1397                 "\t-d dst_ip[:port[-dst_ip:port]]   single or range\n"
1398                 "\t-s src_ip[:port[-src_ip:port]]   single or range\n"
1399                 "\t-D dst-mac\n"
1400                 "\t-S src-mac\n"
1401                 "\t-a cpu_id            use setaffinity\n"
1402                 "\t-b burst size                testing, mostly\n"
1403                 "\t-c cores             cores to use\n"
1404                 "\t-p threads           processes/threads to use\n"
1405                 "\t-T report_ms         milliseconds between reports\n"
1406                 "\t-P                   use libpcap instead of netmap\n"
1407                 "\t-w wait_for_link_time        in seconds\n"
1408                 "\t-R rate              in packets per second\n"
1409                 "\t-X                   dump payload\n"
1410                 "\t-H len               add empty virtio-net-header with size 'len'\n"
1411                 "\t-P file              load packet from pcap file\n"
1412                 "\t-z                   use random IPv4 src address/port\n"
1413                 "\t-Z                   use random IPv4 dst address/port\n"
1414                 "",
1415                 cmd);
1416
1417         exit(0);
1418 }
1419
1420 static void
1421 start_threads(struct glob_arg *g)
1422 {
1423         int i;
1424
1425         targs = calloc(g->nthreads, sizeof(*targs));
1426         /*
1427          * Now create the desired number of threads, each one
1428          * using a single descriptor.
1429          */
1430         for (i = 0; i < g->nthreads; i++) {
1431                 struct targ *t = &targs[i];
1432
1433                 bzero(t, sizeof(*t));
1434                 t->fd = -1; /* default, with pcap */
1435                 t->g = g;
1436
1437             if (g->dev_type == DEV_NETMAP) {
1438                 struct nm_desc nmd = *g->nmd; /* copy, we overwrite ringid */
1439                 uint64_t nmd_flags = 0;
1440                 nmd.self = &nmd;
1441
1442                 if (g->nthreads > 1) {
1443                         if (nmd.req.nr_flags != NR_REG_ALL_NIC) {
1444                                 D("invalid nthreads mode %d", nmd.req.nr_flags);
1445                                 continue;
1446                         }
1447                         nmd.req.nr_flags = NR_REG_ONE_NIC;
1448                         nmd.req.nr_ringid = i;
1449                 }
1450                 /* Only touch one of the rings (rx is already ok) */
1451                 if (g->td_body == receiver_body)
1452                         nmd_flags |= NETMAP_NO_TX_POLL;
1453
1454                 /* register interface. Override ifname and ringid etc. */
1455                 if (g->options & OPT_MONITOR_TX)
1456                         nmd.req.nr_flags |= NR_MONITOR_TX;
1457                 if (g->options & OPT_MONITOR_RX)
1458                         nmd.req.nr_flags |= NR_MONITOR_RX;
1459
1460                 t->nmd = nm_open(t->g->ifname, NULL, nmd_flags |
1461                         NM_OPEN_IFNAME | NM_OPEN_NO_MMAP, &nmd);
1462                 if (t->nmd == NULL) {
1463                         D("Unable to open %s: %s",
1464                                 t->g->ifname, strerror(errno));
1465                         continue;
1466                 }
1467                 t->fd = t->nmd->fd;
1468                 set_vnet_hdr_len(t);
1469
1470             } else {
1471                 targs[i].fd = g->main_fd;
1472             }
1473                 t->used = 1;
1474                 t->me = i;
1475                 if (g->affinity >= 0) {
1476                         if (g->affinity < g->cpus)
1477                                 t->affinity = g->affinity;
1478                         else
1479                                 t->affinity = i % g->cpus;
1480                 } else {
1481                         t->affinity = -1;
1482                 }
1483                 /* default, init packets */
1484                 initialize_packet(t);
1485
1486                 if (pthread_create(&t->thread, NULL, g->td_body, t) == -1) {
1487                         D("Unable to create thread %d: %s", i, strerror(errno));
1488                         t->used = 0;
1489                 }
1490         }
1491 }
1492
1493 static void
1494 main_thread(struct glob_arg *g)
1495 {
1496         int i;
1497
1498         uint64_t prev = 0;
1499         uint64_t count = 0;
1500         double delta_t;
1501         struct timeval tic, toc;
1502
1503         gettimeofday(&toc, NULL);
1504         for (;;) {
1505                 struct timeval now, delta;
1506                 uint64_t pps, usec, my_count, npkts;
1507                 int done = 0;
1508
1509                 delta.tv_sec = g->report_interval/1000;
1510                 delta.tv_usec = (g->report_interval%1000)*1000;
1511                 select(0, NULL, NULL, NULL, &delta);
1512                 gettimeofday(&now, NULL);
1513                 timersub(&now, &toc, &toc);
1514                 my_count = 0;
1515                 for (i = 0; i < g->nthreads; i++) {
1516                         my_count += targs[i].count;
1517                         if (targs[i].used == 0)
1518                                 done++;
1519                 }
1520                 usec = toc.tv_sec* 1000000 + toc.tv_usec;
1521                 if (usec < 10000)
1522                         continue;
1523                 npkts = my_count - prev;
1524                 pps = (npkts*1000000 + usec/2) / usec;
1525                 D("%llu pps (%llu pkts in %llu usec)",
1526                         (unsigned long long)pps,
1527                         (unsigned long long)npkts,
1528                         (unsigned long long)usec);
1529                 prev = my_count;
1530                 toc = now;
1531                 if (done == g->nthreads)
1532                         break;
1533         }
1534
1535         timerclear(&tic);
1536         timerclear(&toc);
1537         for (i = 0; i < g->nthreads; i++) {
1538                 struct timespec t_tic, t_toc;
1539                 /*
1540                  * Join active threads, unregister interfaces and close
1541                  * file descriptors.
1542                  */
1543                 if (targs[i].used)
1544                         pthread_join(targs[i].thread, NULL);
1545                 close(targs[i].fd);
1546
1547                 if (targs[i].completed == 0)
1548                         D("ouch, thread %d exited with error", i);
1549
1550                 /*
1551                  * Collect threads output and extract information about
1552                  * how long it took to send all the packets.
1553                  */
1554                 count += targs[i].count;
1555                 t_tic = timeval2spec(&tic);
1556                 t_toc = timeval2spec(&toc);
1557                 if (!timerisset(&tic) || timespec_ge(&targs[i].tic, &t_tic))
1558                         tic = timespec2val(&targs[i].tic);
1559                 if (!timerisset(&toc) || timespec_ge(&targs[i].toc, &t_toc))
1560                         toc = timespec2val(&targs[i].toc);
1561         }
1562
1563         /* print output. */
1564         timersub(&toc, &tic, &toc);
1565         delta_t = toc.tv_sec + 1e-6* toc.tv_usec;
1566         if (g->td_body == sender_body)
1567                 tx_output(count, g->pkt_size, delta_t);
1568         else
1569                 rx_output(count, delta_t);
1570
1571         if (g->dev_type == DEV_NETMAP) {
1572                 munmap(g->nmd->mem, g->nmd->req.nr_memsize);
1573                 close(g->main_fd);
1574         }
1575 }
1576
1577
1578 struct sf {
1579         char *key;
1580         void *f;
1581 };
1582
1583 static struct sf func[] = {
1584         { "tx", sender_body },
1585         { "rx", receiver_body },
1586         { "ping",       pinger_body },
1587         { "pong",       ponger_body },
1588         { NULL, NULL }
1589 };
1590
1591 static int
1592 tap_alloc(char *dev)
1593 {
1594         struct ifreq ifr;
1595         int fd, err;
1596         char *clonedev = TAP_CLONEDEV;
1597
1598         (void)err;
1599         (void)dev;
1600         /* Arguments taken by the function:
1601          *
1602          * char *dev: the name of an interface (or '\0'). MUST have enough
1603          *   space to hold the interface name if '\0' is passed
1604          * int flags: interface flags (eg, IFF_TUN etc.)
1605          */
1606
1607 #ifdef __FreeBSD__
1608         if (dev[3]) { /* tapSomething */
1609                 static char buf[128];
1610                 snprintf(buf, sizeof(buf), "/dev/%s", dev);
1611                 clonedev = buf;
1612         }
1613 #endif
1614         /* open the device */
1615         if( (fd = open(clonedev, O_RDWR)) < 0 ) {
1616                 return fd;
1617         }
1618         D("%s open successful", clonedev);
1619
1620         /* preparation of the struct ifr, of type "struct ifreq" */
1621         memset(&ifr, 0, sizeof(ifr));
1622
1623 #ifdef linux
1624         ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1625
1626         if (*dev) {
1627                 /* if a device name was specified, put it in the structure; otherwise,
1628                 * the kernel will try to allocate the "next" device of the
1629                 * specified type */
1630                 strncpy(ifr.ifr_name, dev, IFNAMSIZ);
1631         }
1632
1633         /* try to create the device */
1634         if( (err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0 ) {
1635                 D("failed to to a TUNSETIFF: %s", strerror(errno));
1636                 close(fd);
1637                 return err;
1638         }
1639
1640         /* if the operation was successful, write back the name of the
1641         * interface to the variable "dev", so the caller can know
1642         * it. Note that the caller MUST reserve space in *dev (see calling
1643         * code below) */
1644         strcpy(dev, ifr.ifr_name);
1645         D("new name is %s", dev);
1646 #endif /* linux */
1647
1648         /* this is the special file descriptor that the caller will use to talk
1649          * with the virtual interface */
1650         return fd;
1651 }
1652
1653 int
1654 main(int arc, char **argv)
1655 {
1656         int i;
1657
1658         struct glob_arg g;
1659
1660         int ch;
1661         int wait_link = 2;
1662         int devqueues = 1;      /* how many device queues */
1663
1664         bzero(&g, sizeof(g));
1665
1666         g.main_fd = -1;
1667         g.td_body = receiver_body;
1668         g.report_interval = 1000;       /* report interval */
1669         g.affinity = -1;
1670         /* ip addresses can also be a range x.x.x.x-x.x.x.y */
1671         g.src_ip.name = "10.0.0.1";
1672         g.dst_ip.name = "10.1.0.1";
1673         g.dst_mac.name = "ff:ff:ff:ff:ff:ff";
1674         g.src_mac.name = NULL;
1675         g.pkt_size = 60;
1676         g.burst = 512;          // default
1677         g.nthreads = 1;
1678         g.cpus = 1;
1679         g.forever = 1;
1680         g.tx_rate = 0;
1681         g.frags = 1;
1682         g.nmr_config = "";
1683         g.virt_header = 0;
1684
1685         while ( (ch = getopt(arc, argv,
1686                         "a:f:F:n:i:Il:d:s:D:S:b:c:o:p:T:w:WvR:XC:H:e:m:P:zZ")) != -1) {
1687                 struct sf *fn;
1688
1689                 switch(ch) {
1690                 default:
1691                         D("bad option %c %s", ch, optarg);
1692                         usage();
1693                         break;
1694
1695                 case 'n':
1696                         g.npackets = atoi(optarg);
1697                         break;
1698
1699                 case 'F':
1700                         i = atoi(optarg);
1701                         if (i < 1 || i > 63) {
1702                                 D("invalid frags %d [1..63], ignore", i);
1703                                 break;
1704                         }
1705                         g.frags = i;
1706                         break;
1707
1708                 case 'f':
1709                         for (fn = func; fn->key; fn++) {
1710                                 if (!strcmp(fn->key, optarg))
1711                                         break;
1712                         }
1713                         if (fn->key)
1714                                 g.td_body = fn->f;
1715                         else
1716                                 D("unrecognised function %s", optarg);
1717                         break;
1718
1719                 case 'o':       /* data generation options */
1720                         g.options = atoi(optarg);
1721                         break;
1722
1723                 case 'a':       /* force affinity */
1724                         g.affinity = atoi(optarg);
1725                         break;
1726
1727                 case 'i':       /* interface */
1728                         /* a prefix of tap: netmap: or pcap: forces the mode.
1729                          * otherwise we guess
1730                          */
1731                         D("interface is %s", optarg);
1732                         if (strlen(optarg) > MAX_IFNAMELEN - 8) {
1733                                 D("ifname too long %s", optarg);
1734                                 break;
1735                         }
1736                         strcpy(g.ifname, optarg);
1737                         if (!strcmp(optarg, "null")) {
1738                                 g.dev_type = DEV_NETMAP;
1739                                 g.dummy_send = 1;
1740                         } else if (!strncmp(optarg, "tap:", 4)) {
1741                                 g.dev_type = DEV_TAP;
1742                                 strcpy(g.ifname, optarg + 4);
1743                         } else if (!strncmp(optarg, "pcap:", 5)) {
1744                                 g.dev_type = DEV_PCAP;
1745                                 strcpy(g.ifname, optarg + 5);
1746                         } else if (!strncmp(optarg, "netmap:", 7) ||
1747                                    !strncmp(optarg, "vale", 4)) {
1748                                 g.dev_type = DEV_NETMAP;
1749                         } else if (!strncmp(optarg, "tap", 3)) {
1750                                 g.dev_type = DEV_TAP;
1751                         } else { /* prepend netmap: */
1752                                 g.dev_type = DEV_NETMAP;
1753                                 sprintf(g.ifname, "netmap:%s", optarg);
1754                         }
1755                         break;
1756
1757                 case 'I':
1758                         g.options |= OPT_INDIRECT;      /* XXX use indirect buffer */
1759                         break;
1760
1761                 case 'l':       /* pkt_size */
1762                         g.pkt_size = atoi(optarg);
1763                         break;
1764
1765                 case 'd':
1766                         g.dst_ip.name = optarg;
1767                         break;
1768
1769                 case 's':
1770                         g.src_ip.name = optarg;
1771                         break;
1772
1773                 case 'T':       /* report interval */
1774                         g.report_interval = atoi(optarg);
1775                         break;
1776
1777                 case 'w':
1778                         wait_link = atoi(optarg);
1779                         break;
1780
1781                 case 'W': /* XXX changed default */
1782                         g.forever = 0; /* do not exit rx even with no traffic */
1783                         break;
1784
1785                 case 'b':       /* burst */
1786                         g.burst = atoi(optarg);
1787                         break;
1788                 case 'c':
1789                         g.cpus = atoi(optarg);
1790                         break;
1791                 case 'p':
1792                         g.nthreads = atoi(optarg);
1793                         break;
1794
1795                 case 'D': /* destination mac */
1796                         g.dst_mac.name = optarg;
1797                         break;
1798
1799                 case 'S': /* source mac */
1800                         g.src_mac.name = optarg;
1801                         break;
1802                 case 'v':
1803                         verbose++;
1804                         break;
1805                 case 'R':
1806                         g.tx_rate = atoi(optarg);
1807                         break;
1808                 case 'X':
1809                         g.options |= OPT_DUMP;
1810                         break;
1811                 case 'C':
1812                         g.nmr_config = strdup(optarg);
1813                         break;
1814                 case 'H':
1815                         g.virt_header = atoi(optarg);
1816                         break;
1817                 case 'e': /* extra bufs */
1818                         g.extra_bufs = atoi(optarg);
1819                         break;
1820                 case 'm':
1821                         if (strcmp(optarg, "tx") == 0) {
1822                                 g.options |= OPT_MONITOR_TX;
1823                         } else if (strcmp(optarg, "rx") == 0) {
1824                                 g.options |= OPT_MONITOR_RX;
1825                         } else {
1826                                 D("unrecognized monitor mode %s", optarg);
1827                         }
1828                         break;
1829                 case 'P':
1830                         g.packet_file = strdup(optarg);
1831                         break;
1832                 case 'z':
1833                         g.options |= OPT_RANDOM_SRC;
1834                         break;
1835                 case 'Z':
1836                         g.options |= OPT_RANDOM_DST;
1837                         break;
1838                 }
1839         }
1840
1841         if (strlen(g.ifname) <=0 ) {
1842                 D("missing ifname");
1843                 usage();
1844         }
1845
1846         i = system_ncpus();
1847         if (g.cpus < 0 || g.cpus > i) {
1848                 D("%d cpus is too high, have only %d cpus", g.cpus, i);
1849                 usage();
1850         }
1851         if (g.cpus == 0)
1852                 g.cpus = i;
1853
1854         if (g.pkt_size < 16 || g.pkt_size > MAX_PKTSIZE) {
1855                 D("bad pktsize %d [16..%d]\n", g.pkt_size, MAX_PKTSIZE);
1856                 usage();
1857         }
1858
1859         if (g.src_mac.name == NULL) {
1860                 static char mybuf[20] = "00:00:00:00:00:00";
1861                 /* retrieve source mac address. */
1862                 if (source_hwaddr(g.ifname, mybuf) == -1) {
1863                         D("Unable to retrieve source mac");
1864                         // continue, fail later
1865                 }
1866                 g.src_mac.name = mybuf;
1867         }
1868         /* extract address ranges */
1869         extract_ip_range(&g.src_ip);
1870         extract_ip_range(&g.dst_ip);
1871         extract_mac_range(&g.src_mac);
1872         extract_mac_range(&g.dst_mac);
1873
1874         if (g.src_ip.start != g.src_ip.end ||
1875             g.src_ip.port0 != g.src_ip.port1 ||
1876             g.dst_ip.start != g.dst_ip.end ||
1877             g.dst_ip.port0 != g.dst_ip.port1)
1878                 g.options |= OPT_COPY;
1879
1880         if (g.virt_header != 0 && g.virt_header != VIRT_HDR_1
1881                         && g.virt_header != VIRT_HDR_2) {
1882                 D("bad virtio-net-header length");
1883                 usage();
1884         }
1885
1886     if (g.dev_type == DEV_TAP) {
1887         D("want to use tap %s", g.ifname);
1888         g.main_fd = tap_alloc(g.ifname);
1889         if (g.main_fd < 0) {
1890                 D("cannot open tap %s", g.ifname);
1891                 usage();
1892         }
1893 #ifndef NO_PCAP
1894     } else if (g.dev_type == DEV_PCAP) {
1895         char pcap_errbuf[PCAP_ERRBUF_SIZE];
1896
1897         pcap_errbuf[0] = '\0'; // init the buffer
1898         g.p = pcap_open_live(g.ifname, 256 /* XXX */, 1, 100, pcap_errbuf);
1899         if (g.p == NULL) {
1900                 D("cannot open pcap on %s", g.ifname);
1901                 usage();
1902         }
1903         g.main_fd = pcap_fileno(g.p);
1904         D("using pcap on %s fileno %d", g.ifname, g.main_fd);
1905 #endif /* !NO_PCAP */
1906     } else if (g.dummy_send) { /* but DEV_NETMAP */
1907         D("using a dummy send routine");
1908     } else {
1909         struct nmreq base_nmd;
1910
1911         bzero(&base_nmd, sizeof(base_nmd));
1912
1913         parse_nmr_config(g.nmr_config, &base_nmd);
1914         if (g.extra_bufs) {
1915                 base_nmd.nr_arg3 = g.extra_bufs;
1916         }
1917
1918         /*
1919          * Open the netmap device using nm_open().
1920          *
1921          * protocol stack and may cause a reset of the card,
1922          * which in turn may take some time for the PHY to
1923          * reconfigure. We do the open here to have time to reset.
1924          */
1925         g.nmd = nm_open(g.ifname, &base_nmd, 0, NULL);
1926         if (g.nmd == NULL) {
1927                 D("Unable to open %s: %s", g.ifname, strerror(errno));
1928                 goto out;
1929         }
1930         g.main_fd = g.nmd->fd;
1931         D("mapped %dKB at %p", g.nmd->req.nr_memsize>>10, g.nmd->mem);
1932
1933         /* get num of queues in tx or rx */
1934         if (g.td_body == sender_body)
1935                 devqueues = g.nmd->req.nr_tx_rings;
1936         else
1937                 devqueues = g.nmd->req.nr_rx_rings;
1938
1939         /* validate provided nthreads. */
1940         if (g.nthreads < 1 || g.nthreads > devqueues) {
1941                 D("bad nthreads %d, have %d queues", g.nthreads, devqueues);
1942                 // continue, fail later
1943         }
1944
1945         if (verbose) {
1946                 struct netmap_if *nifp = g.nmd->nifp;
1947                 struct nmreq *req = &g.nmd->req;
1948
1949                 D("nifp at offset %d, %d tx %d rx region %d",
1950                     req->nr_offset, req->nr_tx_rings, req->nr_rx_rings,
1951                     req->nr_arg2);
1952                 for (i = 0; i <= req->nr_tx_rings; i++) {
1953                         struct netmap_ring *ring = NETMAP_TXRING(nifp, i);
1954                         D("   TX%d at 0x%lx slots %d", i,
1955                             (char *)ring - (char *)nifp, ring->num_slots);
1956                 }
1957                 for (i = 0; i <= req->nr_rx_rings; i++) {
1958                         struct netmap_ring *ring = NETMAP_RXRING(nifp, i);
1959                         D("   RX%d at 0x%lx slots %d", i,
1960                             (char *)ring - (char *)nifp, ring->num_slots);
1961                 }
1962         }
1963
1964         /* Print some debug information. */
1965         fprintf(stdout,
1966                 "%s %s: %d queues, %d threads and %d cpus.\n",
1967                 (g.td_body == sender_body) ? "Sending on" : "Receiving from",
1968                 g.ifname,
1969                 devqueues,
1970                 g.nthreads,
1971                 g.cpus);
1972         if (g.td_body == sender_body) {
1973                 fprintf(stdout, "%s -> %s (%s -> %s)\n",
1974                         g.src_ip.name, g.dst_ip.name,
1975                         g.src_mac.name, g.dst_mac.name);
1976         }
1977
1978 out:
1979         /* Exit if something went wrong. */
1980         if (g.main_fd < 0) {
1981                 D("aborting");
1982                 usage();
1983         }
1984     }
1985
1986
1987         if (g.options) {
1988                 D("--- SPECIAL OPTIONS:%s%s%s%s%s\n",
1989                         g.options & OPT_PREFETCH ? " prefetch" : "",
1990                         g.options & OPT_ACCESS ? " access" : "",
1991                         g.options & OPT_MEMCPY ? " memcpy" : "",
1992                         g.options & OPT_INDIRECT ? " indirect" : "",
1993                         g.options & OPT_COPY ? " copy" : "");
1994         }
1995
1996         g.tx_period.tv_sec = g.tx_period.tv_nsec = 0;
1997         if (g.tx_rate > 0) {
1998                 /* try to have at least something every second,
1999                  * reducing the burst size to some 0.01s worth of data
2000                  * (but no less than one full set of fragments)
2001                  */
2002                 uint64_t x;
2003                 int lim = (g.tx_rate)/300;
2004                 if (g.burst > lim)
2005                         g.burst = lim;
2006                 if (g.burst < g.frags)
2007                         g.burst = g.frags;
2008                 x = ((uint64_t)1000000000 * (uint64_t)g.burst) / (uint64_t) g.tx_rate;
2009                 g.tx_period.tv_nsec = x;
2010                 g.tx_period.tv_sec = g.tx_period.tv_nsec / 1000000000;
2011                 g.tx_period.tv_nsec = g.tx_period.tv_nsec % 1000000000;
2012         }
2013         if (g.td_body == sender_body)
2014             D("Sending %d packets every  %ld.%09ld s",
2015                         g.burst, g.tx_period.tv_sec, g.tx_period.tv_nsec);
2016         /* Wait for PHY reset. */
2017         D("Wait %d secs for phy reset", wait_link);
2018         sleep(wait_link);
2019         D("Ready...");
2020
2021         /* Install ^C handler. */
2022         global_nthreads = g.nthreads;
2023         signal(SIGINT, sigint_h);
2024
2025         start_threads(&g);
2026         main_thread(&g);
2027         return 0;
2028 }
2029
2030 /* end of file */