X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fofp-util.c;h=9210413a1417f15d78b9e07df12b0f3623f3d932;hb=6e11a6a15519561d932a018b2ca19dc3acee87c2;hp=88851f846f99b63ccadd9810e2019c87872a1f19;hpb=e41a91300789b03398007ebdb6025ca9d94fec26;p=openvswitch

diff --git a/lib/ofp-util.c b/lib/ofp-util.c
index 88851f84..9210413a 100644
--- a/lib/ofp-util.c
+++ b/lib/ofp-util.c
@@ -20,6 +20,7 @@
 #include <stdlib.h>
 #include "byte-order.h"
 #include "classifier.h"
+#include "multipath.h"
 #include "nx-match.h"
 #include "ofp-util.h"
 #include "ofpbuf.h"
@@ -127,10 +128,10 @@ ofputil_cls_rule_from_match(const struct ofp_match *match,
     wc->nw_dst_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_DST_SHIFT);
 
     if (flow_format == NXFF_TUN_ID_FROM_COOKIE && !(ofpfw & NXFW_TUN_ID)) {
-        rule->flow.tun_id = htonl(ntohll(cookie) >> 32);
+        rule->flow.tun_id = htonll(ntohll(cookie) >> 32);
     } else {
         wc->wildcards |= FWW_TUN_ID;
-        rule->flow.tun_id = 0;
+        rule->flow.tun_id = htonll(0);
     }
 
     if (ofpfw & OFPFW_DL_DST) {
@@ -200,16 +201,21 @@ ofputil_cls_rule_from_match(const struct ofp_match *match,
     cls_rule_zero_wildcarded_fields(rule);
 }
 
-/* Extract 'flow' with 'wildcards' into the OpenFlow match structure
- * 'match'.
+/* Convert 'rule' into the OpenFlow match structure 'match'.  'flow_format'
+ * must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE.
  *
- * 'flow_format' must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE.  In
- * the latter case only, 'match''s NXFW_TUN_ID bit will be filled in; otherwise
- * it is always set to 0. */
+ * The NXFF_TUN_ID_FROM_COOKIE flow format requires modifying the flow cookie.
+ * This function can help with that, if 'cookie_out' is nonnull.  For
+ * NXFF_OPENFLOW10, or if the tunnel ID is wildcarded, 'cookie_in' will be
+ * copied directly to '*cookie_out'.  For NXFF_TUN_ID_FROM_COOKIE when tunnel
+ * ID is matched, 'cookie_in' will be modified appropriately before setting
+ * '*cookie_out'.
+ */
 void
 ofputil_cls_rule_to_match(const struct cls_rule *rule,
                           enum nx_flow_format flow_format,
-                          struct ofp_match *match)
+                          struct ofp_match *match,
+                          ovs_be64 cookie_in, ovs_be64 *cookie_out)
 {
     const struct flow_wildcards *wc = &rule->wc;
     unsigned int ofpfw;
@@ -221,8 +227,19 @@ ofputil_cls_rule_to_match(const struct cls_rule *rule,
     if (wc->wildcards & FWW_NW_TOS) {
         ofpfw |= OFPFW_NW_TOS;
     }
-    if (flow_format == NXFF_TUN_ID_FROM_COOKIE && wc->wildcards & FWW_TUN_ID) {
-        ofpfw |= NXFW_TUN_ID;
+
+    /* Tunnel ID. */
+    if (flow_format == NXFF_TUN_ID_FROM_COOKIE) {
+        if (wc->wildcards & FWW_TUN_ID) {
+            ofpfw |= NXFW_TUN_ID;
+        } else {
+            uint32_t cookie_lo = ntohll(cookie_in);
+            uint32_t cookie_hi = ntohll(rule->flow.tun_id);
+            cookie_in = htonll(cookie_lo | ((uint64_t) cookie_hi << 32));
+        }
+    }
+    if (cookie_out) {
+        *cookie_out = cookie_in;
     }
 
     /* Translate VLANs. */
@@ -346,7 +363,7 @@ ofputil_lookup_openflow_message(const struct ofputil_msg_category *cat,
         }
     }
 
-    VLOG_WARN_RL(&bad_ofmsg_rl, "received %s of unknown type %u",
+    VLOG_WARN_RL(&bad_ofmsg_rl, "received %s of unknown type %"PRIu32,
                  cat->name, value);
     return cat->missing_error;
 }
@@ -455,7 +472,7 @@ ofputil_decode_nxst_request(const struct ofp_header *oh,
     };
 
     static const struct ofputil_msg_category nxst_request_category = {
-        "Nicira extension statistics",
+        "Nicira extension statistics request",
         nxst_requests, ARRAY_SIZE(nxst_requests),
         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE)
     };
@@ -489,7 +506,7 @@ ofputil_decode_nxst_reply(const struct ofp_header *oh,
     };
 
     static const struct ofputil_msg_category nxst_reply_category = {
-        "Nicira extension statistics",
+        "Nicira extension statistics reply",
         nxst_replies, ARRAY_SIZE(nxst_replies),
         OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE)
     };
@@ -840,7 +857,7 @@ ofputil_min_flow_format(const struct cls_rule *rule, bool cookie_support,
         || !regs_fully_wildcarded(wc)
         || (!(wc->wildcards & FWW_TUN_ID)
             && (!cookie_support
-                || (cookie_hi && cookie_hi != rule->flow.tun_id)))) {
+                || (cookie_hi && cookie_hi != ntohll(rule->flow.tun_id))))) {
         return NXFF_NXM;
     } else if (!(wc->wildcards & FWW_TUN_ID)) {
         return NXFF_TUN_ID_FROM_COOKIE;
@@ -979,15 +996,8 @@ ofputil_encode_flow_mod(const struct flow_mod *fm,
 
         msg = ofpbuf_new(sizeof *ofm + actions_len);
         ofm = put_openflow(sizeof *ofm, OFPT_FLOW_MOD, msg);
-        ofputil_cls_rule_to_match(&fm->cr, flow_format, &ofm->match);
-        if (flow_format != NXFF_TUN_ID_FROM_COOKIE
-            || fm->cr.wc.wildcards & FWW_TUN_ID) {
-            ofm->cookie = fm->cookie;
-        } else {
-            uint32_t cookie_lo = ntohll(fm->cookie);
-            uint32_t cookie_hi = ntohl(fm->cr.flow.tun_id);
-            ofm->cookie = htonll(cookie_lo | ((uint64_t) cookie_hi << 32));
-        }
+        ofputil_cls_rule_to_match(&fm->cr, flow_format, &ofm->match,
+                                  fm->cookie, &ofm->cookie);
         ofm->command = htons(fm->command);
         ofm->idle_timeout = htons(fm->idle_timeout);
         ofm->hard_timeout = htons(fm->hard_timeout);
@@ -1124,14 +1134,17 @@ ofputil_encode_flow_stats_request(const struct flow_stats_request *fsr,
 
         type = fsr->aggregate ? OFPST_AGGREGATE : OFPST_FLOW;
         ofsr = ofputil_make_stats_request(sizeof *ofsr, type, &msg);
-        ofputil_cls_rule_to_match(&fsr->match, flow_format, &ofsr->match);
+        ofputil_cls_rule_to_match(&fsr->match, flow_format, &ofsr->match,
+                                  0, NULL);
         ofsr->table_id = fsr->table_id;
         ofsr->out_port = htons(fsr->out_port);
     } else if (flow_format == NXFF_NXM) {
         struct nx_flow_stats_request *nfsr;
         int match_len;
+        int subtype;
 
-        ofputil_make_nxstats_request(sizeof *nfsr, NXST_FLOW, &msg);
+        subtype = fsr->aggregate ? NXST_AGGREGATE : NXST_FLOW;
+        ofputil_make_nxstats_request(sizeof *nfsr, subtype, &msg);
         match_len = nx_put_match(msg, &fsr->match);
 
         nfsr = msg->data;
@@ -1427,7 +1440,7 @@ make_flow_mod(uint16_t command, const struct cls_rule *rule,
     ofm->header.length = htons(size);
     ofm->cookie = 0;
     ofm->priority = htons(MIN(rule->priority, UINT16_MAX));
-    ofputil_cls_rule_to_match(rule, NXFF_OPENFLOW10, &ofm->match);
+    ofputil_cls_rule_to_match(rule, NXFF_OPENFLOW10, &ofm->match, 0, NULL);
     ofm->command = htons(command);
     return out;
 }
@@ -1624,9 +1637,23 @@ check_action_exact_len(const union ofp_action *a, unsigned int len,
                        unsigned int required_len)
 {
     if (len != required_len) {
-        VLOG_DBG_RL(&bad_ofmsg_rl,
-                    "action %u has invalid length %"PRIu16" (must be %u)\n",
-                    a->type, ntohs(a->header.len), required_len);
+        VLOG_WARN_RL(&bad_ofmsg_rl, "action %"PRIu16" has invalid length "
+                     "%"PRIu16" (must be %u)\n",
+                     ntohs(a->type), ntohs(a->header.len), required_len);
+        return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
+    }
+    return 0;
+}
+
+static int
+check_nx_action_exact_len(const struct nx_action_header *a,
+                          unsigned int len, unsigned int required_len)
+{
+    if (len != required_len) {
+        VLOG_WARN_RL(&bad_ofmsg_rl,
+                     "Nicira action %"PRIu16" has invalid length %"PRIu16" "
+                     "(must be %u)\n",
+                     ntohs(a->subtype), ntohs(a->len), required_len);
         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
     }
     return 0;
@@ -1691,8 +1718,8 @@ check_nicira_action(const union ofp_action *a, unsigned int len,
     int error;
 
     if (len < 16) {
-        VLOG_DBG_RL(&bad_ofmsg_rl,
-                    "Nicira vendor action only %u bytes", len);
+        VLOG_WARN_RL(&bad_ofmsg_rl,
+                     "Nicira vendor action only %u bytes", len);
         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
     }
     nah = (const struct nx_action_header *) a;
@@ -1710,19 +1737,19 @@ check_nicira_action(const union ofp_action *a, unsigned int len,
     case NXAST_DROP_SPOOFED_ARP:
     case NXAST_SET_QUEUE:
     case NXAST_POP_QUEUE:
-        return check_action_exact_len(a, len, 16);
+        return check_nx_action_exact_len(nah, len, 16);
 
     case NXAST_REG_MOVE:
-        error = check_action_exact_len(a, len,
-                                       sizeof(struct nx_action_reg_move));
+        error = check_nx_action_exact_len(nah, len,
+                                          sizeof(struct nx_action_reg_move));
         if (error) {
             return error;
         }
         return nxm_check_reg_move((const struct nx_action_reg_move *) a, flow);
 
     case NXAST_REG_LOAD:
-        error = check_action_exact_len(a, len,
-                                       sizeof(struct nx_action_reg_load));
+        error = check_nx_action_exact_len(nah, len,
+                                          sizeof(struct nx_action_reg_load));
         if (error) {
             return error;
         }
@@ -1731,8 +1758,23 @@ check_nicira_action(const union ofp_action *a, unsigned int len,
     case NXAST_NOTE:
         return 0;
 
+    case NXAST_SET_TUNNEL64:
+        return check_nx_action_exact_len(
+            nah, len, sizeof(struct nx_action_set_tunnel64));
+
+    case NXAST_MULTIPATH:
+        error = check_nx_action_exact_len(
+            nah, len, sizeof(struct nx_action_multipath));
+        if (error) {
+            return error;
+        }
+        return multipath_check((const struct nx_action_multipath *) a);
+
     case NXAST_SNAT__OBSOLETE:
     default:
+        VLOG_WARN_RL(&bad_ofmsg_rl,
+                     "unknown Nicira vendor action subtype %"PRIu16,
+                     ntohs(nah->subtype));
         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
     }
 }
@@ -1812,16 +1854,16 @@ validate_actions(const union ofp_action *actions, size_t n_actions,
         int error;
 
         if (n_slots > slots_left) {
-            VLOG_DBG_RL(&bad_ofmsg_rl,
-                        "action requires %u slots but only %u remain",
-                        n_slots, slots_left);
+            VLOG_WARN_RL(&bad_ofmsg_rl,
+                         "action requires %u slots but only %u remain",
+                         n_slots, slots_left);
             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
         } else if (!len) {
-            VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0");
+            VLOG_WARN_RL(&bad_ofmsg_rl, "action has invalid length 0");
             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
         } else if (len % OFP_ACTION_ALIGN) {
-            VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple "
-                        "of %d", len, OFP_ACTION_ALIGN);
+            VLOG_WARN_RL(&bad_ofmsg_rl, "action length %u is not a multiple "
+                         "of %d", len, OFP_ACTION_ALIGN);
             return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
         }
 
@@ -2098,16 +2140,16 @@ ofputil_pull_actions(struct ofpbuf *b, unsigned int actions_len,
                      union ofp_action **actionsp, size_t *n_actionsp)
 {
     if (actions_len % OFP_ACTION_ALIGN != 0) {
-        VLOG_DBG_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
-                    "is not a multiple of %d", actions_len, OFP_ACTION_ALIGN);
+        VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
+                     "is not a multiple of %d", actions_len, OFP_ACTION_ALIGN);
         goto error;
     }
 
     *actionsp = ofpbuf_try_pull(b, actions_len);
     if (*actionsp == NULL) {
-        VLOG_DBG_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
-                    "exceeds remaining message length (%zu)",
-                    actions_len, b->size);
+        VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
+                     "exceeds remaining message length (%zu)",
+                     actions_len, b->size);
         goto error;
     }