Add an ability to set the mcast snooping option and mcast querier option on a bridge.

Signed-off-by: Nogah Frankel nogahf@mellanox.com Reviewed-by: Yotam Gigi yotamg@mellanox.com --- lnst/Controller/Machine.py | 8 ++++++++ lnst/Controller/Task.py | 6 ++++++ lnst/Slave/BridgeTool.py | 10 ++++++++++ lnst/Slave/NetTestSlave.py | 18 ++++++++++++++++++ 4 files changed, 42 insertions(+)

diff --git a/lnst/Controller/Machine.py b/lnst/Controller/Machine.py index 7077018..a6a3165 100644 --- a/lnst/Controller/Machine.py +++ b/lnst/Controller/Machine.py @@ -966,6 +966,14 @@ class Interface(object): self._machine._rpc_call_x(self._netns, "set_br_state", self._id, br_state_info)

+ def set_br_mcast_snooping(self, set_on): + self._machine._rpc_call_x(self._netns, "set_br_mcast_snooping", + self._id, set_on) + + def set_br_mcast_querier(self, set_on): + self._machine._rpc_call_x(self._netns, "set_br_mcast_querier", self._id, + set_on) + def set_mcast_flood(self, on): self._machine._rpc_call_x(self._netns, "set_mcast_flood", self._id, on)

diff --git a/lnst/Controller/Task.py b/lnst/Controller/Task.py index daf52ab..10b937d 100644 --- a/lnst/Controller/Task.py +++ b/lnst/Controller/Task.py @@ -700,6 +700,12 @@ class InterfaceAPI(object): def set_br_state(_self, state, self=False, master=False): _self._if.set_br_state({"state": state, "self": self, "master": master})

+ def set_br_mcast_snooping(_self, set_on = True): + _self._if.set_br_mcast_snooping(set_on) + + def set_br_mcast_querier(_self, set_on = True): + _self._if.set_br_mcast_querier(set_on) + def set_mcast_flood(self, on): return self._if.set_mcast_flood(on)

diff --git a/lnst/Slave/BridgeTool.py b/lnst/Slave/BridgeTool.py index 5e8f497..d93b1b9 100644 --- a/lnst/Slave/BridgeTool.py +++ b/lnst/Slave/BridgeTool.py @@ -117,3 +117,13 @@ class BridgeTool: if br_state_info["master"]: cmd += " master" exec_cmd(cmd) + + def set_mcast_snooping(self, set_on = True): + cmd = "ip link set %s type bridge mcast_snooping %d" % (self._dev_name, + set_on) + exec_cmd(cmd) + + def set_mcast_querier(self, set_on = True): + cmd = "ip link set %s type bridge mcast_querier %d" % (self._dev_name, + set_on) + exec_cmd(cmd) diff --git a/lnst/Slave/NetTestSlave.py b/lnst/Slave/NetTestSlave.py index 8a39f90..af80f55 100644 --- a/lnst/Slave/NetTestSlave.py +++ b/lnst/Slave/NetTestSlave.py @@ -937,6 +937,24 @@ class SlaveMethods: brt.set_state(br_state_info) return True

+ def set_br_mcast_snooping(self, if_id, set_on = True): + dev = self._if_manager.get_mapped_device(if_id) + if not dev: + logging.error("Device with id '%s' not found." % if_id) + return False + brt = BridgeTool(dev.get_name()) + brt.set_mcast_snooping(set_on) + return True + + def set_br_mcast_querier(self, if_id, set_on = True): + dev = self._if_manager.get_mapped_device(if_id) + if not dev: + logging.error("Device with id '%s' not found." % if_id) + return False + brt = BridgeTool(dev.get_name()) + brt.set_mcast_querier(set_on) + return True + def set_speed(self, if_id, speed): dev = self._if_manager.get_mapped_device(if_id) if dev is not None:

Currently the function iperf_mc have 3 tasks: * set up the environment for mc (setting mc enable, sending join requests, etc.). * send mc traffic and check who got it. * compare the results to the expected ones.

Following patches will introduce tests for more complicated scenarios. So this patch breaks the 3 tasks apart. The first one will be done in each test. The second remains in iperf_mc and the third will be done in a new function in Testlib called mc_ipref_compare_result. This patch also updates test 20 to keep up with these changes.

Signed-off-by: Nogah Frankel nogahf@mellanox.com Reviewed-by: Yotam Gigi yotamg@mellanox.com --- recipes/switchdev/TestLib.py | 79 +++++++++++++++------------------- recipes/switchdev/l2-020-bridge_mdb.py | 31 ++++++++++--- 2 files changed, 58 insertions(+), 52 deletions(-)

diff --git a/recipes/switchdev/TestLib.py b/recipes/switchdev/TestLib.py index e34161c..62db24e 100644 --- a/recipes/switchdev/TestLib.py +++ b/recipes/switchdev/TestLib.py @@ -201,75 +201,64 @@ class TestLib: } return self._ctl.get_module("Iperf", options = modules_options)

- def iperf_mc(self, sender, listeners, bridged, mc_group, desc=None): + def iperf_mc_listen(self, listener, mc_group): + host = listener.get_host() + srv_m = self._get_iperf_srv_mod(mc_group) + proc = host.run(srv_m, bg=True, netns=listener.get_netns()) + return proc + + def iperf_mc(self, sender, recivers, mc_group, desc=None): if not desc: - desc = self._generate_default_desc(sender, listeners) + desc = self._generate_default_desc(sender, recivers)

sender.set_mtu(self._mtu) - sender.enable_multicast() - map(lambda i:i.enable_multicast(), listeners + bridged) - map(lambda i:i.set_mtu(self._mtu), listeners + bridged) + map(lambda i:i.set_mtu(self._mtu), recivers)

sender_host = sender.get_host() - listeners_host = map(lambda i:i.get_host(), listeners) - bridged_host = map(lambda i:i.get_host(), bridged) + recivers_host = map(lambda i:i.get_host(), recivers)

map(lambda i:i.sync_resources(modules=["Iperf"]), - listeners_host + bridged_host) + recivers_host)

duration = self._netperf_duration speed = self._mc_speed

# read link-stats - sender_stats = sender.link_stats() - listeners_stats = map(lambda i:i.link_stats(), listeners) - bridged_stats = map(lambda i:i.link_stats(), bridged) - - # Run iperf server for all listeners - srv_m = self._get_iperf_srv_mod(mc_group) - s_procs = map(lambda i:i[0].run(srv_m, bg=True, netns=i[1].get_netns()), - zip(listeners_host, listeners)) - self._ctl.wait(2) + sender_stats_before = sender.link_stats() + recivers_stats_before = map(lambda i:i.link_stats(), recivers)

# An send traffic to all listeners but bridged cli_m = self._get_iperf_cli_mod(mc_group, duration, speed) sender_host.run(cli_m, timeout=duration + 10, desc=desc, netns=sender.get_netns()) - map(lambda i:i.intr(), s_procs) - map(lambda i:i.disable_multicast(), listeners + bridged) - sender.disable_multicast()

# re-read link-stats - sender_stats1 = sender.link_stats() - listeners_stats1 = map(lambda i:i.link_stats(), listeners) - bridged_stats1 = map(lambda i:i.link_stats(), bridged) - - # Check that listeners got multi cast traffic - tx = sender_stats1["tx_bytes"] - sender_stats["tx_bytes"] - rx = map(lambda i:i[1]["rx_bytes"] - i[0]["rx_bytes"], - zip(listeners_stats, listeners_stats1)) - err = filter(lambda i:i[0] < self._mc_high_thershold, zip(rx, listeners)) - err_str = map(lambda i:("Traffic isn't received for %s:%s count %d" % - (i[1].get_host().get_id(), i[1].get_id(), i[0]), - i[1]), err) - for i in err_str: - self.custom(i[1].get_host(), "iperf_mc", i[0]) - for i in zip(rx, listeners): + sender_stats_after = sender.link_stats() + recivers_stats_after = map(lambda i:i.link_stats(), recivers) + + # Check that who got multi cast traffic + tx = sender_stats_after["tx_bytes"] - sender_stats_before["tx_bytes"] + rx = map(lambda i,l:i["rx_bytes"] - l["rx_bytes"], + recivers_stats_after, recivers_stats_before) + recivers_result = [rate > self._mc_high_thershold for rate in rx] + for i in zip(rx, recivers): logging.info("Measured traffic on %s:%s is %dMb, bytes lost %d (%d%%)" % (i[1].get_host().get_id(), i[1].get_id(), i[0] / 1000000, max(tx - i[0], 0), (max(tx - i[0], 0) * 100) / tx)) - - # Check that only listeners got traffic - rx = map(lambda i:i[1]["rx_bytes"] - i[0]["rx_bytes"], - zip(bridged_stats, bridged_stats1)) - err = filter(lambda i:i[0] > self._mc_low_thershold, zip(rx, bridged)) - err_str = map(lambda i:("Received unwanted traffic for %s:%s count %d" % - (i[1].get_host().get_id(), i[1].get_id(), i[0]), - i[1]), err) - for i in err_str: - self.custom(i[1].get_host(), "iperf_mc", i[0]) + return recivers_result + + def mc_ipref_compare_result(self, ifaces, results, expected): + err_indices = [i for i in range(len(results)) + if results[i] != expected[i]] + for i in err_indices: + iface, result, expect = ifaces[i], results[i], expected[i] + err_str = "interface %s in %s %s traffic, when it %s get" % \ + (iface.get_id(), iface.get_host().get_id(), \ + ["didn't get", "got"][result], \ + ["shouldn't", "should"][expect]) + self.custom(iface.get_host(), "iperf_mc", err_str)

def pktgen(self, if1, if2, pkt_size, desc=None, thread_option=[], **kwargs): if1.set_mtu(self._mtu) diff --git a/recipes/switchdev/l2-020-bridge_mdb.py b/recipes/switchdev/l2-020-bridge_mdb.py index 04bcae9..f48d11e 100644 --- a/recipes/switchdev/l2-020-bridge_mdb.py +++ b/recipes/switchdev/l2-020-bridge_mdb.py @@ -7,6 +7,7 @@ published by the Free Software Foundation; see COPYING for details. __author__ = """ eladr@mellanox.com (Elad Raz) jiri@mellanox.com (Jiri Pirko) +nogahf@mellanox.com (Nogah Frankel) """

from lnst.Controller.Task import ctl @@ -17,6 +18,16 @@ def test_ip(major, minor): return ["192.168.10%d.%d/24" % (major, minor), "2002:%d::%d/64" % (major, minor)]

+def mcgrp(i): + return "239.255.1.%d" % i + +def test_standard_mutlicast(tl, sender, listeners, bridged, group): + s_procs = [tl.iperf_mc_listen(listener, group) for listener in listeners] + res = tl.iperf_mc(sender, listeners+ bridged, group) + expected = [True for l in listeners] + [False for l in bridged] + tl.mc_ipref_compare_result(listeners + bridged, res, expected) + map(lambda i:i.intr(), s_procs) + def do_task(ctl, hosts, ifaces, aliases): m1, m2, sw = hosts m1_if, m2_if, m3_if, m4_if, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces @@ -25,16 +36,22 @@ def do_task(ctl, hosts, ifaces, aliases): sw_br = sw.create_bridge(slaves=[sw_if1, sw_if2, sw_if3, sw_if4], options={"vlan_filtering": 1})

- m1_if.set_addresses(["192.168.101.10/24", "2002::1/64"]) - m2_if.set_addresses(["192.168.101.11/24", "2002::2/64"]) - m3_if.set_addresses(["192.168.101.13/24", "2002::3/64"]) - m4_if.set_addresses(["192.168.101.14/24", "2002::4/64"]) + m1_if.set_addresses(test_ip(1,1)) + m2_if.set_addresses(test_ip(1, 2)) + m3_if.set_addresses(test_ip(1, 3)) + m4_if.set_addresses(test_ip(1, 4)) sleep(30)

tl = TestLib(ctl, aliases) - tl.iperf_mc(m1_if, [m2_if, m4_if], [m3_if], "239.255.1.3") - tl.iperf_mc(m1_if, [m4_if], [], "239.255.1.4") - tl.iperf_mc(m2_if, [m3_if, m4_if, m1_if] , [], "239.255.1.5") + + for iface in [m1_if, m2_if, m3_if, m4_if]: + iface.enable_multicast() + + test_standard_mutlicast(tl, m1_if, [m2_if, m4_if], [m3_if], mcgrp(3)) + test_standard_mutlicast(tl, m1_if, [m4_if], [m2_if, m3_if], mcgrp(4)) + test_standard_mutlicast(tl, m2_if, [m3_if, m4_if, m1_if], [], mcgrp(5)) + for iface in [m1_if, m2_if, m3_if, m4_if]: + iface.disable_multicast()

do_task(ctl, [ctl.get_host("machine1"), ctl.get_host("machine2"),

The mdb mcast disabled test case tests that the bridge mcast_disabled flag gets offloaded right

The test's algorithm is as follows: - Add ports to mcast group - Send traffic to that group - Validate that traffic received only by joined ports - Turn mcast_disabled flag on - Send traffic to that same group - Validate that traffic received by all ports - Check that all the traffic hadn't gone via slowpath

Signed-off-by: Yotam Gigi yotamg@mellanox.com Signed-off-by: Nogah Frankel nogahf@mellanox.com --- .../switchdev/l2-022-bridge_mdb_mcast_disabled.py | 85 ++++++++++++++++++++++ .../switchdev/l2-022-bridge_mdb_mcast_disabled.xml | 70 ++++++++++++++++++ 2 files changed, 155 insertions(+) create mode 100644 recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.py create mode 100644 recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.xml

diff --git a/recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.py b/recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.py new file mode 100644 index 0000000..0351582 --- /dev/null +++ b/recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.py @@ -0,0 +1,85 @@ +""" +Copyright 2016 Mellanox Technologies. All rights reserved. +Licensed under the GNU General Public License, version 2 as +published by the Free Software Foundation; see COPYING for details. +""" + +__author__ = """ +yotamg@mellanox.com (Yotam Gigi) +""" + +from lnst.Controller.Task import ctl +from TestLib import TestLib +from time import sleep + +def test_ip(major, minor): + return ["192.168.10%d.%d/24" % (major, minor), + "2002:%d::%d/64" % (major, minor)] + +def mcgrp(i): + return "239.255.1.%d" % i + +def test_mcast_onoff(tl, sw_br, sender, listeners, bridged, group): + mcast_ifaces = listeners + bridged + sw = sw_br.get_host() + + expected_mcast_on = [True for l in listeners] + [False for l in bridged] + expected_mcast_off = [True for l in listeners] + [True for l in bridged] + + s_procs = [tl.iperf_mc_listen(listener, group) for listener in listeners] + tl._ctl.wait(2) + + result = tl.iperf_mc(sender, mcast_ifaces, group) + tl.mc_ipref_compare_result(mcast_ifaces, result, expected_mcast_on) + + sw_br.set_br_mcast_snooping(False) + result = tl.iperf_mc(sender, mcast_ifaces, group) + tl.mc_ipref_compare_result(mcast_ifaces, result, expected_mcast_off) + + sw_br.set_br_mcast_snooping(True) + result = tl.iperf_mc(sender, mcast_ifaces, group) + tl.mc_ipref_compare_result(mcast_ifaces, result, expected_mcast_on) + + for proc in s_procs: + proc.intr() + +def do_task(ctl, hosts, ifaces, aliases): + m1, m2, sw = hosts + m1_if, m2_if, m3_if, m4_if, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces + + # Create a bridge + sw_ifaces = [sw_if1, sw_if2, sw_if3, sw_if4] + sw_br = sw.create_bridge(slaves=sw_ifaces, options={"vlan_filtering": 1}) + + m1_if.set_addresses(test_ip(1, 1)) + m2_if.set_addresses(test_ip(1, 2)) + m3_if.set_addresses(test_ip(1, 3)) + m4_if.set_addresses(test_ip(1, 4)) + sleep(15) + + tl = TestLib(ctl, aliases) + for iface in [m1_if, m2_if, m3_if, m4_if]: + iface.enable_multicast() + tl.check_cpu_traffic(sw_ifaces, test=False) + + test_mcast_onoff(tl, sw_br, m1_if, [], [m3_if, m2_if, m4_if], mcgrp(1)) + test_mcast_onoff(tl, sw_br, m1_if, [m2_if], [m3_if, m4_if], mcgrp(2)) + test_mcast_onoff(tl, sw_br, m1_if, [m2_if, m4_if], [m3_if], mcgrp(3)) + test_mcast_onoff(tl, sw_br, m3_if, [m1_if, m4_if], [m2_if], mcgrp(4)) + + for iface in [m1_if, m2_if, m3_if, m4_if]: + iface.disable_multicast() + tl.check_cpu_traffic(sw_ifaces) + +do_task(ctl, [ctl.get_host("machine1"), + ctl.get_host("machine2"), + ctl.get_host("switch")], + [ctl.get_host("machine1").get_interface("veth1"), + ctl.get_host("machine1").get_interface("veth3"), + ctl.get_host("machine2").get_interface("veth1"), + ctl.get_host("machine2").get_interface("veth3"), + ctl.get_host("switch").get_interface("if1"), + ctl.get_host("switch").get_interface("if2"), + ctl.get_host("switch").get_interface("if3"), + ctl.get_host("switch").get_interface("if4")], + ctl.get_aliases()) diff --git a/recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.xml b/recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.xml new file mode 100644 index 0000000..8e17b59 --- /dev/null +++ b/recipes/switchdev/l2-022-bridge_mdb_mcast_disabled.xml @@ -0,0 +1,70 @@ +<lnstrecipe xmlns:xi="http://www.w3.org/2003/XInclude"> + <xi:include href="default_aliases.xml" /> + <network> + <host id="machine1"> + <interfaces> + <eth id="if1" label="A" /> + <veth_pair> + <veth id="veth0"/> + <veth id="veth1" netns="nsif1"> + </veth> + </veth_pair> + <bridge id="brif1"> + <slaves> + <slave id="if1"/> + <slave id="veth0"/> + </slaves> + </bridge> + <eth id="if2" label="B" /> + <veth_pair> + <veth id="veth2"/> + <veth id="veth3" netns="nsif2"> + </veth> + </veth_pair> + <bridge id="brif2"> + <slaves> + <slave id="if2"/> + <slave id="veth2"/> + </slaves> + </bridge> + </interfaces> + </host> + <host id="machine2"> + <interfaces> + <eth id="if1" label="C" /> + <veth_pair> + <veth id="veth0"/> + <veth id="veth1" netns="nsif1"> + </veth> + </veth_pair> + <bridge id="brif1"> + <slaves> + <slave id="if1"/> + <slave id="veth0"/> + </slaves> + </bridge> + <eth id="if2" label="D" /> + <veth_pair> + <veth id="veth2"/> + <veth id="veth3" netns="nsif2"> + </veth> + </veth_pair> + <bridge id="brif2"> + <slaves> + <slave id="if2"/> + <slave id="veth2"/> + </slaves> + </bridge> + </interfaces> + </host> + <host id="switch"> + <interfaces> + <eth id="if1" label="A" /> + <eth id="if2" label="B" /> + <eth id="if3" label="C" /> + <eth id="if4" label="D" /> + </interfaces> + </host> + </network> + <task python="l2-022-bridge_mdb_mcast_disabled.py" /> +</lnstrecipe>

Add a test that check that mrouter state id offloaded correctly for a port in mrouter learning state (and not just statically set by user). The test check 2 MC groups, one unregistered and one registered but not by the PUT (port under test).

The test's algorithm is as follows: - Send the needed join request. - Set all ports but the PUT to mrouter fixed off. Set the PUT to learning mrouter state. - Send MC traffic of both groups. - Check that it was received according to the join request. - Set the PUT's peer to be a MC querier. (This should make the bridge to learn that the PUT is mrouter.) - Send MC traffic of both groups. - check that PUT receives both of them - Check that it was received by the other ports according to the join request. - Check that all the traffic hadn't gone via slowpath

Signed-off-by: Nogah Frankel nogahf@mellanox.com Reviewed-by: Yotam Gigi yotamg@mellanox.com --- .../l2-024-bridge_mdb_mc_router_port_learning.py | 91 ++++++++++++++++++++++ .../l2-024-bridge_mdb_mc_router_port_learning.xml | 70 +++++++++++++++++ 2 files changed, 161 insertions(+) create mode 100644 recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.py create mode 100644 recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.xml

diff --git a/recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.py b/recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.py new file mode 100644 index 0000000..576528d --- /dev/null +++ b/recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.py @@ -0,0 +1,91 @@ +""" +Copyright 2016 Mellanox Technologies. All rights reserved. +Licensed under the GNU General Public License, version 2 as +published by the Free Software Foundation; see COPYING for details. +""" + +__author__ = """ +nogahf@mellanox.com (Nogah Frankel) +""" + +from lnst.Controller.Task import ctl +from TestLib import TestLib +from time import sleep +import logging +from lnst.Common.Consts import MCAST_ROUTER_PORT + +def test_ip(major, minor): + return ["192.168.10%d.%d/24" % (major, minor), + "2002:%d::%d/64" % (major, minor)] + +def mcgrp(i): + return "239.255.1.%d" % i + +def do_task(ctl, hosts, ifaces, host_br, aliases): + m1, m2, sw = hosts + m1_if, m2_if, m3_if, m4_if, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces + + sw_ports = [sw_if1, sw_if2, sw_if3, sw_if4] + sw_br = sw.create_bridge(slaves=sw_ports, options={"vlan_filtering": 1}) + + m1_if.set_addresses(test_ip(1, 1)) + m2_if.set_addresses(test_ip(1, 2)) + m3_if.set_addresses(test_ip(1, 3)) + m4_if.set_addresses(test_ip(1, 4)) + + tl = TestLib(ctl, aliases) + mcast_iface = [m1_if, m3_if, m4_if] + m2_if.enable_multicast() + for iface in mcast_iface: + iface.enable_multicast() + for iface in sw_ports: + iface.set_mcast_router(MCAST_ROUTER_PORT.FIXED_OFF) + + sw_if1.set_mcast_router(MCAST_ROUTER_PORT.LEARNING) + sleep(15) + + s_procs = tl.iperf_mc_listen(m3_if, mcgrp(1)) + tl._ctl.wait(2) + + tl.check_cpu_traffic(sw_ports, test=False) + result = tl.iperf_mc(m2_if, mcast_iface, mcgrp(1)) + tl.mc_ipref_compare_result(mcast_iface, result, [False, True, False]) + tl.check_cpu_traffic(sw_ports) + + result = tl.iperf_mc(m2_if, mcast_iface, mcgrp(2)) + tl.mc_ipref_compare_result(mcast_iface, result, [False, False, False]) + tl.check_cpu_traffic(sw_ports) + + host_br.set_br_mcast_snooping() + host_br.set_br_mcast_querier(True) + tl._ctl.wait(30) + + result = tl.iperf_mc(m2_if, mcast_iface, mcgrp(1)) + tl.mc_ipref_compare_result(mcast_iface, result, [True, True, False]) + tl.check_cpu_traffic(sw_ports) + + result = tl.iperf_mc(m2_if, mcast_iface, mcgrp(2)) + tl.mc_ipref_compare_result(mcast_iface, result, [True, False, False]) + tl.check_cpu_traffic(sw_ports) + + for iface in sw_ports: + iface.set_mcast_router(MCAST_ROUTER_PORT.LEARNING) + s_procs.intr() + + for iface in mcast_iface: + iface.disable_multicast() + m2_if.disable_multicast() + +do_task(ctl, [ctl.get_host("machine1"), + ctl.get_host("machine2"), + ctl.get_host("switch")], + [ctl.get_host("machine1").get_interface("if1"), + ctl.get_host("machine1").get_interface("veth3"), + ctl.get_host("machine2").get_interface("veth1"), + ctl.get_host("machine2").get_interface("veth3"), + ctl.get_host("switch").get_interface("if1"), + ctl.get_host("switch").get_interface("if2"), + ctl.get_host("switch").get_interface("if3"), + ctl.get_host("switch").get_interface("if4")], + ctl.get_host("machine1").get_interface("brif1"), + ctl.get_aliases()) diff --git a/recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.xml b/recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.xml new file mode 100644 index 0000000..f49c977 --- /dev/null +++ b/recipes/switchdev/l2-024-bridge_mdb_mc_router_port_learning.xml @@ -0,0 +1,70 @@ +<lnstrecipe xmlns:xi="http://www.w3.org/2003/XInclude"> + <xi:include href="default_aliases.xml" /> + <network> + <host id="machine1"> + <interfaces> + <eth id="if1" label="A" /> + <veth_pair> + <veth id="veth0"/> + <veth id="veth1" netns="nsif1"> + </veth> + </veth_pair> + <bridge id="brif1"> + <slaves> + <slave id="if1"/> + <slave id="veth0"/> + </slaves> + </bridge> + <eth id="if2" label="B" /> + <veth_pair> + <veth id="veth2"/> + <veth id="veth3" netns="nsif2"> + </veth> + </veth_pair> + <bridge id="brif2"> + <slaves> + <slave id="if2"/> + <slave id="veth2"/> + </slaves> + </bridge> + </interfaces> + </host> + <host id="machine2"> + <interfaces> + <eth id="if1" label="C" /> + <veth_pair> + <veth id="veth0"/> + <veth id="veth1" netns="nsif1"> + </veth> + </veth_pair> + <bridge id="brif1"> + <slaves> + <slave id="if1"/> + <slave id="veth0"/> + </slaves> + </bridge> + <eth id="if2" label="D" /> + <veth_pair> + <veth id="veth2"/> + <veth id="veth3" netns="nsif2"> + </veth> + </veth_pair> + <bridge id="brif2"> + <slaves> + <slave id="if2"/> + <slave id="veth2"/> + </slaves> + </bridge> + </interfaces> + </host> + <host id="switch"> + <interfaces> + <eth id="if1" label="A" /> + <eth id="if2" label="B" /> + <eth id="if3" label="C" /> + <eth id="if4" label="D" /> + </interfaces> + </host> + </network> + <task python="l2-024-bridge_mdb_mc_router_port_learning.py" /> +</lnstrecipe>

This recipe tests unregistered MC traffic that should be flooded in the following way: * When MC is enabled it should be sent to all the mrouter ports * When MC is disabled it should be sent to all the ports that marked with MC flood flag (default on)

The test's algorithm is as follows: - Set MC on - Set one port as mrouter (statically on) and as MC flood off. - Check that unregistered MC traffic is received by this port and no other port. - Set MC off - Check that unregistered MC traffic if not received by this port but is received by the other ports. - Change this port to not be mrouter (statically off) and to flood MC packets. Change another port to be MC flood off and mrouter on. - Check unregistered MC traffic is not received by the new port but is received by the other ports. - Set MC on - Check that unregistered MC traffic is received only by the new port.

Signed-off-by: Nogah Frankel nogahf@mellanox.com Reviewed-by: Yotam Gigi yotamg@mellanox.com --- recipes/switchdev/l2-026-bridge_mdb_unreg_flood.py | 92 ++++++++++++++++++++++ .../switchdev/l2-026-bridge_mdb_unreg_flood.xml | 70 ++++++++++++++++ 2 files changed, 162 insertions(+) create mode 100644 recipes/switchdev/l2-026-bridge_mdb_unreg_flood.py create mode 100644 recipes/switchdev/l2-026-bridge_mdb_unreg_flood.xml

diff --git a/recipes/switchdev/l2-026-bridge_mdb_unreg_flood.py b/recipes/switchdev/l2-026-bridge_mdb_unreg_flood.py new file mode 100644 index 0000000..bdb8b1c --- /dev/null +++ b/recipes/switchdev/l2-026-bridge_mdb_unreg_flood.py @@ -0,0 +1,92 @@ +""" +Copyright 2016 Mellanox Technologies. All rights reserved. +Licensed under the GNU General Public License, version 2 as +published by the Free Software Foundation; see COPYING for details. +""" + +__author__ = """ +nogahf@mellanox.com (Nogah Frankel) +""" + +from lnst.Controller.Task import ctl +from TestLib import TestLib +from time import sleep +import logging +from lnst.Common.Consts import MCAST_ROUTER_PORT + +def test_ip(major, minor): + return ["192.168.10%d.%d/24" % (major, minor), + "2002:%d::%d/64" % (major, minor)] + +def mcgrp(i): + return "239.255.1.%d" % i + +def do_task(ctl, hosts, ifaces, aliases): + m1, m2, sw = hosts + m1_if, m2_if, m3_if, m4_if, sw_if1, sw_if2, sw_if3, sw_if4 = ifaces + + # Create a bridge + sw_ports = [sw_if1, sw_if2, sw_if3, sw_if4] + sw_br = sw.create_bridge(slaves = sw_ports, options={"vlan_filtering": 1}) + + m1_if.set_addresses(test_ip(1, 1)) + m2_if.set_addresses(test_ip(1, 2)) + m3_if.set_addresses(test_ip(1, 3)) + m4_if.set_addresses(test_ip(1, 4)) + sleep(15) + + tl = TestLib(ctl, aliases) + for iface in [m1_if, m2_if, m3_if, m4_if]: + iface.enable_multicast() + + tl._ctl.wait(2) + tl.check_cpu_traffic(sw_ports, test=False) + + mcast_iface = [m2_if, m3_if, m4_if] + sw_if2.set_mcast_router(MCAST_ROUTER_PORT.FIXED_ON) + sw_if2.set_mcast_flood(False) + + result = tl.iperf_mc(m1_if, mcast_iface, mcgrp(1)) + tl.mc_ipref_compare_result(mcast_iface, result, [True, False, False]) + tl.check_cpu_traffic(sw_ports) + + sw_br.set_br_mcast_snooping(False) + tl._ctl.wait(2) + result = tl.iperf_mc(m1_if, mcast_iface, mcgrp(1)) + tl.mc_ipref_compare_result(mcast_iface, result, [False, True, True]) + tl.check_cpu_traffic(sw_ports) + + sw_if2.set_mcast_flood(True) + sw_if2.set_mcast_router(MCAST_ROUTER_PORT.FIXED_OFF) + sw_if3.set_mcast_router(MCAST_ROUTER_PORT.FIXED_ON) + sw_if3.set_mcast_flood(False) + + result = tl.iperf_mc(m1_if, mcast_iface, mcgrp(1)) + tl.mc_ipref_compare_result(mcast_iface, result, [True, False, True]) + tl.check_cpu_traffic(sw_ports) + + sw_br.set_br_mcast_snooping() + tl._ctl.wait(2) + + result = tl.iperf_mc(m1_if, mcast_iface, mcgrp(1)) + tl.mc_ipref_compare_result(mcast_iface, result, [False, True, False]) + tl.check_cpu_traffic(sw_ports) + + sw_if2.set_mcast_router(MCAST_ROUTER_PORT.LEARNING) + sw_if2.set_mcast_router(MCAST_ROUTER_PORT.LEARNING) + sw_if3.set_mcast_flood(True) + for iface in [m1_if, m2_if, m3_if, m4_if]: + iface.disable_multicast() + +do_task(ctl, [ctl.get_host("machine1"), + ctl.get_host("machine2"), + ctl.get_host("switch")], + [ctl.get_host("machine1").get_interface("veth1"), + ctl.get_host("machine1").get_interface("veth3"), + ctl.get_host("machine2").get_interface("veth1"), + ctl.get_host("machine2").get_interface("veth3"), + ctl.get_host("switch").get_interface("if1"), + ctl.get_host("switch").get_interface("if2"), + ctl.get_host("switch").get_interface("if3"), + ctl.get_host("switch").get_interface("if4")], + ctl.get_aliases()) diff --git a/recipes/switchdev/l2-026-bridge_mdb_unreg_flood.xml b/recipes/switchdev/l2-026-bridge_mdb_unreg_flood.xml new file mode 100644 index 0000000..3a29330 --- /dev/null +++ b/recipes/switchdev/l2-026-bridge_mdb_unreg_flood.xml @@ -0,0 +1,70 @@ +<lnstrecipe xmlns:xi="http://www.w3.org/2003/XInclude"> + <xi:include href="default_aliases.xml" /> + <network> + <host id="machine1"> + <interfaces> + <eth id="if1" label="A" /> + <veth_pair> + <veth id="veth0"/> + <veth id="veth1" netns="nsif1"> + </veth> + </veth_pair> + <bridge id="brif1"> + <slaves> + <slave id="if1"/> + <slave id="veth0"/> + </slaves> + </bridge> + <eth id="if2" label="B" /> + <veth_pair> + <veth id="veth2"/> + <veth id="veth3" netns="nsif2"> + </veth> + </veth_pair> + <bridge id="brif2"> + <slaves> + <slave id="if2"/> + <slave id="veth2"/> + </slaves> + </bridge> + </interfaces> + </host> + <host id="machine2"> + <interfaces> + <eth id="if1" label="C" /> + <veth_pair> + <veth id="veth0"/> + <veth id="veth1" netns="nsif1"> + </veth> + </veth_pair> + <bridge id="brif1"> + <slaves> + <slave id="if1"/> + <slave id="veth0"/> + </slaves> + </bridge> + <eth id="if2" label="D" /> + <veth_pair> + <veth id="veth2"/> + <veth id="veth3" netns="nsif2"> + </veth> + </veth_pair> + <bridge id="brif2"> + <slaves> + <slave id="if2"/> + <slave id="veth2"/> + </slaves> + </bridge> + </interfaces> + </host> + <host id="switch"> + <interfaces> + <eth id="if1" label="A" /> + <eth id="if2" label="B" /> + <eth id="if3" label="C" /> + <eth id="if4" label="D" /> + </interfaces> + </host> + </network> + <task python="l2-026-bridge_mdb_unreg_flood.py" /> +</lnstrecipe>