X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fofp-print.c;h=013561f3fa11ce6bb5f10bb276a9d40008d44ca0;hb=a64f0b0fcd00da464aa87a93d303f7564a29e1a1;hp=c4e7b8f4512359727acb1aacc71c215f9653f70a;hpb=e2b9ac44c82590c2a9a27bff79ae43899277f703;p=openvswitch

diff --git a/lib/ofp-print.c b/lib/ofp-print.c
index c4e7b8f4..013561f3 100644
--- a/lib/ofp-print.c
+++ b/lib/ofp-print.c
@@ -442,6 +442,7 @@ ofputil_capabilities_to_name(uint32_t bit)
     case OFPUTIL_C_ARP_MATCH_IP: return "ARP_MATCH_IP";
     case OFPUTIL_C_STP:          return "STP";
     case OFPUTIL_C_GROUP_STATS:  return "GROUP_STATS";
+    case OFPUTIL_C_PORT_BLOCKED: return "PORT_BLOCKED";
     }
 
     return NULL;
@@ -507,10 +508,19 @@ ofp_print_switch_features(struct ds *string, const struct ofp_header *oh)
                         ofputil_capabilities_to_name, ' ');
     ds_put_char(string, '\n');
 
-    ds_put_cstr(string, "actions: ");
-    ofp_print_bit_names(string, features.actions,
-                        ofputil_action_bitmap_to_name, ' ');
-    ds_put_char(string, '\n');
+    switch ((enum ofp_version)oh->version) {
+    case OFP10_VERSION:
+        ds_put_cstr(string, "actions: ");
+        ofp_print_bit_names(string, features.actions,
+                            ofputil_action_bitmap_to_name, ' ');
+        ds_put_char(string, '\n');
+        break;
+    case OFP11_VERSION:
+    case OFP12_VERSION:
+        break;
+    default:
+        NOT_REACHED();
+    }
 
     ofp_print_phy_ports(string, oh->version, &b);
 }
@@ -675,9 +685,13 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity)
     bool need_priority;
     enum ofperr error;
     enum ofpraw raw;
+    enum ofputil_protocol protocol;
+
+    protocol = ofputil_protocol_from_ofp_version(oh->version);
+    protocol = ofputil_protocol_set_tid(protocol, true);
 
     ofpbuf_init(&ofpacts, 64);
-    error = ofputil_decode_flow_mod(&fm, oh, OFPUTIL_P_OF10_TID, &ofpacts);
+    error = ofputil_decode_flow_mod(&fm, oh, protocol, &ofpacts);
     if (error) {
         ofpbuf_uninit(&ofpacts);
         ofp_print_error(s, error);
@@ -711,7 +725,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity)
     ds_put_char(s, ' ');
     ofpraw_decode(&raw, oh);
     if (verbosity >= 3 && raw == OFPRAW_OFPT10_FLOW_MOD) {
-        const struct ofp_flow_mod *ofm = ofpmsg_body(oh);
+        const struct ofp10_flow_mod *ofm = ofpmsg_body(oh);
         ofp10_match_print(s, &ofm->match, verbosity);
 
         /* ofp_print_match() doesn't print priority. */
@@ -770,11 +784,11 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity)
         if (flags & OFPFF_CHECK_OVERLAP) {
             ds_put_cstr(s, "check_overlap ");
         }
-        if (flags & OFPFF_EMERG) {
+        if (flags & OFPFF10_EMERG) {
             ds_put_cstr(s, "emerg ");
         }
 
-        flags &= ~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP | OFPFF_EMERG);
+        flags &= ~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP | OFPFF10_EMERG);
         if (flags) {
             ds_put_format(s, "flags:0x%"PRIx16" ", flags);
         }
@@ -842,8 +856,14 @@ ofp_print_flow_removed(struct ds *string, const struct ofp_header *oh)
     }
     ds_put_cstr(string, " duration");
     ofp_print_duration(string, fr.duration_sec, fr.duration_nsec);
-    ds_put_format(string, " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n",
-         fr.idle_timeout, fr.packet_count, fr.byte_count);
+    ds_put_format(string, " idle%"PRIu16, fr.idle_timeout);
+    if (fr.hard_timeout) {
+        /* The hard timeout was only added in OF1.2, so only print it if it is
+         * actually in use to avoid gratuitous change to the formatting. */
+        ds_put_format(string, " hard%"PRIu16, fr.hard_timeout);
+    }
+    ds_put_format(string, " pkts%"PRIu64" bytes%"PRIu64"\n",
+                  fr.packet_count, fr.byte_count);
 }
 
 static void
@@ -1121,8 +1141,124 @@ ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh,
 }
 
 static void
-ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh,
-                            int verbosity)
+ofp_print_one_ofpst_table_reply(struct ds *string, enum ofp_version ofp_version,
+                                const char *name, struct ofp12_table_stats *ts)
+{
+    char name_[OFP_MAX_TABLE_NAME_LEN + 1];
+
+    ovs_strlcpy(name_, name, sizeof name_);
+
+    ds_put_format(string, "  %d: %-8s: ", ts->table_id, name_);
+    ds_put_format(string, "wild=0x%05"PRIx64", ", ntohll(ts->wildcards));
+    ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries));
+    ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "lookup=%"PRIu64", ", ntohll(ts->lookup_count));
+    ds_put_format(string, "matched=%"PRIu64"\n", ntohll(ts->matched_count));
+
+    if (ofp_version < OFP11_VERSION) {
+        return;
+    }
+
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "match=0x%08"PRIx64", ", ntohll(ts->match));
+    ds_put_format(string, "instructions=0x%08"PRIx32", ",
+                  ntohl(ts->instructions));
+    ds_put_format(string, "config=0x%08"PRIx32"\n", ntohl(ts->config));
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "write_actions=0x%08"PRIx32", ",
+                  ntohl(ts->write_actions));
+    ds_put_format(string, "apply_actions=0x%08"PRIx32"\n",
+                  ntohl(ts->apply_actions));
+
+    if (ofp_version < OFP12_VERSION) {
+        return;
+    }
+
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "write_setfields=0x%016"PRIx64"\n",
+                  ntohll(ts->write_setfields));
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "apply_setfields=0x%016"PRIx64"\n",
+                  ntohll(ts->apply_setfields));
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "metadata_match=0x%016"PRIx64"\n",
+                  ntohll(ts->metadata_match));
+    ds_put_cstr(string, "               ");
+    ds_put_format(string, "metadata_write=0x%016"PRIx64"\n",
+                  ntohll(ts->metadata_write));
+}
+
+static void
+ofp_print_ofpst_table_reply12(struct ds *string, const struct ofp_header *oh,
+                              int verbosity)
+{
+    struct ofp12_table_stats *ts;
+    struct ofpbuf b;
+    size_t n;
+
+    ofpbuf_use_const(&b, oh, ntohs(oh->length));
+    ofpraw_pull_assert(&b);
+
+    n = b.size / sizeof *ts;
+    ds_put_format(string, " %zu tables\n", n);
+    if (verbosity < 1) {
+        return;
+    }
+
+    for (;;) {
+        ts = ofpbuf_try_pull(&b, sizeof *ts);
+        if (!ts) {
+            return;
+        }
+
+        ofp_print_one_ofpst_table_reply(string, OFP12_VERSION, ts->name, ts);
+     }
+}
+
+static void
+ofp_print_ofpst_table_reply11(struct ds *string, const struct ofp_header *oh,
+                              int verbosity)
+{
+    struct ofp11_table_stats *ts;
+    struct ofpbuf b;
+    size_t n;
+
+    ofpbuf_use_const(&b, oh, ntohs(oh->length));
+    ofpraw_pull_assert(&b);
+
+    n = b.size / sizeof *ts;
+    ds_put_format(string, " %zu tables\n", n);
+    if (verbosity < 1) {
+        return;
+    }
+
+    for (;;) {
+        struct ofp12_table_stats ts12;
+
+        ts = ofpbuf_try_pull(&b, sizeof *ts);
+        if (!ts) {
+            return;
+        }
+
+        ts12.table_id = ts->table_id;
+        ts12.wildcards = htonll(ntohl(ts->wildcards));
+        ts12.max_entries = ts->max_entries;
+        ts12.active_count = ts->active_count;
+        ts12.lookup_count = ts->lookup_count;
+        ts12.matched_count = ts->matched_count;
+        ts12.match = htonll(ntohl(ts->match));
+        ts12.instructions = ts->instructions;
+        ts12.config = ts->config;
+        ts12.write_actions = ts->write_actions;
+        ts12.apply_actions = ts->apply_actions;
+        ofp_print_one_ofpst_table_reply(string, OFP11_VERSION, ts->name, &ts12);
+     }
+}
+
+static void
+ofp_print_ofpst_table_reply10(struct ds *string, const struct ofp_header *oh,
+                              int verbosity)
 {
     struct ofp10_table_stats *ts;
     struct ofpbuf b;
@@ -1138,27 +1274,45 @@ ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh,
     }
 
     for (;;) {
-        char name[OFP_MAX_TABLE_NAME_LEN + 1];
+        struct ofp12_table_stats ts12;
 
         ts = ofpbuf_try_pull(&b, sizeof *ts);
         if (!ts) {
             return;
         }
 
-        ovs_strlcpy(name, ts->name, sizeof name);
-
-        ds_put_format(string, "  %d: %-8s: ", ts->table_id, name);
-        ds_put_format(string, "wild=0x%05"PRIx32", ", ntohl(ts->wildcards));
-        ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries));
-        ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count));
-        ds_put_cstr(string, "               ");
-        ds_put_format(string, "lookup=%"PRIu64", ",
-                      ntohll(get_32aligned_be64(&ts->lookup_count)));
-        ds_put_format(string, "matched=%"PRIu64"\n",
-                      ntohll(get_32aligned_be64(&ts->matched_count)));
+        ts12.table_id = ts->table_id;
+        ts12.wildcards = htonll(ntohl(ts->wildcards));
+        ts12.max_entries = ts->max_entries;
+        ts12.active_count = ts->active_count;
+        ts12.lookup_count = get_32aligned_be64(&ts->lookup_count);
+        ts12.matched_count = get_32aligned_be64(&ts->matched_count);
+        ofp_print_one_ofpst_table_reply(string, OFP10_VERSION, ts->name, &ts12);
      }
 }
 
+static void
+ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh,
+                            int verbosity)
+{
+    switch ((enum ofp_version)oh->version) {
+    case OFP12_VERSION:
+        ofp_print_ofpst_table_reply12(string, oh, verbosity);
+        break;
+
+    case OFP11_VERSION:
+        ofp_print_ofpst_table_reply11(string, oh, verbosity);
+        break;
+
+    case OFP10_VERSION:
+        ofp_print_ofpst_table_reply10(string, oh, verbosity);
+        break;
+
+    default:
+        NOT_REACHED();
+    }
+}
+
 static void
 ofp_print_queue_name(struct ds *string, uint32_t queue_id)
 {