/*
- * Copyright (c) 2008, 2009, 2010 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
VLOG_DEFINE_THIS_MODULE(ofctl);
-/* Use strict matching for flow mod commands? */
+/* --strict: Use strict matching for flow mod commands? */
static bool strict;
+/* -F, --flow-format: Flow format to use. Either one of NXFF_* to force a
+ * particular flow format or -1 to let ovs-ofctl choose intelligently. */
+static int preferred_flow_format = -1;
+
+/* -m, --more: Additional verbosity for ofp-print functions. */
+static int verbosity;
+
static const struct command all_commands[];
static void usage(void) NO_RETURN;
static struct option long_options[] = {
{"timeout", required_argument, 0, 't'},
{"strict", no_argument, 0, OPT_STRICT},
+ {"flow-format", required_argument, 0, 'F'},
+ {"more", no_argument, 0, 'm'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
VLOG_LONG_OPTIONS,
}
break;
+ case 'F':
+ preferred_flow_format = ofputil_flow_format_from_string(optarg);
+ if (preferred_flow_format < 0) {
+ ovs_fatal(0, "unknown flow format `%s'", optarg);
+ }
+ break;
+
+ case 'm':
+ verbosity++;
+ break;
+
case 'h':
usage();
"usage: %s [OPTIONS] COMMAND [ARG...]\n"
"\nFor OpenFlow switches:\n"
" show SWITCH show OpenFlow information\n"
- " status SWITCH [KEY] report statistics (about KEY)\n"
" dump-desc SWITCH print switch description\n"
" dump-tables SWITCH print table stats\n"
" mod-port SWITCH IFACE ACT modify port behavior\n"
vlog_usage();
printf("\nOther options:\n"
" --strict use strict match for flow commands\n"
+ " -F, --flow-format=FORMAT force particular flow format\n"
+ " -m, --more be more verbose printing OpenFlow\n"
" -t, --timeout=SECS give up after SECS seconds\n"
" -h, --help display this help message\n"
" -V, --version display version information\n");
open_vconn_socket(const char *name, struct vconn **vconnp)
{
char *vconn_name = xasprintf("unix:%s", name);
- VLOG_INFO("connecting to %s", vconn_name);
+ VLOG_DBG("connecting to %s", vconn_name);
run(vconn_open_block(vconn_name, OFP_VERSION, vconnp),
"connecting to %s", vconn_name);
free(vconn_name);
"obtaining name of %s", dpif_name);
dpif_close(dpif);
if (strcmp(dpif_name, name)) {
- VLOG_INFO("datapath %s is named %s", name, dpif_name);
+ VLOG_DBG("datapath %s is named %s", name, dpif_name);
}
socket_name = xasprintf("%s/%s.%s",
update_openflow_length(request);
open_vconn(vconn_name, &vconn);
run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
- ofp_print(stdout, reply->data, reply->size, 1);
+ ofp_print(stdout, reply->data, reply->size, verbosity + 1);
vconn_close(vconn);
}
if (send_xid == recv_xid) {
struct ofp_stats_reply *osr;
- ofp_print(stdout, reply->data, reply->size, 1);
+ ofp_print(stdout, reply->data, reply->size, verbosity + 1);
osr = ofpbuf_at(reply, 0, sizeof *osr);
done = !osr || !(ntohs(osr->flags) & OFPSF_REPLY_MORE);
* occurs, and waits for it to succeed or fail. If an error does occur, prints
* it and exits with an error. */
static void
-dump_noreply_transaction(struct vconn *vconn, struct ofpbuf *request)
+transact_multiple_noreply(struct vconn *vconn, struct list *requests)
{
- struct ofpbuf *reply;
+ struct ofpbuf *request, *reply;
- update_openflow_length(request);
- run(vconn_transact_noreply(vconn, request, &reply),
+ LIST_FOR_EACH (request, list_node, requests) {
+ update_openflow_length(request);
+ }
+
+ run(vconn_transact_multiple_noreply(vconn, requests, &reply),
"talking to %s", vconn_get_name(vconn));
if (reply) {
- ofp_print(stderr, reply->data, reply->size, 2);
+ ofp_print(stderr, reply->data, reply->size, verbosity + 2);
exit(1);
}
ofpbuf_delete(reply);
}
+/* Sends 'request', which should be a request that only has a reply if an error
+ * occurs, and waits for it to succeed or fail. If an error does occur, prints
+ * it and exits with an error. */
static void
-do_show(int argc OVS_UNUSED, char *argv[])
+transact_noreply(struct vconn *vconn, struct ofpbuf *request)
{
- dump_trivial_transaction(argv[1], OFPT_FEATURES_REQUEST);
- dump_trivial_transaction(argv[1], OFPT_GET_CONFIG_REQUEST);
+ struct list requests;
+
+ list_init(&requests);
+ list_push_back(&requests, &request->list_node);
+ transact_multiple_noreply(vconn, &requests);
}
static void
-do_status(int argc, char *argv[])
+do_show(int argc OVS_UNUSED, char *argv[])
{
- struct nicira_header *request, *reply;
- struct vconn *vconn;
- struct ofpbuf *b;
-
- request = make_nxmsg(sizeof *request, NXT_STATUS_REQUEST, &b);
- if (argc > 2) {
- ofpbuf_put(b, argv[2], strlen(argv[2]));
- update_openflow_length(b);
- }
- open_vconn(argv[1], &vconn);
- run(vconn_transact(vconn, b, &b), "talking to %s", argv[1]);
- vconn_close(vconn);
-
- if (b->size < sizeof *reply) {
- ovs_fatal(0, "short reply (%zu bytes)", b->size);
- }
- reply = b->data;
- if (reply->header.type != OFPT_VENDOR
- || reply->vendor != ntohl(NX_VENDOR_ID)
- || reply->subtype != ntohl(NXT_STATUS_REPLY)) {
- ofp_print(stderr, b->data, b->size, 2);
- ovs_fatal(0, "bad reply");
- }
-
- fwrite(reply + 1, b->size - sizeof *reply, 1, stdout);
+ dump_trivial_transaction(argv[1], OFPT_FEATURES_REQUEST);
+ dump_trivial_transaction(argv[1], OFPT_GET_CONFIG_REQUEST);
}
static void
if (port_no != UINT_MAX
? htons(port_no) == opp->port_no
- : !strncmp((char *) opp->name, port_name, sizeof opp->name)) {
+ : !strncmp(opp->name, port_name, sizeof opp->name)) {
*oppp = *opp;
ofpbuf_delete(reply);
vconn_close(vconn);
}
}
+static bool
+try_set_flow_format(struct vconn *vconn, enum nx_flow_format flow_format)
+{
+ struct ofpbuf *sff, *reply;
+
+ sff = ofputil_make_set_flow_format(flow_format);
+ run(vconn_transact_noreply(vconn, sff, &reply),
+ "talking to %s", vconn_get_name(vconn));
+ if (reply) {
+ char *s = ofp_to_string(reply->data, reply->size, 2);
+ VLOG_DBG("%s: failed to set flow format %s, controller replied: %s",
+ vconn_get_name(vconn),
+ ofputil_flow_format_to_string(flow_format),
+ s);
+ free(s);
+ ofpbuf_delete(reply);
+ return false;
+ }
+ return true;
+}
+
static void
-do_dump_flows(int argc, char *argv[])
+set_flow_format(struct vconn *vconn, enum nx_flow_format flow_format)
{
- struct ofp_flow_stats_request *req;
- struct parsed_flow pf;
- struct ofpbuf *request;
+ struct ofpbuf *sff = ofputil_make_set_flow_format(flow_format);
+ transact_noreply(vconn, sff);
+ VLOG_DBG("%s: using user-specified flow format %s",
+ vconn_get_name(vconn),
+ ofputil_flow_format_to_string(flow_format));
+}
- req = alloc_stats_request(sizeof *req, OFPST_FLOW, &request);
- parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
- ofputil_cls_rule_to_match(&pf.rule, NXFF_OPENFLOW10, &req->match);
- memset(&req->pad, 0, sizeof req->pad);
- req->out_port = htons(pf.out_port);
+static enum nx_flow_format
+negotiate_highest_flow_format(struct vconn *vconn, const struct cls_rule *rule,
+ bool cookie_support, ovs_be64 cookie)
+{
+ enum nx_flow_format min_format;
+
+ min_format = ofputil_min_flow_format(rule, cookie_support, cookie);
+ if (preferred_flow_format != -1) {
+ if (preferred_flow_format < min_format) {
+ ovs_fatal(0, "%s: cannot use requested flow format %s for "
+ "specified flow", vconn_get_name(vconn),
+ ofputil_flow_format_to_string(min_format));
+ }
- dump_stats_transaction(argv[1], request);
+ set_flow_format(vconn, preferred_flow_format);
+ return preferred_flow_format;
+ } else {
+ enum nx_flow_format flow_format;
+
+ if (try_set_flow_format(vconn, NXFF_NXM)) {
+ flow_format = NXFF_NXM;
+ } else if (try_set_flow_format(vconn, NXFF_TUN_ID_FROM_COOKIE)) {
+ flow_format = NXFF_TUN_ID_FROM_COOKIE;
+ } else {
+ flow_format = NXFF_OPENFLOW10;
+ }
+
+ if (flow_format < min_format) {
+ ovs_fatal(0, "%s: cannot use switch's most advanced flow format "
+ "%s for specified flow", vconn_get_name(vconn),
+ ofputil_flow_format_to_string(min_format));
+ }
+
+ VLOG_DBG("%s: negotiated flow format %s", vconn_get_name(vconn),
+ ofputil_flow_format_to_string(flow_format));
+ return flow_format;
+ }
}
static void
-do_dump_aggregate(int argc, char *argv[])
+do_dump_flows__(int argc, char *argv[], bool aggregate)
{
- struct ofp_aggregate_stats_request *req;
+ enum nx_flow_format flow_format;
+ struct flow_stats_request fsr;
struct ofpbuf *request;
- struct parsed_flow pf;
+ struct vconn *vconn;
- req = alloc_stats_request(sizeof *req, OFPST_AGGREGATE, &request);
- parse_ofp_str(&pf, NULL, argc > 2 ? argv[2] : "");
- ofputil_cls_rule_to_match(&pf.rule, NXFF_OPENFLOW10, &req->match);
- memset(&req->pad, 0, sizeof req->pad);
- req->out_port = htons(pf.out_port);
+ parse_ofp_flow_stats_request_str(&fsr, aggregate, argc > 2 ? argv[2] : "");
+ open_vconn(argv[1], &vconn);
+ flow_format = negotiate_highest_flow_format(vconn, &fsr.match, false, 0);
+ request = ofputil_encode_flow_stats_request(&fsr, flow_format);
dump_stats_transaction(argv[1], request);
+ vconn_close(vconn);
+}
+
+static void
+do_dump_flows(int argc, char *argv[])
+{
+ return do_dump_flows__(argc, argv, false);
+}
+
+static void
+do_dump_aggregate(int argc, char *argv[])
+{
+ return do_dump_flows__(argc, argv, true);
}
static void
dump_stats_transaction(argv[1], request);
}
+/* Sets up the flow format for a vconn that will be used to modify the flow
+ * table. Returns the flow format used, after possibly adding an OpenFlow
+ * request to 'requests'.
+ *
+ * If 'preferred_flow_format' is -1, returns NXFF_OPENFLOW10 without modifying
+ * 'requests', since NXFF_OPENFLOW10 is the default flow format for any
+ * OpenFlow connection.
+ *
+ * If 'preferred_flow_format' is a specific format, adds a request to set that
+ * format to 'requests' and returns the format. */
+static enum nx_flow_format
+set_initial_format_for_flow_mod(struct list *requests)
+{
+ if (preferred_flow_format < 0) {
+ return NXFF_OPENFLOW10;
+ } else {
+ struct ofpbuf *sff;
+
+ sff = ofputil_make_set_flow_format(preferred_flow_format);
+ list_push_back(requests, &sff->list_node);
+ return preferred_flow_format;
+ }
+}
+
+/* Checks that 'flow_format' is acceptable as a flow format after a flow_mod
+ * operation, given the global 'preferred_flow_format'. */
static void
-do_add_flow(int argc OVS_UNUSED, char *argv[])
+check_final_format_for_flow_mod(enum nx_flow_format flow_format)
{
+ if (preferred_flow_format >= 0 && flow_format != preferred_flow_format) {
+ ovs_fatal(0, "flow cannot be expressed in flow format %s "
+ "(flow format %s or better is required)",
+ ofputil_flow_format_to_string(preferred_flow_format),
+ ofputil_flow_format_to_string(flow_format));
+ }
+}
+
+static void
+do_flow_mod__(int argc OVS_UNUSED, char *argv[], uint16_t command)
+{
+ enum nx_flow_format flow_format;
+ struct list requests;
struct vconn *vconn;
- struct ofpbuf *request;
- request = parse_ofp_flow_mod_str(argv[2], OFPFC_ADD);
+ list_init(&requests);
+ flow_format = set_initial_format_for_flow_mod(&requests);
+
+ parse_ofp_flow_mod_str(&requests, &flow_format, argc > 2 ? argv[2] : "",
+ command);
+ check_final_format_for_flow_mod(flow_format);
open_vconn(argv[1], &vconn);
- dump_noreply_transaction(vconn, request);
+ transact_multiple_noreply(vconn, &requests);
vconn_close(vconn);
}
+static void
+do_add_flow(int argc, char *argv[])
+{
+ do_flow_mod__(argc, argv, OFPFC_ADD);
+}
+
static void
do_add_flows(int argc OVS_UNUSED, char *argv[])
{
+ enum nx_flow_format flow_format;
+ struct list requests;
struct vconn *vconn;
- struct ofpbuf *b;
FILE *file;
- file = fopen(argv[2], "r");
+ file = !strcmp(argv[2], "-") ? stdin : fopen(argv[2], "r");
if (file == NULL) {
ovs_fatal(errno, "%s: open", argv[2]);
}
+ list_init(&requests);
+ flow_format = set_initial_format_for_flow_mod(&requests);
+
open_vconn(argv[1], &vconn);
- while ((b = parse_ofp_add_flow_file(file)) != NULL) {
- dump_noreply_transaction(vconn, b);
+ while (parse_ofp_add_flow_file(&requests, &flow_format, file)) {
+ check_final_format_for_flow_mod(flow_format);
+ transact_multiple_noreply(vconn, &requests);
}
vconn_close(vconn);
- fclose(file);
+
+ if (file != stdin) {
+ fclose(file);
+ }
}
static void
-do_mod_flows(int argc OVS_UNUSED, char *argv[])
+do_mod_flows(int argc, char *argv[])
{
- struct vconn *vconn;
- struct ofpbuf *buffer;
- uint16_t command;
-
- command = strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY;
- buffer = parse_ofp_flow_mod_str(argv[2], command);
- open_vconn(argv[1], &vconn);
- dump_noreply_transaction(vconn, buffer);
- vconn_close(vconn);
+ do_flow_mod__(argc, argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY);
}
-static void do_del_flows(int argc, char *argv[])
+static void
+do_del_flows(int argc, char *argv[])
{
- struct vconn *vconn;
- struct ofpbuf *buffer;
- uint16_t command;
-
- command = strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE;
- buffer = parse_ofp_flow_mod_str(argc > 2 ? argv[2] : "", command);
-
- open_vconn(argv[1], &vconn);
- dump_noreply_transaction(vconn, buffer);
- vconn_close(vconn);
+ do_flow_mod__(argc, argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE);
}
static void
for (;;) {
struct ofpbuf *b;
run(vconn_recv_block(vconn, &b), "vconn_recv");
- ofp_print(stderr, b->data, b->size, 2);
+ ofp_print(stderr, b->data, b->size, verbosity + 2);
ofpbuf_delete(b);
}
}
osc = make_openflow(sizeof *osc, OFPT_SET_CONFIG, &buf);
osc->miss_send_len = htons(miss_send_len);
- dump_noreply_transaction(vconn, buf);
+ transact_noreply(vconn, buf);
}
monitor_vconn(vconn);
}
}
open_vconn(argv[1], &vconn);
- dump_noreply_transaction(vconn, request);
+ transact_noreply(vconn, request);
vconn_close(vconn);
}
|| rpy_hdr->xid != rq_hdr->xid
|| rpy_hdr->type != OFPT_ECHO_REPLY) {
printf("Reply does not match request. Request:\n");
- ofp_print(stdout, request, request->size, 2);
+ ofp_print(stdout, request, request->size, verbosity + 2);
printf("Reply:\n");
- ofp_print(stdout, reply, reply->size, 2);
+ ofp_print(stdout, reply, reply->size, verbosity + 2);
}
printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
reply->size - sizeof *rpy_hdr, argv[1], ntohl(rpy_hdr->xid),
\f
/* Undocumented commands for unit testing. */
+static void
+print_packet_list(struct list *packets)
+{
+ struct ofpbuf *packet, *next;
+
+ LIST_FOR_EACH_SAFE (packet, next, list_node, packets) {
+ ofp_print(stdout, packet->data, packet->size, verbosity);
+ list_remove(&packet->list_node);
+ ofpbuf_delete(packet);
+ }
+}
+
+/* "parse-flow FLOW": parses the argument as a flow (like add-flow) and prints
+ * it back to stdout. */
+static void
+do_parse_flow(int argc OVS_UNUSED, char *argv[])
+{
+ enum nx_flow_format flow_format;
+ struct list packets;
+
+ flow_format = NXFF_OPENFLOW10;
+ if (preferred_flow_format > 0) {
+ flow_format = preferred_flow_format;
+ }
+
+ list_init(&packets);
+ parse_ofp_flow_mod_str(&packets, &flow_format, argv[1], OFPFC_ADD);
+ print_packet_list(&packets);
+}
+
+/* "parse-flows FILENAME": reads the named file as a sequence of flows (like
+ * add-flows) and prints each of the flows back to stdout. */
static void
do_parse_flows(int argc OVS_UNUSED, char *argv[])
{
- struct ofpbuf *b;
+ enum nx_flow_format flow_format;
+ struct list packets;
FILE *file;
file = fopen(argv[1], "r");
ovs_fatal(errno, "%s: open", argv[2]);
}
- while ((b = parse_ofp_add_flow_file(file)) != NULL) {
- ofp_print(stdout, b->data, b->size, 0);
- ofpbuf_delete(b);
+ flow_format = NXFF_OPENFLOW10;
+ if (preferred_flow_format > 0) {
+ flow_format = preferred_flow_format;
+ }
+
+ list_init(&packets);
+ while (parse_ofp_add_flow_file(&packets, &flow_format, file)) {
+ print_packet_list(&packets);
}
fclose(file);
}
+/* "parse-nx-match": reads a series of nx_match specifications as strings from
+ * stdin, does some internal fussing with them, and then prints them back as
+ * strings on stdout. */
static void
do_parse_nx_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
{
ds_destroy(&in);
}
+/* "ofp-print HEXSTRING [VERBOSITY]": Converts the hex digits in HEXSTRING into
+ * binary data, interpreting them as an OpenFlow message, and prints the
+ * OpenFlow message on stdout, at VERBOSITY (level 2 by default). */
+static void
+do_ofp_print(int argc, char *argv[])
+{
+ struct ofpbuf packet;
+
+ ofpbuf_init(&packet, strlen(argv[1]) / 2);
+ if (ofpbuf_put_hex(&packet, argv[1], NULL)[0] != '\0') {
+ ovs_fatal(0, "trailing garbage following hex bytes");
+ }
+ ofp_print(stdout, packet.data, packet.size, argc > 2 ? atoi(argv[2]) : 2);
+ ofpbuf_uninit(&packet);
+}
+
static const struct command all_commands[] = {
{ "show", 1, 1, do_show },
- { "status", 1, 2, do_status },
{ "monitor", 1, 2, do_monitor },
{ "snoop", 1, 1, do_snoop },
{ "dump-desc", 1, 1, do_dump_desc },
{ "help", 0, INT_MAX, do_help },
/* Undocumented commands for testing. */
+ { "parse-flow", 1, 1, do_parse_flow },
{ "parse-flows", 1, 1, do_parse_flows },
{ "parse-nx-match", 0, 0, do_parse_nx_match },
+ { "ofp-print", 1, 2, do_ofp_print },
{ NULL, 0, 0, NULL },
};
git://git.onelab.eu / sliver-openvswitch.git / blobdiff