[mirror_ovs.git] / utilities / ovs-benchmark.c

/*
 * Copyright (c) 2010, 2011, 2012, 2013 Nicira, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <config.h>

#include <errno.h>
#include <getopt.h>
#include <limits.h>
#include <poll.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <stddef.h>
#include <unistd.h>

#include "command-line.h"
#include "poll-loop.h"
#include "socket-util.h"
#include "timeval.h"
#include "util.h"
#include "openvswitch/vlog.h"

#define DEFAULT_PORT 6630

#define MAX_SOCKETS 65535
static int n_batches = 1;
static int n_sockets = 100;

static struct in_addr local_addr;
static unsigned short int local_min_port, local_max_port;

static struct in_addr remote_addr;
static unsigned short int remote_min_port, remote_max_port;

static double max_rate;

static double timeout;

static const struct ovs_cmdl_command *get_all_commands(void);

static void parse_options(int argc, char *argv[]);
static void usage(void);

static int
do_poll(struct pollfd *fds, int nfds, int timeout)
{
    int retval;
#ifndef _WIN32
    do {
        retval = poll(fds, nfds, timeout);
    } while (retval < 0 && errno == EINTR);
#else
    retval = WSAPoll(fds, nfds, timeout);
#endif
    return retval;
}

static long long int
time_in_msec(void)
{
    struct timeval tv;

    xgettimeofday(&tv);

    return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
}

int
main(int argc, char *argv[])
{
    struct ovs_cmdl_context ctx = { .argc = 0, };
    set_program_name(argv[0]);
    vlog_set_levels(NULL, VLF_ANY_DESTINATION, VLL_EMER);
    parse_options(argc, argv);
    ctx.argc = argc - optind;
    ctx.argv = argv + optind;
    ovs_cmdl_run_command(&ctx, get_all_commands());
    return 0;
}

static void
parse_target(const char *s_, struct in_addr *addr,
             unsigned short int *min, unsigned short int *max)
{
    char *s = xstrdup(s_);
    char *colon;
    int error;

    colon = strchr(s, ':');
    if (colon) {
        *colon = '\0';
    }

    if (*s != '\0') {
        error = lookup_hostname(s, addr);
        if (error) {
            ovs_fatal(error, "failed to look up IP address for \"%s\"", s_);
        }
    } else {
        addr->s_addr = htonl(INADDR_ANY);
    }

    *min = *max = 0;
    if (colon && colon[1] != '\0') {
        const char *ports = colon + 1;
        if (ovs_scan(ports, "%hu-%hu", min, max)) {
            if (*min > *max) {
                ovs_fatal(0, "%s: minimum is greater than maximum", s_);
            }
        } else if (ovs_scan(ports, "%hu", min)) {
            *max = *min;
        } else {
            ovs_fatal(0, "%s: number or range expected", s_);
        }
    }

    free(s);
}

static void
parse_options(int argc, char *argv[])
{
    static const struct option long_options[] = {
        {"local", required_argument, NULL, 'l'},
        {"remote", required_argument, NULL, 'r'},
        {"batches", required_argument, NULL, 'b'},
        {"sockets", required_argument, NULL, 's'},
        {"max-rate", required_argument, NULL, 'c'},
        {"timeout", required_argument, NULL, 'T'},
        {"help", no_argument, NULL, 'h'},
        {"version", no_argument, NULL, 'V'},
        {NULL, 0, NULL, 0},
    };
    char *short_options = ovs_cmdl_long_options_to_short_options(long_options);

    local_addr.s_addr = htonl(INADDR_ANY);
    local_min_port = local_max_port = 0;

    remote_addr.s_addr = htonl(0);
    remote_min_port = remote_max_port = 0;

    for (;;) {
        int c;

        c = getopt_long(argc, argv, short_options, long_options, NULL);
        if (c == -1) {
            break;
        }

        switch (c) {
        case 'l':
            parse_target(optarg,
                         &local_addr, &local_min_port, &local_max_port);
            break;

        case 'r':
            parse_target(optarg,
                         &remote_addr, &remote_min_port, &remote_max_port);
            if (remote_addr.s_addr == htonl(INADDR_ANY)) {
                ovs_fatal(0, "remote IP address is required");
            }
            break;

        case 'b':
            n_batches = atoi(optarg);
            if (n_batches < 0) {
                ovs_fatal(0, "--batches or -b argument must be at least 1");
            }
            break;

        case 's':
            n_sockets = atoi(optarg);
            if (n_sockets < 1 || n_sockets > MAX_SOCKETS) {
                ovs_fatal(0, "--sockets or -s argument must be between 1 "
                          "and %d (inclusive)", MAX_SOCKETS);
            }
            break;

        case 'c':
            max_rate = atof(optarg);
            if (max_rate <= 0.0) {
                ovs_fatal(0, "--max-rate or -c argument must be positive");
            }
            break;

        case 'T':
            timeout = atoi(optarg);
            if (!timeout) {
                ovs_fatal(0, "-T or --timeout argument must be positive");
            }
            break;

        case 'h':
            usage();

        case 'V':
            ovs_print_version(0, 0);
            exit(EXIT_SUCCESS);

        case '?':
            exit(EXIT_FAILURE);

        default:
            abort();
        }
    }
    free(short_options);
}

static void
usage(void)
{
    printf("\
%s: Open vSwitch flow setup benchmark utility\n\
usage: %s [OPTIONS] COMMAND [ARG...]\n\
  latency                     connect many times all at once\n\
  rate                        measure sustained flow setup rate\n\
  listen                      accept TCP connections\n\
  help                        display this help message\n\
\n\
Command options:\n\
  -l, --local [IP][:PORTS]    use local IP and range of PORTS\n\
  -r, --remote IP[:PORTS]     connect to remote IP and PORTS\n\
  -s, --sockets N             number of sockets for \"rate\" or \"latency\"\n\
  -b, --batches N             number of connection batches for \"latency\"\n\
  -c, --max-rate NPERSEC      connection rate limit for \"rate\"\n\
  -T, --timeout MAXSECS       max number of seconds to run for \"rate\"\n\
\n\
Other options:\n\
  -h, --help                  display this help message\n\
  -V, --version               display version information\n",
           program_name, program_name);
    exit(EXIT_SUCCESS);
}

static void
cmd_listen(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
    struct pollfd *fds;
    int n_fds;
    int port;
    int i;

    if (!local_min_port && !local_max_port) {
        local_min_port = local_max_port = DEFAULT_PORT;
    }
    fds = xmalloc((1 + local_max_port - local_min_port) * sizeof *fds);
    n_fds = 0;
    for (port = local_min_port; port <= local_max_port; port++) {
        struct sockaddr_in sin;
        unsigned int yes = 1;
        int error;
        int fd;

        /* Create socket, set SO_REUSEADDR. */
        fd = socket(AF_INET, SOCK_STREAM, 0);
        if (fd < 0) {
            ovs_fatal(errno, "failed to create socket");
        }
        error = set_nonblocking(fd);
        if (error) {
            ovs_fatal(error, "failed to set non-blocking mode");
        }
        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
            ovs_fatal(errno, "setsockopt(SO_REUSEADDR) failed");
        }

        /* Bind. */
        sin.sin_family = AF_INET;
        sin.sin_addr = remote_addr;
        sin.sin_port = htons(port);
        if (bind(fd, (struct sockaddr *) &sin, sizeof sin) < 0) {
            ovs_fatal(errno, "bind failed");
        }

        /* Listen. */
        if (listen(fd, 10000) < 0) {
            ovs_fatal(errno, "listen failed");
        }

        fds[n_fds].fd = fd;
        fds[n_fds].events = POLLIN;
        n_fds++;
    }

    for (;;) {
        int retval;

        retval = do_poll(fds, n_fds, -1);
        if (retval < 0) {
            ovs_fatal(errno, "poll failed");
        }

        for (i = 0; i < n_fds; i++) {
            if (fds[i].revents & POLLIN) {
                int newfd;

                do {
                    newfd = accept(fds[i].fd, NULL, NULL);
                } while (newfd < 0 && errno == EINTR);

                if (newfd >= 0) {
                    close(newfd);
                } else if (errno != EAGAIN) {
                    ovs_fatal(errno, "accept failed");
                }
            }
        }
    }
}

/* Increments '*value' within the range 'min...max' inclusive.  Returns true
 * if '*value' wraps around to 'min', otherwise false. */
static bool
increment(unsigned short int *value,
          unsigned short int min, unsigned short int max)
{
    if (*value < max) {
        ++*value;
        return false;
    } else {
        *value = min;
        return true;
    }
}

static void
next_ports(unsigned short int *local_port, unsigned short int *remote_port)
{
    if (increment(local_port, local_min_port, local_max_port)) {
        increment(remote_port, remote_min_port, remote_max_port);
    }
}

static void
bind_local_port(int fd, unsigned short int *local_port,
                unsigned short int *remote_port)
{
    int error;

    if (!local_min_port && !local_max_port) {
        next_ports(local_port, remote_port);
        return;
    }

    do {
        struct sockaddr_in local;

        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;
        local.sin_addr = local_addr;
        local.sin_port = htons(*local_port);
        error = (bind(fd, (struct sockaddr *) &local, sizeof local) < 0
                 ? errno : 0);
        next_ports(local_port, remote_port);
    } while (error == EADDRINUSE || error == EINTR);
    if (error) {
        ovs_fatal(error, "bind failed");
    }
}

static void
cmd_rate(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
    unsigned short int local_port;
    unsigned short int remote_port;
    unsigned int completed = 0;
    unsigned int failures = 0;
    long long int start, prev;
    struct pollfd *fds;
    int n_fds;

    if (!remote_addr.s_addr) {
        ovs_fatal(0, "remote address must be specified with -r or --remote");
    }
    if (!remote_min_port && !remote_max_port) {
        remote_min_port = remote_max_port = DEFAULT_PORT;
    }

    local_port = local_min_port;
    remote_port = remote_min_port;
    fds = xmalloc(n_sockets * sizeof *fds);
    n_fds = 0;
    start = prev = time_in_msec();
    for (;;) {
        long long int now;
        long long int may_open;
        int delay;
        int error;
        int j;

        if (max_rate > 0) {
            long long int cur_total = completed + n_fds;
            long long int max_total = (time_in_msec() - start) * (max_rate / 1000.0);
            if (max_total > cur_total) {
                may_open = MIN(n_sockets, max_total - cur_total);
            } else {
                may_open = 0;
            }
            delay = 1000.0 / max_rate;
        } else {
            may_open = n_sockets;
            delay = 1000;
        }

        while (may_open-- > 0 && n_fds < n_sockets) {
            struct sockaddr_in remote;
            int error;
            int fd;

            fd = socket(AF_INET, SOCK_STREAM, 0);
            if (fd < 0) {
                ovs_fatal(errno, "socket failed");
            }

            error = set_nonblocking(fd);
            if (error) {
                ovs_fatal(error, "set_nonblocking failed");
            }

            bind_local_port(fd, &local_port, &remote_port);

            memset(&remote, 0, sizeof remote);
            remote.sin_family = AF_INET;
            remote.sin_addr = remote_addr;
            remote.sin_port = htons(remote_port);
            if (connect(fd, (struct sockaddr *) &remote, sizeof remote) < 0) {
                if (errno == EINPROGRESS) {
                    fds[n_fds].fd = fd;
                    fds[n_fds].events = POLLOUT;
                    fds[n_fds].revents = 0;
                    n_fds++;
                } else if (errno != ECONNREFUSED) {
                    ovs_fatal(errno, "connect");
                }
            } else {
                /* Success, I guess. */
                shutdown(fd, 2);
                close(fd);
                completed++;
            }
        }

        if (n_fds == n_sockets) {
            delay = 1000;
        }

        error = do_poll(fds, n_fds, delay);
        if (error) {
            ovs_fatal(errno, "poll");
        }

        for (j = 0; j < n_fds; ) {
            if (fds[j].revents) {
                if (fds[j].revents & POLLERR) {
                    failures++;
                }
                shutdown(fds[j].fd, 2);
                close(fds[j].fd);
                fds[j] = fds[--n_fds];
                completed++;
            } else {
                j++;
            }
        }

        now = time_in_msec();
        if (now >= prev + 1000) {
            long long int elapsed = now - start;
            printf("%.3f s elapsed, %u OK, %u failed, avg %.1f/s\n",
                   elapsed / 1000.0, completed - failures, failures,
                   completed / (elapsed / 1000.0));
            fflush(stdout);
            prev = now;

            if (timeout && elapsed > timeout * 1000LL) {
                break;
            }
        }
    }
}

static void
timer_end(long long int start, bool error,
          int *min, int *max, unsigned long long int *total)
{
    int elapsed = time_in_msec() - start;
    static int last_elapsed = INT_MIN;
    char c = error ? '!' : '.';

    if (last_elapsed != elapsed) {
        if (last_elapsed != INT_MIN) {
            putchar('\n');
        }
        printf("%5d %c", elapsed, c);
        fflush(stdout);
        last_elapsed = elapsed;
    } else {
        putchar(c);
        fflush(stdout);
    }

    if (elapsed < *min) {
        *min = elapsed;
    }
    if (elapsed > *max) {
        *max = elapsed;
    }
    *total += elapsed;
}

static void
cmd_latency(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
    unsigned short int local_port;
    unsigned short int remote_port;
    int min = INT_MAX;
    int max = 0;
    unsigned long long int total = 0;
    int i;

    if (!remote_addr.s_addr) {
        ovs_fatal(0, "remote address must be specified with -r or --rate");
    }
    if (!remote_min_port && !remote_max_port) {
        remote_min_port = remote_max_port = DEFAULT_PORT;
    }

    local_port = local_min_port;
    remote_port = remote_min_port;
    for (i = 0; i < n_batches; i++) {
        struct pollfd fds[MAX_SOCKETS];
        long long int start;
        int n_fds;
        int j;

        start = time_in_msec();
        n_fds = 0;
        for (j = 0; j < n_sockets; j++) {
            struct sockaddr_in remote;
            int error;
            int fd;

            fd = socket(AF_INET, SOCK_STREAM, 0);
            if (fd < 0) {
                ovs_fatal(errno, "socket failed");
            }

            error = set_nonblocking(fd);
            if (error) {
                ovs_fatal(error, "set_nonblocking failed");
            }

            bind_local_port(fd, &local_port, &remote_port);

            memset(&remote, 0, sizeof remote);
            remote.sin_family = AF_INET;
            remote.sin_addr = remote_addr;
            remote.sin_port = htons(remote_port);
            if (connect(fd, (struct sockaddr *) &remote, sizeof remote) < 0) {
                if (errno == EINPROGRESS) {
                    fds[n_fds].fd = fd;
                    fds[n_fds].events = POLLOUT;
                    fds[n_fds].revents = 0;
                    n_fds++;
                } else if (errno != ECONNREFUSED) {
                    ovs_fatal(errno, "connect");
                }
            } else {
                /* Success, I guess. */
                close(fd);
                timer_end(start, 0, &min, &max, &total);
            }
        }

        while (n_fds > 0) {
            int error;

            error = do_poll(fds, n_fds, -1);
            if (error) {
                ovs_fatal(errno, "poll");
            }

            for (j = 0; j < n_fds; ) {
                if (fds[j].revents) {
                    timer_end(start,
                              fds[j].revents & (POLLERR|POLLHUP) ? 1 : 0,
                              &min, &max, &total);
                    close(fds[j].fd);
                    fds[j] = fds[--n_fds];
                } else {
                    j++;
                }
            }
        }
        putchar('\n');
    }

    printf("min %d ms, max %d ms, avg %llu ms\n",
           min, max, total / (1ULL * n_sockets * n_batches));
}

static void
cmd_help(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
    usage();
}

static const struct ovs_cmdl_command all_commands[] = {
    { "listen", NULL, 0, 0, cmd_listen },
    { "rate", NULL, 0, 0, cmd_rate },
    { "latency", NULL, 0, 0, cmd_latency },
    { "help", NULL, 0, 0, cmd_help },
    { NULL, NULL, 0, 0, NULL },
};

static const struct ovs_cmdl_command *get_all_commands(void)
{
  return all_commands;
}
Commit	Line	Data
5e00790e	1	/*
d5155945	2	* Copyright (c) 2010, 2011, 2012, 2013 Nicira, Inc.
5e00790e BP	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at:
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*/
	16
	17	#include <config.h>
	18
	19	#include <errno.h>
	20	#include <getopt.h>
	21	#include <limits.h>
	22	#include <poll.h>
	23	#include <stdlib.h>
	24	#include <sys/socket.h>
	25	#include <sys/time.h>
	26	#include <stddef.h>
	27	#include <unistd.h>
	28
	29	#include "command-line.h"
	30	#include "poll-loop.h"
	31	#include "socket-util.h"
	32	#include "timeval.h"
	33	#include "util.h"
e6211adc	34	#include "openvswitch/vlog.h"
5e00790e BP	35
	36	#define DEFAULT_PORT 6630
	37
	38	#define MAX_SOCKETS 65535
	39	static int n_batches = 1;
	40	static int n_sockets = 100;
	41
	42	static struct in_addr local_addr;
	43	static unsigned short int local_min_port, local_max_port;
	44
	45	static struct in_addr remote_addr;
	46	static unsigned short int remote_min_port, remote_max_port;
	47
	48	static double max_rate;
	49
	50	static double timeout;
	51
5f383751	52	static const struct ovs_cmdl_command *get_all_commands(void);
5e00790e BP	53
	54	static void parse_options(int argc, char *argv[]);
	55	static void usage(void);
	56
6d1e400e GS	57	static int
	58	do_poll(struct pollfd *fds, int nfds, int timeout)
	59	{
	60	int retval;
	61	#ifndef _WIN32
	62	do {
	63	retval = poll(fds, nfds, timeout);
	64	} while (retval < 0 && errno == EINTR);
	65	#else
	66	retval = WSAPoll(fds, nfds, timeout);
	67	#endif
	68	return retval;
	69	}
	70
5e00790e BP	71	static long long int
	72	time_in_msec(void)
	73	{
	74	struct timeval tv;
	75
6d1e400e	76	xgettimeofday(&tv);
5e00790e BP	77
	78	return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
	79	}
	80
	81	int
	82	main(int argc, char *argv[])
	83	{
1636c761	84	struct ovs_cmdl_context ctx = { .argc = 0, };
5e00790e	85	set_program_name(argv[0]);
d5460484	86	vlog_set_levels(NULL, VLF_ANY_DESTINATION, VLL_EMER);
5e00790e	87	parse_options(argc, argv);
1636c761 RB	88	ctx.argc = argc - optind;
	89	ctx.argv = argv + optind;
	90	ovs_cmdl_run_command(&ctx, get_all_commands());
5e00790e BP	91	return 0;
	92	}
	93
	94	static void
	95	parse_target(const char s_, struct in_addr addr,
	96	unsigned short int min, unsigned short int max)
	97	{
	98	char *s = xstrdup(s_);
	99	char *colon;
	100	int error;
	101
	102	colon = strchr(s, ':');
	103	if (colon) {
	104	*colon = '\0';
	105	}
	106
	107	if (*s != '\0') {
	108	error = lookup_hostname(s, addr);
	109	if (error) {
	110	ovs_fatal(error, "failed to look up IP address for \"%s\"", s_);
	111	}
	112	} else {
	113	addr->s_addr = htonl(INADDR_ANY);
	114	}
	115
	116	min = max = 0;
	117	if (colon && colon[1] != '\0') {
	118	const char *ports = colon + 1;
c2c28dfd	119	if (ovs_scan(ports, "%hu-%hu", min, max)) {
5e00790e BP	120	if (min > max) {
	121	ovs_fatal(0, "%s: minimum is greater than maximum", s_);
	122	}
c2c28dfd	123	} else if (ovs_scan(ports, "%hu", min)) {
5e00790e BP	124	max = min;
	125	} else {
	126	ovs_fatal(0, "%s: number or range expected", s_);
	127	}
	128	}
	129
	130	free(s);
	131	}
	132
	133	static void
	134	parse_options(int argc, char *argv[])
	135	{
07fc4ed3	136	static const struct option long_options[] = {
5e00790e BP	137	{"local", required_argument, NULL, 'l'},
	138	{"remote", required_argument, NULL, 'r'},
	139	{"batches", required_argument, NULL, 'b'},
	140	{"sockets", required_argument, NULL, 's'},
	141	{"max-rate", required_argument, NULL, 'c'},
	142	{"timeout", required_argument, NULL, 'T'},
	143	{"help", no_argument, NULL, 'h'},
	144	{"version", no_argument, NULL, 'V'},
	145	{NULL, 0, NULL, 0},
	146	};
5f383751	147	char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
5e00790e BP	148
	149	local_addr.s_addr = htonl(INADDR_ANY);
	150	local_min_port = local_max_port = 0;
	151
	152	remote_addr.s_addr = htonl(0);
	153	remote_min_port = remote_max_port = 0;
	154
	155	for (;;) {
	156	int c;
	157
	158	c = getopt_long(argc, argv, short_options, long_options, NULL);
	159	if (c == -1) {
	160	break;
	161	}
	162
	163	switch (c) {
	164	case 'l':
	165	parse_target(optarg,
	166	&local_addr, &local_min_port, &local_max_port);
	167	break;
	168
	169	case 'r':
	170	parse_target(optarg,
	171	&remote_addr, &remote_min_port, &remote_max_port);
	172	if (remote_addr.s_addr == htonl(INADDR_ANY)) {
	173	ovs_fatal(0, "remote IP address is required");
	174	}
	175	break;
	176
	177	case 'b':
	178	n_batches = atoi(optarg);
	179	if (n_batches < 0) {
	180	ovs_fatal(0, "--batches or -b argument must be at least 1");
	181	}
	182	break;
	183
	184	case 's':
	185	n_sockets = atoi(optarg);
	186	if (n_sockets < 1 \|\| n_sockets > MAX_SOCKETS) {
	187	ovs_fatal(0, "--sockets or -s argument must be between 1 "
	188	"and %d (inclusive)", MAX_SOCKETS);
	189	}
	190	break;
	191
	192	case 'c':
	193	max_rate = atof(optarg);
	194	if (max_rate <= 0.0) {
	195	ovs_fatal(0, "--max-rate or -c argument must be positive");
	196	}
	197	break;
	198
	199	case 'T':
	200	timeout = atoi(optarg);
	201	if (!timeout) {
	202	ovs_fatal(0, "-T or --timeout argument must be positive");
	203	}
	204	break;
	205
	206	case 'h':
	207	usage();
	208
	209	case 'V':
55d5bb44	210	ovs_print_version(0, 0);
5e00790e BP	211	exit(EXIT_SUCCESS);
	212
	213	case '?':
	214	exit(EXIT_FAILURE);
	215
	216	default:
	217	abort();
	218	}
	219	}
	220	free(short_options);
	221	}
	222
	223	static void
	224	usage(void)
	225	{
	226	printf("\
	227	%s: Open vSwitch flow setup benchmark utility\n\
	228	usage: %s [OPTIONS] COMMAND [ARG...]\n\
	229	latency connect many times all at once\n\
	230	rate measure sustained flow setup rate\n\
	231	listen accept TCP connections\n\
	232	help display this help message\n\
	233	\n\
	234	Command options:\n\
	235	-l, --local [IP][:PORTS] use local IP and range of PORTS\n\
	236	-r, --remote IP[:PORTS] connect to remote IP and PORTS\n\
	237	-s, --sockets N number of sockets for \"rate\" or \"latency\"\n\
	238	-b, --batches N number of connection batches for \"latency\"\n\
	239	-c, --max-rate NPERSEC connection rate limit for \"rate\"\n\
	240	-T, --timeout MAXSECS max number of seconds to run for \"rate\"\n\
	241	\n\
	242	Other options:\n\
	243	-h, --help display this help message\n\
	244	-V, --version display version information\n",
	245	program_name, program_name);
	246	exit(EXIT_SUCCESS);
	247	}
	248
	249	static void
1636c761	250	cmd_listen(struct ovs_cmdl_context *ctx OVS_UNUSED)
5e00790e BP	251	{
	252	struct pollfd *fds;
	253	int n_fds;
	254	int port;
	255	int i;
	256
	257	if (!local_min_port && !local_max_port) {
	258	local_min_port = local_max_port = DEFAULT_PORT;
	259	}
	260	fds = xmalloc((1 + local_max_port - local_min_port) * sizeof *fds);
	261	n_fds = 0;
	262	for (port = local_min_port; port <= local_max_port; port++) {
	263	struct sockaddr_in sin;
	264	unsigned int yes = 1;
	265	int error;
	266	int fd;
	267
	268	/* Create socket, set SO_REUSEADDR. */
	269	fd = socket(AF_INET, SOCK_STREAM, 0);
	270	if (fd < 0) {
	271	ovs_fatal(errno, "failed to create socket");
	272	}
	273	error = set_nonblocking(fd);
	274	if (error) {
	275	ovs_fatal(error, "failed to set non-blocking mode");
	276	}
	277	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) {
	278	ovs_fatal(errno, "setsockopt(SO_REUSEADDR) failed");
	279	}
	280
	281	/* Bind. */
	282	sin.sin_family = AF_INET;
	283	sin.sin_addr = remote_addr;
	284	sin.sin_port = htons(port);
	285	if (bind(fd, (struct sockaddr *) &sin, sizeof sin) < 0) {
	286	ovs_fatal(errno, "bind failed");
	287	}
	288
	289	/* Listen. */
	290	if (listen(fd, 10000) < 0) {
	291	ovs_fatal(errno, "listen failed");
	292	}
	293
	294	fds[n_fds].fd = fd;
	295	fds[n_fds].events = POLLIN;
	296	n_fds++;
	297	}
	298
	299	for (;;) {
	300	int retval;
	301
6d1e400e	302	retval = do_poll(fds, n_fds, -1);
5e00790e BP	303	if (retval < 0) {
	304	ovs_fatal(errno, "poll failed");
	305	}
	306
	307	for (i = 0; i < n_fds; i++) {
	308	if (fds[i].revents & POLLIN) {
	309	int newfd;
	310
	311	do {
	312	newfd = accept(fds[i].fd, NULL, NULL);
	313	} while (newfd < 0 && errno == EINTR);
	314
	315	if (newfd >= 0) {
	316	close(newfd);
	317	} else if (errno != EAGAIN) {
	318	ovs_fatal(errno, "accept failed");
	319	}
	320	}
	321	}
	322	}
	323	}
	324
	325	/* Increments '*value' within the range 'min...max' inclusive. Returns true
	326	* if 'value' wraps around to 'min', otherwise false. /
	327	static bool
	328	increment(unsigned short int *value,
	329	unsigned short int min, unsigned short int max)
	330	{
	331	if (*value < max) {
	332	++*value;
	333	return false;
	334	} else {
	335	*value = min;
	336	return true;
	337	}
	338	}
	339
	340	static void
	341	next_ports(unsigned short int local_port, unsigned short int remote_port)
	342	{
	343	if (increment(local_port, local_min_port, local_max_port)) {
	344	increment(remote_port, remote_min_port, remote_max_port);
	345	}
	346	}
	347
	348	static void
	349	bind_local_port(int fd, unsigned short int *local_port,
	350	unsigned short int *remote_port)
	351	{
	352	int error;
	353
	354	if (!local_min_port && !local_max_port) {
	355	next_ports(local_port, remote_port);
	356	return;
	357	}
	358
	359	do {
	360	struct sockaddr_in local;
	361
	362	memset(&local, 0, sizeof local);
	363	local.sin_family = AF_INET;
	364	local.sin_addr = local_addr;
	365	local.sin_port = htons(*local_port);
	366	error = (bind(fd, (struct sockaddr *) &local, sizeof local) < 0
367	? errno : 0);
368	next_ports(local_port, remote_port);
369	} while (error == EADDRINUSE \|\| error == EINTR);
370	if (error) {
371	ovs_fatal(error, "bind failed");
372	}
373	}
374
375	static void
1636c761	376	cmd_rate(struct ovs_cmdl_context *ctx OVS_UNUSED)
5e00790e BP	377	{
	378	unsigned short int local_port;
	379	unsigned short int remote_port;
	380	unsigned int completed = 0;
	381	unsigned int failures = 0;
	382	long long int start, prev;
	383	struct pollfd *fds;
	384	int n_fds;
	385
	386	if (!remote_addr.s_addr) {
	387	ovs_fatal(0, "remote address must be specified with -r or --remote");
	388	}
	389	if (!remote_min_port && !remote_max_port) {
	390	remote_min_port = remote_max_port = DEFAULT_PORT;
	391	}
	392
	393	local_port = local_min_port;
	394	remote_port = remote_min_port;
	395	fds = xmalloc(n_sockets * sizeof *fds);
	396	n_fds = 0;
	397	start = prev = time_in_msec();
	398	for (;;) {
	399	long long int now;
	400	long long int may_open;
	401	int delay;
	402	int error;
	403	int j;
	404
	405	if (max_rate > 0) {
	406	long long int cur_total = completed + n_fds;
	407	long long int max_total = (time_in_msec() - start) * (max_rate / 1000.0);
	408	if (max_total > cur_total) {
	409	may_open = MIN(n_sockets, max_total - cur_total);
	410	} else {
	411	may_open = 0;
	412	}
	413	delay = 1000.0 / max_rate;
	414	} else {
	415	may_open = n_sockets;
	416	delay = 1000;
	417	}
	418
	419	while (may_open-- > 0 && n_fds < n_sockets) {
	420	struct sockaddr_in remote;
	421	int error;
	422	int fd;
	423
	424	fd = socket(AF_INET, SOCK_STREAM, 0);
	425	if (fd < 0) {
	426	ovs_fatal(errno, "socket failed");
	427	}
	428
	429	error = set_nonblocking(fd);
	430	if (error) {
	431	ovs_fatal(error, "set_nonblocking failed");
	432	}
	433
	434	bind_local_port(fd, &local_port, &remote_port);
	435
	436	memset(&remote, 0, sizeof remote);
	437	remote.sin_family = AF_INET;
	438	remote.sin_addr = remote_addr;
	439	remote.sin_port = htons(remote_port);
	440	if (connect(fd, (struct sockaddr *) &remote, sizeof remote) < 0) {
441	if (errno == EINPROGRESS) {
442	fds[n_fds].fd = fd;
443	fds[n_fds].events = POLLOUT;
444	fds[n_fds].revents = 0;
445	n_fds++;
446	} else if (errno != ECONNREFUSED) {
447	ovs_fatal(errno, "connect");
448	}
449	} else {
450	/* Success, I guess. */
451	shutdown(fd, 2);
452	close(fd);
453	completed++;
454	}
455	}
456
457	if (n_fds == n_sockets) {
458	delay = 1000;
459	}
460
6d1e400e	461	error = do_poll(fds, n_fds, delay);
5e00790e BP	462	if (error) {
	463	ovs_fatal(errno, "poll");
	464	}
	465
	466	for (j = 0; j < n_fds; ) {
	467	if (fds[j].revents) {
	468	if (fds[j].revents & POLLERR) {
	469	failures++;
	470	}
	471	shutdown(fds[j].fd, 2);
	472	close(fds[j].fd);
	473	fds[j] = fds[--n_fds];
	474	completed++;
	475	} else {
	476	j++;
	477	}
	478	}
	479
	480	now = time_in_msec();
440c5152	481	if (now >= prev + 1000) {
5e00790e	482	long long int elapsed = now - start;
440c5152	483	printf("%.3f s elapsed, %u OK, %u failed, avg %.1f/s\n",
5e00790e BP	484	elapsed / 1000.0, completed - failures, failures,
5e00790e BP	485	completed / (elapsed / 1000.0));
d5155945	486	fflush(stdout);
5e00790e BP	487	prev = now;
	488
	489	if (timeout && elapsed > timeout * 1000LL) {
	490	break;
	491	}
	492	}
	493	}
	494	}
	495
	496	static void
	497	timer_end(long long int start, bool error,
	498	int min, int max, unsigned long long int *total)
	499	{
	500	int elapsed = time_in_msec() - start;
	501	static int last_elapsed = INT_MIN;
	502	char c = error ? '!' : '.';
	503
	504	if (last_elapsed != elapsed) {
	505	if (last_elapsed != INT_MIN) {
	506	putchar('\n');
	507	}
	508	printf("%5d %c", elapsed, c);
	509	fflush(stdout);
	510	last_elapsed = elapsed;
	511	} else {
	512	putchar(c);
	513	fflush(stdout);
	514	}
	515
	516	if (elapsed < *min) {
	517	*min = elapsed;
	518	}
	519	if (elapsed > *max) {
	520	*max = elapsed;
	521	}
	522	*total += elapsed;
	523	}
	524
	525	static void
1636c761	526	cmd_latency(struct ovs_cmdl_context *ctx OVS_UNUSED)
5e00790e BP	527	{
	528	unsigned short int local_port;
	529	unsigned short int remote_port;
	530	int min = INT_MAX;
	531	int max = 0;
	532	unsigned long long int total = 0;
	533	int i;
	534
	535	if (!remote_addr.s_addr) {
	536	ovs_fatal(0, "remote address must be specified with -r or --rate");
	537	}
	538	if (!remote_min_port && !remote_max_port) {
	539	remote_min_port = remote_max_port = DEFAULT_PORT;
	540	}
	541
	542	local_port = local_min_port;
	543	remote_port = remote_min_port;
	544	for (i = 0; i < n_batches; i++) {
	545	struct pollfd fds[MAX_SOCKETS];
	546	long long int start;
	547	int n_fds;
	548	int j;
	549
	550	start = time_in_msec();
	551	n_fds = 0;
	552	for (j = 0; j < n_sockets; j++) {
	553	struct sockaddr_in remote;
	554	int error;
	555	int fd;
	556
	557	fd = socket(AF_INET, SOCK_STREAM, 0);
	558	if (fd < 0) {
	559	ovs_fatal(errno, "socket failed");
	560	}
	561
	562	error = set_nonblocking(fd);
	563	if (error) {
	564	ovs_fatal(error, "set_nonblocking failed");
	565	}
	566
	567	bind_local_port(fd, &local_port, &remote_port);
	568
	569	memset(&remote, 0, sizeof remote);
	570	remote.sin_family = AF_INET;
	571	remote.sin_addr = remote_addr;
	572	remote.sin_port = htons(remote_port);
	573	if (connect(fd, (struct sockaddr *) &remote, sizeof remote) < 0) {
	574	if (errno == EINPROGRESS) {
	575	fds[n_fds].fd = fd;
	576	fds[n_fds].events = POLLOUT;
	577	fds[n_fds].revents = 0;
	578	n_fds++;
	579	} else if (errno != ECONNREFUSED) {
	580	ovs_fatal(errno, "connect");
	581	}
	582	} else {
	583	/* Success, I guess. */
	584	close(fd);
	585	timer_end(start, 0, &min, &max, &total);
	586	}
	587	}
	588
	589	while (n_fds > 0) {
	590	int error;
591
6d1e400e	592	error = do_poll(fds, n_fds, -1);
5e00790e BP	593	if (error) {
	594	ovs_fatal(errno, "poll");
	595	}
	596
	597	for (j = 0; j < n_fds; ) {
	598	if (fds[j].revents) {
	599	timer_end(start,
	600	fds[j].revents & (POLLERR\|POLLHUP) ? 1 : 0,
	601	&min, &max, &total);
	602	close(fds[j].fd);
	603	fds[j] = fds[--n_fds];
	604	} else {
	605	j++;
	606	}
	607	}
	608	}
	609	putchar('\n');
	610	}
	611
	612	printf("min %d ms, max %d ms, avg %llu ms\n",
	613	min, max, total / (1ULL * n_sockets * n_batches));
	614	}
	615
	616	static void
1636c761	617	cmd_help(struct ovs_cmdl_context *ctx OVS_UNUSED)
5e00790e BP	618	{
	619	usage();
	620	}
	621
5f383751	622	static const struct ovs_cmdl_command all_commands[] = {
451de37e AW	623	{ "listen", NULL, 0, 0, cmd_listen },
	624	{ "rate", NULL, 0, 0, cmd_rate },
	625	{ "latency", NULL, 0, 0, cmd_latency },
	626	{ "help", NULL, 0, 0, cmd_help },
	627	{ NULL, NULL, 0, 0, NULL },
5e00790e	628	};
3815d6c2	629
5f383751	630	static const struct ovs_cmdl_command *get_all_commands(void)
3815d6c2 LS	631	{
	632	return all_commands;
	633	}