X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Ftunnel.c;h=a63cf716bc17980afda344e0e10ece86056d7b55;hb=d0a46cb4608e632f5028034762f0adde2ce947a0;hp=5a4607e736622bb87d8e3b4da30fe866474b7809;hpb=baa73637907696c9f0a0a124eba2ce55a4af8e2b;p=cascardo%2Fovs.git

diff --git a/ofproto/tunnel.c b/ofproto/tunnel.c
index 5a4607e73..a63cf716b 100644
--- a/ofproto/tunnel.c
+++ b/ofproto/tunnel.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013 Nicira, Inc.
+/* Copyright (c) 2013, 2014, 2015 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,87 +17,159 @@
 
 #include <errno.h>
 
-#include "ofproto/ofproto-provider.h"
 #include "byte-order.h"
+#include "connectivity.h"
+#include "csum.h"
+#include "dpif.h"
 #include "dynamic-string.h"
+#include "fat-rwlock.h"
 #include "hash.h"
 #include "hmap.h"
-#include "netdev-vport.h"
+#include "netdev.h"
 #include "odp-util.h"
+#include "ofpbuf.h"
 #include "packets.h"
+#include "route-table.h"
+#include "seq.h"
 #include "smap.h"
 #include "socket-util.h"
+#include "tnl-ports.h"
 #include "tunnel.h"
-#include "vlog.h"
-
-/* XXX:
- *
- * Ability to generate actions on input for ECN
- * Ability to generate metadata for packet-outs
- * IPsec using skb mark.
- * VXLAN.
- * Multicast group management (possibly).
- * Disallow netdevs with names like "gre64_system" to prevent collisions. */
+#include "openvswitch/vlog.h"
+#include "unaligned.h"
+#include "ofproto-dpif.h"
 
 VLOG_DEFINE_THIS_MODULE(tunnel);
 
+/* skb mark used for IPsec tunnel packets */
+#define IPSEC_MARK 1
+
 struct tnl_match {
     ovs_be64 in_key;
-    ovs_be32 ip_src;
-    ovs_be32 ip_dst;
-    uint32_t odp_port;
+    struct in6_addr ipv6_src;
+    struct in6_addr ipv6_dst;
+    odp_port_t odp_port;
+    uint32_t pkt_mark;
     bool in_key_flow;
+    bool ip_src_flow;
+    bool ip_dst_flow;
 };
 
 struct tnl_port {
+    struct hmap_node ofport_node;
     struct hmap_node match_node;
 
-    const struct ofport *ofport;
-    unsigned int netdev_seq;
+    const struct ofport_dpif *ofport;
+    uint64_t change_seq;
+    struct netdev *netdev;
+
     struct tnl_match match;
 };
 
-static struct hmap tnl_match_map = HMAP_INITIALIZER(&tnl_match_map);
+static struct fat_rwlock rwlock;
 
-/* Returned to callers when their ofport will never be used to receive or send
- * tunnel traffic. Alternatively, we could ask the caller to delete their
- * ofport, but this would be unclean in the reconfguration case.  For the first
- * time, an ofproto provider would have to call ofproto_port_del() on itself.*/
-static struct tnl_port void_tnl_port;
+/* Tunnel matches.
+ *
+ * This module maps packets received over tunnel protocols to vports.  The
+ * tunnel protocol and, for some protocols, tunnel-specific information (e.g.,
+ * for VXLAN, the UDP destination port number) are always use as part of the
+ * mapping.  Which other fields are used for the mapping depends on the vports
+ * themselves (the parenthesized notations refer to "struct tnl_match" fields):
+ *
+ *     - in_key: A vport may match a specific tunnel ID (in_key_flow == false)
+ *       or arrange for the tunnel ID to be matched as tunnel.tun_id in the
+ *       OpenFlow flow (in_key_flow == true).
+ *
+ *     - ip_dst: A vport may match a specific destination IP address
+ *       (ip_dst_flow == false) or arrange for the destination IP to be matched
+ *       as tunnel.ip_dst in the OpenFlow flow (ip_dst_flow == true).
+ *
+ *     - ip_src: A vport may match a specific IP source address (ip_src_flow ==
+ *       false, ip_src != 0), wildcard all source addresses (ip_src_flow ==
+ *       false, ip_src == 0), or arrange for the IP source address to be
+ *       handled in the OpenFlow flow table (ip_src_flow == true).
+ *
+ * Thus, there are 2 * 2 * 3 == 12 possible ways a vport can match against a
+ * tunnel packet.  We number the possibilities for each field in increasing
+ * order as listed in each bullet above.  We order the 12 overall combinations
+ * in lexicographic order considering in_key first, then ip_dst, then
+ * ip_src. */
+#define N_MATCH_TYPES (2 * 2 * 3)
+
+/* The three possibilities (see above) for vport ip_src matches. */
+enum ip_src_type {
+    IP_SRC_CFG,             /* ip_src must equal configured address. */
+    IP_SRC_ANY,             /* Any ip_src is acceptable. */
+    IP_SRC_FLOW             /* ip_src is handled in flow table. */
+};
+
+/* Each hmap contains "struct tnl_port"s.
+ * The index is a combination of how each of the fields listed under "Tunnel
+ * matches" above matches, see the final paragraph for ordering. */
+static struct hmap *tnl_match_maps[N_MATCH_TYPES] OVS_GUARDED_BY(rwlock);
+static struct hmap **tnl_match_map(const struct tnl_match *);
+
+static struct hmap ofport_map__ = HMAP_INITIALIZER(&ofport_map__);
+static struct hmap *ofport_map OVS_GUARDED_BY(rwlock) = &ofport_map__;
 
 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 static struct vlog_rate_limit dbg_rl = VLOG_RATE_LIMIT_INIT(60, 60);
 
-static struct tnl_port *tnl_find(struct tnl_match *);
-static struct tnl_port *tnl_find_exact(struct tnl_match *);
+static struct tnl_port *tnl_find(const struct flow *) OVS_REQ_RDLOCK(rwlock);
+static struct tnl_port *tnl_find_exact(struct tnl_match *, struct hmap *)
+    OVS_REQ_RDLOCK(rwlock);
+static struct tnl_port *tnl_find_ofport(const struct ofport_dpif *)
+    OVS_REQ_RDLOCK(rwlock);
+
 static uint32_t tnl_hash(struct tnl_match *);
 static void tnl_match_fmt(const struct tnl_match *, struct ds *);
-static char *tnl_port_fmt(const struct tnl_port *);
-static void tnl_port_mod_log(const struct tnl_port *, const char *action);
-static const char *tnl_port_get_name(const struct tnl_port *);
+static char *tnl_port_fmt(const struct tnl_port *) OVS_REQ_RDLOCK(rwlock);
+static void tnl_port_mod_log(const struct tnl_port *, const char *action)
+    OVS_REQ_RDLOCK(rwlock);
+static const char *tnl_port_get_name(const struct tnl_port *)
+    OVS_REQ_RDLOCK(rwlock);
+static void tnl_port_del__(const struct ofport_dpif *) OVS_REQ_WRLOCK(rwlock);
 
-static struct tnl_port *
-tnl_port_add__(const struct ofport *ofport, uint32_t odp_port,
-               bool warn)
+void
+ofproto_tunnel_init(void)
+{
+    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
+
+    if (ovsthread_once_start(&once)) {
+        fat_rwlock_init(&rwlock);
+        ovsthread_once_done(&once);
+    }
+}
+
+static bool
+tnl_port_add__(const struct ofport_dpif *ofport, const struct netdev *netdev,
+               odp_port_t odp_port, bool warn, bool native_tnl, const char name[])
+    OVS_REQ_WRLOCK(rwlock)
 {
     const struct netdev_tunnel_config *cfg;
     struct tnl_port *existing_port;
     struct tnl_port *tnl_port;
+    struct hmap **map;
 
-    cfg = netdev_get_tunnel_config(ofport->netdev);
+    cfg = netdev_get_tunnel_config(netdev);
     ovs_assert(cfg);
 
     tnl_port = xzalloc(sizeof *tnl_port);
     tnl_port->ofport = ofport;
-    tnl_port->netdev_seq = netdev_change_seq(tnl_port->ofport->netdev);
+    tnl_port->netdev = netdev_ref(netdev);
+    tnl_port->change_seq = netdev_get_change_seq(tnl_port->netdev);
 
     tnl_port->match.in_key = cfg->in_key;
-    tnl_port->match.ip_src = cfg->ip_src;
-    tnl_port->match.ip_dst = cfg->ip_dst;
+    tnl_port->match.ipv6_src = cfg->ipv6_src;
+    tnl_port->match.ipv6_dst = cfg->ipv6_dst;
+    tnl_port->match.ip_src_flow = cfg->ip_src_flow;
+    tnl_port->match.ip_dst_flow = cfg->ip_dst_flow;
+    tnl_port->match.pkt_mark = cfg->ipsec ? IPSEC_MARK : 0;
     tnl_port->match.in_key_flow = cfg->in_key_flow;
     tnl_port->match.odp_port = odp_port;
 
-    existing_port = tnl_find_exact(&tnl_port->match);
+    map = tnl_match_map(&tnl_port->match);
+    existing_port = tnl_find_exact(&tnl_port->match, *map);
     if (existing_port) {
         if (warn) {
             struct ds ds = DS_EMPTY_INITIALIZER;
@@ -106,110 +178,141 @@ tnl_port_add__(const struct ofport *ofport, uint32_t odp_port,
                       "port '%s' (%s)", tnl_port_get_name(tnl_port),
                       tnl_port_get_name(existing_port), ds_cstr(&ds));
             ds_destroy(&ds);
-            free(tnl_port);
         }
-        return &void_tnl_port;
+        netdev_close(tnl_port->netdev);
+        free(tnl_port);
+        return false;
     }
 
-    hmap_insert(&tnl_match_map, &tnl_port->match_node,
-                tnl_hash(&tnl_port->match));
+    hmap_insert(ofport_map, &tnl_port->ofport_node, hash_pointer(ofport, 0));
+
+    if (!*map) {
+        *map = xmalloc(sizeof **map);
+        hmap_init(*map);
+    }
+    hmap_insert(*map, &tnl_port->match_node, tnl_hash(&tnl_port->match));
     tnl_port_mod_log(tnl_port, "adding");
-    return tnl_port;
+
+    if (native_tnl) {
+        tnl_port_map_insert(odp_port, cfg->dst_port, name);
+    }
+    return true;
 }
 
 /* Adds 'ofport' to the module with datapath port number 'odp_port'. 'ofport's
  * must be added before they can be used by the module. 'ofport' must be a
- * tunnel. */
-struct tnl_port *
-tnl_port_add(const struct ofport *ofport, uint32_t odp_port)
+ * tunnel.
+ *
+ * Returns 0 if successful, otherwise a positive errno value. */
+int
+tnl_port_add(const struct ofport_dpif *ofport, const struct netdev *netdev,
+             odp_port_t odp_port, bool native_tnl, const char name[]) OVS_EXCLUDED(rwlock)
 {
-    return tnl_port_add__(ofport, odp_port, true);
+    bool ok;
+
+    fat_rwlock_wrlock(&rwlock);
+    ok = tnl_port_add__(ofport, netdev, odp_port, true, native_tnl, name);
+    fat_rwlock_unlock(&rwlock);
+
+    return ok ? 0 : EEXIST;
 }
 
-/* Checks if the tnl_port pointed to by 'tnl_portp' needs reconfiguration due
- * to changes in its netdev_tunnel_config.  If it does, updates 'tnl_portp' to
- * point to a new tnl_port and returns true.  Otherwise, returns false.
- * 'ofport' and 'odp_port' should be the same as would be passed to
+/* Checks if the tunnel represented by 'ofport' reconfiguration due to changes
+ * in its netdev_tunnel_config.  If it does, returns true. Otherwise, returns
+ * false.  'ofport' and 'odp_port' should be the same as would be passed to
  * tnl_port_add(). */
 bool
-tnl_port_reconfigure(const struct ofport *ofport, uint32_t odp_port,
-                     struct tnl_port **tnl_portp)
+tnl_port_reconfigure(const struct ofport_dpif *ofport,
+                     const struct netdev *netdev, odp_port_t odp_port,
+                     bool native_tnl, const char name[])
+    OVS_EXCLUDED(rwlock)
 {
-    struct tnl_port *tnl_port = *tnl_portp;
+    struct tnl_port *tnl_port;
+    bool changed = false;
 
-    if (tnl_port == &void_tnl_port) {
-        *tnl_portp = tnl_port_add__(ofport, odp_port, false);
-        return *tnl_portp != &void_tnl_port;
-    } else if (tnl_port->ofport != ofport
+    fat_rwlock_wrlock(&rwlock);
+    tnl_port = tnl_find_ofport(ofport);
+    if (!tnl_port) {
+        changed = tnl_port_add__(ofport, netdev, odp_port, false, native_tnl, name);
+    } else if (tnl_port->netdev != netdev
                || tnl_port->match.odp_port != odp_port
-               || tnl_port->netdev_seq != netdev_change_seq(ofport->netdev)) {
+               || tnl_port->change_seq != netdev_get_change_seq(tnl_port->netdev)) {
         VLOG_DBG("reconfiguring %s", tnl_port_get_name(tnl_port));
-        tnl_port_del(tnl_port);
-        *tnl_portp = tnl_port_add(ofport, odp_port);
-        return true;
+        tnl_port_del__(ofport);
+        tnl_port_add__(ofport, netdev, odp_port, true, native_tnl, name);
+        changed = true;
     }
-    return false;
+    fat_rwlock_unlock(&rwlock);
+    return changed;
 }
 
-/* Removes 'tnl_port' from the module. */
-void
-tnl_port_del(struct tnl_port *tnl_port)
+static void
+tnl_port_del__(const struct ofport_dpif *ofport) OVS_REQ_WRLOCK(rwlock)
 {
-    if (tnl_port && tnl_port != &void_tnl_port) {
+    struct tnl_port *tnl_port;
+
+    if (!ofport) {
+        return;
+    }
+
+    tnl_port = tnl_find_ofport(ofport);
+    if (tnl_port) {
+        const struct netdev_tunnel_config *cfg =
+            netdev_get_tunnel_config(tnl_port->netdev);
+        struct hmap **map;
+
+        tnl_port_map_delete(cfg->dst_port);
         tnl_port_mod_log(tnl_port, "removing");
-        hmap_remove(&tnl_match_map, &tnl_port->match_node);
+        map = tnl_match_map(&tnl_port->match);
+        hmap_remove(*map, &tnl_port->match_node);
+        if (hmap_is_empty(*map)) {
+            hmap_destroy(*map);
+            free(*map);
+            *map = NULL;
+        }
+        hmap_remove(ofport_map, &tnl_port->ofport_node);
+        netdev_close(tnl_port->netdev);
         free(tnl_port);
     }
 }
 
-/* Transforms 'flow' so that it appears to have been received by a tunnel
- * OpenFlow port controlled by this module instead of the datapath port it
- * actually came in on.  Sets 'flow''s in_port to the appropriate OpenFlow port
- * number.  Returns the 'ofport' corresponding to the new in_port.
+/* Removes 'ofport' from the module. */
+void
+tnl_port_del(const struct ofport_dpif *ofport) OVS_EXCLUDED(rwlock)
+{
+    fat_rwlock_wrlock(&rwlock);
+    tnl_port_del__(ofport);
+    fat_rwlock_unlock(&rwlock);
+}
+
+/* Looks in the table of tunnels for a tunnel matching the metadata in 'flow'.
+ * Returns the 'ofport' corresponding to the new in_port, or a null pointer if
+ * none is found.
  *
  * Callers should verify that 'flow' needs to be received by calling
- * tnl_port_should_receive() before this function.
- *
- * Leaves 'flow' untouched and returns null if unsuccessful. */
-const struct ofport *
-tnl_port_receive(struct flow *flow)
+ * tnl_port_should_receive() before this function. */
+const struct ofport_dpif *
+tnl_port_receive(const struct flow *flow) OVS_EXCLUDED(rwlock)
 {
     char *pre_flow_str = NULL;
+    const struct ofport_dpif *ofport;
     struct tnl_port *tnl_port;
-    struct tnl_match match;
-
-    memset(&match, 0, sizeof match);
-    match.odp_port = flow->in_port;
-    match.ip_src = flow->tunnel.ip_dst;
-    match.ip_dst = flow->tunnel.ip_src;
-    match.in_key = flow->tunnel.tun_id;
 
-    tnl_port = tnl_find(&match);
+    fat_rwlock_rdlock(&rwlock);
+    tnl_port = tnl_find(flow);
+    ofport = tnl_port ? tnl_port->ofport : NULL;
     if (!tnl_port) {
-        struct ds ds = DS_EMPTY_INITIALIZER;
+        char *flow_str = flow_to_string(flow);
 
-        tnl_match_fmt(&match, &ds);
-        VLOG_WARN_RL(&rl, "receive tunnel port not found (%s)", ds_cstr(&ds));
-        ds_destroy(&ds);
-        return NULL;
-    }
-
-    if (is_ip_any(flow)
-        && ((flow->tunnel.ip_tos & IP_ECN_MASK) == IP_ECN_CE)
-        && (flow->nw_tos & IP_ECN_MASK) == IP_ECN_NOT_ECT) {
-        VLOG_WARN_RL(&rl, "dropping tunnel packet marked ECN CE but is not ECN"
-                     " capable");
-        return NULL;
+        VLOG_WARN_RL(&rl, "receive tunnel port not found (%s)", flow_str);
+        free(flow_str);
+        goto out;
     }
 
     if (!VLOG_DROP_DBG(&dbg_rl)) {
         pre_flow_str = flow_to_string(flow);
     }
 
-    flow->in_port = tnl_port->ofport->ofp_port;
-    memset(&flow->tunnel, 0, sizeof flow->tunnel);
-    flow->tunnel.tun_id = match.in_key;
-
     if (pre_flow_str) {
         char *post_flow_str = flow_to_string(flow);
         char *tnl_str = tnl_port_fmt(tnl_port);
@@ -222,56 +325,148 @@ tnl_port_receive(struct flow *flow)
         free(pre_flow_str);
         free(post_flow_str);
     }
-    return tnl_port->ofport;
+
+out:
+    fat_rwlock_unlock(&rwlock);
+    return ofport;
+}
+
+/* Should be called at the beginning of action translation to initialize
+ * wildcards and perform any actions based on receiving on tunnel port.
+ *
+ * Returns false if the packet must be dropped. */
+bool
+tnl_process_ecn(struct flow *flow)
+{
+    if (!tnl_port_should_receive(flow)) {
+        return true;
+    }
+
+    if (is_ip_any(flow) && (flow->tunnel.ip_tos & IP_ECN_MASK) == IP_ECN_CE) {
+        if ((flow->nw_tos & IP_ECN_MASK) == IP_ECN_NOT_ECT) {
+            VLOG_WARN_RL(&rl, "dropping tunnel packet marked ECN CE"
+                         " but is not ECN capable");
+            return false;
+        }
+
+        /* Set the ECN CE value in the tunneled packet. */
+        flow->nw_tos |= IP_ECN_CE;
+    }
+
+    flow->pkt_mark &= ~IPSEC_MARK;
+    return true;
+}
+
+void
+tnl_wc_init(struct flow *flow, struct flow_wildcards *wc)
+{
+    if (tnl_port_should_receive(flow)) {
+        wc->masks.tunnel.tun_id = OVS_BE64_MAX;
+        if (flow->tunnel.ip_dst) {
+            wc->masks.tunnel.ip_src = OVS_BE32_MAX;
+            wc->masks.tunnel.ip_dst = OVS_BE32_MAX;
+        } else {
+            wc->masks.tunnel.ipv6_src = in6addr_exact;
+            wc->masks.tunnel.ipv6_dst = in6addr_exact;
+        }
+        wc->masks.tunnel.flags = (FLOW_TNL_F_DONT_FRAGMENT |
+                                  FLOW_TNL_F_CSUM |
+                                  FLOW_TNL_F_KEY);
+        wc->masks.tunnel.ip_tos = UINT8_MAX;
+        wc->masks.tunnel.ip_ttl = 0;
+        /* The tp_src and tp_dst members in flow_tnl are set to be always
+         * wildcarded, not to unwildcard them here. */
+        wc->masks.tunnel.tp_src = 0;
+        wc->masks.tunnel.tp_dst = 0;
+
+        memset(&wc->masks.pkt_mark, 0xff, sizeof wc->masks.pkt_mark);
+
+        if (is_ip_any(flow)
+            && (flow->tunnel.ip_tos & IP_ECN_MASK) == IP_ECN_CE) {
+            wc->masks.nw_tos |= IP_ECN_MASK;
+        }
+    }
 }
 
 /* Given that 'flow' should be output to the ofport corresponding to
  * 'tnl_port', updates 'flow''s tunnel headers and returns the actual datapath
- * port that the output should happen on.  May return OVSP_NONE if the output
+ * port that the output should happen on.  May return ODPP_NONE if the output
  * shouldn't occur. */
-uint32_t
-tnl_port_send(const struct tnl_port *tnl_port, struct flow *flow)
+odp_port_t
+tnl_port_send(const struct ofport_dpif *ofport, struct flow *flow,
+              struct flow_wildcards *wc) OVS_EXCLUDED(rwlock)
 {
     const struct netdev_tunnel_config *cfg;
+    struct tnl_port *tnl_port;
     char *pre_flow_str = NULL;
+    odp_port_t out_port;
 
-    if (tnl_port == &void_tnl_port) {
-        return OVSP_NONE;
+    fat_rwlock_rdlock(&rwlock);
+    tnl_port = tnl_find_ofport(ofport);
+    out_port = tnl_port ? tnl_port->match.odp_port : ODPP_NONE;
+    if (!tnl_port) {
+        goto out;
     }
 
-    cfg = netdev_get_tunnel_config(tnl_port->ofport->netdev);
+    cfg = netdev_get_tunnel_config(tnl_port->netdev);
     ovs_assert(cfg);
 
     if (!VLOG_DROP_DBG(&dbg_rl)) {
         pre_flow_str = flow_to_string(flow);
     }
 
-    flow->tunnel.ip_src = tnl_port->match.ip_src;
-    flow->tunnel.ip_dst = tnl_port->match.ip_dst;
+    if (!cfg->ip_src_flow) {
+        flow->tunnel.ip_src = in6_addr_get_mapped_ipv4(&tnl_port->match.ipv6_src);
+        if (!flow->tunnel.ip_src) {
+            flow->tunnel.ipv6_src = tnl_port->match.ipv6_src;
+        }
+    }
+    if (!cfg->ip_dst_flow) {
+        flow->tunnel.ip_dst = in6_addr_get_mapped_ipv4(&tnl_port->match.ipv6_dst);
+        if (!flow->tunnel.ip_dst) {
+            flow->tunnel.ipv6_dst = tnl_port->match.ipv6_dst;
+        }
+    }
+    if (ipv6_addr_is_set(&flow->tunnel.ipv6_dst) ||
+        ipv6_addr_is_set(&flow->tunnel.ipv6_src)) {
+        out_port = ODPP_NONE;
+        VLOG_WARN_RL(&rl, "port (%s): IPv6 tunnel endpoint is not supported",
+                     netdev_get_name(tnl_port->netdev));
+        goto out;
+    }
+
+    flow->pkt_mark = tnl_port->match.pkt_mark;
 
     if (!cfg->out_key_flow) {
         flow->tunnel.tun_id = cfg->out_key;
     }
 
     if (cfg->ttl_inherit && is_ip_any(flow)) {
+        wc->masks.nw_ttl = 0xff;
         flow->tunnel.ip_ttl = flow->nw_ttl;
     } else {
         flow->tunnel.ip_ttl = cfg->ttl;
     }
 
     if (cfg->tos_inherit && is_ip_any(flow)) {
+        wc->masks.nw_tos |= IP_DSCP_MASK;
         flow->tunnel.ip_tos = flow->nw_tos & IP_DSCP_MASK;
     } else {
         flow->tunnel.ip_tos = cfg->tos;
     }
 
-    if ((flow->nw_tos & IP_ECN_MASK) == IP_ECN_CE) {
-        flow->tunnel.ip_tos |= IP_ECN_ECT_0;
-    } else {
-        flow->tunnel.ip_tos |= flow->nw_tos & IP_ECN_MASK;
+    /* ECN fields are always inherited. */
+    if (is_ip_any(flow)) {
+        wc->masks.nw_tos |= IP_ECN_MASK;
+
+        if ((flow->nw_tos & IP_ECN_MASK) == IP_ECN_CE) {
+            flow->tunnel.ip_tos |= IP_ECN_ECT_0;
+        } else {
+            flow->tunnel.ip_tos |= flow->nw_tos & IP_ECN_MASK;
+        }
     }
 
-    flow->tunnel.flags = (cfg->dont_fragment ? FLOW_TNL_F_DONT_FRAGMENT : 0)
+    flow->tunnel.flags |= (cfg->dont_fragment ? FLOW_TNL_F_DONT_FRAGMENT : 0)
         | (cfg->csum ? FLOW_TNL_F_CSUM : 0)
         | (cfg->out_key_present ? FLOW_TNL_F_KEY : 0);
 
@@ -288,7 +483,9 @@ tnl_port_send(const struct tnl_port *tnl_port, struct flow *flow)
         free(post_flow_str);
     }
 
-    return tnl_port->match.odp_port;
+out:
+    fat_rwlock_unlock(&rwlock);
+    return out_port;
 }
 
 static uint32_t
@@ -299,13 +496,13 @@ tnl_hash(struct tnl_match *match)
 }
 
 static struct tnl_port *
-tnl_find_exact(struct tnl_match *match)
+tnl_find_ofport(const struct ofport_dpif *ofport) OVS_REQ_RDLOCK(rwlock)
 {
     struct tnl_port *tnl_port;
 
-    HMAP_FOR_EACH_WITH_HASH (tnl_port, match_node, tnl_hash(match),
-                             &tnl_match_map) {
-        if (!memcmp(match, &tnl_port->match, sizeof *match)) {
+    HMAP_FOR_EACH_IN_BUCKET (tnl_port, ofport_node, hash_pointer(ofport, 0),
+                             ofport_map) {
+        if (tnl_port->ofport == ofport) {
             return tnl_port;
         }
     }
@@ -313,78 +510,103 @@ tnl_find_exact(struct tnl_match *match)
 }
 
 static struct tnl_port *
-tnl_find(struct tnl_match *match_)
+tnl_find_exact(struct tnl_match *match, struct hmap *map)
+    OVS_REQ_RDLOCK(rwlock)
 {
-    struct tnl_match match = *match_;
-    bool is_multicast = ip_is_multicast(match.ip_src);
-    struct tnl_port *tnl_port;
+    if (map) {
+        struct tnl_port *tnl_port;
 
-    /* remote_ip, local_ip, in_key */
-    if (!is_multicast) {
-        tnl_port = tnl_find_exact(&match);
-        if (tnl_port) {
-            return tnl_port;
+        HMAP_FOR_EACH_WITH_HASH (tnl_port, match_node, tnl_hash(match), map) {
+            if (!memcmp(match, &tnl_port->match, sizeof *match)) {
+                return tnl_port;
+            }
         }
     }
+    return NULL;
+}
 
-    /* remote_ip, in_key */
-    match.ip_src = 0;
-    tnl_port = tnl_find_exact(&match);
-    if (tnl_port) {
-        return tnl_port;
-    }
-    match.ip_src = match_->ip_src;
-
-    /* remote_ip, local_ip */
-    if (!is_multicast) {
-        match.in_key = 0;
-        match.in_key_flow = true;
-        tnl_port = tnl_find_exact(&match);
-        if (tnl_port) {
-            return tnl_port;
+/* Returns the tnl_port that is the best match for the tunnel data in 'flow',
+ * or NULL if no tnl_port matches 'flow'. */
+static struct tnl_port *
+tnl_find(const struct flow *flow) OVS_REQ_RDLOCK(rwlock)
+{
+    enum ip_src_type ip_src;
+    int in_key_flow;
+    int ip_dst_flow;
+    int i;
+
+    i = 0;
+    for (in_key_flow = 0; in_key_flow < 2; in_key_flow++) {
+        for (ip_dst_flow = 0; ip_dst_flow < 2; ip_dst_flow++) {
+            for (ip_src = 0; ip_src < 3; ip_src++) {
+                struct hmap *map = tnl_match_maps[i];
+
+                if (map) {
+                    struct tnl_port *tnl_port;
+                    struct tnl_match match;
+
+                    memset(&match, 0, sizeof match);
+
+                    /* The apparent mix-up of 'ip_dst' and 'ip_src' below is
+                     * correct, because "struct tnl_match" is expressed in
+                     * terms of packets being sent out, but we are using it
+                     * here as a description of how to treat received
+                     * packets. */
+                    match.in_key = in_key_flow ? 0 : flow->tunnel.tun_id;
+                    if (ip_src == IP_SRC_CFG) {
+                        match.ipv6_src = flow_tnl_dst(&flow->tunnel);
+                    }
+                    if (!ip_dst_flow) {
+                        match.ipv6_dst = flow_tnl_src(&flow->tunnel);
+                    }
+                    match.odp_port = flow->in_port.odp_port;
+                    match.pkt_mark = flow->pkt_mark;
+                    match.in_key_flow = in_key_flow;
+                    match.ip_dst_flow = ip_dst_flow;
+                    match.ip_src_flow = ip_src == IP_SRC_FLOW;
+
+                    tnl_port = tnl_find_exact(&match, map);
+                    if (tnl_port) {
+                        return tnl_port;
+                    }
+                }
+
+                i++;
+            }
         }
-        match.in_key = match_->in_key;
-        match.in_key_flow = false;
     }
 
-    /* remote_ip */
-    match.ip_src = 0;
-    match.in_key = 0;
-    match.in_key_flow = true;
-    tnl_port = tnl_find_exact(&match);
-    if (tnl_port) {
-        return tnl_port;
-    }
-    match.ip_src = match_->ip_src;
-    match.in_key = match_->in_key;
-    match.in_key_flow = false;
+    return NULL;
+}
 
-    if (is_multicast) {
-        match.ip_src = 0;
-        match.ip_dst = match_->ip_src;
+/* Returns a pointer to the 'tnl_match_maps' element corresponding to 'm''s
+ * matching criteria. */
+static struct hmap **
+tnl_match_map(const struct tnl_match *m)
+{
+    enum ip_src_type ip_src;
 
-        /* multicast remote_ip, in_key */
-        tnl_port = tnl_find_exact(&match);
-        if (tnl_port) {
-            return tnl_port;
-        }
+    ip_src = (m->ip_src_flow ? IP_SRC_FLOW
+              : ipv6_addr_is_set(&m->ipv6_src) ? IP_SRC_CFG
+              : IP_SRC_ANY);
 
-        /* multicast remote_ip */
-        match.in_key = 0;
-        match.in_key_flow = true;
-        tnl_port = tnl_find_exact(&match);
-        if (tnl_port) {
-            return tnl_port;
-        }
-    }
-    return NULL;
+    return &tnl_match_maps[6 * m->in_key_flow + 3 * m->ip_dst_flow + ip_src];
 }
 
 static void
 tnl_match_fmt(const struct tnl_match *match, struct ds *ds)
+    OVS_REQ_RDLOCK(rwlock)
 {
-    ds_put_format(ds, IP_FMT"->"IP_FMT, IP_ARGS(match->ip_src),
-                  IP_ARGS(match->ip_dst));
+    if (!match->ip_dst_flow) {
+        ipv6_format_mapped(&match->ipv6_src, ds);
+        ds_put_cstr(ds, "->");
+        ipv6_format_mapped(&match->ipv6_dst, ds);
+    } else if (!match->ip_src_flow) {
+        ipv6_format_mapped(&match->ipv6_src, ds);
+        ds_put_cstr(ds, "->flow");
+    } else {
+        ds_put_cstr(ds, "flow->flow");
+    }
 
     if (match->in_key_flow) {
         ds_put_cstr(ds, ", key=flow");
@@ -393,10 +615,12 @@ tnl_match_fmt(const struct tnl_match *match, struct ds *ds)
     }
 
     ds_put_format(ds, ", dp port=%"PRIu32, match->odp_port);
+    ds_put_format(ds, ", pkt mark=%"PRIu32, match->pkt_mark);
 }
 
 static void
 tnl_port_mod_log(const struct tnl_port *tnl_port, const char *action)
+    OVS_REQ_RDLOCK(rwlock)
 {
     if (VLOG_IS_DBG_ENABLED()) {
         struct ds ds = DS_EMPTY_INITIALIZER;
@@ -409,15 +633,15 @@ tnl_port_mod_log(const struct tnl_port *tnl_port, const char *action)
 }
 
 static char *
-tnl_port_fmt(const struct tnl_port *tnl_port)
+tnl_port_fmt(const struct tnl_port *tnl_port) OVS_REQ_RDLOCK(rwlock)
 {
     const struct netdev_tunnel_config *cfg =
-        netdev_get_tunnel_config(tnl_port->ofport->netdev);
+        netdev_get_tunnel_config(tnl_port->netdev);
     struct ds ds = DS_EMPTY_INITIALIZER;
 
     ds_put_format(&ds, "port %"PRIu32": %s (%s: ", tnl_port->match.odp_port,
                   tnl_port_get_name(tnl_port),
-                  netdev_get_type(tnl_port->ofport->netdev));
+                  netdev_get_type(tnl_port->netdev));
     tnl_match_fmt(&tnl_port->match, &ds);
 
     if (cfg->out_key != cfg->in_key ||
@@ -459,7 +683,73 @@ tnl_port_fmt(const struct tnl_port *tnl_port)
 }
 
 static const char *
-tnl_port_get_name(const struct tnl_port *tnl_port)
+tnl_port_get_name(const struct tnl_port *tnl_port) OVS_REQ_RDLOCK(rwlock)
+{
+    return netdev_get_name(tnl_port->netdev);
+}
+
+int
+tnl_port_build_header(const struct ofport_dpif *ofport,
+                      const struct flow *tnl_flow,
+                      const struct eth_addr dmac,
+                      const struct eth_addr smac,
+                      const struct in6_addr * ipv6_src,
+                      struct ovs_action_push_tnl *data)
 {
-    return netdev_get_name(tnl_port->ofport->netdev);
+    struct tnl_port *tnl_port;
+    struct eth_header *eth;
+    struct ip_header *ip;
+    struct ovs_16aligned_ip6_hdr *ip6;
+    void *l3;
+    int res;
+    ovs_be32 ip_src;
+
+    fat_rwlock_rdlock(&rwlock);
+    tnl_port = tnl_find_ofport(ofport);
+    ovs_assert(tnl_port);
+
+    ip_src = in6_addr_get_mapped_ipv4(ipv6_src);
+
+    /* Build Ethernet and IP headers. */
+    memset(data->header, 0, sizeof data->header);
+
+    eth = (struct eth_header *)data->header;
+    eth->eth_dst = dmac;
+    eth->eth_src = smac;
+    eth->eth_type = ip_src ? htons(ETH_TYPE_IP) : htons(ETH_TYPE_IPV6);
+
+    l3 = (eth + 1);
+
+    if (ip_src) {
+        ip = (struct ip_header *) l3;
+
+        ip->ip_ihl_ver = IP_IHL_VER(5, 4);
+        ip->ip_tos = tnl_flow->tunnel.ip_tos;
+        ip->ip_ttl = tnl_flow->tunnel.ip_ttl;
+        ip->ip_frag_off = (tnl_flow->tunnel.flags & FLOW_TNL_F_DONT_FRAGMENT) ?
+                          htons(IP_DF) : 0;
+
+        put_16aligned_be32(&ip->ip_src, ip_src);
+        put_16aligned_be32(&ip->ip_dst, tnl_flow->tunnel.ip_dst);
+    } else {
+        ip6 = (struct ovs_16aligned_ip6_hdr *) l3;
+
+        ip6->ip6_vfc = 0x60;
+        ip6->ip6_hlim = tnl_flow->tunnel.ip_ttl;
+
+        /* next header, plen - at netdev_build_header? */
+
+        memcpy(&ip6->ip6_src, ipv6_src, sizeof(ovs_be32[4]));
+        memcpy(&ip6->ip6_dst, &tnl_flow->tunnel.ipv6_dst, sizeof(ovs_be32[4]));
+    }
+
+    res = netdev_build_header(tnl_port->netdev, data, tnl_flow);
+
+    if (ip_src) {
+        ip->ip_csum = csum(ip, sizeof *ip);
+    }
+
+    fat_rwlock_unlock(&rwlock);
+
+    return res;
 }