1 /* Copyright (c) 2015 Nicira, Inc.
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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include "ofp-actions.h"
23 #include "ovn-controller.h"
24 #include "ovn/lib/ovn-sb-idl.h"
25 #include "openvswitch/vlog.h"
30 #include "vswitch-idl.h"
32 VLOG_DEFINE_THIS_MODULE(physical
);
35 physical_register_ovs_idl(struct ovsdb_idl
*ovs_idl
)
37 ovsdb_idl_add_table(ovs_idl
, &ovsrec_table_bridge
);
38 ovsdb_idl_add_column(ovs_idl
, &ovsrec_bridge_col_ports
);
40 ovsdb_idl_add_table(ovs_idl
, &ovsrec_table_port
);
41 ovsdb_idl_add_column(ovs_idl
, &ovsrec_port_col_name
);
42 ovsdb_idl_add_column(ovs_idl
, &ovsrec_port_col_interfaces
);
43 ovsdb_idl_add_column(ovs_idl
, &ovsrec_port_col_external_ids
);
45 ovsdb_idl_add_table(ovs_idl
, &ovsrec_table_interface
);
46 ovsdb_idl_add_column(ovs_idl
, &ovsrec_interface_col_name
);
47 ovsdb_idl_add_column(ovs_idl
, &ovsrec_interface_col_ofport
);
48 ovsdb_idl_add_column(ovs_idl
, &ovsrec_interface_col_external_ids
);
51 /* Maps from a chassis to the OpenFlow port number of the tunnel that can be
52 * used to reach that chassis. */
53 struct chassis_tunnel
{
54 struct hmap_node hmap_node
;
55 const char *chassis_id
;
57 enum chassis_tunnel_type type
;
60 static struct chassis_tunnel
*
61 chassis_tunnel_find(struct hmap
*tunnels
, const char *chassis_id
)
63 struct chassis_tunnel
*tun
;
64 HMAP_FOR_EACH_WITH_HASH (tun
, hmap_node
, hash_string(chassis_id
, 0),
66 if (!strcmp(tun
->chassis_id
, chassis_id
)) {
74 put_load(uint64_t value
, enum mf_field_id dst
, int ofs
, int n_bits
,
75 struct ofpbuf
*ofpacts
)
77 struct ofpact_set_field
*sf
= ofpact_put_SET_FIELD(ofpacts
);
78 sf
->field
= mf_from_id(dst
);
79 sf
->flow_has_vlan
= false;
81 ovs_be64 n_value
= htonll(value
);
82 bitwise_copy(&n_value
, 8, 0, &sf
->value
, sf
->field
->n_bytes
, ofs
, n_bits
);
83 bitwise_one(&sf
->mask
, sf
->field
->n_bytes
, ofs
, n_bits
);
87 put_move(enum mf_field_id src
, int src_ofs
,
88 enum mf_field_id dst
, int dst_ofs
,
90 struct ofpbuf
*ofpacts
)
92 struct ofpact_reg_move
*move
= ofpact_put_REG_MOVE(ofpacts
);
93 move
->src
.field
= mf_from_id(src
);
94 move
->src
.ofs
= src_ofs
;
95 move
->src
.n_bits
= n_bits
;
96 move
->dst
.field
= mf_from_id(dst
);
97 move
->dst
.ofs
= dst_ofs
;
98 move
->dst
.n_bits
= n_bits
;
102 put_resubmit(uint8_t table_id
, struct ofpbuf
*ofpacts
)
104 struct ofpact_resubmit
*resubmit
= ofpact_put_RESUBMIT(ofpacts
);
105 resubmit
->in_port
= OFPP_IN_PORT
;
106 resubmit
->table_id
= table_id
;
110 put_encapsulation(enum mf_field_id mff_ovn_geneve
,
111 const struct chassis_tunnel
*tun
,
112 const struct sbrec_datapath_binding
*datapath
,
113 uint16_t outport
, struct ofpbuf
*ofpacts
)
115 if (tun
->type
== GENEVE
) {
116 put_load(datapath
->tunnel_key
, MFF_TUN_ID
, 0, 24, ofpacts
);
117 put_load(outport
, mff_ovn_geneve
, 0, 32, ofpacts
);
118 put_move(MFF_LOG_INPORT
, 0, mff_ovn_geneve
, 16, 15, ofpacts
);
119 } else if (tun
->type
== STT
) {
120 put_load(datapath
->tunnel_key
| (outport
<< 24), MFF_TUN_ID
, 0, 64,
122 put_move(MFF_LOG_INPORT
, 0, MFF_TUN_ID
, 40, 15, ofpacts
);
123 } else if (tun
->type
== VXLAN
) {
124 put_load(datapath
->tunnel_key
, MFF_TUN_ID
, 0, 24, ofpacts
);
131 put_stack(enum mf_field_id field
, struct ofpact_stack
*stack
)
133 stack
->subfield
.field
= mf_from_id(field
);
134 stack
->subfield
.ofs
= 0;
135 stack
->subfield
.n_bits
= stack
->subfield
.field
->n_bits
;
139 physical_run(struct controller_ctx
*ctx
, enum mf_field_id mff_ovn_geneve
,
140 const struct ovsrec_bridge
*br_int
, const char *this_chassis_id
,
141 const struct simap
*ct_zones
, struct hmap
*flow_table
)
143 struct simap localvif_to_ofport
= SIMAP_INITIALIZER(&localvif_to_ofport
);
144 struct hmap tunnels
= HMAP_INITIALIZER(&tunnels
);
145 struct simap localnet_to_ofport
= SIMAP_INITIALIZER(&localnet_to_ofport
);
147 for (int i
= 0; i
< br_int
->n_ports
; i
++) {
148 const struct ovsrec_port
*port_rec
= br_int
->ports
[i
];
149 if (!strcmp(port_rec
->name
, br_int
->name
)) {
153 const char *chassis_id
= smap_get(&port_rec
->external_ids
,
155 if (chassis_id
&& !strcmp(chassis_id
, this_chassis_id
)) {
159 const char *localnet
= smap_get(&port_rec
->external_ids
,
160 "ovn-localnet-port");
161 const char *logpatch
= smap_get(&port_rec
->external_ids
,
162 "ovn-logical-patch-port");
164 for (int j
= 0; j
< port_rec
->n_interfaces
; j
++) {
165 const struct ovsrec_interface
*iface_rec
= port_rec
->interfaces
[j
];
167 /* Get OpenFlow port number. */
168 if (!iface_rec
->n_ofport
) {
171 int64_t ofport
= iface_rec
->ofport
[0];
172 if (ofport
< 1 || ofport
> ofp_to_u16(OFPP_MAX
)) {
176 /* Record as patch to local net, logical patch port, chassis, or
177 * local logical port. */
178 bool is_patch
= !strcmp(iface_rec
->type
, "patch");
179 if (is_patch
&& localnet
) {
180 simap_put(&localnet_to_ofport
, localnet
, ofport
);
182 } else if (is_patch
&& logpatch
) {
183 /* Logical patch ports can be handled just like VIFs. */
184 simap_put(&localvif_to_ofport
, logpatch
, ofport
);
186 } else if (chassis_id
) {
187 enum chassis_tunnel_type tunnel_type
;
188 if (!strcmp(iface_rec
->type
, "geneve")) {
189 tunnel_type
= GENEVE
;
190 if (!mff_ovn_geneve
) {
193 } else if (!strcmp(iface_rec
->type
, "stt")) {
195 } else if (!strcmp(iface_rec
->type
, "vxlan")) {
201 struct chassis_tunnel
*tun
= xmalloc(sizeof *tun
);
202 hmap_insert(&tunnels
, &tun
->hmap_node
,
203 hash_string(chassis_id
, 0));
204 tun
->chassis_id
= chassis_id
;
205 tun
->ofport
= u16_to_ofp(ofport
);
206 tun
->type
= tunnel_type
;
209 const char *iface_id
= smap_get(&iface_rec
->external_ids
,
212 simap_put(&localvif_to_ofport
, iface_id
, ofport
);
218 struct ofpbuf ofpacts
;
219 ofpbuf_init(&ofpacts
, 0);
221 struct binding_elem
{
222 struct ovs_list list_elem
;
223 const struct sbrec_port_binding
*binding
;
225 /* The bindings for a given VLAN on a localnet port. */
226 struct localnet_vlan
{
227 struct hmap_node node
;
229 struct ovs_list bindings
;
231 /* A hash of localnet_vlans, hashed on VLAN ID, for a localnet port */
232 struct localnet_bindings
{
236 /* Maps from network name to "struct localnet_bindings". */
237 struct shash localnet_inputs
= SHASH_INITIALIZER(&localnet_inputs
);
239 /* Contains bare "struct hmap_node"s whose hash values are the tunnel_key
240 * of datapaths with at least one local port binding. */
241 struct hmap local_datapaths
= HMAP_INITIALIZER(&local_datapaths
);
243 /* Set up flows in table 0 for physical-to-logical translation and in table
244 * 64 for logical-to-physical translation. */
245 const struct sbrec_port_binding
*binding
;
246 SBREC_PORT_BINDING_FOR_EACH (binding
, ctx
->ovnsb_idl
) {
247 /* Find the OpenFlow port for the logical port, as 'ofport'. This is
250 * - If the port is a VIF on the chassis we're managing, the
251 * OpenFlow port for the VIF. 'tun' will be NULL.
253 * In this or the next case, for a container nested inside a VM
254 * and accessible via a VLAN, 'tag' is the VLAN ID; otherwise
257 * The same logic handles logical patch ports.
259 * - If the port is on a remote chassis, the OpenFlow port for a
260 * tunnel to the VIF's remote chassis. 'tun' identifies that
263 * - If the port is a "localnet" port for a network that is
264 * attached to the chassis we're managing, the OpenFlow port for
265 * the localnet port (a patch port).
267 * The "localnet" port may be configured with a VLAN ID. If so,
268 * 'tag' will be set to that VLAN ID; otherwise 'tag' is 0.
273 if (!strcmp(binding
->type
, "localnet")) {
274 const char *network
= smap_get(&binding
->options
, "network_name");
278 ofport
= u16_to_ofp(simap_get(&localnet_to_ofport
, network
));
279 if (ofport
&& binding
->tag
) {
282 } else if (binding
->parent_port
&& *binding
->parent_port
) {
286 ofport
= u16_to_ofp(simap_get(&localvif_to_ofport
,
287 binding
->parent_port
));
292 ofport
= u16_to_ofp(simap_get(&localvif_to_ofport
,
293 binding
->logical_port
));
296 const struct chassis_tunnel
*tun
= NULL
;
298 if (!binding
->chassis
) {
301 tun
= chassis_tunnel_find(&tunnels
, binding
->chassis
->name
);
305 ofport
= tun
->ofport
;
310 int zone_id
= simap_get(ct_zones
, binding
->logical_port
);
311 /* Packets that arrive from a vif can belong to a VM or
312 * to a container located inside that VM. Packets that
313 * arrive from containers have a tag (vlan) associated with them.
316 /* Table 0, Priority 150 and 100.
317 * ==============================
319 * Priority 150 is for tagged traffic. This may be containers in a
320 * VM or a VLAN on a local network. For such traffic, match on the
321 * tags and then strip the tag.
323 * Priority 100 is for traffic belonging to VMs or untagged locally
324 * connected networks.
326 * For both types of traffic: set MFF_LOG_INPORT to the logical
327 * input port, MFF_LOG_DATAPATH to the logical datapath, and
328 * resubmit into the logical ingress pipeline starting at table
330 if (!strcmp(binding
->type
, "localnet")) {
331 /* The same OpenFlow port may correspond to localnet ports
332 * attached to more than one logical datapath, so keep track of
333 * all associated bindings and add a flow at the end. */
336 = smap_get(&binding
->options
, "network_name");
337 struct localnet_bindings
*ln_bindings
;
338 struct hmap_node
*node
;
339 struct localnet_vlan
*ln_vlan
;
341 ln_bindings
= shash_find_data(&localnet_inputs
, network
);
343 ln_bindings
= xmalloc(sizeof *ln_bindings
);
344 ln_bindings
->ofport
= ofport
;
345 hmap_init(&ln_bindings
->vlans
);
346 shash_add(&localnet_inputs
, network
, ln_bindings
);
348 node
= hmap_first_with_hash(&ln_bindings
->vlans
, tag
);
350 ASSIGN_CONTAINER(ln_vlan
, node
, node
);
352 ln_vlan
= xmalloc(sizeof *ln_vlan
);
354 list_init(&ln_vlan
->bindings
);
355 hmap_insert(&ln_bindings
->vlans
, &ln_vlan
->node
, tag
);
358 struct binding_elem
*b
= xmalloc(sizeof *b
);
359 b
->binding
= binding
;
360 list_insert(&ln_vlan
->bindings
, &b
->list_elem
);
362 struct hmap_node
*ld
;
363 ld
= hmap_first_with_hash(&local_datapaths
,
364 binding
->datapath
->tunnel_key
);
366 ld
= xmalloc(sizeof *ld
);
367 hmap_insert(&local_datapaths
, ld
,
368 binding
->datapath
->tunnel_key
);
371 ofpbuf_clear(&ofpacts
);
372 match_init_catchall(&match
);
373 match_set_in_port(&match
, ofport
);
375 match_set_dl_vlan(&match
, htons(tag
));
379 put_load(zone_id
, MFF_LOG_CT_ZONE
, 0, 32, &ofpacts
);
382 /* Set MFF_LOG_DATAPATH and MFF_LOG_INPORT. */
383 put_load(binding
->datapath
->tunnel_key
, MFF_LOG_DATAPATH
, 0, 64,
385 put_load(binding
->tunnel_key
, MFF_LOG_INPORT
, 0, 32,
390 ofpact_put_STRIP_VLAN(&ofpacts
);
393 /* Resubmit to first logical ingress pipeline table. */
394 put_resubmit(OFTABLE_LOG_INGRESS_PIPELINE
, &ofpacts
);
395 ofctrl_add_flow(flow_table
, OFTABLE_PHY_TO_LOG
,
396 tag
? 150 : 100, &match
, &ofpacts
);
399 /* Table 33, priority 100.
400 * =======================
402 * Implements output to local hypervisor. Each flow matches a
403 * logical output port on the local hypervisor, and resubmits to
407 match_init_catchall(&match
);
408 ofpbuf_clear(&ofpacts
);
410 /* Match MFF_LOG_DATAPATH, MFF_LOG_OUTPORT. */
411 match_set_metadata(&match
, htonll(binding
->datapath
->tunnel_key
));
412 match_set_reg(&match
, MFF_LOG_OUTPORT
- MFF_REG0
,
413 binding
->tunnel_key
);
416 put_load(zone_id
, MFF_LOG_CT_ZONE
, 0, 32, &ofpacts
);
419 /* Resubmit to table 34. */
420 put_resubmit(OFTABLE_DROP_LOOPBACK
, &ofpacts
);
421 ofctrl_add_flow(flow_table
, OFTABLE_LOCAL_OUTPUT
, 100, &match
,
424 /* Table 64, Priority 100.
425 * =======================
427 * Deliver the packet to the local vif. */
428 match_init_catchall(&match
);
429 ofpbuf_clear(&ofpacts
);
430 match_set_metadata(&match
, htonll(binding
->datapath
->tunnel_key
));
431 match_set_reg(&match
, MFF_LOG_OUTPORT
- MFF_REG0
,
432 binding
->tunnel_key
);
434 /* For containers sitting behind a local vif, tag the packets
435 * before delivering them. */
436 struct ofpact_vlan_vid
*vlan_vid
;
437 vlan_vid
= ofpact_put_SET_VLAN_VID(&ofpacts
);
438 vlan_vid
->vlan_vid
= tag
;
439 vlan_vid
->push_vlan_if_needed
= true;
441 /* A packet might need to hair-pin back into its ingress
442 * OpenFlow port (to a different logical port, which we already
443 * checked back in table 34), so set the in_port to zero. */
444 put_stack(MFF_IN_PORT
, ofpact_put_STACK_PUSH(&ofpacts
));
445 put_load(0, MFF_IN_PORT
, 0, 16, &ofpacts
);
447 ofpact_put_OUTPUT(&ofpacts
)->port
= ofport
;
449 /* Revert the tag added to the packets headed to containers
450 * in the previous step. If we don't do this, the packets
451 * that are to be broadcasted to a VM in the same logical
452 * switch will also contain the tag. Also revert the zero'd
454 ofpact_put_STRIP_VLAN(&ofpacts
);
455 put_stack(MFF_IN_PORT
, ofpact_put_STACK_POP(&ofpacts
));
457 ofctrl_add_flow(flow_table
, OFTABLE_LOG_TO_PHY
, 100,
460 /* Table 32, priority 100.
461 * =======================
463 * Implements output to remote hypervisors. Each flow matches an
464 * output port that includes a logical port on a remote hypervisor,
465 * and tunnels the packet to that hypervisor.
468 match_init_catchall(&match
);
469 ofpbuf_clear(&ofpacts
);
471 /* Match MFF_LOG_DATAPATH, MFF_LOG_OUTPORT. */
472 match_set_metadata(&match
, htonll(binding
->datapath
->tunnel_key
));
473 match_set_reg(&match
, MFF_LOG_OUTPORT
- MFF_REG0
,
474 binding
->tunnel_key
);
476 put_encapsulation(mff_ovn_geneve
, tun
, binding
->datapath
,
477 binding
->tunnel_key
, &ofpacts
);
479 /* Output to tunnel. */
480 ofpact_put_OUTPUT(&ofpacts
)->port
= ofport
;
481 ofctrl_add_flow(flow_table
, OFTABLE_REMOTE_OUTPUT
, 100,
485 /* Table 34, Priority 100.
486 * =======================
488 * Drop packets whose logical inport and outport are the same. */
489 match_init_catchall(&match
);
490 ofpbuf_clear(&ofpacts
);
491 match_set_metadata(&match
, htonll(binding
->datapath
->tunnel_key
));
492 match_set_reg(&match
, MFF_LOG_INPORT
- MFF_REG0
, binding
->tunnel_key
);
493 match_set_reg(&match
, MFF_LOG_OUTPORT
- MFF_REG0
, binding
->tunnel_key
);
494 ofctrl_add_flow(flow_table
, OFTABLE_DROP_LOOPBACK
, 100,
498 /* Handle output to multicast groups, in tables 32 and 33. */
499 const struct sbrec_multicast_group
*mc
;
500 struct ofpbuf remote_ofpacts
;
501 ofpbuf_init(&remote_ofpacts
, 0);
502 SBREC_MULTICAST_GROUP_FOR_EACH (mc
, ctx
->ovnsb_idl
) {
503 struct sset remote_chassis
= SSET_INITIALIZER(&remote_chassis
);
506 match_init_catchall(&match
);
507 match_set_metadata(&match
, htonll(mc
->datapath
->tunnel_key
));
508 match_set_reg(&match
, MFF_LOG_OUTPORT
- MFF_REG0
, mc
->tunnel_key
);
510 /* Go through all of the ports in the multicast group:
512 * - For remote ports, add the chassis to 'remote_chassis'.
514 * - For local ports (other than logical patch ports), add actions
515 * to 'ofpacts' to set the output port and resubmit.
517 * - For logical patch ports, add actions to 'remote_ofpacts'
518 * instead. (If we put them in 'ofpacts', then the output
519 * would happen on every hypervisor in the multicast group,
520 * effectively duplicating the packet.)
522 ofpbuf_clear(&ofpacts
);
523 ofpbuf_clear(&remote_ofpacts
);
524 for (size_t i
= 0; i
< mc
->n_ports
; i
++) {
525 struct sbrec_port_binding
*port
= mc
->ports
[i
];
527 if (port
->datapath
!= mc
->datapath
) {
528 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(5, 1);
529 VLOG_WARN_RL(&rl
, UUID_FMT
": multicast group contains ports "
531 UUID_ARGS(&mc
->header_
.uuid
));
535 int zone_id
= simap_get(ct_zones
, port
->logical_port
);
537 put_load(zone_id
, MFF_LOG_CT_ZONE
, 0, 32, &ofpacts
);
540 if (!strcmp(port
->type
, "patch")) {
541 put_load(port
->tunnel_key
, MFF_LOG_OUTPORT
, 0, 32,
543 put_resubmit(OFTABLE_DROP_LOOPBACK
, &remote_ofpacts
);
544 } else if (simap_contains(&localvif_to_ofport
,
545 (port
->parent_port
&& *port
->parent_port
)
546 ? port
->parent_port
: port
->logical_port
)) {
547 put_load(port
->tunnel_key
, MFF_LOG_OUTPORT
, 0, 32, &ofpacts
);
548 put_resubmit(OFTABLE_DROP_LOOPBACK
, &ofpacts
);
549 } else if (port
->chassis
) {
550 sset_add(&remote_chassis
, port
->chassis
->name
);
551 } else if (!strcmp(port
->type
, "localnet")) {
552 const char *network
= smap_get(&port
->options
, "network_name");
556 if (!simap_contains(&localnet_to_ofport
, network
)) {
559 put_load(port
->tunnel_key
, MFF_LOG_OUTPORT
, 0, 32, &ofpacts
);
560 put_resubmit(OFTABLE_DROP_LOOPBACK
, &ofpacts
);
564 /* Table 33, priority 100.
565 * =======================
567 * Handle output to the local logical ports in the multicast group, if
569 bool local_ports
= ofpacts
.size
> 0;
571 /* Following delivery to local logical ports, restore the multicast
572 * group as the logical output port. */
573 put_load(mc
->tunnel_key
, MFF_LOG_OUTPORT
, 0, 32, &ofpacts
);
575 ofctrl_add_flow(flow_table
, OFTABLE_LOCAL_OUTPUT
, 100,
579 /* Table 32, priority 100.
580 * =======================
582 * Handle output to the remote chassis in the multicast group, if
584 if (!sset_is_empty(&remote_chassis
) || remote_ofpacts
.size
> 0) {
585 if (remote_ofpacts
.size
> 0) {
586 /* Following delivery to logical patch ports, restore the
587 * multicast group as the logical output port. */
588 put_load(mc
->tunnel_key
, MFF_LOG_OUTPORT
, 0, 32,
593 const struct chassis_tunnel
*prev
= NULL
;
594 SSET_FOR_EACH (chassis
, &remote_chassis
) {
595 const struct chassis_tunnel
*tun
596 = chassis_tunnel_find(&tunnels
, chassis
);
601 if (!prev
|| tun
->type
!= prev
->type
) {
602 put_encapsulation(mff_ovn_geneve
, tun
, mc
->datapath
,
603 mc
->tunnel_key
, &remote_ofpacts
);
606 ofpact_put_OUTPUT(&remote_ofpacts
)->port
= tun
->ofport
;
609 if (remote_ofpacts
.size
) {
611 put_resubmit(OFTABLE_LOCAL_OUTPUT
, &remote_ofpacts
);
613 ofctrl_add_flow(flow_table
, OFTABLE_REMOTE_OUTPUT
, 100,
614 &match
, &remote_ofpacts
);
617 sset_destroy(&remote_chassis
);
619 ofpbuf_uninit(&remote_ofpacts
);
621 /* Table 0, priority 100.
622 * ======================
624 * Process packets that arrive from a remote hypervisor (by matching
625 * on tunnel in_port). */
627 /* Add flows for Geneve and STT encapsulations. These
628 * encapsulations have metadata about the ingress and egress logical
629 * ports. We set MFF_LOG_DATAPATH, MFF_LOG_INPORT, and
630 * MFF_LOG_OUTPORT from the tunnel key data, then resubmit to table
631 * 33 to handle packets to the local hypervisor. */
632 struct chassis_tunnel
*tun
;
633 HMAP_FOR_EACH (tun
, hmap_node
, &tunnels
) {
634 struct match match
= MATCH_CATCHALL_INITIALIZER
;
635 match_set_in_port(&match
, tun
->ofport
);
637 ofpbuf_clear(&ofpacts
);
638 if (tun
->type
== GENEVE
) {
639 put_move(MFF_TUN_ID
, 0, MFF_LOG_DATAPATH
, 0, 24, &ofpacts
);
640 put_move(mff_ovn_geneve
, 16, MFF_LOG_INPORT
, 0, 15,
642 put_move(mff_ovn_geneve
, 0, MFF_LOG_OUTPORT
, 0, 16,
644 } else if (tun
->type
== STT
) {
645 put_move(MFF_TUN_ID
, 40, MFF_LOG_INPORT
, 0, 15, &ofpacts
);
646 put_move(MFF_TUN_ID
, 24, MFF_LOG_OUTPORT
, 0, 16, &ofpacts
);
647 put_move(MFF_TUN_ID
, 0, MFF_LOG_DATAPATH
, 0, 24, &ofpacts
);
648 } else if (tun
->type
== VXLAN
) {
649 /* We'll handle VXLAN later. */
655 put_resubmit(OFTABLE_LOCAL_OUTPUT
, &ofpacts
);
657 ofctrl_add_flow(flow_table
, OFTABLE_PHY_TO_LOG
, 100, &match
, &ofpacts
);
660 /* Add flows for VXLAN encapsulations. Due to the limited amount of
661 * metadata, we only support VXLAN for connections to gateways. The
662 * VNI is used to populate MFF_LOG_DATAPATH. The gateway's logical
663 * port is set to MFF_LOG_INPORT. Then the packet is resubmitted to
664 * table 16 to determine the logical egress port.
666 * xxx Due to resubmitting to table 16, broadcasts will be re-sent to
667 * xxx all logical ports, including non-local ones which could cause
668 * xxx duplicate packets to be received by multiply-connected gateways. */
669 HMAP_FOR_EACH (tun
, hmap_node
, &tunnels
) {
670 if (tun
->type
!= VXLAN
) {
674 SBREC_PORT_BINDING_FOR_EACH (binding
, ctx
->ovnsb_idl
) {
675 struct match match
= MATCH_CATCHALL_INITIALIZER
;
677 if (!binding
->chassis
||
678 strcmp(tun
->chassis_id
, binding
->chassis
->name
)) {
682 match_set_in_port(&match
, tun
->ofport
);
683 match_set_tun_id(&match
, htonll(binding
->datapath
->tunnel_key
));
685 ofpbuf_clear(&ofpacts
);
686 put_move(MFF_TUN_ID
, 0, MFF_LOG_DATAPATH
, 0, 24, &ofpacts
);
687 put_load(binding
->tunnel_key
, MFF_LOG_INPORT
, 0, 15, &ofpacts
);
688 put_resubmit(OFTABLE_LOG_INGRESS_PIPELINE
, &ofpacts
);
690 ofctrl_add_flow(flow_table
, OFTABLE_PHY_TO_LOG
, 100, &match
,
695 /* Table 32, Priority 0.
696 * =======================
698 * Resubmit packets that are not directed at tunnels or part of a
699 * multicast group to the local output table. */
701 match_init_catchall(&match
);
702 ofpbuf_clear(&ofpacts
);
703 put_resubmit(OFTABLE_LOCAL_OUTPUT
, &ofpacts
);
704 ofctrl_add_flow(flow_table
, OFTABLE_REMOTE_OUTPUT
, 0, &match
, &ofpacts
);
706 /* Table 34, Priority 0.
707 * =======================
709 * Resubmit packets that don't output to the ingress port (already checked
710 * in table 33) to the logical egress pipeline, clearing the logical
711 * registers (for consistent behavior with packets that get tunneled). */
712 match_init_catchall(&match
);
713 ofpbuf_clear(&ofpacts
);
714 #define MFF_LOG_REG(ID) put_load(0, ID, 0, 32, &ofpacts);
717 put_resubmit(OFTABLE_LOG_EGRESS_PIPELINE
, &ofpacts
);
718 ofctrl_add_flow(flow_table
, OFTABLE_DROP_LOOPBACK
, 0, &match
, &ofpacts
);
720 ofpbuf_uninit(&ofpacts
);
721 simap_destroy(&localvif_to_ofport
);
722 struct chassis_tunnel
*tun_next
;
723 HMAP_FOR_EACH_SAFE (tun
, tun_next
, hmap_node
, &tunnels
) {
724 hmap_remove(&tunnels
, &tun
->hmap_node
);
727 hmap_destroy(&tunnels
);
729 /* Table 0, Priority 100.
730 * ======================
732 * We have now determined the full set of port bindings associated with
733 * each "localnet" network. Only create flows for datapaths that have
734 * another local binding. Otherwise, we know it would just be dropped.
736 struct shash_node
*ln_bindings_node
, *ln_bindings_node_next
;
737 SHASH_FOR_EACH_SAFE (ln_bindings_node
, ln_bindings_node_next
,
739 struct localnet_bindings
*ln_bindings
= ln_bindings_node
->data
;
740 struct localnet_vlan
*ln_vlan
, *ln_vlan_next
;
741 HMAP_FOR_EACH_SAFE (ln_vlan
, ln_vlan_next
, node
, &ln_bindings
->vlans
) {
743 match_init_catchall(&match
);
744 match_set_in_port(&match
, ln_bindings
->ofport
);
746 match_set_dl_vlan(&match
, htons(ln_vlan
->tag
));
748 /* Match priority-tagged frames, e.g. VLAN ID 0.
750 * We'll add a second flow for frames that lack any 802.1Q
752 match_set_dl_tci_masked(&match
, htons(VLAN_CFI
),
753 htons(VLAN_VID_MASK
| VLAN_CFI
));
756 struct ofpbuf ofpacts
;
757 ofpbuf_init(&ofpacts
, 0);
759 ofpact_put_STRIP_VLAN(&ofpacts
);
760 uint32_t ofpacts_orig_size
= ofpacts
.size
;
762 struct binding_elem
*b
;
763 LIST_FOR_EACH_POP (b
, list_elem
, &ln_vlan
->bindings
) {
764 struct hmap_node
*ld
;
765 ld
= hmap_first_with_hash(&local_datapaths
,
766 b
->binding
->datapath
->tunnel_key
);
768 /* Set MFF_LOG_DATAPATH and MFF_LOG_INPORT. */
769 put_load(b
->binding
->datapath
->tunnel_key
, MFF_LOG_DATAPATH
,
771 put_load(b
->binding
->tunnel_key
, MFF_LOG_INPORT
, 0, 32,
773 put_resubmit(OFTABLE_LOG_INGRESS_PIPELINE
, &ofpacts
);
779 if (ofpacts
.size
> ofpacts_orig_size
) {
780 ofctrl_add_flow(flow_table
, 0, 100, &match
, &ofpacts
);
783 /* Add a second flow for frames that lack any 802.1Q
784 * header. For these, drop the OFPACT_STRIP_VLAN
786 ofpbuf_pull(&ofpacts
, ofpacts_orig_size
);
787 match_set_dl_tci_masked(&match
, 0, htons(VLAN_CFI
));
788 ofctrl_add_flow(flow_table
, 0, 100, &match
, &ofpacts
);
792 ofpbuf_uninit(&ofpacts
);
794 hmap_remove(&ln_bindings
->vlans
, &ln_vlan
->node
);
797 shash_delete(&localnet_inputs
, ln_bindings_node
);
798 hmap_destroy(&ln_bindings
->vlans
);
801 shash_destroy(&localnet_inputs
);
803 struct hmap_node
*node
;
804 while ((node
= hmap_first(&local_datapaths
))) {
805 hmap_remove(&local_datapaths
, node
);
808 hmap_destroy(&local_datapaths
);
810 simap_destroy(&localnet_to_ofport
);