X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto-dpif.c;h=246b34ae4381c3c6e9344823d989ca9d0437a0f7;hb=d0918789c75c172c78963f5edbad6758af38d12c;hp=e206f43168691851e360bbd3718c7445ebe437b5;hpb=2284188b69fc8d935ae1ecf9d1b939e3efbbe10b;p=sliver-openvswitch.git

diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
index e206f4316..246b34ae4 100644
--- a/ofproto/ofproto-dpif.c
+++ b/ofproto/ofproto-dpif.c
@@ -34,6 +34,7 @@
 #include "lacp.h"
 #include "learn.h"
 #include "mac-learning.h"
+#include "meta-flow.h"
 #include "multipath.h"
 #include "netdev.h"
 #include "netlink.h"
@@ -320,21 +321,21 @@ struct facet {
 };
 
 static struct facet *facet_create(struct rule_dpif *, const struct flow *);
-static void facet_remove(struct ofproto_dpif *, struct facet *);
+static void facet_remove(struct facet *);
 static void facet_free(struct facet *);
 
 static struct facet *facet_find(struct ofproto_dpif *, const struct flow *);
 static struct facet *facet_lookup_valid(struct ofproto_dpif *,
                                         const struct flow *);
-static bool facet_revalidate(struct ofproto_dpif *, struct facet *);
+static bool facet_revalidate(struct facet *);
+static bool facet_check_consistency(struct facet *);
 
-static void facet_flush_stats(struct ofproto_dpif *, struct facet *);
+static void facet_flush_stats(struct facet *);
 
-static void facet_update_time(struct ofproto_dpif *, struct facet *,
-                              long long int used);
+static void facet_update_time(struct facet *, long long int used);
 static void facet_reset_counters(struct facet *);
 static void facet_push_stats(struct facet *);
-static void facet_account(struct ofproto_dpif *, struct facet *);
+static void facet_account(struct facet *);
 
 static bool facet_is_controller_flow(struct facet *);
 
@@ -376,26 +377,26 @@ struct subfacet {
     ovs_be16 initial_tci;       /* Initial VLAN TCI value. */
 };
 
-static struct subfacet *subfacet_create(struct ofproto_dpif *, struct facet *,
-                                        enum odp_key_fitness,
+static struct subfacet *subfacet_create(struct facet *, enum odp_key_fitness,
                                         const struct nlattr *key,
                                         size_t key_len, ovs_be16 initial_tci);
 static struct subfacet *subfacet_find(struct ofproto_dpif *,
                                       const struct nlattr *key, size_t key_len);
-static void subfacet_destroy(struct ofproto_dpif *, struct subfacet *);
-static void subfacet_destroy__(struct ofproto_dpif *, struct subfacet *);
+static void subfacet_destroy(struct subfacet *);
+static void subfacet_destroy__(struct subfacet *);
+static void subfacet_get_key(struct subfacet *, struct odputil_keybuf *,
+                             struct ofpbuf *key);
 static void subfacet_reset_dp_stats(struct subfacet *,
                                     struct dpif_flow_stats *);
-static void subfacet_update_time(struct ofproto_dpif *, struct subfacet *,
-                                 long long int used);
-static void subfacet_update_stats(struct ofproto_dpif *, struct subfacet *,
+static void subfacet_update_time(struct subfacet *, long long int used);
+static void subfacet_update_stats(struct subfacet *,
                                   const struct dpif_flow_stats *);
-static void subfacet_make_actions(struct ofproto_dpif *, struct subfacet *,
+static void subfacet_make_actions(struct subfacet *,
                                   const struct ofpbuf *packet);
-static int subfacet_install(struct ofproto_dpif *, struct subfacet *,
+static int subfacet_install(struct subfacet *,
                             const struct nlattr *actions, size_t actions_len,
                             struct dpif_flow_stats *);
-static void subfacet_uninstall(struct ofproto_dpif *, struct subfacet *);
+static void subfacet_uninstall(struct subfacet *);
 
 struct ofport_dpif {
     struct ofport up;
@@ -638,9 +639,7 @@ construct(struct ofproto *ofproto_, int *n_tablesp)
     dpif_flow_flush(ofproto->dpif);
     dpif_recv_purge(ofproto->dpif);
 
-    error = dpif_recv_set_mask(ofproto->dpif,
-                               ((1u << DPIF_UC_MISS) |
-                                (1u << DPIF_UC_ACTION)));
+    error = dpif_recv_set(ofproto->dpif, true);
     if (error) {
         VLOG_ERR("failed to listen on datapath %s: %s", name, strerror(error));
         dpif_close(ofproto->dpif);
@@ -706,7 +705,7 @@ destruct(struct ofproto *ofproto_)
 {
     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
     struct rule_dpif *rule, *next_rule;
-    struct classifier *table;
+    struct oftable *table;
     int i;
 
     hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node);
@@ -715,7 +714,7 @@ destruct(struct ofproto *ofproto_)
     OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
         struct cls_cursor cursor;
 
-        cls_cursor_init(&cursor, table, NULL);
+        cls_cursor_init(&cursor, &table->cls, NULL);
         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
             ofproto_rule_destroy(&rule->up);
         }
@@ -821,7 +820,20 @@ run(struct ofproto *ofproto_)
         HMAP_FOR_EACH_SAFE (facet, next, hmap_node, &ofproto->facets) {
             if (revalidate_all
                 || tag_set_intersects(&revalidate_set, facet->tags)) {
-                facet_revalidate(ofproto, facet);
+                facet_revalidate(facet);
+            }
+        }
+    }
+
+    /* Check the consistency of a random facet, to aid debugging. */
+    if (!hmap_is_empty(&ofproto->facets) && !ofproto->need_revalidate) {
+        struct facet *facet;
+
+        facet = CONTAINER_OF(hmap_random_node(&ofproto->facets),
+                             struct facet, hmap_node);
+        if (!tag_set_intersects(&ofproto->revalidate_set, facet->tags)) {
+            if (!facet_check_consistency(facet)) {
+                ofproto->need_revalidate = true;
             }
         }
     }
@@ -886,7 +898,7 @@ flush(struct ofproto *ofproto_)
             subfacet->dp_packet_count = 0;
             subfacet->dp_byte_count = 0;
         }
-        facet_remove(ofproto, facet);
+        facet_remove(facet);
     }
     dpif_flow_flush(ofproto->dpif);
 }
@@ -1182,7 +1194,7 @@ update_stp_port_state(struct ofport_dpif *ofport)
         if (stp_learn_in_state(ofport->stp_state)
                 != stp_learn_in_state(state)) {
             /* xxx Learning action flows should also be flushed. */
-            mac_learning_flush(ofproto->ml);
+            mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
         }
         fwd_change = stp_forward_in_state(ofport->stp_state)
                         != stp_forward_in_state(state);
@@ -1285,6 +1297,10 @@ stp_run(struct ofproto_dpif *ofproto)
                 update_stp_port_state(ofport);
             }
         }
+
+        if (stp_check_and_reset_fdb_flush(ofproto->stp)) {
+            mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
+        }
     }
 }
 
@@ -1868,7 +1884,7 @@ bundle_run(struct ofbundle *bundle)
         }
 
         bond_run(bundle->bond, &bundle->ofproto->revalidate_set,
-                 lacp_negotiated(bundle->lacp));
+                 lacp_status(bundle->lacp));
         if (bond_should_send_learning_packets(bundle->bond)) {
             bundle_send_learning_packets(bundle);
         }
@@ -2053,7 +2069,7 @@ mirror_set(struct ofproto *ofproto_, void *aux,
     }
 
     ofproto->need_revalidate = true;
-    mac_learning_flush(ofproto->ml);
+    mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
     mirror_update_dups(ofproto);
 
     return 0;
@@ -2072,7 +2088,7 @@ mirror_destroy(struct ofmirror *mirror)
 
     ofproto = mirror->ofproto;
     ofproto->need_revalidate = true;
-    mac_learning_flush(ofproto->ml);
+    mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
 
     mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
@@ -2115,8 +2131,7 @@ set_flood_vlans(struct ofproto *ofproto_, unsigned long *flood_vlans)
 {
     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
     if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
-        ofproto->need_revalidate = true;
-        mac_learning_flush(ofproto->ml);
+        mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
     }
     return 0;
 }
@@ -2402,7 +2417,7 @@ struct flow_miss {
 };
 
 struct flow_miss_op {
-    union dpif_op dpif_op;
+    struct dpif_op dpif_op;
     struct subfacet *subfacet;
 };
 
@@ -2410,7 +2425,7 @@ struct flow_miss_op {
  * OpenFlow controller as necessary according to their individual
  * configurations. */
 static void
-send_packet_in_miss(struct ofproto_dpif *ofproto, struct ofpbuf *packet,
+send_packet_in_miss(struct ofproto_dpif *ofproto, const struct ofpbuf *packet,
                     const struct flow *flow)
 {
     struct ofputil_packet_in pin;
@@ -2528,7 +2543,7 @@ handle_flow_miss(struct ofproto_dpif *ofproto, struct flow_miss *miss,
         facet = facet_create(rule, flow);
     }
 
-    subfacet = subfacet_create(ofproto, facet,
+    subfacet = subfacet_create(facet,
                                miss->key_fitness, miss->key, miss->key_len,
                                miss->initial_tci);
 
@@ -2537,7 +2552,6 @@ handle_flow_miss(struct ofproto_dpif *ofproto, struct flow_miss *miss,
         struct flow_miss_op *op;
         struct dpif_execute *execute;
 
-        list_remove(&packet->list_node);
         ofproto->n_matches++;
 
         if (facet->rule->up.cr.priority == FAIL_OPEN_PRIORITY) {
@@ -2555,11 +2569,16 @@ handle_flow_miss(struct ofproto_dpif *ofproto, struct flow_miss *miss,
         }
 
         if (!facet->may_install || !subfacet->actions) {
-            subfacet_make_actions(ofproto, subfacet, packet);
+            subfacet_make_actions(subfacet, packet);
         }
 
         dpif_flow_stats_extract(&facet->flow, packet, &stats);
-        subfacet_update_stats(ofproto, subfacet, &stats);
+        subfacet_update_stats(subfacet, &stats);
+
+        if (!subfacet->actions_len) {
+            /* No actions to execute, so skip talking to the dpif. */
+            continue;
+        }
 
         if (flow->vlan_tci != subfacet->initial_tci) {
             /* This packet was received on a VLAN splinter port.  We added
@@ -2571,9 +2590,9 @@ handle_flow_miss(struct ofproto_dpif *ofproto, struct flow_miss *miss,
         }
 
         op = &ops[(*n_ops)++];
-        execute = &op->dpif_op.execute;
+        execute = &op->dpif_op.u.execute;
         op->subfacet = subfacet;
-        execute->type = DPIF_OP_EXECUTE;
+        op->dpif_op.type = DPIF_OP_EXECUTE;
         execute->key = miss->key;
         execute->key_len = miss->key_len;
         execute->actions = (facet->may_install
@@ -2586,10 +2605,10 @@ handle_flow_miss(struct ofproto_dpif *ofproto, struct flow_miss *miss,
 
     if (facet->may_install && subfacet->key_fitness != ODP_FIT_TOO_LITTLE) {
         struct flow_miss_op *op = &ops[(*n_ops)++];
-        struct dpif_flow_put *put = &op->dpif_op.flow_put;
+        struct dpif_flow_put *put = &op->dpif_op.u.flow_put;
 
         op->subfacet = subfacet;
-        put->type = DPIF_OP_FLOW_PUT;
+        op->dpif_op.type = DPIF_OP_FLOW_PUT;
         put->flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
         put->key = miss->key;
         put->key_len = miss->key_len;
@@ -2671,7 +2690,7 @@ handle_miss_upcalls(struct ofproto_dpif *ofproto, struct dpif_upcall *upcalls,
     struct dpif_upcall *upcall;
     struct flow_miss *miss, *next_miss;
     struct flow_miss_op flow_miss_ops[FLOW_MISS_MAX_BATCH * 2];
-    union dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH * 2];
+    struct dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH * 2];
     struct hmap todo;
     size_t n_ops;
     size_t i;
@@ -2723,14 +2742,10 @@ handle_miss_upcalls(struct ofproto_dpif *ofproto, struct dpif_upcall *upcalls,
     /* Process each element in the to-do list, constructing the set of
      * operations to batch. */
     n_ops = 0;
-    HMAP_FOR_EACH_SAFE (miss, next_miss, hmap_node, &todo) {
+    HMAP_FOR_EACH (miss, hmap_node, &todo) {
         handle_flow_miss(ofproto, miss, flow_miss_ops, &n_ops);
-        ofpbuf_list_delete(&miss->packets);
-        hmap_remove(&todo, &miss->hmap_node);
-        free(miss);
     }
     assert(n_ops <= ARRAY_SIZE(flow_miss_ops));
-    hmap_destroy(&todo);
 
     /* Execute batch. */
     for (i = 0; i < n_ops; i++) {
@@ -2742,25 +2757,28 @@ handle_miss_upcalls(struct ofproto_dpif *ofproto, struct dpif_upcall *upcalls,
     for (i = 0; i < n_ops; i++) {
         struct flow_miss_op *op = &flow_miss_ops[i];
         struct dpif_execute *execute;
-        struct dpif_flow_put *put;
 
         switch (op->dpif_op.type) {
         case DPIF_OP_EXECUTE:
-            execute = &op->dpif_op.execute;
+            execute = &op->dpif_op.u.execute;
             if (op->subfacet->actions != execute->actions) {
                 free((struct nlattr *) execute->actions);
             }
-            ofpbuf_delete((struct ofpbuf *) execute->packet);
             break;
 
         case DPIF_OP_FLOW_PUT:
-            put = &op->dpif_op.flow_put;
-            if (!put->error) {
+            if (!op->dpif_op.error) {
                 op->subfacet->installed = true;
             }
             break;
         }
     }
+    HMAP_FOR_EACH_SAFE (miss, next_miss, hmap_node, &todo) {
+        ofpbuf_list_delete(&miss->packets);
+        hmap_remove(&todo, &miss->hmap_node);
+        free(miss);
+    }
+    hmap_destroy(&todo);
 }
 
 static void
@@ -2852,7 +2870,7 @@ static int
 expire(struct ofproto_dpif *ofproto)
 {
     struct rule_dpif *rule, *next_rule;
-    struct classifier *table;
+    struct oftable *table;
     int dp_max_idle;
 
     /* Update stats for each flow in the datapath. */
@@ -2866,7 +2884,7 @@ expire(struct ofproto_dpif *ofproto)
     OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
         struct cls_cursor cursor;
 
-        cls_cursor_init(&cursor, table, NULL);
+        cls_cursor_init(&cursor, &table->cls, NULL);
         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
             rule_expire(rule);
         }
@@ -2930,8 +2948,8 @@ update_stats(struct ofproto_dpif *p)
             subfacet->dp_packet_count = stats->n_packets;
             subfacet->dp_byte_count = stats->n_bytes;
 
-            subfacet_update_time(p, subfacet, stats->used);
-            facet_account(p, facet);
+            subfacet_update_time(subfacet, stats->used);
+            facet_account(facet);
             facet_push_stats(facet);
         } else {
             if (!VLOG_DROP_WARN(&rl)) {
@@ -3049,7 +3067,7 @@ expire_subfacets(struct ofproto_dpif *ofproto, int dp_max_idle)
     HMAP_FOR_EACH_SAFE (subfacet, next_subfacet, hmap_node,
                         &ofproto->subfacets) {
         if (subfacet->used < cutoff) {
-            subfacet_destroy(ofproto, subfacet);
+            subfacet_destroy(subfacet);
         }
     }
 }
@@ -3059,7 +3077,6 @@ expire_subfacets(struct ofproto_dpif *ofproto, int dp_max_idle)
 static void
 rule_expire(struct rule_dpif *rule)
 {
-    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
     struct facet *facet, *next_facet;
     long long int now;
     uint8_t reason;
@@ -3081,7 +3098,7 @@ rule_expire(struct rule_dpif *rule)
     /* Update stats.  (This is a no-op if the rule expired due to an idle
      * timeout, because that only happens when the rule has no facets left.) */
     LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
-        facet_remove(ofproto, facet);
+        facet_remove(facet);
     }
 
     /* Get rid of the rule. */
@@ -3154,15 +3171,16 @@ execute_odp_actions(struct ofproto_dpif *ofproto, const struct flow *flow,
  *   - Removes 'facet' from its rule and from ofproto->facets.
  */
 static void
-facet_remove(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_remove(struct facet *facet)
 {
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     struct subfacet *subfacet, *next_subfacet;
 
     assert(!list_is_empty(&facet->subfacets));
 
     /* First uninstall all of the subfacets to get final statistics. */
     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
-        subfacet_uninstall(ofproto, subfacet);
+        subfacet_uninstall(subfacet);
     }
 
     /* Flush the final stats to the rule.
@@ -3170,12 +3188,12 @@ facet_remove(struct ofproto_dpif *ofproto, struct facet *facet)
      * This might require us to have at least one subfacet around so that we
      * can use its actions for accounting in facet_account(), which is why we
      * have uninstalled but not yet destroyed the subfacets. */
-    facet_flush_stats(ofproto, facet);
+    facet_flush_stats(facet);
 
     /* Now we're really all done so destroy everything. */
     LIST_FOR_EACH_SAFE (subfacet, next_subfacet, list_node,
                         &facet->subfacets) {
-        subfacet_destroy__(ofproto, subfacet);
+        subfacet_destroy__(subfacet);
     }
     hmap_remove(&ofproto->facets, &facet->hmap_node);
     list_remove(&facet->list_node);
@@ -3183,8 +3201,9 @@ facet_remove(struct ofproto_dpif *ofproto, struct facet *facet)
 }
 
 static void
-facet_account(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_account(struct facet *facet)
 {
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     uint64_t n_bytes;
     struct subfacet *subfacet;
     const struct nlattr *a;
@@ -3269,8 +3288,9 @@ facet_is_controller_flow(struct facet *facet)
  * 'facet''s statistics in the datapath should have been zeroed and folded into
  * its packet and byte counts before this function is called. */
 static void
-facet_flush_stats(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_flush_stats(struct facet *facet)
 {
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     struct subfacet *subfacet;
 
     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
@@ -3279,7 +3299,7 @@ facet_flush_stats(struct ofproto_dpif *ofproto, struct facet *facet)
     }
 
     facet_push_stats(facet);
-    facet_account(ofproto, facet);
+    facet_account(facet);
 
     if (ofproto->netflow && !facet_is_controller_flow(facet)) {
         struct ofexpired expired;
@@ -3334,7 +3354,7 @@ facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
     if (facet
         && (ofproto->need_revalidate
             || tag_set_intersects(&ofproto->revalidate_set, facet->tags))
-        && !facet_revalidate(ofproto, facet)) {
+        && !facet_revalidate(facet)) {
         COVERAGE_INC(facet_invalidated);
         return NULL;
     }
@@ -3342,7 +3362,126 @@ facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
     return facet;
 }
 
-/* Re-searches 'ofproto''s classifier for a rule matching 'facet':
+static bool
+facet_check_consistency(struct facet *facet)
+{
+    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
+
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
+
+    struct rule_dpif *rule;
+    struct subfacet *subfacet;
+    bool may_log = false;
+    bool ok;
+
+    /* Check the rule for consistency. */
+    rule = rule_dpif_lookup(ofproto, &facet->flow, 0);
+    if (!rule) {
+        if (!VLOG_DROP_WARN(&rl)) {
+            char *s = flow_to_string(&facet->flow);
+            VLOG_WARN("%s: facet should not exist", s);
+            free(s);
+        }
+        return false;
+    } else if (rule != facet->rule) {
+        may_log = !VLOG_DROP_WARN(&rl);
+        ok = false;
+        if (may_log) {
+            struct ds s;
+
+            ds_init(&s);
+            flow_format(&s, &facet->flow);
+            ds_put_format(&s, ": facet associated with wrong rule (was "
+                          "table=%"PRIu8",", facet->rule->up.table_id);
+            cls_rule_format(&facet->rule->up.cr, &s);
+            ds_put_format(&s, ") (should have been table=%"PRIu8",",
+                          rule->up.table_id);
+            cls_rule_format(&rule->up.cr, &s);
+            ds_put_char(&s, ')');
+
+            VLOG_WARN("%s", ds_cstr(&s));
+            ds_destroy(&s);
+        }
+    } else {
+        ok = true;
+    }
+
+    /* Check the datapath actions for consistency. */
+    LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
+        struct action_xlate_ctx ctx;
+        struct ofpbuf *odp_actions;
+        bool actions_changed;
+        bool should_install;
+
+        action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
+                              subfacet->initial_tci, rule->up.flow_cookie,
+                              NULL);
+        odp_actions = xlate_actions(&ctx, rule->up.actions,
+                                    rule->up.n_actions);
+
+        should_install = (ctx.may_set_up_flow
+                          && subfacet->key_fitness != ODP_FIT_TOO_LITTLE);
+        if (!should_install && !subfacet->installed) {
+            /* The actions for uninstallable flows may vary from one packet to
+             * the next, so don't compare the actions. */
+            goto next;
+        }
+
+        actions_changed = (subfacet->actions_len != odp_actions->size
+                           || memcmp(subfacet->actions, odp_actions->data,
+                                     subfacet->actions_len));
+        if (should_install != subfacet->installed || actions_changed) {
+            if (ok) {
+                may_log = !VLOG_DROP_WARN(&rl);
+                ok = false;
+            }
+
+            if (may_log) {
+                struct odputil_keybuf keybuf;
+                struct ofpbuf key;
+                struct ds s;
+
+                ds_init(&s);
+                subfacet_get_key(subfacet, &keybuf, &key);
+                odp_flow_key_format(key.data, key.size, &s);
+
+                ds_put_cstr(&s, ": inconsistency in subfacet");
+                if (should_install != subfacet->installed) {
+                    enum odp_key_fitness fitness = subfacet->key_fitness;
+
+                    ds_put_format(&s, " (should%s have been installed)",
+                                  should_install ? "" : " not");
+                    ds_put_format(&s, " (may_set_up_flow=%s, fitness=%s)",
+                                  ctx.may_set_up_flow ? "true" : "false",
+                                  odp_key_fitness_to_string(fitness));
+                }
+                if (actions_changed) {
+                    ds_put_cstr(&s, " (actions were: ");
+                    format_odp_actions(&s, subfacet->actions,
+                                       subfacet->actions_len);
+                    ds_put_cstr(&s, ") (correct actions: ");
+                    format_odp_actions(&s, odp_actions->data,
+                                       odp_actions->size);
+                    ds_put_char(&s, ')');
+                } else {
+                    ds_put_cstr(&s, " (actions: ");
+                    format_odp_actions(&s, subfacet->actions,
+                                       subfacet->actions_len);
+                    ds_put_char(&s, ')');
+                }
+                VLOG_WARN("%s", ds_cstr(&s));
+                ds_destroy(&s);
+            }
+        }
+
+    next:
+        ofpbuf_delete(odp_actions);
+    }
+
+    return ok;
+}
+
+/* Re-searches the classifier for 'facet':
  *
  *   - If the rule found is different from 'facet''s current rule, moves
  *     'facet' to the new rule and recompiles its actions.
@@ -3354,8 +3493,9 @@ facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
  *
  * Returns true if 'facet' still exists, false if it has been destroyed. */
 static bool
-facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
+facet_revalidate(struct facet *facet)
 {
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     struct actions {
         struct nlattr *odp_actions;
         size_t actions_len;
@@ -3374,7 +3514,7 @@ facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
     new_rule = rule_dpif_lookup(ofproto, &facet->flow, 0);
     if (!new_rule) {
         /* No new rule, so delete the facet. */
-        facet_remove(ofproto, facet);
+        facet_remove(facet);
         return false;
     }
 
@@ -3408,11 +3548,11 @@ facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
             if (should_install) {
                 struct dpif_flow_stats stats;
 
-                subfacet_install(ofproto, subfacet,
+                subfacet_install(subfacet,
                                  odp_actions->data, odp_actions->size, &stats);
-                subfacet_update_stats(ofproto, subfacet, &stats);
+                subfacet_update_stats(subfacet, &stats);
             } else {
-                subfacet_uninstall(ofproto, subfacet);
+                subfacet_uninstall(subfacet);
             }
 
             if (!new_actions) {
@@ -3428,7 +3568,7 @@ facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
         i++;
     }
     if (new_actions) {
-        facet_flush_stats(ofproto, facet);
+        facet_flush_stats(facet);
     }
 
     /* Update 'facet' now that we've taken care of all the old state. */
@@ -3465,9 +3605,9 @@ facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
 /* Updates 'facet''s used time.  Caller is responsible for calling
  * facet_push_stats() to update the flows which 'facet' resubmits into. */
 static void
-facet_update_time(struct ofproto_dpif *ofproto, struct facet *facet,
-                  long long int used)
+facet_update_time(struct facet *facet, long long int used)
 {
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     if (used > facet->used) {
         facet->used = used;
         if (used > facet->rule->used) {
@@ -3582,10 +3722,10 @@ subfacet_find__(struct ofproto_dpif *ofproto,
  * which case the caller must populate the actions with
  * subfacet_make_actions(). */
 static struct subfacet *
-subfacet_create(struct ofproto_dpif *ofproto, struct facet *facet,
-                enum odp_key_fitness key_fitness,
+subfacet_create(struct facet *facet, enum odp_key_fitness key_fitness,
                 const struct nlattr *key, size_t key_len, ovs_be16 initial_tci)
 {
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     uint32_t key_hash = odp_flow_key_hash(key, key_len);
     struct subfacet *subfacet;
 
@@ -3597,7 +3737,7 @@ subfacet_create(struct ofproto_dpif *ofproto, struct facet *facet,
 
         /* This shouldn't happen. */
         VLOG_ERR_RL(&rl, "subfacet with wrong facet");
-        subfacet_destroy(ofproto, subfacet);
+        subfacet_destroy(subfacet);
     }
 
     subfacet = xzalloc(sizeof *subfacet);
@@ -3637,9 +3777,12 @@ subfacet_find(struct ofproto_dpif *ofproto,
 /* Uninstalls 'subfacet' from the datapath, if it is installed, removes it from
  * its facet within 'ofproto', and frees it. */
 static void
-subfacet_destroy__(struct ofproto_dpif *ofproto, struct subfacet *subfacet)
+subfacet_destroy__(struct subfacet *subfacet)
 {
-    subfacet_uninstall(ofproto, subfacet);
+    struct facet *facet = subfacet->facet;
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
+
+    subfacet_uninstall(subfacet);
     hmap_remove(&ofproto->subfacets, &subfacet->hmap_node);
     list_remove(&subfacet->list_node);
     free(subfacet->key);
@@ -3650,15 +3793,15 @@ subfacet_destroy__(struct ofproto_dpif *ofproto, struct subfacet *subfacet)
 /* Destroys 'subfacet', as with subfacet_destroy__(), and then if this was the
  * last remaining subfacet in its facet destroys the facet too. */
 static void
-subfacet_destroy(struct ofproto_dpif *ofproto, struct subfacet *subfacet)
+subfacet_destroy(struct subfacet *subfacet)
 {
     struct facet *facet = subfacet->facet;
 
     if (list_is_singleton(&facet->subfacets)) {
         /* facet_remove() needs at least one subfacet (it will remove it). */
-        facet_remove(ofproto, facet);
+        facet_remove(facet);
     } else {
-        subfacet_destroy__(ofproto, subfacet);
+        subfacet_destroy__(subfacet);
     }
 }
 
@@ -3679,15 +3822,15 @@ subfacet_get_key(struct subfacet *subfacet, struct odputil_keybuf *keybuf,
 
 /* Composes the datapath actions for 'subfacet' based on its rule's actions. */
 static void
-subfacet_make_actions(struct ofproto_dpif *p, struct subfacet *subfacet,
-                      const struct ofpbuf *packet)
+subfacet_make_actions(struct subfacet *subfacet, const struct ofpbuf *packet)
 {
     struct facet *facet = subfacet->facet;
     const struct rule_dpif *rule = facet->rule;
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
     struct ofpbuf *odp_actions;
     struct action_xlate_ctx ctx;
 
-    action_xlate_ctx_init(&ctx, p, &facet->flow, subfacet->initial_tci,
+    action_xlate_ctx_init(&ctx, ofproto, &facet->flow, subfacet->initial_tci,
                           rule->up.flow_cookie, packet);
     odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
     facet->tags = ctx.tags;
@@ -3714,10 +3857,12 @@ subfacet_make_actions(struct ofproto_dpif *p, struct subfacet *subfacet,
  *
  * Returns 0 if successful, otherwise a positive errno value. */
 static int
-subfacet_install(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
+subfacet_install(struct subfacet *subfacet,
                  const struct nlattr *actions, size_t actions_len,
                  struct dpif_flow_stats *stats)
 {
+    struct facet *facet = subfacet->facet;
+    struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
     struct odputil_keybuf keybuf;
     enum dpif_flow_put_flags flags;
     struct ofpbuf key;
@@ -3741,19 +3886,21 @@ subfacet_install(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
 
 /* If 'subfacet' is installed in the datapath, uninstalls it. */
 static void
-subfacet_uninstall(struct ofproto_dpif *p, struct subfacet *subfacet)
+subfacet_uninstall(struct subfacet *subfacet)
 {
     if (subfacet->installed) {
+        struct rule_dpif *rule = subfacet->facet->rule;
+        struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
         struct odputil_keybuf keybuf;
         struct dpif_flow_stats stats;
         struct ofpbuf key;
         int error;
 
         subfacet_get_key(subfacet, &keybuf, &key);
-        error = dpif_flow_del(p->dpif, key.data, key.size, &stats);
+        error = dpif_flow_del(ofproto->dpif, key.data, key.size, &stats);
         subfacet_reset_dp_stats(subfacet, &stats);
         if (!error) {
-            subfacet_update_stats(p, subfacet, &stats);
+            subfacet_update_stats(subfacet, &stats);
         }
         subfacet->installed = false;
     } else {
@@ -3785,12 +3932,11 @@ subfacet_reset_dp_stats(struct subfacet *subfacet,
 /* Updates 'subfacet''s used time.  The caller is responsible for calling
  * facet_push_stats() to update the flows which 'subfacet' resubmits into. */
 static void
-subfacet_update_time(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
-                     long long int used)
+subfacet_update_time(struct subfacet *subfacet, long long int used)
 {
     if (used > subfacet->used) {
         subfacet->used = used;
-        facet_update_time(ofproto, subfacet->facet, used);
+        facet_update_time(subfacet->facet, used);
     }
 }
 
@@ -3801,13 +3947,13 @@ subfacet_update_time(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
  * represents a packet that was sent by hand or if it represents statistics
  * that have been cleared out of the datapath. */
 static void
-subfacet_update_stats(struct ofproto_dpif *ofproto, struct subfacet *subfacet,
+subfacet_update_stats(struct subfacet *subfacet,
                       const struct dpif_flow_stats *stats)
 {
     if (stats->n_packets || stats->used > subfacet->used) {
         struct facet *facet = subfacet->facet;
 
-        subfacet_update_time(ofproto, subfacet, stats->used);
+        subfacet_update_time(subfacet, stats->used);
         facet->packet_count += stats->n_packets;
         facet->byte_count += stats->n_bytes;
         facet_push_stats(facet);
@@ -3828,7 +3974,7 @@ rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow,
         return NULL;
     }
 
-    cls = &ofproto->up.tables[table_id];
+    cls = &ofproto->up.tables[table_id].cls;
     if (flow->nw_frag & FLOW_NW_FRAG_ANY
         && ofproto->up.frag_handling == OFPC_FRAG_NORMAL) {
         /* For OFPC_NORMAL frag_handling, we must pretend that transport ports
@@ -3872,14 +4018,14 @@ rule_dealloc(struct rule *rule_)
     free(rule);
 }
 
-static int
+static enum ofperr
 rule_construct(struct rule *rule_)
 {
     struct rule_dpif *rule = rule_dpif_cast(rule_);
     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
     struct rule_dpif *victim;
     uint8_t table_id;
-    int error;
+    enum ofperr error;
 
     error = validate_actions(rule->up.actions, rule->up.n_actions,
                              &rule->up.cr.flow, ofproto->max_ports);
@@ -3926,11 +4072,10 @@ static void
 rule_destruct(struct rule *rule_)
 {
     struct rule_dpif *rule = rule_dpif_cast(rule_);
-    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
     struct facet *facet, *next_facet;
 
     LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
-        facet_revalidate(ofproto, facet);
+        facet_revalidate(facet);
     }
 
     complete_operation(rule);
@@ -3956,7 +4101,7 @@ rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes)
     }
 }
 
-static int
+static enum ofperr
 rule_execute(struct rule *rule_, const struct flow *flow,
              struct ofpbuf *packet)
 {
@@ -3987,7 +4132,7 @@ rule_modify_actions(struct rule *rule_)
 {
     struct rule_dpif *rule = rule_dpif_cast(rule_);
     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
-    int error;
+    enum ofperr error;
 
     error = validate_actions(rule->up.actions, rule->up.n_actions,
                              &rule->up.cr.flow, ofproto->max_ports);
@@ -4293,7 +4438,8 @@ flood_packets(struct action_xlate_ctx *ctx, bool all)
 }
 
 static void
-execute_controller_action(struct action_xlate_ctx *ctx, int len)
+execute_controller_action(struct action_xlate_ctx *ctx, int len,
+                          enum ofp_packet_in_reason reason)
 {
     struct ofputil_packet_in pin;
     struct ofpbuf *packet;
@@ -4338,7 +4484,7 @@ execute_controller_action(struct action_xlate_ctx *ctx, int len)
 
     pin.packet = packet->data;
     pin.packet_len = packet->size;
-    pin.reason = OFPR_ACTION;
+    pin.reason = reason;
     pin.table_id = ctx->table_id;
     pin.cookie = ctx->cookie;
 
@@ -4351,6 +4497,25 @@ execute_controller_action(struct action_xlate_ctx *ctx, int len)
     ofpbuf_delete(packet);
 }
 
+static bool
+compose_dec_ttl(struct action_xlate_ctx *ctx)
+{
+    if (ctx->flow.dl_type != htons(ETH_TYPE_IP) &&
+        ctx->flow.dl_type != htons(ETH_TYPE_IPV6)) {
+        return false;
+    }
+
+    if (ctx->flow.nw_ttl > 1) {
+        ctx->flow.nw_ttl--;
+        return false;
+    } else {
+        execute_controller_action(ctx, UINT16_MAX, OFPR_INVALID_TTL);
+
+        /* Stop processing for current table. */
+        return true;
+    }
+}
+
 static void
 xlate_output_action__(struct action_xlate_ctx *ctx,
                       uint16_t port, uint16_t max_len)
@@ -4376,7 +4541,7 @@ xlate_output_action__(struct action_xlate_ctx *ctx,
         flood_packets(ctx, true);
         break;
     case OFPP_CONTROLLER:
-        execute_controller_action(ctx, max_len);
+        execute_controller_action(ctx, max_len, OFPR_ACTION);
         break;
     case OFPP_LOCAL:
         compose_output_action(ctx, OFPP_LOCAL);
@@ -4404,9 +4569,11 @@ static void
 xlate_output_reg_action(struct action_xlate_ctx *ctx,
                         const struct nx_action_output_reg *naor)
 {
+    struct mf_subfield src;
     uint64_t ofp_port;
 
-    ofp_port = nxm_read_field_bits(naor->src, naor->ofs_nbits, &ctx->flow);
+    nxm_decode(&src, naor->src, naor->ofs_nbits);
+    ofp_port = mf_get_subfield(&src, &ctx->flow);
 
     if (ofp_port <= UINT16_MAX) {
         xlate_output_action__(ctx, ofp_port, ntohs(naor->max_len));
@@ -4535,9 +4702,8 @@ xlate_learn_action(struct action_xlate_ctx *ctx,
 
     error = ofproto_flow_mod(&ctx->ofproto->up, &fm);
     if (error && !VLOG_DROP_WARN(&rl)) {
-        char *msg = ofputil_error_to_string(error);
-        VLOG_WARN("learning action failed to modify flow table (%s)", msg);
-        free(msg);
+        VLOG_WARN("learning action failed to modify flow table (%s)",
+                  ofperr_get_name(error));
     }
 
     free(fm.actions);
@@ -4634,8 +4800,11 @@ do_xlate_actions(const union ofp_action *in, size_t n_in,
             break;
 
         case OFPUTIL_OFPAT_SET_NW_TOS:
-            ctx->flow.nw_tos &= ~IP_DSCP_MASK;
-            ctx->flow.nw_tos |= ia->nw_tos.nw_tos & IP_DSCP_MASK;
+            /* OpenFlow 1.0 only supports IPv4. */
+            if (ctx->flow.dl_type == htons(ETH_TYPE_IP)) {
+                ctx->flow.nw_tos &= ~IP_DSCP_MASK;
+                ctx->flow.nw_tos |= ia->nw_tos.nw_tos & IP_DSCP_MASK;
+            }
             break;
 
         case OFPUTIL_OFPAT_SET_TP_SRC:
@@ -4730,12 +4899,19 @@ do_xlate_actions(const union ofp_action *in, size_t n_in,
             }
             break;
 
+        case OFPUTIL_NXAST_DEC_TTL:
+            if (compose_dec_ttl(ctx)) {
+                goto out;
+            }
+            break;
+
         case OFPUTIL_NXAST_EXIT:
             ctx->exit = true;
             break;
         }
     }
 
+out:
     /* We've let OFPP_NORMAL and the learning action look at the packet,
      * so drop it now if forwarding is disabled. */
     if (port && !stp_forward_in_state(port->stp_state)) {
@@ -4799,6 +4975,9 @@ xlate_actions(struct action_xlate_ctx *ctx,
         case OFPC_FRAG_NX_MATCH:
             /* Nothing to do. */
             break;
+
+        case OFPC_INVALID_TTL_TO_CONTROLLER:
+            NOT_REACHED();
         }
     }
 
@@ -5439,13 +5618,13 @@ static void
 table_update_taggable(struct ofproto_dpif *ofproto, uint8_t table_id)
 {
     struct table_dpif *table = &ofproto->tables[table_id];
-    const struct classifier *cls = &ofproto->up.tables[table_id];
+    const struct oftable *oftable = &ofproto->up.tables[table_id];
     struct cls_table *catchall, *other;
     struct cls_table *t;
 
     catchall = other = NULL;
 
-    switch (hmap_count(&cls->tables)) {
+    switch (hmap_count(&oftable->cls.tables)) {
     case 0:
         /* We could tag this OpenFlow table but it would make the logic a
          * little harder and it's a corner case that doesn't seem worth it
@@ -5454,7 +5633,7 @@ table_update_taggable(struct ofproto_dpif *ofproto, uint8_t table_id)
 
     case 1:
     case 2:
-        HMAP_FOR_EACH (t, hmap_node, &cls->tables) {
+        HMAP_FOR_EACH (t, hmap_node, &oftable->cls.tables) {
             if (cls_table_is_catchall(t)) {
                 catchall = t;
             } else if (!other) {
@@ -5518,16 +5697,16 @@ set_frag_handling(struct ofproto *ofproto_,
     }
 }
 
-static int
+static enum ofperr
 packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
            const struct flow *flow,
            const union ofp_action *ofp_actions, size_t n_ofp_actions)
 {
     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
-    int error;
+    enum ofperr error;
 
     if (flow->in_port >= ofproto->max_ports && flow->in_port < OFPP_MAX) {
-        return ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_IN_PORT);
+        return OFPERR_NXBRC_BAD_IN_PORT;
     }
 
     error = validate_actions(ofp_actions, n_ofp_actions, flow,
@@ -5600,9 +5779,9 @@ send_active_timeout(struct ofproto_dpif *ofproto, struct facet *facet)
             if (subfacet->installed) {
                 struct dpif_flow_stats stats;
 
-                subfacet_install(ofproto, subfacet, subfacet->actions,
+                subfacet_install(subfacet, subfacet->actions,
                                  subfacet->actions_len, &stats);
-                subfacet_update_stats(ofproto, subfacet, &stats);
+                subfacet_update_stats(subfacet, &stats);
             }
         }
 
@@ -5639,17 +5818,23 @@ ofproto_dpif_lookup(const char *name)
 }
 
 static void
-ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc OVS_UNUSED,
+ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
                           const char *argv[], void *aux OVS_UNUSED)
 {
-    const struct ofproto_dpif *ofproto;
+    struct ofproto_dpif *ofproto;
 
-    ofproto = ofproto_dpif_lookup(argv[1]);
-    if (!ofproto) {
-        unixctl_command_reply(conn, 501, "no such bridge");
-        return;
+    if (argc > 1) {
+        ofproto = ofproto_dpif_lookup(argv[1]);
+        if (!ofproto) {
+            unixctl_command_reply(conn, 501, "no such bridge");
+            return;
+        }
+        mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
+    } else {
+        HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
+            mac_learning_flush(ofproto->ml, &ofproto->revalidate_set);
+        }
     }
-    mac_learning_flush(ofproto->ml);
 
     unixctl_command_reply(conn, 200, "table successfully flushed");
 }
@@ -5886,6 +6071,57 @@ ofproto_dpif_unclog(struct unixctl_conn *conn OVS_UNUSED, int argc OVS_UNUSED,
     unixctl_command_reply(conn, 200, NULL);
 }
 
+/* Runs a self-check of flow translations in 'ofproto'.  Appends a message to
+ * 'reply' describing the results. */
+static void
+ofproto_dpif_self_check__(struct ofproto_dpif *ofproto, struct ds *reply)
+{
+    struct facet *facet;
+    int errors;
+
+    errors = 0;
+    HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
+        if (!facet_check_consistency(facet)) {
+            errors++;
+        }
+    }
+    if (errors) {
+        ofproto->need_revalidate = true;
+    }
+
+    if (errors) {
+        ds_put_format(reply, "%s: self-check failed (%d errors)\n",
+                      ofproto->up.name, errors);
+    } else {
+        ds_put_format(reply, "%s: self-check passed\n", ofproto->up.name);
+    }
+}
+
+static void
+ofproto_dpif_self_check(struct unixctl_conn *conn,
+                        int argc, const char *argv[], void *aux OVS_UNUSED)
+{
+    struct ds reply = DS_EMPTY_INITIALIZER;
+    struct ofproto_dpif *ofproto;
+
+    if (argc > 1) {
+        ofproto = ofproto_dpif_lookup(argv[1]);
+        if (!ofproto) {
+            unixctl_command_reply(conn, 501, "Unknown ofproto (use "
+                                  "ofproto/list for help)");
+            return;
+        }
+        ofproto_dpif_self_check__(ofproto, &reply);
+    } else {
+        HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
+            ofproto_dpif_self_check__(ofproto, &reply);
+        }
+    }
+
+    unixctl_command_reply(conn, 200, ds_cstr(&reply));
+    ds_destroy(&reply);
+}
+
 static void
 ofproto_dpif_unixctl_init(void)
 {
@@ -5898,8 +6134,8 @@ ofproto_dpif_unixctl_init(void)
     unixctl_command_register(
         "ofproto/trace",
         "bridge {tun_id in_port packet | odp_flow [-generate]}",
-        2, 4, ofproto_unixctl_trace, NULL);
-    unixctl_command_register("fdb/flush", "bridge", 1, 1,
+        2, 5, ofproto_unixctl_trace, NULL);
+    unixctl_command_register("fdb/flush", "[bridge]", 0, 1,
                              ofproto_unixctl_fdb_flush, NULL);
     unixctl_command_register("fdb/show", "bridge", 1, 1,
                              ofproto_unixctl_fdb_show, NULL);
@@ -5907,6 +6143,8 @@ ofproto_dpif_unixctl_init(void)
                              ofproto_dpif_clog, NULL);
     unixctl_command_register("ofproto/unclog", "", 0, 0,
                              ofproto_dpif_unclog, NULL);
+    unixctl_command_register("ofproto/self-check", "[bridge]", 0, 1,
+                             ofproto_dpif_self_check, NULL);
 }
 
 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)