Merge pull request #2851 from anarkiwi/resetpcp

Ensure vlan_pcp is 0 when loop protection enabled.

Author: anarkiwi

faucet/dp.py

@@ -470,6 +470,9 @@ def _configure_tables(self):
             flood_table.match_types += ((faucet_pipeline.STACK_LOOP_PROTECT_FIELD, False),)
             vlan_table = table_configs['vlan']
             vlan_table.set_fields += (faucet_pipeline.STACK_LOOP_PROTECT_FIELD,)
+            vlan_table.match_types += ((faucet_pipeline.STACK_LOOP_PROTECT_FIELD, False),)
+            eth_dst_table = table_configs['eth_dst']
+            eth_dst_table.set_fields = (faucet_pipeline.STACK_LOOP_PROTECT_FIELD,)
 
         oxm_fields = set(valve_of.MATCH_FIELDS.keys())
 
@@ -807,7 +810,7 @@ def is_in_path(self, src_dp, dst_dp):
         path = self.shortest_path(dst_dp.name, src_dp.name)
         return self.name in path
 
-    def reset_refs(self, vlans=None):
+    def reset_refs(self, vlans=None, root_dp=None):
         """Resets vlan references"""
         if vlans is None:
             vlans = self.vlans
@@ -816,6 +819,8 @@ def reset_refs(self, vlans=None):
             vlan.reset_ports(self.ports.values())
             if vlan.get_ports() or vlan.reserved_internal_vlan:
                 self.vlans[vlan.vid] = vlan
+        if root_dp is not None:
+            self.stack['root_dp'] = root_dp
 
     def resolve_port(self, port_name):
         """Resolve a port by number or name."""
@@ -833,6 +838,7 @@ def finalize_config(self, dps):
 
         dp_by_name = {}
         vlan_by_name = {}
+        external_ports = False
 
         def resolve_ports(port_names):
             """Resolve list of ports, by port by name or number."""
@@ -858,7 +864,7 @@ def resolve_stack_dps():
             if self.stack_ports:
                 if self.stack is None:
                     self.stack = {}
-                self.stack['externals'] = False
+                self.stack['externals'] = external_ports
                 port_stack_dp = {}
                 for port in self.stack_ports:
                     stack_dp = port.stack['dp']
@@ -871,10 +877,6 @@ def resolve_stack_dps():
                     test_config_condition(stack_port is None, (
                         'stack port %s not defined in DP %s' % (port.stack['port'], dp.name)))
                     port.stack['port'] = stack_port
-                for vlan in vlan_by_name.values():
-                    if vlan.loop_protect_external_ports():
-                        self.stack['externals'] = True
-                        break
 
         def resolve_mirror_destinations():
             """Resolve mirror port references and destinations."""
@@ -1075,6 +1077,11 @@ def resolve_vlan_names_in_routers():
                 test_config_condition(
                     self.global_vlan == vlan.vid, 'VLAN %u is reserved by global_vlan' % vlan.vid)
 
+        for vlan in vlan_by_name.values():
+            if vlan.loop_protect_external_ports():
+                external_ports = True
+                break
+
         resolve_stack_dps()
         resolve_mirror_destinations()
         resolve_override_output_ports()

faucet/valve.py

@@ -203,7 +203,7 @@ def dp_init(self):
             self.dp.vlans, self.dp.tables['eth_src'],
             self.dp.tables['eth_dst'], eth_dst_hairpin_table, self.pipeline,
             self.dp.timeout, self.dp.learn_jitter, self.dp.learn_ban_timeout,
-            self.dp.cache_update_guard_time, self.dp.idle_dst)
+            self.dp.cache_update_guard_time, self.dp.idle_dst, self.dp.stack)
         if 'port_acl' in self.dp.tables or 'vlan_acl' in self.dp.tables or self.dp.tunnel_acls:
             self.acl_manager = valve_acl.ValveAclManager(
                 self.dp.tables.get('port_acl'), self.dp.tables.get('vlan_acl'),

faucet/valve_host.py

@@ -28,7 +28,7 @@ class ValveHostManager(ValveManagerBase):
 
     def __init__(self, logger, ports, vlans, eth_src_table, eth_dst_table,
                  eth_dst_hairpin_table, pipeline, learn_timeout, learn_jitter,
-                 learn_ban_timeout, cache_update_guard_time, idle_dst):
+                 learn_ban_timeout, cache_update_guard_time, idle_dst, stack):
         self.logger = logger
         self.ports = ports
         self.vlans = vlans
@@ -44,6 +44,7 @@ def __init__(self, logger, ports, vlans, eth_src_table, eth_dst_table,
         self.cache_update_guard_time = cache_update_guard_time
         self.output_table = self.eth_dst_table
         self.idle_dst = idle_dst
+        self.stack = stack
         if self.eth_dst_hairpin_table:
             self.output_table = self.eth_dst_hairpin_table
 
@@ -201,6 +202,11 @@ def learn_host_on_vlan_port_flows(self, port, vlan, eth_src,
         if port.override_output_port:
             inst = valve_of.apply_actions([
                 valve_of.output_port(port.override_output_port.number)])
+
+        loop_protect_field = None
+        if port.tagged_vlans and port.loop_protect_external and self.stack:
+            loop_protect_field = 0
+
         ofmsgs.append(self.eth_src_table.flowmod(
             match=src_match,
             priority=src_priority,
@@ -218,7 +224,7 @@ def learn_host_on_vlan_port_flows(self, port, vlan, eth_src,
         ofmsgs.append(self.eth_dst_table.flowmod(
             self.eth_dst_table.match(vlan=vlan, eth_dst=eth_src),
             priority=self.host_priority,
-            inst=self.pipeline.output(port, vlan),
+            inst=self.pipeline.output(port, vlan, loop_protect_field=loop_protect_field),
             idle_timeout=dst_rule_idle_timeout))
 
         # If port is in hairpin mode, install a special rule

tests/integration/mininet_tests.py

@@ -4493,6 +4493,13 @@ def test_tagged(self):
         self.verify_broadcast(hosts=(ext_port1, ext_port2), broadcast_expected=False)
         self.verify_broadcast(hosts=(ext_port1, int_port1), broadcast_expected=True)
         self.verify_broadcast(hosts=(int_port1, int_port2), broadcast_expected=True)
+        self.one_ipv4_ping(ext_port1, int_port2.IP())
+        tcpdump_filter = 'ether dst %s' % int_port2.MAC()
+        tcpdump_txt = self.tcpdump_helper(
+            ext_port1, tcpdump_filter, [
+                lambda: ext_port1.cmd(
+                    'ping -c3 %s' % int_port2.IP())], root_intf=True, packets=1)
+        self.assertTrue(re.search('vlan 100, p 0,', tcpdump_txt))
 
 
 class FaucetTaggedWithUntaggedTest(FaucetTaggedTest):