X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=utilities%2Fovs-ofctl.c;h=8da6e1a033cec188665140773576f9af8968e637;hb=e70f33fc8ae27732edd40841402bc38a3ca5d42a;hp=3beef3b6b00c7fd97ebcac62d4bef999cb257a3f;hpb=24cd0dee6ed7d96e5397f0ae3a9d3957504e8665;p=sliver-openvswitch.git

diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c
index 3beef3b6b..8da6e1a03 100644
--- a/utilities/ovs-ofctl.c
+++ b/utilities/ovs-ofctl.c
@@ -51,9 +51,16 @@
 
 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;
@@ -79,6 +86,8 @@ parse_options(int argc, char *argv[])
     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,
@@ -107,6 +116,17 @@ parse_options(int argc, char *argv[])
             }
             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();
 
@@ -163,6 +183,8 @@ usage(void)
     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");
@@ -286,7 +308,7 @@ dump_transaction(const char *vconn_name, struct ofpbuf *request)
     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);
 }
 
@@ -316,7 +338,7 @@ dump_stats_transaction(const char *vconn_name, struct ofpbuf *request)
         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);
@@ -341,20 +363,36 @@ dump_trivial_stats_transaction(const char *vconn_name, uint8_t stats_type)
  * 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
+transact_noreply(struct vconn *vconn, struct ofpbuf *request)
+{
+    struct list requests;
+
+    list_init(&requests);
+    list_push_back(&requests, &request->list_node);
+    transact_multiple_noreply(vconn, &requests);
+}
+
 static void
 do_show(int argc OVS_UNUSED, char *argv[])
 {
@@ -385,7 +423,7 @@ do_status(int argc, char *argv[])
     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);
+        ofp_print(stderr, b->data, b->size, verbosity + 2);
         ovs_fatal(0, "bad reply");
     }
 
@@ -467,38 +505,97 @@ str_to_port_no(const char *vconn_name, const char *port_name)
     }
 }
 
+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->table_id = pf.table_idx;
-    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)
+{
+    int flow_format;
 
-    dump_stats_transaction(argv[1], request);
+    if (preferred_flow_format != -1) {
+        enum nx_flow_format min_format;
+
+        min_format = ofputil_min_flow_format(rule, cookie_support, cookie);
+        if (preferred_flow_format >= min_format) {
+            set_flow_format(vconn, preferred_flow_format);
+            return preferred_flow_format;
+        }
+
+        VLOG_WARN("%s: cannot use requested flow format %s for "
+                  "specified flow", vconn_get_name(vconn),
+                  ofputil_flow_format_to_string(min_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;
+    }
+
+    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->table_id = pf.table_idx;
-    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
@@ -526,23 +623,34 @@ do_queue_stats(int argc, char *argv[])
 }
 
 static void
-do_add_flow(int argc OVS_UNUSED, char *argv[])
+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 = NXFF_OPENFLOW10;
+    parse_ofp_flow_mod_str(&requests, &flow_format, argc > 2 ? argv[2] : "",
+                           command);
 
     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");
@@ -550,40 +658,28 @@ do_add_flows(int argc OVS_UNUSED, char *argv[])
         ovs_fatal(errno, "%s: open", argv[2]);
     }
 
+    list_init(&requests);
+    flow_format = NXFF_OPENFLOW10;
+
     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)) {
+        transact_multiple_noreply(vconn, &requests);
     }
     vconn_close(vconn);
+
     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
@@ -592,7 +688,7 @@ monitor_vconn(struct vconn *vconn)
     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);
     }
 }
@@ -610,7 +706,7 @@ do_monitor(int argc, char *argv[])
 
         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);
 }
@@ -686,7 +782,7 @@ do_mod_port(int argc OVS_UNUSED, char *argv[])
     }
 
     open_vconn(argv[1], &vconn);
-    dump_noreply_transaction(vconn, request);
+    transact_noreply(vconn, request);
     vconn_close(vconn);
 }
 
@@ -723,9 +819,9 @@ do_ping(int argc, char *argv[])
             || 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),
@@ -791,7 +887,8 @@ do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 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");
@@ -799,9 +896,20 @@ do_parse_flows(int argc OVS_UNUSED, char *argv[])
         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);
+    list_init(&packets);
+    flow_format = NXFF_OPENFLOW10;
+    if (preferred_flow_format > 0) {
+        flow_format = preferred_flow_format;
+    }
+
+    while (parse_ofp_add_flow_file(&packets, &flow_format, file)) {
+        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);
+        }
     }
     fclose(file);
 }