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 { GENEVE, STT } 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);
129 put_stack(enum mf_field_id field, struct ofpact_stack *stack)
131 stack->subfield.field = mf_from_id(field);
132 stack->subfield.ofs = 0;
133 stack->subfield.n_bits = stack->subfield.field->n_bits;
137 physical_run(struct controller_ctx *ctx, enum mf_field_id mff_ovn_geneve,
138 const struct ovsrec_bridge *br_int, const char *this_chassis_id,
139 const struct simap *ct_zones, struct hmap *flow_table)
141 struct simap localvif_to_ofport = SIMAP_INITIALIZER(&localvif_to_ofport);
142 struct hmap tunnels = HMAP_INITIALIZER(&tunnels);
143 struct simap localnet_to_ofport = SIMAP_INITIALIZER(&localnet_to_ofport);
145 for (int i = 0; i < br_int->n_ports; i++) {
146 const struct ovsrec_port *port_rec = br_int->ports[i];
147 if (!strcmp(port_rec->name, br_int->name)) {
151 const char *chassis_id = smap_get(&port_rec->external_ids,
153 if (chassis_id && !strcmp(chassis_id, this_chassis_id)) {
157 const char *localnet = smap_get(&port_rec->external_ids,
160 for (int j = 0; j < port_rec->n_interfaces; j++) {
161 const struct ovsrec_interface *iface_rec = port_rec->interfaces[j];
163 /* Get OpenFlow port number. */
164 if (!iface_rec->n_ofport) {
167 int64_t ofport = iface_rec->ofport[0];
168 if (ofport < 1 || ofport > ofp_to_u16(OFPP_MAX)) {
172 /* Record as patch to local net, chassis, or local logical port. */
173 if (!strcmp(iface_rec->type, "patch") && localnet) {
174 simap_put(&localnet_to_ofport, localnet, ofport);
176 } else if (chassis_id) {
177 enum chassis_tunnel_type tunnel_type;
178 if (!strcmp(iface_rec->type, "geneve")) {
179 tunnel_type = GENEVE;
180 if (!mff_ovn_geneve) {
183 } else if (!strcmp(iface_rec->type, "stt")) {
189 struct chassis_tunnel *tun = xmalloc(sizeof *tun);
190 hmap_insert(&tunnels, &tun->hmap_node,
191 hash_string(chassis_id, 0));
192 tun->chassis_id = chassis_id;
193 tun->ofport = u16_to_ofp(ofport);
194 tun->type = tunnel_type;
197 const char *iface_id = smap_get(&iface_rec->external_ids,
200 simap_put(&localvif_to_ofport, iface_id, ofport);
206 struct ofpbuf ofpacts;
207 ofpbuf_init(&ofpacts, 0);
209 struct binding_elem {
210 struct ovs_list list_elem;
211 const struct sbrec_port_binding *binding;
213 /* The bindings for a given VLAN on a localnet port. */
214 struct localnet_vlan {
215 struct hmap_node node;
217 struct ovs_list bindings;
219 /* A hash of localnet_vlans, hashed on VLAN ID, for a localnet port */
220 struct localnet_bindings {
224 /* Maps from network name to "struct localnet_bindings". */
225 struct shash localnet_inputs = SHASH_INITIALIZER(&localnet_inputs);
227 /* Contains bare "struct hmap_node"s whose hash values are the tunnel_key
228 * of datapaths with at least one local port binding. */
229 struct hmap local_datapaths = HMAP_INITIALIZER(&local_datapaths);
231 /* Set up flows in table 0 for physical-to-logical translation and in table
232 * 64 for logical-to-physical translation. */
233 const struct sbrec_port_binding *binding;
234 SBREC_PORT_BINDING_FOR_EACH (binding, ctx->ovnsb_idl) {
235 /* Find the OpenFlow port for the logical port, as 'ofport'. This is
238 * - If the port is a VIF on the chassis we're managing, the
239 * OpenFlow port for the VIF. 'tun' will be NULL.
241 * In this or the next case, for a container nested inside a VM
242 * and accessible via a VLAN, 'tag' is the VLAN ID; otherwise
245 * - If the port is on a remote chassis, the OpenFlow port for a
246 * tunnel to the VIF's remote chassis. 'tun' identifies that
249 * - If the port is a "localnet" port for a network that is
250 * attached to the chassis we're managing, the OpenFlow port for
251 * the localnet port (a patch port).
253 * The "localnet" port may be configured with a VLAN ID. If so,
254 * 'tag' will be set to that VLAN ID; otherwise 'tag' is 0.
259 if (!strcmp(binding->type, "localnet")) {
260 const char *network = smap_get(&binding->options, "network_name");
264 ofport = u16_to_ofp(simap_get(&localnet_to_ofport, network));
265 if (ofport && binding->tag) {
268 } else if (binding->parent_port) {
272 ofport = u16_to_ofp(simap_get(&localvif_to_ofport,
273 binding->parent_port));
278 ofport = u16_to_ofp(simap_get(&localvif_to_ofport,
279 binding->logical_port));
282 const struct chassis_tunnel *tun = NULL;
284 if (!binding->chassis) {
287 tun = chassis_tunnel_find(&tunnels, binding->chassis->name);
291 ofport = tun->ofport;
296 int zone_id = simap_get(ct_zones, binding->logical_port);
297 /* Packets that arrive from a vif can belong to a VM or
298 * to a container located inside that VM. Packets that
299 * arrive from containers have a tag (vlan) associated with them.
302 /* Table 0, Priority 150 and 100.
303 * ==============================
305 * Priority 150 is for tagged traffic. This may be containers in a
306 * VM or a VLAN on a local network. For such traffic, match on the
307 * tags and then strip the tag.
309 * Priority 100 is for traffic belonging to VMs or untagged locally
310 * connected networks.
312 * For both types of traffic: set MFF_LOG_INPORT to the logical
313 * input port, MFF_LOG_DATAPATH to the logical datapath, and
314 * resubmit into the logical ingress pipeline starting at table
316 if (!strcmp(binding->type, "localnet")) {
317 /* The same OpenFlow port may correspond to localnet ports
318 * attached to more than one logical datapath, so keep track of
319 * all associated bindings and add a flow at the end. */
322 = smap_get(&binding->options, "network_name");
323 struct localnet_bindings *ln_bindings;
324 struct hmap_node *node;
325 struct localnet_vlan *ln_vlan;
327 ln_bindings = shash_find_data(&localnet_inputs, network);
329 ln_bindings = xmalloc(sizeof *ln_bindings);
330 ln_bindings->ofport = ofport;
331 hmap_init(&ln_bindings->vlans);
332 shash_add(&localnet_inputs, network, ln_bindings);
334 node = hmap_first_with_hash(&ln_bindings->vlans, tag);
336 ASSIGN_CONTAINER(ln_vlan, node, node);
338 ln_vlan = xmalloc(sizeof *ln_vlan);
340 list_init(&ln_vlan->bindings);
341 hmap_insert(&ln_bindings->vlans, &ln_vlan->node, tag);
344 struct binding_elem *b = xmalloc(sizeof *b);
345 b->binding = binding;
346 list_insert(&ln_vlan->bindings, &b->list_elem);
348 struct hmap_node *ld;
349 ld = hmap_first_with_hash(&local_datapaths,
350 binding->datapath->tunnel_key);
352 ld = xmalloc(sizeof *ld);
353 hmap_insert(&local_datapaths, ld,
354 binding->datapath->tunnel_key);
357 ofpbuf_clear(&ofpacts);
358 match_init_catchall(&match);
359 match_set_in_port(&match, ofport);
361 match_set_dl_vlan(&match, htons(tag));
365 put_load(zone_id, MFF_LOG_CT_ZONE, 0, 32, &ofpacts);
368 /* Set MFF_LOG_DATAPATH and MFF_LOG_INPORT. */
369 put_load(binding->datapath->tunnel_key, MFF_LOG_DATAPATH, 0, 64,
371 put_load(binding->tunnel_key, MFF_LOG_INPORT, 0, 32,
376 ofpact_put_STRIP_VLAN(&ofpacts);
379 /* Resubmit to first logical ingress pipeline table. */
380 put_resubmit(OFTABLE_LOG_INGRESS_PIPELINE, &ofpacts);
381 ofctrl_add_flow(flow_table, OFTABLE_PHY_TO_LOG,
382 tag ? 150 : 100, &match, &ofpacts);
385 /* Table 33, priority 100.
386 * =======================
388 * Implements output to local hypervisor. Each flow matches a
389 * logical output port on the local hypervisor, and resubmits to
393 match_init_catchall(&match);
394 ofpbuf_clear(&ofpacts);
396 /* Match MFF_LOG_DATAPATH, MFF_LOG_OUTPORT. */
397 match_set_metadata(&match, htonll(binding->datapath->tunnel_key));
398 match_set_reg(&match, MFF_LOG_OUTPORT - MFF_REG0,
399 binding->tunnel_key);
402 put_load(zone_id, MFF_LOG_CT_ZONE, 0, 32, &ofpacts);
405 /* Resubmit to table 34. */
406 put_resubmit(OFTABLE_DROP_LOOPBACK, &ofpacts);
407 ofctrl_add_flow(flow_table, OFTABLE_LOCAL_OUTPUT, 100, &match,
410 /* Table 64, Priority 100.
411 * =======================
413 * Deliver the packet to the local vif. */
414 match_init_catchall(&match);
415 ofpbuf_clear(&ofpacts);
416 match_set_metadata(&match, htonll(binding->datapath->tunnel_key));
417 match_set_reg(&match, MFF_LOG_OUTPORT - MFF_REG0,
418 binding->tunnel_key);
420 /* For containers sitting behind a local vif, tag the packets
421 * before delivering them. */
422 struct ofpact_vlan_vid *vlan_vid;
423 vlan_vid = ofpact_put_SET_VLAN_VID(&ofpacts);
424 vlan_vid->vlan_vid = tag;
425 vlan_vid->push_vlan_if_needed = true;
427 /* A packet might need to hair-pin back into its ingress
428 * OpenFlow port (to a different logical port, which we already
429 * checked back in table 34), so set the in_port to zero. */
430 put_stack(MFF_IN_PORT, ofpact_put_STACK_PUSH(&ofpacts));
431 put_load(0, MFF_IN_PORT, 0, 16, &ofpacts);
433 ofpact_put_OUTPUT(&ofpacts)->port = ofport;
435 /* Revert the tag added to the packets headed to containers
436 * in the previous step. If we don't do this, the packets
437 * that are to be broadcasted to a VM in the same logical
438 * switch will also contain the tag. Also revert the zero'd
440 ofpact_put_STRIP_VLAN(&ofpacts);
441 put_stack(MFF_IN_PORT, ofpact_put_STACK_POP(&ofpacts));
443 ofctrl_add_flow(flow_table, OFTABLE_LOG_TO_PHY, 100,
446 /* Table 32, priority 100.
447 * =======================
449 * Implements output to remote hypervisors. Each flow matches an
450 * output port that includes a logical port on a remote hypervisor,
451 * and tunnels the packet to that hypervisor.
454 match_init_catchall(&match);
455 ofpbuf_clear(&ofpacts);
457 /* Match MFF_LOG_DATAPATH, MFF_LOG_OUTPORT. */
458 match_set_metadata(&match, htonll(binding->datapath->tunnel_key));
459 match_set_reg(&match, MFF_LOG_OUTPORT - MFF_REG0,
460 binding->tunnel_key);
462 put_encapsulation(mff_ovn_geneve, tun, binding->datapath,
463 binding->tunnel_key, &ofpacts);
465 /* Output to tunnel. */
466 ofpact_put_OUTPUT(&ofpacts)->port = ofport;
467 ofctrl_add_flow(flow_table, OFTABLE_REMOTE_OUTPUT, 100,
471 /* Table 34, Priority 100.
472 * =======================
474 * Drop packets whose logical inport and outport are the same. */
475 match_init_catchall(&match);
476 ofpbuf_clear(&ofpacts);
477 match_set_metadata(&match, htonll(binding->datapath->tunnel_key));
478 match_set_reg(&match, MFF_LOG_INPORT - MFF_REG0, binding->tunnel_key);
479 match_set_reg(&match, MFF_LOG_OUTPORT - MFF_REG0, binding->tunnel_key);
480 ofctrl_add_flow(flow_table, OFTABLE_DROP_LOOPBACK, 100,
484 /* Handle output to multicast groups, in tables 32 and 33. */
485 const struct sbrec_multicast_group *mc;
486 SBREC_MULTICAST_GROUP_FOR_EACH (mc, ctx->ovnsb_idl) {
487 struct sset remote_chassis = SSET_INITIALIZER(&remote_chassis);
490 match_init_catchall(&match);
491 match_set_metadata(&match, htonll(mc->datapath->tunnel_key));
492 match_set_reg(&match, MFF_LOG_OUTPORT - MFF_REG0, mc->tunnel_key);
494 /* Go through all of the ports in the multicast group:
496 * - For local ports, add actions to 'ofpacts' to set the output
499 * - For remote ports, add the chassis to 'remote_chassis'. */
500 ofpbuf_clear(&ofpacts);
501 for (size_t i = 0; i < mc->n_ports; i++) {
502 struct sbrec_port_binding *port = mc->ports[i];
504 if (port->datapath != mc->datapath) {
505 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
506 VLOG_WARN_RL(&rl, UUID_FMT": multicast group contains ports "
508 UUID_ARGS(&mc->header_.uuid));
512 int zone_id = simap_get(ct_zones, port->logical_port);
514 put_load(zone_id, MFF_LOG_CT_ZONE, 0, 32, &ofpacts);
517 if (simap_contains(&localvif_to_ofport,
519 ? port->parent_port : port->logical_port)) {
520 put_load(port->tunnel_key, MFF_LOG_OUTPORT, 0, 32, &ofpacts);
521 put_resubmit(OFTABLE_DROP_LOOPBACK, &ofpacts);
522 } else if (port->chassis) {
523 sset_add(&remote_chassis, port->chassis->name);
524 } else if (!strcmp(port->type, "localnet")) {
525 const char *network = smap_get(&port->options, "network_name");
529 if (!simap_contains(&localnet_to_ofport, network)) {
532 put_load(port->tunnel_key, MFF_LOG_OUTPORT, 0, 32, &ofpacts);
533 put_resubmit(OFTABLE_DROP_LOOPBACK, &ofpacts);
537 /* Table 33, priority 100.
538 * =======================
540 * Handle output to the local logical ports in the multicast group, if
542 bool local_ports = ofpacts.size > 0;
544 /* Following delivery to local logical ports, restore the multicast
545 * group as the logical output port. */
546 put_load(mc->tunnel_key, MFF_LOG_OUTPORT, 0, 32, &ofpacts);
548 ofctrl_add_flow(flow_table, OFTABLE_LOCAL_OUTPUT, 100,
552 /* Table 32, priority 100.
553 * =======================
555 * Handle output to the remote chassis in the multicast group, if
557 if (!sset_is_empty(&remote_chassis)) {
558 ofpbuf_clear(&ofpacts);
561 const struct chassis_tunnel *prev = NULL;
562 SSET_FOR_EACH (chassis, &remote_chassis) {
563 const struct chassis_tunnel *tun
564 = chassis_tunnel_find(&tunnels, chassis);
569 if (!prev || tun->type != prev->type) {
570 put_encapsulation(mff_ovn_geneve, tun,
571 mc->datapath, mc->tunnel_key, &ofpacts);
574 ofpact_put_OUTPUT(&ofpacts)->port = tun->ofport;
579 put_resubmit(OFTABLE_LOCAL_OUTPUT, &ofpacts);
581 ofctrl_add_flow(flow_table, OFTABLE_REMOTE_OUTPUT, 100,
585 sset_destroy(&remote_chassis);
588 /* Table 0, priority 100.
589 * ======================
591 * For packets that arrive from a remote hypervisor (by matching a tunnel
592 * in_port), set MFF_LOG_DATAPATH, MFF_LOG_INPORT, and MFF_LOG_OUTPORT from
593 * the tunnel key data, then resubmit to table 33 to handle packets to the
594 * local hypervisor. */
596 struct chassis_tunnel *tun;
597 HMAP_FOR_EACH (tun, hmap_node, &tunnels) {
598 struct match match = MATCH_CATCHALL_INITIALIZER;
599 match_set_in_port(&match, tun->ofport);
601 ofpbuf_clear(&ofpacts);
602 if (tun->type == GENEVE) {
603 put_move(MFF_TUN_ID, 0, MFF_LOG_DATAPATH, 0, 24, &ofpacts);
604 put_move(mff_ovn_geneve, 16, MFF_LOG_INPORT, 0, 15,
606 put_move(mff_ovn_geneve, 0, MFF_LOG_OUTPORT, 0, 16,
608 } else if (tun->type == STT) {
609 put_move(MFF_TUN_ID, 40, MFF_LOG_INPORT, 0, 15, &ofpacts);
610 put_move(MFF_TUN_ID, 24, MFF_LOG_OUTPORT, 0, 16, &ofpacts);
611 put_move(MFF_TUN_ID, 0, MFF_LOG_DATAPATH, 0, 24, &ofpacts);
615 put_resubmit(OFTABLE_LOCAL_OUTPUT, &ofpacts);
617 ofctrl_add_flow(flow_table, OFTABLE_PHY_TO_LOG, 100, &match, &ofpacts);
620 /* Table 32, Priority 0.
621 * =======================
623 * Resubmit packets that are not directed at tunnels or part of a
624 * multicast group to the local output table. */
626 match_init_catchall(&match);
627 ofpbuf_clear(&ofpacts);
628 put_resubmit(OFTABLE_LOCAL_OUTPUT, &ofpacts);
629 ofctrl_add_flow(flow_table, OFTABLE_REMOTE_OUTPUT, 0, &match, &ofpacts);
631 /* Table 34, Priority 0.
632 * =======================
634 * Resubmit packets that don't output to the ingress port (already checked
635 * in table 33) to the logical egress pipeline, clearing the logical
636 * registers (for consistent behavior with packets that get tunneled). */
637 match_init_catchall(&match);
638 ofpbuf_clear(&ofpacts);
639 #define MFF_LOG_REG(ID) put_load(0, ID, 0, 32, &ofpacts);
642 put_resubmit(OFTABLE_LOG_EGRESS_PIPELINE, &ofpacts);
643 ofctrl_add_flow(flow_table, OFTABLE_DROP_LOOPBACK, 0, &match, &ofpacts);
645 ofpbuf_uninit(&ofpacts);
646 simap_destroy(&localvif_to_ofport);
647 struct chassis_tunnel *tun_next;
648 HMAP_FOR_EACH_SAFE (tun, tun_next, hmap_node, &tunnels) {
649 hmap_remove(&tunnels, &tun->hmap_node);
652 hmap_destroy(&tunnels);
654 /* Table 0, Priority 150 and 100.
655 * ==============================
657 * We have now determined the full set of port bindings associated with
658 * each "localnet" network. Only create flows for datapaths that have
659 * another local binding. Otherwise, we know it would just be dropped.
661 * Use priority 150 for inputs that match both the network and a VLAN tag.
662 * Use priority 100 for matching untagged traffic from the local network.
664 struct shash_node *ln_bindings_node, *ln_bindings_node_next;
665 SHASH_FOR_EACH_SAFE (ln_bindings_node, ln_bindings_node_next,
667 struct localnet_bindings *ln_bindings = ln_bindings_node->data;
668 struct localnet_vlan *ln_vlan, *ln_vlan_next;
669 HMAP_FOR_EACH_SAFE (ln_vlan, ln_vlan_next, node, &ln_bindings->vlans) {
671 match_init_catchall(&match);
672 match_set_in_port(&match, ln_bindings->ofport);
674 match_set_dl_vlan(&match, htons(ln_vlan->tag));
677 struct ofpbuf ofpacts;
678 ofpbuf_init(&ofpacts, 0);
681 ofpact_put_STRIP_VLAN(&ofpacts);
683 uint32_t ofpacts_orig_size = ofpacts.size;
685 struct binding_elem *b;
686 LIST_FOR_EACH_POP (b, list_elem, &ln_vlan->bindings) {
687 struct hmap_node *ld;
688 ld = hmap_first_with_hash(&local_datapaths,
689 b->binding->datapath->tunnel_key);
691 /* Set MFF_LOG_DATAPATH and MFF_LOG_INPORT. */
692 put_load(b->binding->datapath->tunnel_key, MFF_LOG_DATAPATH,
694 put_load(b->binding->tunnel_key, MFF_LOG_INPORT, 0, 32,
696 put_resubmit(OFTABLE_LOG_INGRESS_PIPELINE, &ofpacts);
702 if (ofpacts.size > ofpacts_orig_size) {
703 ofctrl_add_flow(flow_table, 0, ln_vlan->tag ? 150 : 100,
707 ofpbuf_uninit(&ofpacts);
709 hmap_remove(&ln_bindings->vlans, &ln_vlan->node);
712 shash_delete(&localnet_inputs, ln_bindings_node);
713 hmap_destroy(&ln_bindings->vlans);
716 shash_destroy(&localnet_inputs);
718 struct hmap_node *node;
719 while ((node = hmap_first(&local_datapaths))) {
720 hmap_remove(&local_datapaths, node);
723 hmap_destroy(&local_datapaths);
725 simap_destroy(&localnet_to_ofport);