ofproto-dpif-xlate: Honor skip_wildcards in translation.
[cascardo/ovs.git] / ofproto / tunnel.c
1 /* Copyright (c) 2013, 2014 Nicira, Inc.
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License. */
14
15 #include <config.h>
16 #include "tunnel.h"
17
18 #include <errno.h>
19
20 #include "byte-order.h"
21 #include "connectivity.h"
22 #include "csum.h"
23 #include "dpif.h"
24 #include "dynamic-string.h"
25 #include "fat-rwlock.h"
26 #include "hash.h"
27 #include "hmap.h"
28 #include "netdev.h"
29 #include "odp-util.h"
30 #include "ofpbuf.h"
31 #include "packets.h"
32 #include "route-table.h"
33 #include "seq.h"
34 #include "smap.h"
35 #include "socket-util.h"
36 #include "tnl-arp-cache.h"
37 #include "tnl-ports.h"
38 #include "tunnel.h"
39 #include "openvswitch/vlog.h"
40 #include "unaligned.h"
41 #include "ofproto-dpif.h"
42
43 VLOG_DEFINE_THIS_MODULE(tunnel);
44
45 /* skb mark used for IPsec tunnel packets */
46 #define IPSEC_MARK 1
47
48 struct tnl_match {
49     ovs_be64 in_key;
50     ovs_be32 ip_src;
51     ovs_be32 ip_dst;
52     odp_port_t odp_port;
53     uint32_t pkt_mark;
54     bool in_key_flow;
55     bool ip_src_flow;
56     bool ip_dst_flow;
57 };
58
59 struct tnl_port {
60     struct hmap_node ofport_node;
61     struct hmap_node match_node;
62
63     const struct ofport_dpif *ofport;
64     uint64_t change_seq;
65     struct netdev *netdev;
66
67     struct tnl_match match;
68 };
69
70 static struct fat_rwlock rwlock;
71
72 /* Tunnel matches.
73  *
74  * This module maps packets received over tunnel protocols to vports.  The
75  * tunnel protocol and, for some protocols, tunnel-specific information (e.g.,
76  * for VXLAN, the UDP destination port number) are always use as part of the
77  * mapping.  Which other fields are used for the mapping depends on the vports
78  * themselves (the parenthesized notations refer to "struct tnl_match" fields):
79  *
80  *     - in_key: A vport may match a specific tunnel ID (in_key_flow == false)
81  *       or arrange for the tunnel ID to be matched as tunnel.tun_id in the
82  *       OpenFlow flow (in_key_flow == true).
83  *
84  *     - ip_dst: A vport may match a specific destination IP address
85  *       (ip_dst_flow == false) or arrange for the destination IP to be matched
86  *       as tunnel.ip_dst in the OpenFlow flow (ip_dst_flow == true).
87  *
88  *     - ip_src: A vport may match a specific IP source address (ip_src_flow ==
89  *       false, ip_src != 0), wildcard all source addresses (ip_src_flow ==
90  *       false, ip_src == 0), or arrange for the IP source address to be
91  *       handled in the OpenFlow flow table (ip_src_flow == true).
92  *
93  * Thus, there are 2 * 2 * 3 == 12 possible ways a vport can match against a
94  * tunnel packet.  We number the possibilities for each field in increasing
95  * order as listed in each bullet above.  We order the 12 overall combinations
96  * in lexicographic order considering in_key first, then ip_dst, then
97  * ip_src. */
98 #define N_MATCH_TYPES (2 * 2 * 3)
99
100 /* The three possibilities (see above) for vport ip_src matches. */
101 enum ip_src_type {
102     IP_SRC_CFG,             /* ip_src must equal configured address. */
103     IP_SRC_ANY,             /* Any ip_src is acceptable. */
104     IP_SRC_FLOW             /* ip_src is handled in flow table. */
105 };
106
107 /* Each hmap contains "struct tnl_port"s.
108  * The index is a combination of how each of the fields listed under "Tunnel
109  * matches" above matches, see the final paragraph for ordering. */
110 static struct hmap *tnl_match_maps[N_MATCH_TYPES] OVS_GUARDED_BY(rwlock);
111 static struct hmap **tnl_match_map(const struct tnl_match *);
112
113 static struct hmap ofport_map__ = HMAP_INITIALIZER(&ofport_map__);
114 static struct hmap *ofport_map OVS_GUARDED_BY(rwlock) = &ofport_map__;
115
116 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
117 static struct vlog_rate_limit dbg_rl = VLOG_RATE_LIMIT_INIT(60, 60);
118
119 static struct tnl_port *tnl_find(const struct flow *) OVS_REQ_RDLOCK(rwlock);
120 static struct tnl_port *tnl_find_exact(struct tnl_match *, struct hmap *)
121     OVS_REQ_RDLOCK(rwlock);
122 static struct tnl_port *tnl_find_ofport(const struct ofport_dpif *)
123     OVS_REQ_RDLOCK(rwlock);
124
125 static uint32_t tnl_hash(struct tnl_match *);
126 static void tnl_match_fmt(const struct tnl_match *, struct ds *);
127 static char *tnl_port_fmt(const struct tnl_port *) OVS_REQ_RDLOCK(rwlock);
128 static void tnl_port_mod_log(const struct tnl_port *, const char *action)
129     OVS_REQ_RDLOCK(rwlock);
130 static const char *tnl_port_get_name(const struct tnl_port *)
131     OVS_REQ_RDLOCK(rwlock);
132 static void tnl_port_del__(const struct ofport_dpif *) OVS_REQ_WRLOCK(rwlock);
133
134 void
135 ofproto_tunnel_init(void)
136 {
137     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
138
139     if (ovsthread_once_start(&once)) {
140         fat_rwlock_init(&rwlock);
141         ovsthread_once_done(&once);
142     }
143 }
144
145 static bool
146 tnl_port_add__(const struct ofport_dpif *ofport, const struct netdev *netdev,
147                odp_port_t odp_port, bool warn, bool native_tnl, const char name[])
148     OVS_REQ_WRLOCK(rwlock)
149 {
150     const struct netdev_tunnel_config *cfg;
151     struct tnl_port *existing_port;
152     struct tnl_port *tnl_port;
153     struct hmap **map;
154
155     cfg = netdev_get_tunnel_config(netdev);
156     ovs_assert(cfg);
157
158     tnl_port = xzalloc(sizeof *tnl_port);
159     tnl_port->ofport = ofport;
160     tnl_port->netdev = netdev_ref(netdev);
161     tnl_port->change_seq = netdev_get_change_seq(tnl_port->netdev);
162
163     tnl_port->match.in_key = cfg->in_key;
164     tnl_port->match.ip_src = cfg->ip_src;
165     tnl_port->match.ip_dst = cfg->ip_dst;
166     tnl_port->match.ip_src_flow = cfg->ip_src_flow;
167     tnl_port->match.ip_dst_flow = cfg->ip_dst_flow;
168     tnl_port->match.pkt_mark = cfg->ipsec ? IPSEC_MARK : 0;
169     tnl_port->match.in_key_flow = cfg->in_key_flow;
170     tnl_port->match.odp_port = odp_port;
171
172     map = tnl_match_map(&tnl_port->match);
173     existing_port = tnl_find_exact(&tnl_port->match, *map);
174     if (existing_port) {
175         if (warn) {
176             struct ds ds = DS_EMPTY_INITIALIZER;
177             tnl_match_fmt(&tnl_port->match, &ds);
178             VLOG_WARN("%s: attempting to add tunnel port with same config as "
179                       "port '%s' (%s)", tnl_port_get_name(tnl_port),
180                       tnl_port_get_name(existing_port), ds_cstr(&ds));
181             ds_destroy(&ds);
182         }
183         netdev_close(tnl_port->netdev);
184         free(tnl_port);
185         return false;
186     }
187
188     hmap_insert(ofport_map, &tnl_port->ofport_node, hash_pointer(ofport, 0));
189
190     if (!*map) {
191         *map = xmalloc(sizeof **map);
192         hmap_init(*map);
193     }
194     hmap_insert(*map, &tnl_port->match_node, tnl_hash(&tnl_port->match));
195     tnl_port_mod_log(tnl_port, "adding");
196
197     if (native_tnl) {
198         tnl_port_map_insert(odp_port, tnl_port->match.ip_dst,
199                             cfg->dst_port, name);
200     }
201     return true;
202 }
203
204 /* Adds 'ofport' to the module with datapath port number 'odp_port'. 'ofport's
205  * must be added before they can be used by the module. 'ofport' must be a
206  * tunnel. */
207 void
208 tnl_port_add(const struct ofport_dpif *ofport, const struct netdev *netdev,
209              odp_port_t odp_port, bool native_tnl, const char name[]) OVS_EXCLUDED(rwlock)
210 {
211     fat_rwlock_wrlock(&rwlock);
212     tnl_port_add__(ofport, netdev, odp_port, true, native_tnl, name);
213     fat_rwlock_unlock(&rwlock);
214 }
215
216 /* Checks if the tunnel represented by 'ofport' reconfiguration due to changes
217  * in its netdev_tunnel_config.  If it does, returns true. Otherwise, returns
218  * false.  'ofport' and 'odp_port' should be the same as would be passed to
219  * tnl_port_add(). */
220 bool
221 tnl_port_reconfigure(const struct ofport_dpif *ofport,
222                      const struct netdev *netdev, odp_port_t odp_port,
223                      bool native_tnl, const char name[])
224     OVS_EXCLUDED(rwlock)
225 {
226     struct tnl_port *tnl_port;
227     bool changed = false;
228
229     fat_rwlock_wrlock(&rwlock);
230     tnl_port = tnl_find_ofport(ofport);
231     if (!tnl_port) {
232         changed = tnl_port_add__(ofport, netdev, odp_port, false, native_tnl, name);
233     } else if (tnl_port->netdev != netdev
234                || tnl_port->match.odp_port != odp_port
235                || tnl_port->change_seq != netdev_get_change_seq(tnl_port->netdev)) {
236         VLOG_DBG("reconfiguring %s", tnl_port_get_name(tnl_port));
237         tnl_port_del__(ofport);
238         tnl_port_add__(ofport, netdev, odp_port, true, native_tnl, name);
239         changed = true;
240     }
241     fat_rwlock_unlock(&rwlock);
242     return changed;
243 }
244
245 static void
246 tnl_port_del__(const struct ofport_dpif *ofport) OVS_REQ_WRLOCK(rwlock)
247 {
248     struct tnl_port *tnl_port;
249
250     if (!ofport) {
251         return;
252     }
253
254     tnl_port = tnl_find_ofport(ofport);
255     if (tnl_port) {
256         const struct netdev_tunnel_config *cfg =
257             netdev_get_tunnel_config(tnl_port->netdev);
258         struct hmap **map;
259
260         tnl_port_map_delete(tnl_port->match.ip_dst, cfg->dst_port);
261         tnl_port_mod_log(tnl_port, "removing");
262         map = tnl_match_map(&tnl_port->match);
263         hmap_remove(*map, &tnl_port->match_node);
264         if (hmap_is_empty(*map)) {
265             hmap_destroy(*map);
266             free(*map);
267             *map = NULL;
268         }
269         hmap_remove(ofport_map, &tnl_port->ofport_node);
270         netdev_close(tnl_port->netdev);
271         free(tnl_port);
272     }
273 }
274
275 /* Removes 'ofport' from the module. */
276 void
277 tnl_port_del(const struct ofport_dpif *ofport) OVS_EXCLUDED(rwlock)
278 {
279     fat_rwlock_wrlock(&rwlock);
280     tnl_port_del__(ofport);
281     fat_rwlock_unlock(&rwlock);
282 }
283
284 /* Looks in the table of tunnels for a tunnel matching the metadata in 'flow'.
285  * Returns the 'ofport' corresponding to the new in_port, or a null pointer if
286  * none is found.
287  *
288  * Callers should verify that 'flow' needs to be received by calling
289  * tnl_port_should_receive() before this function. */
290 const struct ofport_dpif *
291 tnl_port_receive(const struct flow *flow) OVS_EXCLUDED(rwlock)
292 {
293     char *pre_flow_str = NULL;
294     const struct ofport_dpif *ofport;
295     struct tnl_port *tnl_port;
296
297     fat_rwlock_rdlock(&rwlock);
298     tnl_port = tnl_find(flow);
299     ofport = tnl_port ? tnl_port->ofport : NULL;
300     if (!tnl_port) {
301         char *flow_str = flow_to_string(flow);
302
303         VLOG_WARN_RL(&rl, "receive tunnel port not found (%s)", flow_str);
304         free(flow_str);
305         goto out;
306     }
307
308     if (!VLOG_DROP_DBG(&dbg_rl)) {
309         pre_flow_str = flow_to_string(flow);
310     }
311
312     if (pre_flow_str) {
313         char *post_flow_str = flow_to_string(flow);
314         char *tnl_str = tnl_port_fmt(tnl_port);
315         VLOG_DBG("flow received\n"
316                  "%s"
317                  " pre: %s\n"
318                  "post: %s",
319                  tnl_str, pre_flow_str, post_flow_str);
320         free(tnl_str);
321         free(pre_flow_str);
322         free(post_flow_str);
323     }
324
325 out:
326     fat_rwlock_unlock(&rwlock);
327     return ofport;
328 }
329
330 static bool
331 tnl_ecn_ok(const struct flow *base_flow, struct flow *flow,
332            struct flow_wildcards *wc)
333 {
334     if (is_ip_any(base_flow)) {
335         if ((flow->tunnel.ip_tos & IP_ECN_MASK) == IP_ECN_CE) {
336             if (wc) {
337                 wc->masks.nw_tos |= IP_ECN_MASK;
338             }
339             if ((base_flow->nw_tos & IP_ECN_MASK) == IP_ECN_NOT_ECT) {
340                 VLOG_WARN_RL(&rl, "dropping tunnel packet marked ECN CE"
341                              " but is not ECN capable");
342                 return false;
343             } else {
344                 /* Set the ECN CE value in the tunneled packet. */
345                 flow->nw_tos |= IP_ECN_CE;
346             }
347         }
348     }
349
350     return true;
351 }
352
353 /* Should be called at the beginning of action translation to initialize
354  * wildcards and perform any actions based on receiving on tunnel port.
355  *
356  * Returns false if the packet must be dropped. */
357 bool
358 tnl_xlate_init(const struct flow *base_flow, struct flow *flow,
359                struct flow_wildcards *wc)
360 {
361     /* tnl_port_should_receive() examines the 'tunnel.ip_dst' field to
362      * determine the presence of the tunnel metadata.  However, since tunnels'
363      * datapath port numbers are different from the non-tunnel ports, and we
364      * always unwildcard the 'in_port', we do not need to unwildcard
365      * the 'tunnel.ip_dst' for non-tunneled packets. */
366     if (tnl_port_should_receive(flow)) {
367         if (wc) {
368             wc->masks.tunnel.tun_id = OVS_BE64_MAX;
369             wc->masks.tunnel.ip_src = OVS_BE32_MAX;
370             wc->masks.tunnel.ip_dst = OVS_BE32_MAX;
371             wc->masks.tunnel.flags = (FLOW_TNL_F_DONT_FRAGMENT |
372                                       FLOW_TNL_F_CSUM |
373                                       FLOW_TNL_F_KEY);
374             wc->masks.tunnel.ip_tos = UINT8_MAX;
375             wc->masks.tunnel.ip_ttl = UINT8_MAX;
376             /* The tp_src and tp_dst members in flow_tnl are set to be always
377              * wildcarded, not to unwildcard them here. */
378             wc->masks.tunnel.tp_src = 0;
379             wc->masks.tunnel.tp_dst = 0;
380
381             memset(&wc->masks.pkt_mark, 0xff, sizeof wc->masks.pkt_mark);
382         }
383         if (!tnl_ecn_ok(base_flow, flow, wc)) {
384             return false;
385         }
386
387         flow->pkt_mark &= ~IPSEC_MARK;
388     }
389
390     return true;
391 }
392
393 /* Given that 'flow' should be output to the ofport corresponding to
394  * 'tnl_port', updates 'flow''s tunnel headers and returns the actual datapath
395  * port that the output should happen on.  May return ODPP_NONE if the output
396  * shouldn't occur. */
397 odp_port_t
398 tnl_port_send(const struct ofport_dpif *ofport, struct flow *flow,
399               struct flow_wildcards *wc) OVS_EXCLUDED(rwlock)
400 {
401     const struct netdev_tunnel_config *cfg;
402     struct tnl_port *tnl_port;
403     char *pre_flow_str = NULL;
404     odp_port_t out_port;
405
406     fat_rwlock_rdlock(&rwlock);
407     tnl_port = tnl_find_ofport(ofport);
408     out_port = tnl_port ? tnl_port->match.odp_port : ODPP_NONE;
409     if (!tnl_port) {
410         goto out;
411     }
412
413     cfg = netdev_get_tunnel_config(tnl_port->netdev);
414     ovs_assert(cfg);
415
416     if (!VLOG_DROP_DBG(&dbg_rl)) {
417         pre_flow_str = flow_to_string(flow);
418     }
419
420     if (!cfg->ip_src_flow) {
421         flow->tunnel.ip_src = tnl_port->match.ip_src;
422     }
423     if (!cfg->ip_dst_flow) {
424         flow->tunnel.ip_dst = tnl_port->match.ip_dst;
425     }
426     flow->pkt_mark = tnl_port->match.pkt_mark;
427
428     if (!cfg->out_key_flow) {
429         flow->tunnel.tun_id = cfg->out_key;
430     }
431
432     if (cfg->ttl_inherit && is_ip_any(flow)) {
433         wc->masks.nw_ttl = 0xff;
434         flow->tunnel.ip_ttl = flow->nw_ttl;
435     } else {
436         flow->tunnel.ip_ttl = cfg->ttl;
437     }
438
439     if (cfg->tos_inherit && is_ip_any(flow)) {
440         wc->masks.nw_tos |= IP_DSCP_MASK;
441         flow->tunnel.ip_tos = flow->nw_tos & IP_DSCP_MASK;
442     } else {
443         flow->tunnel.ip_tos = cfg->tos;
444     }
445
446     /* ECN fields are always inherited. */
447     if (is_ip_any(flow)) {
448         wc->masks.nw_tos |= IP_ECN_MASK;
449
450         if ((flow->nw_tos & IP_ECN_MASK) == IP_ECN_CE) {
451             flow->tunnel.ip_tos |= IP_ECN_ECT_0;
452         } else {
453             flow->tunnel.ip_tos |= flow->nw_tos & IP_ECN_MASK;
454         }
455     }
456
457     flow->tunnel.flags = (cfg->dont_fragment ? FLOW_TNL_F_DONT_FRAGMENT : 0)
458         | (cfg->csum ? FLOW_TNL_F_CSUM : 0)
459         | (cfg->out_key_present ? FLOW_TNL_F_KEY : 0);
460
461     if (pre_flow_str) {
462         char *post_flow_str = flow_to_string(flow);
463         char *tnl_str = tnl_port_fmt(tnl_port);
464         VLOG_DBG("flow sent\n"
465                  "%s"
466                  " pre: %s\n"
467                  "post: %s",
468                  tnl_str, pre_flow_str, post_flow_str);
469         free(tnl_str);
470         free(pre_flow_str);
471         free(post_flow_str);
472     }
473
474 out:
475     fat_rwlock_unlock(&rwlock);
476     return out_port;
477 }
478
479 static uint32_t
480 tnl_hash(struct tnl_match *match)
481 {
482     BUILD_ASSERT_DECL(sizeof *match % sizeof(uint32_t) == 0);
483     return hash_words((uint32_t *) match, sizeof *match / sizeof(uint32_t), 0);
484 }
485
486 static struct tnl_port *
487 tnl_find_ofport(const struct ofport_dpif *ofport) OVS_REQ_RDLOCK(rwlock)
488 {
489     struct tnl_port *tnl_port;
490
491     HMAP_FOR_EACH_IN_BUCKET (tnl_port, ofport_node, hash_pointer(ofport, 0),
492                              ofport_map) {
493         if (tnl_port->ofport == ofport) {
494             return tnl_port;
495         }
496     }
497     return NULL;
498 }
499
500 static struct tnl_port *
501 tnl_find_exact(struct tnl_match *match, struct hmap *map)
502     OVS_REQ_RDLOCK(rwlock)
503 {
504     if (map) {
505         struct tnl_port *tnl_port;
506
507         HMAP_FOR_EACH_WITH_HASH (tnl_port, match_node, tnl_hash(match), map) {
508             if (!memcmp(match, &tnl_port->match, sizeof *match)) {
509                 return tnl_port;
510             }
511         }
512     }
513     return NULL;
514 }
515
516 /* Returns the tnl_port that is the best match for the tunnel data in 'flow',
517  * or NULL if no tnl_port matches 'flow'. */
518 static struct tnl_port *
519 tnl_find(const struct flow *flow) OVS_REQ_RDLOCK(rwlock)
520 {
521     enum ip_src_type ip_src;
522     int in_key_flow;
523     int ip_dst_flow;
524     int i;
525
526     i = 0;
527     for (in_key_flow = 0; in_key_flow < 2; in_key_flow++) {
528         for (ip_dst_flow = 0; ip_dst_flow < 2; ip_dst_flow++) {
529             for (ip_src = 0; ip_src < 3; ip_src++) {
530                 struct hmap *map = tnl_match_maps[i];
531
532                 if (map) {
533                     struct tnl_port *tnl_port;
534                     struct tnl_match match;
535
536                     memset(&match, 0, sizeof match);
537
538                     /* The apparent mix-up of 'ip_dst' and 'ip_src' below is
539                      * correct, because "struct tnl_match" is expressed in
540                      * terms of packets being sent out, but we are using it
541                      * here as a description of how to treat received
542                      * packets. */
543                     match.in_key = in_key_flow ? 0 : flow->tunnel.tun_id;
544                     match.ip_src = (ip_src == IP_SRC_CFG
545                                     ? flow->tunnel.ip_dst
546                                     : 0);
547                     match.ip_dst = ip_dst_flow ? 0 : flow->tunnel.ip_src;
548                     match.odp_port = flow->in_port.odp_port;
549                     match.pkt_mark = flow->pkt_mark;
550                     match.in_key_flow = in_key_flow;
551                     match.ip_dst_flow = ip_dst_flow;
552                     match.ip_src_flow = ip_src == IP_SRC_FLOW;
553
554                     tnl_port = tnl_find_exact(&match, map);
555                     if (tnl_port) {
556                         return tnl_port;
557                     }
558                 }
559
560                 i++;
561             }
562         }
563     }
564
565     return NULL;
566 }
567
568 /* Returns a pointer to the 'tnl_match_maps' element corresponding to 'm''s
569  * matching criteria. */
570 static struct hmap **
571 tnl_match_map(const struct tnl_match *m)
572 {
573     enum ip_src_type ip_src;
574
575     ip_src = (m->ip_src_flow ? IP_SRC_FLOW
576               : m->ip_src ? IP_SRC_CFG
577               : IP_SRC_ANY);
578
579     return &tnl_match_maps[6 * m->in_key_flow + 3 * m->ip_dst_flow + ip_src];
580 }
581
582 static void
583 tnl_match_fmt(const struct tnl_match *match, struct ds *ds)
584     OVS_REQ_RDLOCK(rwlock)
585 {
586     if (!match->ip_dst_flow) {
587         ds_put_format(ds, IP_FMT"->"IP_FMT, IP_ARGS(match->ip_src),
588                       IP_ARGS(match->ip_dst));
589     } else if (!match->ip_src_flow) {
590         ds_put_format(ds, IP_FMT"->flow", IP_ARGS(match->ip_src));
591     } else {
592         ds_put_cstr(ds, "flow->flow");
593     }
594
595     if (match->in_key_flow) {
596         ds_put_cstr(ds, ", key=flow");
597     } else {
598         ds_put_format(ds, ", key=%#"PRIx64, ntohll(match->in_key));
599     }
600
601     ds_put_format(ds, ", dp port=%"PRIu32, match->odp_port);
602     ds_put_format(ds, ", pkt mark=%"PRIu32, match->pkt_mark);
603 }
604
605 static void
606 tnl_port_mod_log(const struct tnl_port *tnl_port, const char *action)
607     OVS_REQ_RDLOCK(rwlock)
608 {
609     if (VLOG_IS_DBG_ENABLED()) {
610         struct ds ds = DS_EMPTY_INITIALIZER;
611
612         tnl_match_fmt(&tnl_port->match, &ds);
613         VLOG_INFO("%s tunnel port %s (%s)", action,
614                   tnl_port_get_name(tnl_port), ds_cstr(&ds));
615         ds_destroy(&ds);
616     }
617 }
618
619 static char *
620 tnl_port_fmt(const struct tnl_port *tnl_port) OVS_REQ_RDLOCK(rwlock)
621 {
622     const struct netdev_tunnel_config *cfg =
623         netdev_get_tunnel_config(tnl_port->netdev);
624     struct ds ds = DS_EMPTY_INITIALIZER;
625
626     ds_put_format(&ds, "port %"PRIu32": %s (%s: ", tnl_port->match.odp_port,
627                   tnl_port_get_name(tnl_port),
628                   netdev_get_type(tnl_port->netdev));
629     tnl_match_fmt(&tnl_port->match, &ds);
630
631     if (cfg->out_key != cfg->in_key ||
632         cfg->out_key_present != cfg->in_key_present ||
633         cfg->out_key_flow != cfg->in_key_flow) {
634         ds_put_cstr(&ds, ", out_key=");
635         if (!cfg->out_key_present) {
636             ds_put_cstr(&ds, "none");
637         } else if (cfg->out_key_flow) {
638             ds_put_cstr(&ds, "flow");
639         } else {
640             ds_put_format(&ds, "%#"PRIx64, ntohll(cfg->out_key));
641         }
642     }
643
644     if (cfg->ttl_inherit) {
645         ds_put_cstr(&ds, ", ttl=inherit");
646     } else {
647         ds_put_format(&ds, ", ttl=%"PRIu8, cfg->ttl);
648     }
649
650     if (cfg->tos_inherit) {
651         ds_put_cstr(&ds, ", tos=inherit");
652     } else if (cfg->tos) {
653         ds_put_format(&ds, ", tos=%#"PRIx8, cfg->tos);
654     }
655
656     if (!cfg->dont_fragment) {
657         ds_put_cstr(&ds, ", df=false");
658     }
659
660     if (cfg->csum) {
661         ds_put_cstr(&ds, ", csum=true");
662     }
663
664     ds_put_cstr(&ds, ")\n");
665
666     return ds_steal_cstr(&ds);
667 }
668
669 static const char *
670 tnl_port_get_name(const struct tnl_port *tnl_port) OVS_REQ_RDLOCK(rwlock)
671 {
672     return netdev_get_name(tnl_port->netdev);
673 }
674
675 int
676 tnl_port_build_header(const struct ofport_dpif *ofport,
677                       const struct flow *tnl_flow,
678                       uint8_t dmac[ETH_ADDR_LEN],
679                       uint8_t smac[ETH_ADDR_LEN],
680                       ovs_be32 ip_src, struct ovs_action_push_tnl *data)
681 {
682     struct tnl_port *tnl_port;
683     struct eth_header *eth;
684     struct ip_header *ip;
685     void *l3;
686     int res;
687
688     fat_rwlock_rdlock(&rwlock);
689     tnl_port = tnl_find_ofport(ofport);
690     ovs_assert(tnl_port);
691
692     /* Build Ethernet and IP headers. */
693     memset(data->header, 0, sizeof data->header);
694
695     eth = (struct eth_header *)data->header;
696     memcpy(eth->eth_dst, dmac, ETH_ADDR_LEN);
697     memcpy(eth->eth_src, smac, ETH_ADDR_LEN);
698     eth->eth_type = htons(ETH_TYPE_IP);
699
700     l3 = (eth + 1);
701     ip = (struct ip_header *) l3;
702
703     ip->ip_ihl_ver = IP_IHL_VER(5, 4);
704     ip->ip_tos = tnl_flow->tunnel.ip_tos;
705     ip->ip_ttl = tnl_flow->tunnel.ip_ttl;
706     ip->ip_frag_off = (tnl_flow->tunnel.flags & FLOW_TNL_F_DONT_FRAGMENT) ?
707                       htons(IP_DF) : 0;
708
709     put_16aligned_be32(&ip->ip_src, ip_src);
710     put_16aligned_be32(&ip->ip_dst, tnl_flow->tunnel.ip_dst);
711
712     res = netdev_build_header(tnl_port->netdev, data);
713     ip->ip_csum = csum(ip, sizeof *ip);
714     fat_rwlock_unlock(&rwlock);
715
716     return res;
717 }