[ovs-dev] [PATCH v3 07/13] ofproto-dpif-xlate: Expose xlate cache.

Jarno Rajahalme jarno at ovn.org
Mon Sep 12 20:52:37 UTC 2016


Later patches will need to create xlate cache entries from different
modules.  This patch refactors the xlate cache code in preparation
without any functional changes, so that the changes are clearly
visible in the following patches.

The definition of XC_ENTRY_FOR_EACH() iterator macro is changed so
that it now does not take the xlate cache pointer to unify the usage
accross all call sites.

Signed-off-by: Jarno Rajahalme <jarno at ovn.org>
---
v3: Separated xlate cache to it's own module.

 ofproto/automake.mk                |   2 +
 ofproto/ofproto-dpif-upcall.c      |   1 +
 ofproto/ofproto-dpif-xlate-cache.c | 239 +++++++++++++++++++++++++++++++++
 ofproto/ofproto-dpif-xlate-cache.h | 132 +++++++++++++++++++
 ofproto/ofproto-dpif-xlate.c       | 262 +------------------------------------
 ofproto/ofproto-dpif-xlate.h       |   7 +-
 6 files changed, 379 insertions(+), 264 deletions(-)
 create mode 100644 ofproto/ofproto-dpif-xlate-cache.c
 create mode 100644 ofproto/ofproto-dpif-xlate-cache.h

diff --git a/ofproto/automake.mk b/ofproto/automake.mk
index 7486f2b..5a83a60 100644
--- a/ofproto/automake.mk
+++ b/ofproto/automake.mk
@@ -43,6 +43,8 @@ ofproto_libofproto_la_SOURCES = \
 	ofproto/ofproto-dpif-xlate.c \
 	ofproto/ofproto-dpif-xlate.h \
 	ofproto/ofproto-provider.h \
+	ofproto/ofproto-dpif-xlate-cache.c \
+	ofproto/ofproto-dpif-xlate-cache.h \
 	ofproto/pinsched.c \
 	ofproto/pinsched.h \
 	ofproto/tunnel.c \
diff --git a/ofproto/ofproto-dpif-upcall.c b/ofproto/ofproto-dpif-upcall.c
index 565de5b..3080919 100644
--- a/ofproto/ofproto-dpif-upcall.c
+++ b/ofproto/ofproto-dpif-upcall.c
@@ -33,6 +33,7 @@
 #include "ofproto-dpif-ipfix.h"
 #include "ofproto-dpif-sflow.h"
 #include "ofproto-dpif-xlate.h"
+#include "ofproto-dpif-xlate-cache.h"
 #include "ovs-rcu.h"
 #include "packets.h"
 #include "poll-loop.h"
diff --git a/ofproto/ofproto-dpif-xlate-cache.c b/ofproto/ofproto-dpif-xlate-cache.c
new file mode 100644
index 0000000..ebcfa8a
--- /dev/null
+++ b/ofproto/ofproto-dpif-xlate-cache.c
@@ -0,0 +1,239 @@
+/* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. */
+
+#include <config.h>
+
+#include "ofproto/ofproto-dpif-xlate-cache.h"
+
+#include <errno.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "bfd.h"
+#include "bitmap.h"
+#include "bond.h"
+#include "bundle.h"
+#include "byte-order.h"
+#include "coverage.h"
+#include "dp-packet.h"
+#include "dpif.h"
+#include "learn.h"
+#include "mac-learning.h"
+#include "netdev-vport.h"
+#include "ofproto/ofproto-dpif-mirror.h"
+#include "ofproto/ofproto-dpif.h"
+#include "ofproto/ofproto-dpif-xlate.h"
+#include "ofproto/ofproto-provider.h"
+#include "openvswitch/dynamic-string.h"
+#include "openvswitch/vlog.h"
+#include "ovs-router.h"
+#include "packets.h"
+#include "tnl-neigh-cache.h"
+#include "util.h"
+
+VLOG_DEFINE_THIS_MODULE(ofproto_xlate_cache);
+
+struct xlate_cache *
+xlate_cache_new(void)
+{
+    struct xlate_cache *xcache = xmalloc(sizeof *xcache);
+
+    ofpbuf_init(&xcache->entries, 512);
+    return xcache;
+}
+
+struct xc_entry *
+xlate_cache_add_entry(struct xlate_cache *xcache, enum xc_type type)
+{
+    struct xc_entry *entry;
+
+    entry = ofpbuf_put_zeros(&xcache->entries, sizeof *entry);
+    entry->type = type;
+
+    return entry;
+}
+
+static void
+xlate_cache_netdev(struct xc_entry *entry, const struct dpif_flow_stats *stats)
+{
+    if (entry->u.dev.tx) {
+        netdev_vport_inc_tx(entry->u.dev.tx, stats);
+    }
+    if (entry->u.dev.rx) {
+        netdev_vport_inc_rx(entry->u.dev.rx, stats);
+    }
+    if (entry->u.dev.bfd) {
+        bfd_account_rx(entry->u.dev.bfd, stats);
+    }
+}
+
+/* Push stats and perform side effects of flow translation. */
+void
+xlate_push_stats_entry(struct xc_entry *entry,
+                       const struct dpif_flow_stats *stats)
+{
+    struct eth_addr dmac;
+
+    switch (entry->type) {
+    case XC_RULE:
+        rule_dpif_credit_stats(entry->u.rule, stats);
+        break;
+    case XC_BOND:
+        bond_account(entry->u.bond.bond, entry->u.bond.flow,
+                     entry->u.bond.vid, stats->n_bytes);
+        break;
+    case XC_NETDEV:
+        xlate_cache_netdev(entry, stats);
+        break;
+    case XC_NETFLOW:
+        netflow_flow_update(entry->u.nf.netflow, entry->u.nf.flow,
+                            entry->u.nf.iface, stats);
+        break;
+    case XC_MIRROR:
+        mirror_update_stats(entry->u.mirror.mbridge,
+                            entry->u.mirror.mirrors,
+                            stats->n_packets, stats->n_bytes);
+        break;
+    case XC_LEARN:
+        ofproto_dpif_flow_mod(entry->u.learn.ofproto, entry->u.learn.fm);
+        break;
+    case XC_NORMAL:
+        xlate_mac_learning_update(entry->u.normal.ofproto,
+                                  entry->u.normal.in_port,
+                                  entry->u.normal.dl_src,
+                                  entry->u.normal.vlan,
+                                  entry->u.normal.is_gratuitous_arp);
+        break;
+    case XC_FIN_TIMEOUT:
+        if (stats->tcp_flags & (TCP_FIN | TCP_RST)) {
+            rule_dpif_reduce_timeouts(entry->u.fin.rule, entry->u.fin.idle,
+                                      entry->u.fin.hard);
+        }
+        break;
+    case XC_GROUP:
+        group_dpif_credit_stats(entry->u.group.group, entry->u.group.bucket,
+                                stats);
+        break;
+    case XC_TNL_NEIGH:
+        /* Lookup neighbor to avoid timeout. */
+        tnl_neigh_lookup(entry->u.tnl_neigh_cache.br_name,
+                         &entry->u.tnl_neigh_cache.d_ipv6, &dmac);
+        break;
+    default:
+        OVS_NOT_REACHED();
+    }
+}
+
+void
+xlate_push_stats(struct xlate_cache *xcache,
+                 const struct dpif_flow_stats *stats)
+{
+    if (!stats->n_packets) {
+        return;
+    }
+
+    struct xc_entry *entry;
+    struct ofpbuf entries = xcache->entries;
+    XC_ENTRY_FOR_EACH (entry, &entries) {
+        xlate_push_stats_entry(entry, stats);
+    }
+}
+
+static void
+xlate_dev_unref(struct xc_entry *entry)
+{
+    if (entry->u.dev.tx) {
+        netdev_close(entry->u.dev.tx);
+    }
+    if (entry->u.dev.rx) {
+        netdev_close(entry->u.dev.rx);
+    }
+    if (entry->u.dev.bfd) {
+        bfd_unref(entry->u.dev.bfd);
+    }
+}
+
+static void
+xlate_cache_clear_netflow(struct netflow *netflow, struct flow *flow)
+{
+    netflow_flow_clear(netflow, flow);
+    netflow_unref(netflow);
+    free(flow);
+}
+
+void
+xlate_cache_clear_entry(struct xc_entry *entry)
+{
+    switch (entry->type) {
+    case XC_RULE:
+        rule_dpif_unref(entry->u.rule);
+        break;
+    case XC_BOND:
+        free(entry->u.bond.flow);
+        bond_unref(entry->u.bond.bond);
+        break;
+    case XC_NETDEV:
+        xlate_dev_unref(entry);
+        break;
+    case XC_NETFLOW:
+        xlate_cache_clear_netflow(entry->u.nf.netflow, entry->u.nf.flow);
+        break;
+    case XC_MIRROR:
+        mbridge_unref(entry->u.mirror.mbridge);
+        break;
+    case XC_LEARN:
+        free(entry->u.learn.fm);
+        ofpbuf_delete(entry->u.learn.ofpacts);
+        break;
+    case XC_NORMAL:
+        break;
+    case XC_FIN_TIMEOUT:
+        /* 'u.fin.rule' is always already held as a XC_RULE, which
+         * has already released it's reference above. */
+        break;
+    case XC_GROUP:
+        group_dpif_unref(entry->u.group.group);
+        break;
+    case XC_TNL_NEIGH:
+        break;
+    default:
+        OVS_NOT_REACHED();
+    }
+}
+
+void
+xlate_cache_clear(struct xlate_cache *xcache)
+{
+    if (!xcache) {
+        return;
+    }
+
+    struct xc_entry *entry;
+    struct ofpbuf entries = xcache->entries;
+    XC_ENTRY_FOR_EACH (entry, &entries) {
+        xlate_cache_clear_entry(entry);
+    }
+
+    ofpbuf_clear(&xcache->entries);
+}
+
+void
+xlate_cache_delete(struct xlate_cache *xcache)
+{
+    xlate_cache_clear(xcache);
+    ofpbuf_uninit(&xcache->entries);
+    free(xcache);
+}
diff --git a/ofproto/ofproto-dpif-xlate-cache.h b/ofproto/ofproto-dpif-xlate-cache.h
new file mode 100644
index 0000000..30e5c75
--- /dev/null
+++ b/ofproto/ofproto-dpif-xlate-cache.h
@@ -0,0 +1,132 @@
+/* Copyright (c) 2016 Nicira, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. */
+
+#ifndef OFPROTO_DPIF_XLATE_CACHE_H
+#define OFPROTO_DPIF_XLATE_CACHE_H 1
+
+#include <net/if.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "openvswitch/types.h"
+#include "dp-packet.h"
+#include "odp-util.h"
+#include "ofproto/ofproto-dpif-mirror.h"
+#include "openvswitch/ofpbuf.h"
+
+struct bfd;
+struct bond;
+struct dpif_flow_stats;
+struct rule_dpif;
+struct netdev;
+struct netflow;
+struct flow;
+struct mbridge;
+struct ofputil_flow_mod;
+struct ofpbuf;
+struct ofproto_dpif;
+struct group_dpif;
+struct ofputil_bucket;
+
+enum xc_type {
+    XC_RULE,
+    XC_BOND,
+    XC_NETDEV,
+    XC_NETFLOW,
+    XC_MIRROR,
+    XC_LEARN,
+    XC_NORMAL,
+    XC_FIN_TIMEOUT,
+    XC_GROUP,
+    XC_TNL_NEIGH,
+};
+
+/* xlate_cache entries hold enough information to perform the side effects of
+ * xlate_actions() for a rule, without needing to perform rule translation
+ * from scratch. The primary usage of these is to submit statistics to objects
+ * that a flow relates to, although they may be used for other effects as well
+ * (for instance, refreshing hard timeouts for learned flows).
+ *
+ * An explicit reference is taken to all pointers other than the ones for
+ * struct ofproto_dpif.  ofproto_dpif pointers are explicitly protected by
+ * destroying all xlate caches before the ofproto is destroyed. */
+struct xc_entry {
+    enum xc_type type;
+    union {
+        struct rule_dpif *rule;
+        struct {
+            struct netdev *tx;
+            struct netdev *rx;
+            struct bfd *bfd;
+        } dev;
+        struct {
+            struct netflow *netflow;
+            struct flow *flow;
+            ofp_port_t iface;
+        } nf;
+        struct {
+            struct mbridge *mbridge;
+            mirror_mask_t mirrors;
+        } mirror;
+        struct {
+            struct bond *bond;
+            struct flow *flow;
+            uint16_t vid;
+        } bond;
+        struct {
+            struct ofproto_dpif *ofproto;
+            struct ofputil_flow_mod *fm;
+            struct ofpbuf *ofpacts;
+        } learn;
+        struct {
+            struct ofproto_dpif *ofproto;
+            ofp_port_t in_port;
+            struct eth_addr dl_src;
+            int vlan;
+            bool is_gratuitous_arp;
+        } normal;
+        struct {
+            struct rule_dpif *rule;
+            uint16_t idle;
+            uint16_t hard;
+        } fin;
+        struct {
+            struct group_dpif *group;
+            struct ofputil_bucket *bucket;
+        } group;
+        struct {
+            char br_name[IFNAMSIZ];
+            struct in6_addr d_ipv6;
+        } tnl_neigh_cache;
+    } u;
+};
+
+#define XC_ENTRY_FOR_EACH(ENTRY, ENTRIES)                       \
+    for (ENTRY = ofpbuf_try_pull(ENTRIES, sizeof *ENTRY);       \
+         ENTRY;                                                 \
+         ENTRY = ofpbuf_try_pull(ENTRIES, sizeof *ENTRY))
+
+struct xlate_cache {
+    struct ofpbuf entries;
+};
+
+struct xlate_cache *xlate_cache_new(void);
+struct xc_entry *xlate_cache_add_entry(struct xlate_cache *, enum xc_type);
+void xlate_push_stats_entry(struct xc_entry *, const struct dpif_flow_stats *);
+void xlate_push_stats(struct xlate_cache *, const struct dpif_flow_stats *);
+void xlate_cache_clear_entry(struct xc_entry *);
+void xlate_cache_clear(struct xlate_cache *);
+void xlate_cache_delete(struct xlate_cache *);
+
+#endif /* ofproto-dpif-xlate-cache.h */
diff --git a/ofproto/ofproto-dpif-xlate.c b/ofproto/ofproto-dpif-xlate.c
index e4a0c52..11d3732 100644
--- a/ofproto/ofproto-dpif-xlate.c
+++ b/ofproto/ofproto-dpif-xlate.c
@@ -46,6 +46,7 @@
 #include "ofproto/ofproto-dpif-mirror.h"
 #include "ofproto/ofproto-dpif-monitor.h"
 #include "ofproto/ofproto-dpif-sflow.h"
+#include "ofproto/ofproto-dpif-xlate-cache.h"
 #include "ofproto/ofproto-dpif.h"
 #include "ofproto/ofproto-provider.h"
 #include "openvswitch/dynamic-string.h"
@@ -448,85 +449,6 @@ struct skb_priority_to_dscp {
     uint8_t dscp;               /* DSCP bits to mark outgoing traffic with. */
 };
 
-enum xc_type {
-    XC_RULE,
-    XC_BOND,
-    XC_NETDEV,
-    XC_NETFLOW,
-    XC_MIRROR,
-    XC_LEARN,
-    XC_NORMAL,
-    XC_FIN_TIMEOUT,
-    XC_GROUP,
-    XC_TNL_NEIGH,
-};
-
-/* xlate_cache entries hold enough information to perform the side effects of
- * xlate_actions() for a rule, without needing to perform rule translation
- * from scratch. The primary usage of these is to submit statistics to objects
- * that a flow relates to, although they may be used for other effects as well
- * (for instance, refreshing hard timeouts for learned flows). */
-struct xc_entry {
-    enum xc_type type;
-    union {
-        struct rule_dpif *rule;
-        struct {
-            struct netdev *tx;
-            struct netdev *rx;
-            struct bfd *bfd;
-        } dev;
-        struct {
-            struct netflow *netflow;
-            struct flow *flow;
-            ofp_port_t iface;
-        } nf;
-        struct {
-            struct mbridge *mbridge;
-            mirror_mask_t mirrors;
-        } mirror;
-        struct {
-            struct bond *bond;
-            struct flow *flow;
-            uint16_t vid;
-        } bond;
-        struct {
-            struct ofproto_dpif *ofproto;
-            struct ofputil_flow_mod *fm;
-            struct ofpbuf *ofpacts;
-        } learn;
-        struct {
-            struct ofproto_dpif *ofproto;
-            ofp_port_t in_port;
-            struct eth_addr dl_src;
-            int vlan;
-            bool is_gratuitous_arp;
-        } normal;
-        struct {
-            struct rule_dpif *rule;
-            uint16_t idle;
-            uint16_t hard;
-        } fin;
-        struct {
-            struct group_dpif *group;
-            struct ofputil_bucket *bucket;
-        } group;
-        struct {
-            char br_name[IFNAMSIZ];
-            struct in6_addr d_ipv6;
-        } tnl_neigh_cache;
-    } u;
-};
-
-#define XC_ENTRY_FOR_EACH(ENTRY, ENTRIES, XCACHE)               \
-    ENTRIES = XCACHE->entries;                                  \
-    for (ENTRY = ofpbuf_try_pull(&ENTRIES, sizeof *ENTRY);      \
-         ENTRY;                                                 \
-         ENTRY = ofpbuf_try_pull(&ENTRIES, sizeof *ENTRY))
-
-struct xlate_cache {
-    struct ofpbuf entries;
-};
-
 /* Xlate config contains hash maps of all bridges, bundles and ports.
  * Xcfgp contains the pointer to the current xlate configuration.
  * When the main thread needs to change the configuration, it copies xcfgp to
@@ -580,8 +502,6 @@ static size_t count_skb_priorities(const struct xport *);
 static bool dscp_from_skb_priority(const struct xport *, uint32_t skb_priority,
                                    uint8_t *dscp);
 
-static struct xc_entry *xlate_cache_add_entry(struct xlate_cache *xc,
-                                              enum xc_type type);
 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 *);
@@ -5679,41 +5599,7 @@ xlate_send_packet(const struct ofport_dpif *ofport, bool oam,
                                         ofpacts.data, ofpacts.size, packet);
 }
 
-struct xlate_cache *
-xlate_cache_new(void)
-{
-    struct xlate_cache *xcache = xmalloc(sizeof *xcache);
-
-    ofpbuf_init(&xcache->entries, 512);
-    return xcache;
-}
-
-static struct xc_entry *
-xlate_cache_add_entry(struct xlate_cache *xcache, enum xc_type type)
-{
-    struct xc_entry *entry;
-
-    entry = ofpbuf_put_zeros(&xcache->entries, sizeof *entry);
-    entry->type = type;
-
-    return entry;
-}
-
-static void
-xlate_cache_netdev(struct xc_entry *entry, const struct dpif_flow_stats *stats)
-{
-    if (entry->u.dev.tx) {
-        netdev_vport_inc_tx(entry->u.dev.tx, stats);
-    }
-    if (entry->u.dev.rx) {
-        netdev_vport_inc_rx(entry->u.dev.rx, stats);
-    }
-    if (entry->u.dev.bfd) {
-        bfd_account_rx(entry->u.dev.bfd, stats);
-    }
-}
-
-static void
+void
 xlate_mac_learning_update(const struct ofproto_dpif *ofproto,
                           ofp_port_t in_port, struct eth_addr dl_src,
                           int vlan, bool is_grat_arp)
@@ -5734,147 +5620,3 @@ xlate_mac_learning_update(const struct ofproto_dpif *ofproto,
 
     update_learning_table(xbridge, xbundle, dl_src, vlan, is_grat_arp);
 }
-
-/* Push stats and perform side effects of flow translation. */
-void
-xlate_push_stats(struct xlate_cache *xcache,
-                 const struct dpif_flow_stats *stats)
-{
-    struct xc_entry *entry;
-    struct ofpbuf entries = xcache->entries;
-    struct eth_addr dmac;
-
-    if (!stats->n_packets) {
-        return;
-    }
-
-    XC_ENTRY_FOR_EACH (entry, entries, xcache) {
-        switch (entry->type) {
-        case XC_RULE:
-            rule_dpif_credit_stats(entry->u.rule, stats);
-            break;
-        case XC_BOND:
-            bond_account(entry->u.bond.bond, entry->u.bond.flow,
-                         entry->u.bond.vid, stats->n_bytes);
-            break;
-        case XC_NETDEV:
-            xlate_cache_netdev(entry, stats);
-            break;
-        case XC_NETFLOW:
-            netflow_flow_update(entry->u.nf.netflow, entry->u.nf.flow,
-                                entry->u.nf.iface, stats);
-            break;
-        case XC_MIRROR:
-            mirror_update_stats(entry->u.mirror.mbridge,
-                                entry->u.mirror.mirrors,
-                                stats->n_packets, stats->n_bytes);
-            break;
-        case XC_LEARN:
-            ofproto_dpif_flow_mod(entry->u.learn.ofproto, entry->u.learn.fm);
-            break;
-        case XC_NORMAL:
-            xlate_mac_learning_update(entry->u.normal.ofproto,
-                                      entry->u.normal.in_port,
-                                      entry->u.normal.dl_src,
-                                      entry->u.normal.vlan,
-                                      entry->u.normal.is_gratuitous_arp);
-            break;
-        case XC_FIN_TIMEOUT:
-            xlate_fin_timeout__(entry->u.fin.rule, stats->tcp_flags,
-                                entry->u.fin.idle, entry->u.fin.hard);
-            break;
-        case XC_GROUP:
-            group_dpif_credit_stats(entry->u.group.group, entry->u.group.bucket,
-                                    stats);
-            break;
-        case XC_TNL_NEIGH:
-            /* Lookup neighbor to avoid timeout. */
-            tnl_neigh_lookup(entry->u.tnl_neigh_cache.br_name,
-                             &entry->u.tnl_neigh_cache.d_ipv6, &dmac);
-            break;
-        default:
-            OVS_NOT_REACHED();
-        }
-    }
-}
-
-static void
-xlate_dev_unref(struct xc_entry *entry)
-{
-    if (entry->u.dev.tx) {
-        netdev_close(entry->u.dev.tx);
-    }
-    if (entry->u.dev.rx) {
-        netdev_close(entry->u.dev.rx);
-    }
-    if (entry->u.dev.bfd) {
-        bfd_unref(entry->u.dev.bfd);
-    }
-}
-
-static void
-xlate_cache_clear_netflow(struct netflow *netflow, struct flow *flow)
-{
-    netflow_flow_clear(netflow, flow);
-    netflow_unref(netflow);
-    free(flow);
-}
-
-void
-xlate_cache_clear(struct xlate_cache *xcache)
-{
-    struct xc_entry *entry;
-    struct ofpbuf entries;
-
-    if (!xcache) {
-        return;
-    }
-
-    XC_ENTRY_FOR_EACH (entry, entries, xcache) {
-        switch (entry->type) {
-        case XC_RULE:
-            rule_dpif_unref(entry->u.rule);
-            break;
-        case XC_BOND:
-            free(entry->u.bond.flow);
-            bond_unref(entry->u.bond.bond);
-            break;
-        case XC_NETDEV:
-            xlate_dev_unref(entry);
-            break;
-        case XC_NETFLOW:
-            xlate_cache_clear_netflow(entry->u.nf.netflow, entry->u.nf.flow);
-            break;
-        case XC_MIRROR:
-            mbridge_unref(entry->u.mirror.mbridge);
-            break;
-        case XC_LEARN:
-            free(entry->u.learn.fm);
-            ofpbuf_delete(entry->u.learn.ofpacts);
-            break;
-        case XC_NORMAL:
-            break;
-        case XC_FIN_TIMEOUT:
-            /* 'u.fin.rule' is always already held as a XC_RULE, which
-             * has already released it's reference above. */
-            break;
-        case XC_GROUP:
-            group_dpif_unref(entry->u.group.group);
-            break;
-        case XC_TNL_NEIGH:
-            break;
-        default:
-            OVS_NOT_REACHED();
-        }
-    }
-
-    ofpbuf_clear(&xcache->entries);
-}
-
-void
-xlate_cache_delete(struct xlate_cache *xcache)
-{
-    xlate_cache_clear(xcache);
-    ofpbuf_uninit(&xcache->entries);
-    free(xcache);
-}
diff --git a/ofproto/ofproto-dpif-xlate.h b/ofproto/ofproto-dpif-xlate.h
index 7808a60..29f8204 100644
--- a/ofproto/ofproto-dpif-xlate.h
+++ b/ofproto/ofproto-dpif-xlate.h
@@ -213,10 +213,9 @@ enum ofperr xlate_resume(struct ofproto_dpif *,
 
 int xlate_send_packet(const struct ofport_dpif *, bool oam, struct dp_packet *);
 
-struct xlate_cache *xlate_cache_new(void);
-void xlate_push_stats(struct xlate_cache *, const struct dpif_flow_stats *);
-void xlate_cache_clear(struct xlate_cache *);
-void xlate_cache_delete(struct xlate_cache *);
+void xlate_mac_learning_update(const struct ofproto_dpif *ofproto,
+                               ofp_port_t in_port, struct eth_addr dl_src,
+                               int vlan, bool is_grat_arp);
 
 void xlate_txn_start(void);
 void xlate_txn_commit(void);
-- 
2.1.4




More information about the dev mailing list