* derivatives without specific, written prior permission.
*/
+#include <config.h>
#include <errno.h>
#include <getopt.h>
#include <inttypes.h>
#include <netinet/in.h>
+#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include "openflow.h"
#include "ofp-print.h"
#include "random.h"
+#include "timeval.h"
#include "vconn.h"
#include "vconn-ssl.h"
#include "vlog.h"
#define THIS_MODULE VLM_dpctl
-#define DEFAULT_MAX_IDLE 60
+#define DEFAULT_IDLE_TIMEOUT 60
#define MAX_ADD_ACTS 5
static const char* ifconfigbin = "/sbin/ifconfig";
struct command *p;
set_program_name(argv[0]);
+ time_init();
vlog_init();
parse_options(argc, argv);
+ signal(SIGPIPE, SIG_IGN);
argc -= optind;
argv += optind;
parse_options(int argc, char *argv[])
{
static struct option long_options[] = {
+ {"timeout", required_argument, 0, 't'},
{"verbose", optional_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
char *short_options = long_options_to_short_options(long_options);
for (;;) {
- int indexptr;
+ unsigned long int timeout;
int c;
- c = getopt_long(argc, argv, short_options, long_options, &indexptr);
+ c = getopt_long(argc, argv, short_options, long_options, NULL);
if (c == -1) {
break;
}
switch (c) {
+ case 't':
+ timeout = strtoul(optarg, NULL, 10);
+ if (timeout <= 0) {
+ fatal(0, "value %s on -t or --timeout is not at least 1",
+ optarg);
+ } else {
+ time_alarm(timeout);
+ }
+ break;
+
case 'h':
usage();
printf("%s: OpenFlow switch management utility\n"
"usage: %s [OPTIONS] COMMAND [ARG...]\n"
#ifdef HAVE_NETLINK
- "\nCommands that apply to local datapaths only:\n"
+ "\nFor local datapaths only:\n"
" adddp nl:DP_ID add a new local datapath DP_ID\n"
" deldp nl:DP_ID delete local datapath DP_ID\n"
" addif nl:DP_ID IFACE add IFACE as a port on DP_ID\n"
" delif nl:DP_ID IFACE delete IFACE as a port on DP_ID\n"
" monitor nl:DP_ID print packets received\n"
- " benchmark-nl nl:DP_ID N SIZE send N packets of SIZE bytes\n"
#endif
- "\nCommands that apply to local datapaths and remote switches:\n"
+ "\nFor local datapaths and remote switches:\n"
" show SWITCH show information\n"
" dump-tables SWITCH print table stats\n"
" dump-ports SWITCH print port statistics\n"
" add-flow SWITCH FLOW add flow described by FLOW\n"
" add-flows SWITCH FILE add flows from FILE\n"
" del-flows SWITCH FLOW delete matching FLOWs\n"
- " ping SWITCH [N] time N-byte (default: 64) echos\n"
+ "\nFor local datapaths, remote switches, and controllers:\n"
+ " probe VCONN probe whether VCONN is up\n"
+ " ping VCONN [N] latency of N-byte echos\n"
+ " benchmark VCONN N COUNT bandwidth of COUNT N-byte echos\n"
"where each SWITCH is an active OpenFlow connection method.\n",
program_name, program_name);
vconn_usage(true, false);
printf("\nOptions:\n"
- " -v, --verbose=MODULE:FACILITY:LEVEL configure logging levels\n"
+ " -t, --timeout=SECS give up after SECS seconds\n"
+ " -v, --verbose=MODULE[:FACILITY[:LEVEL]] set logging levels\n"
" -v, --verbose set maximum verbosity level\n"
" -h, --help display this help message\n"
" -V, --version display version information\n");
buffer_delete(b);
}
}
-
-#define BENCHMARK_INCR 100
-
-static void do_benchmark_nl(int argc UNUSED, char *argv[])
-{
- struct dpif dp;
- uint32_t num_packets, i, milestone;
- struct timeval start, end;
-
- open_nl_vconn(argv[1], false, &dp);
- num_packets = atoi(argv[2]);
- milestone = BENCHMARK_INCR;
- run(dpif_benchmark_nl(&dp, num_packets, atoi(argv[3])), "benchmark_nl");
- if (gettimeofday(&start, NULL) == -1) {
- run(errno, "gettimeofday");
- }
- for (i = 0; i < num_packets;i++) {
- struct buffer *b;
- run(dpif_recv_openflow(&dp, &b, true), "dpif_recv_openflow");
- if (i == milestone) {
- gettimeofday(&end, NULL);
- printf("%u packets received in %f ms\n",
- BENCHMARK_INCR,
- (1000*(double)(end.tv_sec - start.tv_sec))
- + (.001*(end.tv_usec - start.tv_usec)));
- milestone += BENCHMARK_INCR;
- start = end;
- }
- buffer_delete(b);
- }
- gettimeofday(&end, NULL);
- printf("%u packets received in %f ms\n",
- i - (milestone - BENCHMARK_INCR),
- (1000*(double)(end.tv_sec - start.tv_sec))
- + (.001*(end.tv_usec - start.tv_usec)));
-
- dpif_close(&dp);
-}
#endif /* HAVE_NETLINK */
\f
/* Generic commands. */
-static void *
-alloc_openflow_buffer(size_t openflow_len, uint8_t type,
- struct buffer **bufferp)
-{
- struct buffer *buffer;
- struct ofp_header *oh;
-
- buffer = *bufferp = buffer_new(openflow_len);
- oh = buffer_put_uninit(buffer, openflow_len);
- memset(oh, 0, openflow_len);
- oh->version = OFP_VERSION;
- oh->type = type;
- oh->length = 0;
- oh->xid = random_uint32();
- return oh;
-}
-
static void *
alloc_stats_request(size_t body_len, uint16_t type, struct buffer **bufferp)
{
struct ofp_stats_request *rq;
- rq = alloc_openflow_buffer((offsetof(struct ofp_stats_request, body)
- + body_len), OFPT_STATS_REQUEST, bufferp);
+ rq = make_openflow((offsetof(struct ofp_stats_request, body)
+ + body_len), OFPT_STATS_REQUEST, bufferp);
rq->type = htons(type);
rq->flags = htons(0);
return rq->body;
static void
send_openflow_buffer(struct vconn *vconn, struct buffer *buffer)
{
- struct ofp_header *oh;
-
- oh = buffer_at_assert(buffer, 0, sizeof *oh);
- oh->length = htons(buffer->size);
-
+ update_openflow_length(buffer);
run(vconn_send_block(vconn, buffer), "failed to send packet to switch");
}
-static struct buffer *
-transact_openflow(struct vconn *vconn, struct buffer *request)
-{
- uint32_t send_xid = ((struct ofp_header *) request->data)->xid;
-
- send_openflow_buffer(vconn, request);
- for (;;) {
- uint32_t recv_xid;
- struct buffer *reply;
-
- run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
- recv_xid = ((struct ofp_header *) reply->data)->xid;
- if (send_xid == recv_xid) {
- return reply;
- }
-
- VLOG_DBG("received reply with xid %08"PRIx32" != expected %08"PRIx32,
- recv_xid, send_xid);
- buffer_delete(reply);
- }
-}
-
static void
dump_transaction(const char *vconn_name, struct buffer *request)
{
struct vconn *vconn;
struct buffer *reply;
+ update_openflow_length(request);
run(vconn_open_block(vconn_name, &vconn), "connecting to %s", vconn_name);
- reply = transact_openflow(vconn, request);
+ run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
ofp_print(stdout, reply->data, reply->size, 1);
vconn_close(vconn);
}
dump_trivial_transaction(const char *vconn_name, uint8_t request_type)
{
struct buffer *request;
- alloc_openflow_buffer(sizeof(struct ofp_header), request_type, &request);
+ make_openflow(sizeof(struct ofp_header), request_type, &request);
dump_transaction(vconn_name, request);
}
static void
str_to_flow(char *string, struct ofp_match *match,
struct ofp_action *action, int *n_actions, uint8_t *table_idx,
- uint16_t *priority, uint16_t *max_idle)
+ uint16_t *priority, uint16_t *idle_timeout, uint16_t *hard_timeout)
{
struct field {
const char *name;
if (priority) {
*priority = OFP_DEFAULT_PRIORITY;
}
- if (max_idle) {
- *max_idle = DEFAULT_MAX_IDLE;
+ if (idle_timeout) {
+ *idle_timeout = DEFAULT_IDLE_TIMEOUT;
+ }
+ if (hard_timeout) {
+ *hard_timeout = OFP_FLOW_PERMANENT;
}
if (action) {
act_str = strstr(string, "action");
continue;
}
- if (max_idle && !strcmp(name, "max_idle")) {
- *max_idle = atoi(value);
+ if (idle_timeout && !strcmp(name, "idle_timeout")) {
+ *idle_timeout = atoi(value);
+ continue;
+ }
+
+ if (hard_timeout && !strcmp(name, "hard_timeout")) {
+ *hard_timeout = atoi(value);
continue;
}
req = alloc_stats_request(sizeof *req, OFPST_FLOW, &request);
str_to_flow(argc > 2 ? argv[2] : "", &req->match, NULL, 0,
- &req->table_id, NULL, NULL);
+ &req->table_id, NULL, NULL, NULL);
memset(req->pad, 0, sizeof req->pad);
dump_stats_transaction(argv[1], request);
req = alloc_stats_request(sizeof *req, OFPST_AGGREGATE, &request);
str_to_flow(argc > 2 ? argv[2] : "", &req->match, NULL, 0,
- &req->table_id, NULL, NULL);
+ &req->table_id, NULL, NULL, NULL);
memset(req->pad, 0, sizeof req->pad);
dump_stats_transaction(argv[1], request);
struct vconn *vconn;
struct buffer *buffer;
struct ofp_flow_mod *ofm;
- uint16_t priority, max_idle;
+ uint16_t priority, idle_timeout, hard_timeout;
size_t size;
int n_actions = MAX_ADD_ACTS;
/* Parse and send. */
size = sizeof *ofm + (sizeof ofm->actions[0] * MAX_ADD_ACTS);
- ofm = alloc_openflow_buffer(size, OFPT_FLOW_MOD, &buffer);
+ ofm = make_openflow(size, OFPT_FLOW_MOD, &buffer);
str_to_flow(argv[2], &ofm->match, &ofm->actions[0], &n_actions,
- NULL, &priority, &max_idle);
+ NULL, &priority, &idle_timeout, &hard_timeout);
ofm->command = htons(OFPFC_ADD);
- ofm->max_idle = htons(max_idle);
+ ofm->idle_timeout = htons(idle_timeout);
+ ofm->hard_timeout = htons(hard_timeout);
ofm->buffer_id = htonl(UINT32_MAX);
ofm->priority = htons(priority);
ofm->reserved = htonl(0);
while (fgets(line, sizeof line, file)) {
struct buffer *buffer;
struct ofp_flow_mod *ofm;
- uint16_t priority, max_idle;
+ uint16_t priority, idle_timeout, hard_timeout;
size_t size;
int n_actions = MAX_ADD_ACTS;
/* Parse and send. */
size = sizeof *ofm + (sizeof ofm->actions[0] * MAX_ADD_ACTS);
- ofm = alloc_openflow_buffer(size, OFPT_FLOW_MOD, &buffer);
+ ofm = make_openflow(size, OFPT_FLOW_MOD, &buffer);
str_to_flow(line, &ofm->match, &ofm->actions[0], &n_actions,
- NULL, &priority, &max_idle);
+ NULL, &priority, &idle_timeout, &hard_timeout);
ofm->command = htons(OFPFC_ADD);
- ofm->max_idle = htons(max_idle);
+ ofm->idle_timeout = htons(idle_timeout);
+ ofm->hard_timeout = htons(hard_timeout);
ofm->buffer_id = htonl(UINT32_MAX);
ofm->priority = htons(priority);
ofm->reserved = htonl(0);
/* Parse and send. */
size = sizeof *ofm;
- ofm = alloc_openflow_buffer(size, OFPT_FLOW_MOD, &buffer);
+ ofm = make_openflow(size, OFPT_FLOW_MOD, &buffer);
str_to_flow(argc > 2 ? argv[2] : "", &ofm->match, NULL, 0, NULL,
- &priority, NULL);
+ &priority, NULL, NULL);
ofm->command = htons(OFPFC_DELETE);
- ofm->max_idle = htons(0);
+ ofm->idle_timeout = htons(0);
+ ofm->hard_timeout = htons(0);
ofm->buffer_id = htonl(UINT32_MAX);
ofm->priority = htons(priority);
ofm->reserved = htonl(0);
dump_trivial_stats_transaction(argv[1], OFPST_PORT);
}
+static void
+do_probe(int argc, char *argv[])
+{
+ struct buffer *request;
+ struct vconn *vconn;
+ struct buffer *reply;
+
+ make_openflow(sizeof(struct ofp_header), OFPT_ECHO_REQUEST, &request);
+ run(vconn_open_block(argv[1], &vconn), "connecting to %s", argv[1]);
+ run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
+ if (reply->size != request->size) {
+ fatal(0, "reply does not match request");
+ }
+ buffer_delete(reply);
+ vconn_close(vconn);
+}
+
static void
do_ping(int argc, char *argv[])
{
struct vconn *vconn;
int i;
- payload = argc > 2 ? atoi(argv[1]) : 64;
+ payload = argc > 2 ? atoi(argv[2]) : 64;
if (payload > max_payload) {
fatal(0, "payload must be between 0 and %zu bytes", max_payload);
}
struct buffer *request, *reply;
struct ofp_header *rq_hdr, *rpy_hdr;
- rq_hdr = alloc_openflow_buffer(sizeof(struct ofp_header) + payload,
- OFPT_ECHO_REQUEST, &request);
+ rq_hdr = make_openflow(sizeof(struct ofp_header) + payload,
+ OFPT_ECHO_REQUEST, &request);
random_bytes(rq_hdr + 1, payload);
gettimeofday(&start, NULL);
- reply = transact_openflow(vconn, buffer_clone(request));
+ run(vconn_transact(vconn, buffer_clone(request), &reply), "transact");
gettimeofday(&end, NULL);
rpy_hdr = reply->data;
vconn_close(vconn);
}
+static void
+do_benchmark(int argc, char *argv[])
+{
+ size_t max_payload = 65535 - sizeof(struct ofp_header);
+ struct timeval start, end;
+ unsigned int payload_size, message_size;
+ struct vconn *vconn;
+ double duration;
+ int count;
+ int i;
+
+ payload_size = atoi(argv[2]);
+ if (payload_size > max_payload) {
+ fatal(0, "payload must be between 0 and %zu bytes", max_payload);
+ }
+ message_size = sizeof(struct ofp_header) + payload_size;
+
+ count = atoi(argv[3]);
+
+ printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
+ count, message_size, count * message_size);
+
+ run(vconn_open_block(argv[1], &vconn), "connecting to %s", argv[1]);
+ gettimeofday(&start, NULL);
+ for (i = 0; i < count; i++) {
+ struct buffer *request, *reply;
+ struct ofp_header *rq_hdr;
+
+ rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request);
+ memset(rq_hdr + 1, 0, payload_size);
+ run(vconn_transact(vconn, request, &reply), "transact");
+ buffer_delete(reply);
+ }
+ gettimeofday(&end, NULL);
+ vconn_close(vconn);
+
+ duration = ((1000*(double)(end.tv_sec - start.tv_sec))
+ + (.001*(end.tv_usec - start.tv_usec)));
+ printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
+ duration, count / (duration / 1000.0),
+ count * message_size / (duration / 1000.0));
+}
+
static void do_help(int argc UNUSED, char *argv[] UNUSED)
{
usage();
{ "deldp", 1, 1, do_del_dp },
{ "addif", 2, 2, do_add_port },
{ "delif", 2, 2, do_del_port },
- { "benchmark-nl", 3, 3, do_benchmark_nl },
#endif
{ "show", 1, 1, do_show },
{ "add-flows", 2, 2, do_add_flows },
{ "del-flows", 1, 2, do_del_flows },
{ "dump-ports", 1, 1, do_dump_ports },
+ { "probe", 1, 1, do_probe },
{ "ping", 1, 2, do_ping },
+ { "benchmark", 3, 3, do_benchmark },
{ NULL, 0, 0, NULL },
};