[ovs-dev] [PATCH v2 3/3] Clean up table lookup code.

Jarno Rajahalme jrajahalme at nicira.com
Wed Oct 8 22:53:04 UTC 2014


Keep knowledge about ofproto-dpif internal rules within ofproto-dpif.
This removes duplication of code (accross multiple files), and allows
making the ofproto-dpif-xlate interface a bit smaller.

'may_packet_in' was previously not honored for the
'LOOKUP_VERDICT_DEFAULT' case.  Now it is, but this change did not
break any unit tests.

Also, previously in the 'LOOKUP_VERDICT_CONTROLLER' case packet-in
messages would have been generated when the in_port could not be found
('config' was set to zero in this case, causing 'OFPUTIL_PC_NO_PACKET_IN'
flag to be zero as well).  This patch changes this behavior and never
issues packet-in messages when the in_port cannot be found.  This did
not break any unit tests either.

Signed-off-by: Jarno Rajahalme <jrajahalme at nicira.com>
---
 ofproto/ofproto-dpif-xlate.c |   80 +++------------
 ofproto/ofproto-dpif-xlate.h |    4 +-
 ofproto/ofproto-dpif.c       |  227 +++++++++++++++++-------------------------
 ofproto/ofproto-dpif.h       |   43 +++-----
 4 files changed, 122 insertions(+), 232 deletions(-)

diff --git a/ofproto/ofproto-dpif-xlate.c b/ofproto/ofproto-dpif-xlate.c
index c8227f9..ab68ceb 100644
--- a/ofproto/ofproto-dpif-xlate.c
+++ b/ofproto/ofproto-dpif-xlate.c
@@ -89,10 +89,6 @@ struct xbridge {
     struct stp *stp;              /* STP or null if disabled. */
     struct rstp *rstp;            /* RSTP or null if disabled. */
 
-    /* Special rules installed by ofproto-dpif. */
-    struct rule_dpif *miss_rule;
-    struct rule_dpif *no_packet_in_rule;
-
     bool has_in_band;             /* Bridge has in band control? */
     bool forward_bpdu;            /* Bridge forwards STP BPDUs? */
 
@@ -361,8 +357,6 @@ static void xlate_xbridge_init(struct xlate_cfg *, struct xbridge *);
 static void xlate_xbundle_init(struct xlate_cfg *, struct xbundle *);
 static void xlate_xport_init(struct xlate_cfg *, struct xport *);
 static void xlate_xbridge_set(struct xbridge *, struct dpif *,
-                              struct rule_dpif *miss_rule,
-                              struct rule_dpif *no_packet_in_rule,
                               const struct mac_learning *, struct stp *,
                               struct rstp *, const struct mcast_snooping *,
                               const struct mbridge *,
@@ -427,8 +421,6 @@ xlate_xport_init(struct xlate_cfg *xcfg, struct xport *xport)
 static void
 xlate_xbridge_set(struct xbridge *xbridge,
                   struct dpif *dpif,
-                  struct rule_dpif *miss_rule,
-                  struct rule_dpif *no_packet_in_rule,
                   const struct mac_learning *ml, struct stp *stp,
                   struct rstp *rstp, const struct mcast_snooping *ms,
                   const struct mbridge *mbridge,
@@ -484,8 +476,6 @@ xlate_xbridge_set(struct xbridge *xbridge,
     xbridge->dpif = dpif;
     xbridge->forward_bpdu = forward_bpdu;
     xbridge->has_in_band = has_in_band;
-    xbridge->miss_rule = miss_rule;
-    xbridge->no_packet_in_rule = no_packet_in_rule;
     xbridge->enable_recirc = enable_recirc;
     xbridge->variable_length_userdata = variable_length_userdata;
     xbridge->max_mpls_depth = max_mpls_depth;
@@ -565,8 +555,7 @@ xlate_xbridge_copy(struct xbridge *xbridge)
     xlate_xbridge_init(new_xcfg, new_xbridge);
 
     xlate_xbridge_set(new_xbridge,
-                      xbridge->dpif, xbridge->miss_rule,
-                      xbridge->no_packet_in_rule, xbridge->ml, xbridge->stp,
+                      xbridge->dpif, xbridge->ml, xbridge->stp,
                       xbridge->rstp, xbridge->ms, xbridge->mbridge,
                       xbridge->sflow, xbridge->ipfix, xbridge->netflow,
                       xbridge->forward_bpdu,
@@ -716,8 +705,7 @@ xlate_xcfg_free(struct xlate_cfg *xcfg)
 
 void
 xlate_ofproto_set(struct ofproto_dpif *ofproto, const char *name,
-                  struct dpif *dpif, struct rule_dpif *miss_rule,
-                  struct rule_dpif *no_packet_in_rule,
+                  struct dpif *dpif,
                   const struct mac_learning *ml, struct stp *stp,
                   struct rstp *rstp, const struct mcast_snooping *ms,
                   const struct mbridge *mbridge,
@@ -743,9 +731,8 @@ xlate_ofproto_set(struct ofproto_dpif *ofproto, const char *name,
     free(xbridge->name);
     xbridge->name = xstrdup(name);
 
-    xlate_xbridge_set(xbridge, dpif, miss_rule, no_packet_in_rule, ml, stp,
-                      rstp, ms, mbridge, sflow, ipfix, netflow,
-                      forward_bpdu, has_in_band, enable_recirc,
+    xlate_xbridge_set(xbridge, dpif, ml, stp, rstp, ms, mbridge, sflow, ipfix,
+                      netflow, forward_bpdu, has_in_band, enable_recirc,
                       variable_length_userdata, max_mpls_depth,
                       masked_set_action);
 }
@@ -2719,63 +2706,22 @@ xlate_table_action(struct xlate_ctx *ctx, ofp_port_t in_port, uint8_t table_id,
                    bool may_packet_in, bool honor_table_miss)
 {
     if (xlate_resubmit_resource_check(ctx)) {
-        ofp_port_t old_in_port = ctx->xin->flow.in_port.ofp_port;
         bool skip_wildcards = ctx->xin->skip_wildcards;
         uint8_t old_table_id = ctx->table_id;
         struct rule_dpif *rule;
-        enum rule_dpif_lookup_verdict verdict;
-        enum ofputil_port_config config = 0;
 
         ctx->table_id = table_id;
 
-        /* Look up a flow with 'in_port' as the input port.  Then restore the
-         * original input port (otherwise OFPP_NORMAL and OFPP_IN_PORT will
-         * have surprising behavior). */
-        ctx->xin->flow.in_port.ofp_port = in_port;
-        verdict = rule_dpif_lookup_from_table(ctx->xbridge->ofproto,
-                                              &ctx->xin->flow,
-                                              !skip_wildcards
-                                              ? &ctx->xout->wc : NULL,
-                                              honor_table_miss,
-                                              &ctx->table_id, &rule,
-                                              ctx->xin->xcache != NULL,
-                                              ctx->xin->resubmit_stats);
-        ctx->xin->flow.in_port.ofp_port = old_in_port;
+        rule = rule_dpif_lookup_from_table(
+            ctx->xbridge->ofproto, &ctx->xin->flow,
+            skip_wildcards ? NULL : &ctx->xout->wc,
+            ctx->xin->xcache != NULL, ctx->xin->resubmit_stats,
+            &ctx->table_id, in_port, may_packet_in, honor_table_miss);
 
         if (ctx->xin->resubmit_hook) {
             ctx->xin->resubmit_hook(ctx->xin, rule, ctx->recurse);
         }
 
-        switch (verdict) {
-        case RULE_DPIF_LOOKUP_VERDICT_MATCH:
-           goto match;
-        case RULE_DPIF_LOOKUP_VERDICT_CONTROLLER:
-            if (may_packet_in) {
-                struct xport *xport;
-
-                xport = get_ofp_port(ctx->xbridge,
-                                     ctx->xin->flow.in_port.ofp_port);
-                config = xport ? xport->config : 0;
-                break;
-            }
-            /* Fall through to drop */
-        case RULE_DPIF_LOOKUP_VERDICT_DROP:
-            config = OFPUTIL_PC_NO_PACKET_IN;
-            break;
-        case RULE_DPIF_LOOKUP_VERDICT_DEFAULT:
-            if (!ofproto_dpif_wants_packet_in_on_miss(ctx->xbridge->ofproto)) {
-                config = OFPUTIL_PC_NO_PACKET_IN;
-            }
-            break;
-        default:
-            OVS_NOT_REACHED();
-        }
-
-        choose_miss_rule(config, ctx->xbridge->miss_rule,
-                         ctx->xbridge->no_packet_in_rule, &rule,
-                         ctx->xin->xcache != NULL);
-
-match:
         if (rule) {
             /* Fill in the cache entry here instead of xlate_recursively
              * to make the reference counting more explicit.  We take a
@@ -4222,10 +4168,10 @@ xlate_actions(struct xlate_in *xin, struct xlate_out *xout)
     ctx.was_mpls = false;
 
     if (!xin->ofpacts && !ctx.rule) {
-        ctx.table_id = rule_dpif_lookup(ctx.xbridge->ofproto, flow,
-                                        !xin->skip_wildcards ? wc : NULL,
-                                        &rule, ctx.xin->xcache != NULL,
-                                        ctx.xin->resubmit_stats);
+        rule = rule_dpif_lookup(ctx.xbridge->ofproto, flow,
+                                xin->skip_wildcards ? NULL : wc,
+                                ctx.xin->xcache != NULL,
+                                ctx.xin->resubmit_stats, &ctx.table_id);
         /* These may have been cleared due to frags handling. */
         if (!(flow->tp_src | flow->tp_dst)) {
             ctx.base_flow.tp_src = flow->tp_src;
diff --git a/ofproto/ofproto-dpif-xlate.h b/ofproto/ofproto-dpif-xlate.h
index 2ec1604..9a03782 100644
--- a/ofproto/ofproto-dpif-xlate.h
+++ b/ofproto/ofproto-dpif-xlate.h
@@ -143,9 +143,7 @@ struct xlate_in {
     struct ofpbuf *odp_actions;
 };
 
-void xlate_ofproto_set(struct ofproto_dpif *, const char *name,
-                       struct dpif *, struct rule_dpif *miss_rule,
-                       struct rule_dpif *no_packet_in_rule,
+void xlate_ofproto_set(struct ofproto_dpif *, const char *name, struct dpif *,
                        const struct mac_learning *, struct stp *,
                        struct rstp *, const struct mcast_snooping *,
                        const struct mbridge *, const struct dpif_sflow *,
diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
index 023bcef..6ca3be4 100644
--- a/ofproto/ofproto-dpif.c
+++ b/ofproto/ofproto-dpif.c
@@ -614,8 +614,7 @@ type_run(const char *type)
 
             xlate_txn_start();
             xlate_ofproto_set(ofproto, ofproto->up.name,
-                              ofproto->backer->dpif, ofproto->miss_rule,
-                              ofproto->no_packet_in_rule, ofproto->ml,
+                              ofproto->backer->dpif, ofproto->ml,
                               ofproto->stp, ofproto->rstp, ofproto->ms,
                               ofproto->mbridge, ofproto->sflow, ofproto->ipfix,
                               ofproto->netflow,
@@ -3566,29 +3565,28 @@ rule_set_recirc_id(struct rule *rule_, uint32_t id)
     ovs_mutex_unlock(&rule->up.mutex);
 }
 
-/* Lookup 'flow' in table 0 of 'ofproto''s classifier.
- * If 'wc' is non-null, sets the fields that were relevant as part of
- * the lookup. Returns the table_id where a match or miss occurred.
- *
- * The return value will be zero unless there was a miss and
- * OFPTC11_TABLE_MISS_CONTINUE is in effect for the sequence of tables
- * where misses occur.
+/* Lookup 'flow' in table 0 of 'ofproto''s classifier.  If 'wc' is non-null,
+ * sets the fields that were relevant as part of the lookup. Returns the table
+ * id where a match or miss occurred via 'table_id'.  This will be zero unless
+ * there was a miss and OFPTC11_TABLE_MISS_CONTINUE is in effect for the
+ * sequence of tables where misses occur, or TBL_INTERNAL if the rule has a
+ * non-zero recirculation ID, and a match was found in the internal table, or
+ * if there was no match and one of the special rules (drop_frags_rule,
+ * miss_rule, or no_packet_in_rule) was returned.
  *
  * 'flow->tp_src' and 'flow->tp_dst' may be modified depending on the
  * frags handling configuration for 'ofproto'.
  *
- * The rule is returned in '*rule', which is valid at least until the next
- * RCU quiescent period.  If the '*rule' needs to stay around longer,
+ * The return value is the found rule, which is valid at least until the next
+ * RCU quiescent period.  If the rule needs to stay around longer,
  * a non-zero 'take_ref' must be passed in to cause a reference to be taken
  * on it before this returns. */
-uint8_t
+struct rule_dpif *
 rule_dpif_lookup(struct ofproto_dpif *ofproto, struct flow *flow,
-                 struct flow_wildcards *wc, struct rule_dpif **rule,
-                 bool take_ref, const struct dpif_flow_stats *stats)
+                 struct flow_wildcards *wc, bool take_ref,
+                 const struct dpif_flow_stats *stats, uint8_t *table_id)
 {
-    enum rule_dpif_lookup_verdict verdict;
-    enum ofputil_port_config config = 0;
-    uint8_t table_id;
+    *table_id = 0;
 
     if (flow->nw_frag & FLOW_NW_FRAG_ANY
         && ofproto->up.frag_handling != OFPC_FRAG_NX_MATCH) {
@@ -3600,7 +3598,6 @@ rule_dpif_lookup(struct ofproto_dpif *ofproto, struct flow *flow,
         } else {
             /* Must be OFPC_FRAG_DROP (we don't have OFPC_FRAG_REASM).
              * Use the drop_frags_rule (which cannot disappear). */
-            *rule = ofproto->drop_frags_rule;
 
             /* XXX: Earlier the stats went to table 0. */
             if (stats) {
@@ -3610,69 +3607,32 @@ rule_dpif_lookup(struct ofproto_dpif *ofproto, struct flow *flow,
                 atomic_add_relaxed(&tbl->n_matched, stats->n_packets, &orig);
             }
             if (take_ref) {
-                rule_dpif_ref(*rule);
+                rule_dpif_ref(ofproto->drop_frags_rule);
             }
-            return TBL_INTERNAL;
+            *table_id = TBL_INTERNAL;
+            return ofproto->drop_frags_rule;
         }
     }
 
     if (ofproto_dpif_get_enable_recirc(ofproto)) {
-        /* Always exactly match recirc_id since datapath supports
-         * recirculation.  */
         if (wc) {
             wc->masks.recirc_id = UINT32_MAX;
         }
-
-        /* Start looking up from internal table for post recirculation flows
-         * or packets. We can also simply send all, including normal flows
-         * or packets to the internal table. They will not match any post
-         * recirculation rules except the 'catch all' rule that resubmit
-         * them to table 0.
-         *
-         * As an optimization, we send normal flows and packets to table 0
-         * directly, saving one table lookup.  */
-        table_id = flow->recirc_id ? TBL_INTERNAL : 0;
-    } else {
-        table_id = 0;
-    }
-
-    verdict = rule_dpif_lookup_from_table(ofproto, flow, wc, true,
-                                          &table_id, rule, take_ref, stats);
-
-    switch (verdict) {
-    case RULE_DPIF_LOOKUP_VERDICT_MATCH:
-        return table_id;
-    case RULE_DPIF_LOOKUP_VERDICT_CONTROLLER: {
-        struct ofport_dpif *port;
-
-        port = get_ofp_port(ofproto, flow->in_port.ofp_port);
-        if (!port) {
-            VLOG_WARN_RL(&rl, "packet-in on unknown OpenFlow port %"PRIu16,
-                         flow->in_port.ofp_port);
+        if (flow->recirc_id) {
+            /* Start looking up from internal table for post recirculation
+             * flows or packets. */
+            *table_id = TBL_INTERNAL;
         }
-        config = port ? port->up.pp.config : 0;
-        break;
-    }
-    case RULE_DPIF_LOOKUP_VERDICT_DROP:
-        config = OFPUTIL_PC_NO_PACKET_IN;
-        break;
-    case RULE_DPIF_LOOKUP_VERDICT_DEFAULT:
-        if (!connmgr_wants_packet_in_on_miss(ofproto->up.connmgr)) {
-            config = OFPUTIL_PC_NO_PACKET_IN;
-        }
-        break;
-    default:
-        OVS_NOT_REACHED();
     }
 
-    choose_miss_rule(config, ofproto->miss_rule,
-                     ofproto->no_packet_in_rule, rule, take_ref);
-    return table_id;
+    return rule_dpif_lookup_from_table(ofproto, flow, wc, take_ref, stats,
+                                       table_id, flow->in_port.ofp_port, true,
+                                       true);
 }
 
-/* The returned rule is valid at least until the next RCU quiescent period.
- * If the '*rule' needs to stay around longer, a non-zero 'take_ref' must be
- * passed in to cause a reference to be taken on it before this returns. */
+/* The returned rule (if any) is valid at least until the next RCU quiescent
+ * period.  If the rule needs to stay around longer, a non-zero 'take_ref'
+ * must be passed in to cause a reference to be taken on it. */
 static struct rule_dpif *
 rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, uint8_t table_id,
                           const struct flow *flow, struct flow_wildcards *wc,
@@ -3694,7 +3654,9 @@ rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, uint8_t table_id,
 }
 
 /* Look up 'flow' in 'ofproto''s classifier starting from table '*table_id'.
- * Stores the rule that was found in '*rule', or NULL if none was found.
+ * Returns the rule that was found, which may be one of the special rules
+ * according to packet miss hadling.  If 'may_packet_in' is false, returning of
+ * the miss_rule (which issues packet ins for the controller) is avoided.
  * Updates 'wc', if nonnull, to reflect the fields that were used during the
  * lookup.
  *
@@ -3707,35 +3669,33 @@ rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, uint8_t table_id,
  * If 'honor_table_miss' is false, then only one table lookup occurs, in
  * '*table_id'.
  *
- * Returns:
- *
- *    - RULE_DPIF_LOOKUP_VERDICT_MATCH if a rule (in '*rule') was found.
- *
- *    - RULE_OFPTC_TABLE_MISS_CONTROLLER if no rule was found and either:
- *      + 'honor_table_miss' is false
- *      + a table miss configuration specified that the packet should be
- *        sent to the controller in this case.
- *
- *    - RULE_DPIF_LOOKUP_VERDICT_DROP if no rule was found, 'honor_table_miss'
- *      is true and a table miss configuration specified that the packet
- *      should be dropped in this case.
- *
- *    - RULE_DPIF_LOOKUP_VERDICT_DEFAULT if no rule was found,
- *      'honor_table_miss' is true and a table miss configuration has
- *      not been specified in this case.
- *
  * The rule is returned in '*rule', which is valid at least until the next
  * RCU quiescent period.  If the '*rule' needs to stay around longer,
  * a non-zero 'take_ref' must be passed in to cause a reference to be taken
- * on it before this returns. */
-enum rule_dpif_lookup_verdict
-rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto,
-                            const struct flow *flow,
-                            struct flow_wildcards *wc,
-                            bool honor_table_miss,
-                            uint8_t *table_id, struct rule_dpif **rule,
-                            bool take_ref, const struct dpif_flow_stats *stats)
-{
+ * on it before this returns.
+ *
+ * 'in_port' allows the lookup to take place as if the in port had the value
+ * 'in_port'.  This is needed for resubmit action support. */
+struct rule_dpif *
+rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, struct flow *flow,
+                            struct flow_wildcards *wc, bool take_ref,
+                            const struct dpif_flow_stats *stats,
+                            uint8_t *table_id, ofp_port_t in_port,
+                            bool may_packet_in, bool honor_table_miss)
+{
+    ofp_port_t old_in_port = flow->in_port.ofp_port;
+    enum ofputil_table_miss miss_config = OFPUTIL_TABLE_MISS_CONTINUE;
+    struct rule_dpif *rule;
+
+    /* Look up a flow with 'in_port' as the input port.  Then restore the
+     * original input port (otherwise OFPP_NORMAL and OFPP_IN_PORT will
+     * have surprising behavior). */
+    flow->in_port.ofp_port = in_port;
+
+    /* Our current implementation depends on n_tables == N_TABLES, and
+     * TBL_INTERNAL being the last table. */
+    BUILD_ASSERT_DECL(N_TABLES == TBL_INTERNAL + 1);
+
     uint8_t next_id;
 
     for (next_id = *table_id;
@@ -3743,56 +3703,55 @@ rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto,
          next_id++, next_id += (next_id == TBL_INTERNAL))
     {
         *table_id = next_id;
-        *rule = rule_dpif_lookup_in_table(ofproto, *table_id, flow, wc,
-                                          take_ref);
+        rule = rule_dpif_lookup_in_table(ofproto, next_id, flow, wc, take_ref);
         if (stats) {
             struct oftable *tbl = &ofproto->up.tables[next_id];
             unsigned long orig;
 
-            atomic_add_relaxed(*rule ? &tbl->n_matched : &tbl->n_missed,
+            atomic_add_relaxed(rule ? &tbl->n_matched : &tbl->n_missed,
                                stats->n_packets, &orig);
         }
-        if (*rule) {
-            return RULE_DPIF_LOOKUP_VERDICT_MATCH;
-        } else if (!honor_table_miss) {
-            return RULE_DPIF_LOOKUP_VERDICT_CONTROLLER;
+        if (rule) {
+            goto out;   /* Match. */
+        }
+        if (!honor_table_miss) {
+            miss_config = OFPUTIL_TABLE_MISS_CONTROLLER;
+            break;
         } else {
-            switch (ofproto_table_get_miss_config(&ofproto->up, *table_id)) {
-            case OFPUTIL_TABLE_MISS_CONTINUE:
+            miss_config = ofproto_table_get_miss_config(&ofproto->up,
+                                                        *table_id);
+            if (miss_config != OFPUTIL_TABLE_MISS_CONTINUE) {
                 break;
-
-            case OFPUTIL_TABLE_MISS_CONTROLLER:
-                return RULE_DPIF_LOOKUP_VERDICT_CONTROLLER;
-
-            case OFPUTIL_TABLE_MISS_DROP:
-                return RULE_DPIF_LOOKUP_VERDICT_DROP;
-
-            case OFPUTIL_TABLE_MISS_DEFAULT:
-                return RULE_DPIF_LOOKUP_VERDICT_DEFAULT;
             }
         }
     }
-
-    return RULE_DPIF_LOOKUP_VERDICT_CONTROLLER;
-}
-
-/* Given a port configuration (specified as zero if there's no port), chooses
- * which of 'miss_rule' and 'no_packet_in_rule' should be used in case of a
- * flow table miss.
- *
- * The rule is returned in '*rule', which is valid at least until the next
- * RCU quiescent period.  If the '*rule' needs to stay around longer,
- * a reference must be taken on it (rule_dpif_ref()).
- */
-void
-choose_miss_rule(enum ofputil_port_config config, struct rule_dpif *miss_rule,
-                 struct rule_dpif *no_packet_in_rule, struct rule_dpif **rule,
-                 bool take_ref)
-{
-    *rule = config & OFPUTIL_PC_NO_PACKET_IN ? no_packet_in_rule : miss_rule;
+    /* Miss. */
+    rule = ofproto->no_packet_in_rule;
+    if (may_packet_in) {
+        if (miss_config == OFPUTIL_TABLE_MISS_CONTROLLER
+            || miss_config == OFPUTIL_TABLE_MISS_CONTINUE) {
+            struct ofport_dpif *port;
+
+            port = get_ofp_port(ofproto, old_in_port);
+            if (!port) {
+                VLOG_WARN_RL(&rl, "packet-in on unknown OpenFlow port %"PRIu16,
+                             old_in_port);
+            } else if (!(port->up.pp.config & OFPUTIL_PC_NO_PACKET_IN)) {
+                rule = ofproto->miss_rule;
+            }
+        } else if (miss_config == OFPUTIL_TABLE_MISS_DEFAULT &&
+                   connmgr_wants_packet_in_on_miss(ofproto->up.connmgr)) {
+            rule = ofproto->miss_rule;
+        }
+    }
     if (take_ref) {
-        rule_dpif_ref(*rule);
+        rule_dpif_ref(rule);
     }
+out:
+    /* Restore the old in port. */
+    flow->in_port.ofp_port = old_in_port;
+
+    return rule;
 }
 
 static void
@@ -4713,10 +4672,12 @@ ofproto_trace(struct ofproto_dpif *ofproto, struct flow *flow,
     if (ofpacts) {
         rule = NULL;
     } else {
+        uint8_t table_id;
         ovs_be16 tp_src = flow->tp_src;
         ovs_be16 tp_dst = flow->tp_dst;
 
-        rule_dpif_lookup(ofproto, flow, &trace.wc, &rule, false, NULL);
+        rule = rule_dpif_lookup(ofproto, flow, &trace.wc, false, NULL,
+                                &table_id);
         /* Restore ports in case they were modified by rule_dpif_lookup(). */
         flow->tp_src = tp_src;
         flow->tp_dst = tp_dst;
diff --git a/ofproto/ofproto-dpif.h b/ofproto/ofproto-dpif.h
index a8c5d48..77ae8f0 100644
--- a/ofproto/ofproto-dpif.h
+++ b/ofproto/ofproto-dpif.h
@@ -40,23 +40,6 @@ struct dpif_backer;
 struct OVS_LOCKABLE rule_dpif;
 struct OVS_LOCKABLE group_dpif;
 
-enum rule_dpif_lookup_verdict {
-    RULE_DPIF_LOOKUP_VERDICT_MATCH,         /* A match occurred. */
-    RULE_DPIF_LOOKUP_VERDICT_CONTROLLER,    /* A miss occurred and the packet
-                                             * should be passed to
-                                             * the controller. */
-    RULE_DPIF_LOOKUP_VERDICT_DROP,          /* A miss occurred and the packet
-                                             * should be dropped. */
-    RULE_DPIF_LOOKUP_VERDICT_DEFAULT,       /* A miss occurred and the packet
-                                             * should handled by the default
-                                             * miss behaviour.
-                                             * For pre-OF1.3 it should be
-                                             * forwarded to the controller.
-                                             * For OF1.3+ it should be
-                                             * dropped. */
-};
-
-
 /* Ofproto-dpif -- DPIF based ofproto implementation.
  *
  * Ofproto-dpif provides an ofproto implementation for those platforms which
@@ -88,18 +71,20 @@ enum rule_dpif_lookup_verdict {
 size_t ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *);
 bool ofproto_dpif_get_enable_recirc(const struct ofproto_dpif *);
 
-uint8_t rule_dpif_lookup(struct ofproto_dpif *, struct flow *,
-                         struct flow_wildcards *, struct rule_dpif **rule,
-                         bool take_ref, const struct dpif_flow_stats *);
-
-enum rule_dpif_lookup_verdict rule_dpif_lookup_from_table(struct ofproto_dpif *,
-                                                          const struct flow *,
-                                                          struct flow_wildcards *,
-                                                          bool force_controller_on_miss,
-                                                          uint8_t *table_id,
-                                                          struct rule_dpif **rule, 
-                                                          bool take_ref,
-                                                          const struct dpif_flow_stats *);
+struct rule_dpif *rule_dpif_lookup(struct ofproto_dpif *, struct flow *,
+                                   struct flow_wildcards *, bool take_ref,
+                                   const struct dpif_flow_stats *,
+                                   uint8_t *table_id);
+
+struct rule_dpif *rule_dpif_lookup_from_table(struct ofproto_dpif *,
+                                              struct flow *,
+                                              struct flow_wildcards *,
+                                              bool take_ref,
+                                              const struct dpif_flow_stats *,
+                                              uint8_t *table_id,
+                                              ofp_port_t in_port,
+                                              bool may_packet_in,
+                                              bool honor_table_miss);
 
 static inline void rule_dpif_ref(struct rule_dpif *);
 static inline void rule_dpif_unref(struct rule_dpif *);
-- 
1.7.10.4




More information about the dev mailing list