* derivatives without specific, written prior permission.
*/
+#include <config.h>
#include <errno.h>
#include <getopt.h>
#include <inttypes.h>
#include "openflow.h"
#include "ofp-print.h"
#include "random.h"
+#include "signal.h"
#include "vconn.h"
#include "vconn-ssl.h"
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 (;;) {
+ unsigned long int timeout;
int indexptr;
int c;
}
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 if (timeout < UINT_MAX) {
+ /* Add 1 because historical implementations allow an alarm to
+ * occur up to a second early. */
+ alarm(timeout + 1);
+ } else {
+ alarm(UINT_MAX);
+ }
+ signal(SIGALRM, SIG_DFL);
+ 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] latency of N-byte echos\n"
- " benchmark SWITCH N COUNT bandwidth of COUNT N-byte 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);
}
/* 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);
ofm->command = htons(OFPFC_ADD);
/* 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, &max_idle);
ofm->command = htons(OFPFC_ADD);
ofm->max_idle = htons(max_idle);
ofm->buffer_id = htonl(UINT32_MAX);
/* 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);
ofm->command = htons(OFPFC_DELETE);
ofm->max_idle = htons(0);
ofm->buffer_id = htonl(UINT32_MAX);
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 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;
run(vconn_open_block(argv[1], &vconn), "connecting to %s", argv[1]);
gettimeofday(&start, NULL);
for (i = 0; i < count; i++) {
- struct buffer *request;
+ struct buffer *request, *reply;
struct ofp_header *rq_hdr;
- rq_hdr = alloc_openflow_buffer(message_size, OFPT_ECHO_REQUEST,
- &request);
+ rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request);
memset(rq_hdr + 1, 0, payload_size);
- buffer_delete(transact_openflow(vconn, request));
+ run(vconn_transact(vconn, request, &reply), "transact");
+ buffer_delete(reply);
}
gettimeofday(&end, NULL);
vconn_close(vconn);
{ "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 },