int
main(int arc, char **argv)
{
int i;
struct glob_arg g;
int ch;
int wait_link = 2;
int devqueues = 1; /* how many device queues */
bzero(&g, sizeof(g));
g.main_fd = -1;
g.td_body = receiver_body;
g.report_interval = 1000; /* report interval */
g.affinity = -1;
/* ip addresses can also be a range x.x.x.x-x.x.x.y */
g.src_ip.name = "10.0.0.1";
g.dst_ip.name = "10.1.0.1";
g.dst_mac.name = "ff:ff:ff:ff:ff:ff";
g.src_mac.name = NULL;
g.pkt_size = 60;
g.burst = 512; // default
g.nthreads = 1;
g.cpus = 1;
g.forever = 1;
g.tx_rate = 0;
g.frags = 1;
g.nmr_config = "";
g.virt_header = 0;
while ( (ch = getopt(arc, argv,
"a:f:F:n:i:Il:d:s:D:S:b:c:o:p:T:w:WvR:XC:H:e:m:P:zZ")) != -1) {
struct sf *fn;
switch(ch) {
default:
D("bad option %c %s", ch, optarg);
usage();
break;
case 'n':
g.npackets = atoi(optarg);
break;
case 'F':
i = atoi(optarg);
if (i < 1 || i > 63) {
D("invalid frags %d [1..63], ignore", i);
break;
}
g.frags = i;
break;
case 'f':
for (fn = func; fn->key; fn++) {
if (!strcmp(fn->key, optarg))
break;
}
if (fn->key)
g.td_body = fn->f;
else
D("unrecognised function %s", optarg);
break;
case 'o': /* data generation options */
g.options = atoi(optarg);
break;
case 'a': /* force affinity */
g.affinity = atoi(optarg);
break;
case 'i': /* interface */
/* a prefix of tap: netmap: or pcap: forces the mode.
* otherwise we guess
*/
D("interface is %s", optarg);
if (strlen(optarg) > MAX_IFNAMELEN - 8) {
D("ifname too long %s", optarg);
break;
}
strcpy(g.ifname, optarg);
if (!strcmp(optarg, "null")) {
g.dev_type = DEV_NETMAP;
g.dummy_send = 1;
} else if (!strncmp(optarg, "tap:", 4)) {
g.dev_type = DEV_TAP;
strcpy(g.ifname, optarg + 4);
} else if (!strncmp(optarg, "pcap:", 5)) {
g.dev_type = DEV_PCAP;
strcpy(g.ifname, optarg + 5);
} else if (!strncmp(optarg, "netmap:", 7) ||
!strncmp(optarg, "vale", 4)) {
g.dev_type = DEV_NETMAP;
} else if (!strncmp(optarg, "tap", 3)) {
g.dev_type = DEV_TAP;
} else { /* prepend netmap: */
g.dev_type = DEV_NETMAP;
sprintf(g.ifname, "netmap:%s", optarg);
}
break;
case 'I':
g.options |= OPT_INDIRECT; /* XXX use indirect buffer */
break;
case 'l': /* pkt_size */
g.pkt_size = atoi(optarg);
break;
case 'd':
g.dst_ip.name = optarg;
break;
case 's':
g.src_ip.name = optarg;
break;
case 'T': /* report interval */
g.report_interval = atoi(optarg);
break;
case 'w':
wait_link = atoi(optarg);
break;
case 'W': /* XXX changed default */
g.forever = 0; /* do not exit rx even with no traffic */
break;
case 'b': /* burst */
g.burst = atoi(optarg);
break;
case 'c':
g.cpus = atoi(optarg);
break;
case 'p':
g.nthreads = atoi(optarg);
break;
case 'D': /* destination mac */
g.dst_mac.name = optarg;
break;
case 'S': /* source mac */
g.src_mac.name = optarg;
break;
case 'v':
verbose++;
break;
case 'R':
g.tx_rate = atoi(optarg);
break;
case 'X':
g.options |= OPT_DUMP;
break;
case 'C':
g.nmr_config = strdup(optarg);
break;
case 'H':
g.virt_header = atoi(optarg);
break;
case 'e': /* extra bufs */
g.extra_bufs = atoi(optarg);
break;
case 'm':
if (strcmp(optarg, "tx") == 0) {
g.options |= OPT_MONITOR_TX;
} else if (strcmp(optarg, "rx") == 0) {
g.options |= OPT_MONITOR_RX;
} else {
D("unrecognized monitor mode %s", optarg);
}
break;
case 'P':
g.packet_file = strdup(optarg);
break;
case 'z':
g.options |= OPT_RANDOM_SRC;
break;
case 'Z':
g.options |= OPT_RANDOM_DST;
break;
}
}
if (strlen(g.ifname) <=0 ) {
D("missing ifname");
usage();
}
i = system_ncpus();
if (g.cpus < 0 || g.cpus > i) {
D("%d cpus is too high, have only %d cpus", g.cpus, i);
usage();
}
if (g.cpus == 0)
g.cpus = i;
if (g.pkt_size < 16 || g.pkt_size > MAX_PKTSIZE) {
D("bad pktsize %d [16..%d]\n", g.pkt_size, MAX_PKTSIZE);
usage();
}
if (g.src_mac.name == NULL) {
static char mybuf[20] = "00:00:00:00:00:00";
/* retrieve source mac address. */
if (source_hwaddr(g.ifname, mybuf) == -1) {
D("Unable to retrieve source mac");
// continue, fail later
}
g.src_mac.name = mybuf;
}
/* extract address ranges */
extract_ip_range(&g.src_ip);
extract_ip_range(&g.dst_ip);
extract_mac_range(&g.src_mac);
extract_mac_range(&g.dst_mac);
if (g.src_ip.start != g.src_ip.end ||
g.src_ip.port0 != g.src_ip.port1 ||
g.dst_ip.start != g.dst_ip.end ||
g.dst_ip.port0 != g.dst_ip.port1)
g.options |= OPT_COPY;
if (g.virt_header != 0 && g.virt_header != VIRT_HDR_1
&& g.virt_header != VIRT_HDR_2) {
D("bad virtio-net-header length");
usage();
}
if (g.dev_type == DEV_TAP) {
D("want to use tap %s", g.ifname);
g.main_fd = tap_alloc(g.ifname);
if (g.main_fd < 0) {
D("cannot open tap %s", g.ifname);
usage();
}
#ifndef NO_PCAP
} else if (g.dev_type == DEV_PCAP) {
char pcap_errbuf[PCAP_ERRBUF_SIZE];
pcap_errbuf[0] = '\0'; // init the buffer
g.p = pcap_open_live(g.ifname, 256 /* XXX */, 1, 100, pcap_errbuf);
if (g.p == NULL) {
D("cannot open pcap on %s", g.ifname);
usage();
}
g.main_fd = pcap_fileno(g.p);
D("using pcap on %s fileno %d", g.ifname, g.main_fd);
#endif /* !NO_PCAP */
} else if (g.dummy_send) { /* but DEV_NETMAP */
D("using a dummy send routine");
} else {
struct nmreq base_nmd;
bzero(&base_nmd, sizeof(base_nmd));
parse_nmr_config(g.nmr_config, &base_nmd);
if (g.extra_bufs) {
base_nmd.nr_arg3 = g.extra_bufs;
}
/*
* Open the netmap device using nm_open().
*
* protocol stack and may cause a reset of the card,
* which in turn may take some time for the PHY to
* reconfigure. We do the open here to have time to reset.
*/
g.nmd = nm_open(g.ifname, &base_nmd, 0, NULL);
if (g.nmd == NULL) {
D("Unable to open %s: %s", g.ifname, strerror(errno));
goto out;
}
g.main_fd = g.nmd->fd;
D("mapped %dKB at %p", g.nmd->req.nr_memsize>>10, g.nmd->mem);
/* get num of queues in tx or rx */
if (g.td_body == sender_body)
devqueues = g.nmd->req.nr_tx_rings;
else
devqueues = g.nmd->req.nr_rx_rings;
/* validate provided nthreads. */
if (g.nthreads < 1 || g.nthreads > devqueues) {
D("bad nthreads %d, have %d queues", g.nthreads, devqueues);
// continue, fail later
}
if (verbose) {
struct netmap_if *nifp = g.nmd->nifp;
struct nmreq *req = &g.nmd->req;
D("nifp at offset %d, %d tx %d rx region %d",
req->nr_offset, req->nr_tx_rings, req->nr_rx_rings,
req->nr_arg2);
for (i = 0; i <= req->nr_tx_rings; i++) {
struct netmap_ring *ring = NETMAP_TXRING(nifp, i);
D(" TX%d at 0x%lx slots %d", i,
(char *)ring - (char *)nifp, ring->num_slots);
}
for (i = 0; i <= req->nr_rx_rings; i++) {
struct netmap_ring *ring = NETMAP_RXRING(nifp, i);
D(" RX%d at 0x%lx slots %d", i,
(char *)ring - (char *)nifp, ring->num_slots);
}
}
/* Print some debug information. */
fprintf(stdout,
"%s %s: %d queues, %d threads and %d cpus.\n",
(g.td_body == sender_body) ? "Sending on" : "Receiving from",
g.ifname,
devqueues,
g.nthreads,
g.cpus);
if (g.td_body == sender_body) {
fprintf(stdout, "%s -> %s (%s -> %s)\n",
g.src_ip.name, g.dst_ip.name,
g.src_mac.name, g.dst_mac.name);
}
out:
/* Exit if something went wrong. */
if (g.main_fd < 0) {
D("aborting");
usage();
}
}
if (g.options) {
D("--- SPECIAL OPTIONS:%s%s%s%s%s\n",
g.options & OPT_PREFETCH ? " prefetch" : "",
g.options & OPT_ACCESS ? " access" : "",
g.options & OPT_MEMCPY ? " memcpy" : "",
g.options & OPT_INDIRECT ? " indirect" : "",
g.options & OPT_COPY ? " copy" : "");
}
g.tx_period.tv_sec = g.tx_period.tv_nsec = 0;
if (g.tx_rate > 0) {
/* try to have at least something every second,
* reducing the burst size to some 0.01s worth of data
* (but no less than one full set of fragments)
*/
uint64_t x;
int lim = (g.tx_rate)/300;
if (g.burst > lim)
g.burst = lim;
if (g.burst < g.frags)
g.burst = g.frags;
x = ((uint64_t)1000000000 * (uint64_t)g.burst) / (uint64_t) g.tx_rate;
g.tx_period.tv_nsec = x;
g.tx_period.tv_sec = g.tx_period.tv_nsec / 1000000000;
g.tx_period.tv_nsec = g.tx_period.tv_nsec % 1000000000;
}
if (g.td_body == sender_body)
D("Sending %d packets every %ld.%09ld s",
g.burst, g.tx_period.tv_sec, g.tx_period.tv_nsec);
/* Wait for PHY reset. */
D("Wait %d secs for phy reset", wait_link);
sleep(wait_link);
D("Ready...");
/* Install ^C handler. */
global_nthreads = g.nthreads;
signal(SIGINT, sigint_h);
start_threads(&g);
main_thread(&g);
return 0;
}
static int CheckValid()
{
char temp_arr[1024];
char *temp_strs[1024];
int i, l, len_strs;
char *port_strs[1024];
char port_range[1024];
char mybuf[] = "00:00:00:00:00:00";
if (strlen(sysconfig.if_in) < 1 || strlen(sysconfig.if_out) < 1)
{
OD("missing ifnames");
return -1;
}
if (sysconfig.is_test)
{
if (strlen(sysconfig.src_mac.name) < 1)
{
/* retrieve source mac address. */
if (source_hwaddr(sysconfig.if_out, mybuf) == -1) {
OD("Unable to retrieve source mac");
return -1;
// continue, fail later
}
strcpy(sysconfig.src_mac.name, mybuf);
}
/* extract address ranges */
extract_ip_range(&sysconfig.src_ip);
extract_mac_range(&sysconfig.src_mac);
for (i = 0; i < sysconfig.dst_count && i < FIO_MAX_DST_TEST; i++)
{
extract_ip_range(&sysconfig.dst_ip[i]);
extract_mac_range(&sysconfig.dst_mac[i]);
}
}
if (source_hwaddr(sysconfig.if_in, mybuf) == -1) {
OD("Unable to retrieve source mac %s", sysconfig.if_in);
return -1;
}
bcopy(ether_aton(mybuf), &sysconfig.if_macs[0], ETH_ALEN);
OD("if %s mac %s", sysconfig.if_in, mybuf);
if (source_hwaddr(sysconfig.if_out, mybuf) == -1) {
OD("Unable to retrieve source mac %s", sysconfig.if_out);
return -1;
}
bcopy(ether_aton(mybuf), &sysconfig.if_macs[1], ETH_ALEN);
OD("if %s mac %s", sysconfig.if_out, mybuf);
extract_mac_range(&sysconfig.defgw_mac);
OD("defgw mac %s", sysconfig.defgw_mac.name);
if (get_if_ip(sysconfig.if_in, &sysconfig.if_ips[0]))
OD("<error> %s get ip", sysconfig.if_in);
if (get_if_ip(sysconfig.if_out, &sysconfig.if_ips[1]))
OD("<error> %s get ip", sysconfig.if_out);
OD("read %d ipmac", g_mac_num);
len_strs = splite_str(sysconfig.str_interested_proto,
sizeof(sysconfig.str_interested_proto), temp_arr,
1024, temp_strs, 1024, ' ');
translate_proto(temp_strs, len_strs, 1);
len_strs = splite_str(sysconfig.str_def_proto,
sizeof(sysconfig.str_def_proto), temp_arr,
1024, temp_strs, 1024, ' ');
translate_proto(temp_strs, len_strs, 2);
len_strs = splite_str(sysconfig.str_interested_port,
sizeof(sysconfig.str_interested_port), temp_arr,
1024, temp_strs, 1024, ' ');
for (i = 0; i < len_strs; i++)
{
l = splite_str(temp_strs[i], strlen(temp_strs[i])+1,
port_range, 1024, port_strs, 1024, '~');
translate_port(port_strs, l, i);
}
sysconfig.mac_lifetime *= 1000000;
sysconfig.mac_buddy_lifetime *= 1000000;
//sysconfig.multip_checktime *= 1000000;
if (strlen(sysconfig.if_in))
strncpy(sysconfig.nic_names[sysconfig.num_nic++], sysconfig.if_in, FIO_MAX_NAME_LEN);
if (strlen(sysconfig.if_out) && strcmp(sysconfig.if_out, sysconfig.if_in))
strncpy(sysconfig.nic_names[sysconfig.num_nic++], sysconfig.if_out, FIO_MAX_NAME_LEN);
return 0;
}
