[PATCH] InterfaceAPI: Add default IP address index to get_ip and get_prefix methods
by Jiri Prochazka
In deprecated HostAPI methods get_ip and get_prefix we had default
IP address index set to 0, so calling get_ip(iface) would return
first IP address assigned to the interface.
This patch adds this functionality to InterfaceAPI methods get_ip and
get_prefix so calling iface.get_ip() will return first IP address assigned
to that interface.
Also InterfaceAPI methods get_ip_addr and get_ip_prefix are patched, but
they are now marked as deprecated.
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
lnst/Controller/Task.py | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/lnst/Controller/Task.py b/lnst/Controller/Task.py
index 49ea816..01aadab 100644
--- a/lnst/Controller/Task.py
+++ b/lnst/Controller/Task.py
@@ -374,25 +374,25 @@ class InterfaceAPI(object):
def get_hwaddr(self):
return VolatileValue(self._if.get_hwaddr)
- def get_ip(self, ip_index):
+ def get_ip(self, ip_index=0):
return VolatileValue(self._if.get_address, ip_index)
def get_ips(self):
return VolatileValue(self._if.get_addresses)
@deprecated
- def get_ip_addr(self, ip_index):
+ def get_ip_addr(self, ip_index=0):
return self.get_ip(ip_index)
@deprecated
def get_ip_addrs(self):
return self.get_ips()
- def get_prefix(self, ip_index):
+ def get_prefix(self, ip_index=0):
return VolatileValue(self._if.get_prefix, ip_index)
@deprecated
- def get_ip_prefix(self, ip_index):
+ def get_ip_prefix(self, ip_index=0):
return self.get_prefix(ip_index)
def get_mtu(self):
--
2.4.3
8 years, 5 months
[PATCH v2 1/4] regression-tests: Replace deprecated methods in phase1 baremetal tests
by Jiri Prochazka
This commit replaces InterfaceAPI methods get_ip() and get_devname() with
HostAPI methods which are supported and recommended.
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 40 ++++++++++---------
.../regression_tests/phase1/3_vlans_over_bond.py | 46 ++++++++++++----------
recipes/regression_tests/phase1/bonding_test.py | 36 ++++++++---------
recipes/regression_tests/phase1/simple_ping.py | 11 ++++--
4 files changed, 71 insertions(+), 62 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index 2007dc4..68974e7 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -99,37 +99,40 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
})
for vlan1 in vlans:
+ m1_vlan1 = m1.get_interface(vlan1)
for vlan2 in vlans:
- ping_mod.update_options({"addr": m2.get_ip(vlan2, 0),
- "iface": m1.get_devname(vlan1)})
+ m2_vlan2 = m2.get_interface(vlan2)
- ping_mod6.update_options({"addr": m2.get_ip(vlan2, 1),
- "iface": m1.get_ip(vlan1, 1)})
+ ping_mod.update_options({"addr": m2_vlan2.get_ip(0),
+ "iface": m1_vlan1.get_devname()})
- netperf_srv.update_options({"bind": m1.get_ip(vlan1, 0)})
+ ping_mod6.update_options({"addr": m2_vlan2.get_ip(1),
+ "iface": m1_vlan1.get_ip(1)})
- netperf_srv6.update_options({"bind": m1.get_ip(vlan1, 1)})
+ netperf_srv.update_options({"bind": m1_vlan1.get_ip(0)})
- netperf_cli_tcp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_srv6.update_options({"bind": m1_vlan1.get_ip(1)})
- netperf_cli_udp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_cli_tcp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_tcp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_udp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_udp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_tcp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
+
+ netperf_cli_udp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
if vlan1 == vlan2:
# These tests should pass
# Ping between same VLANs
for setting in offload_settings:
for offload in setting:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy1.get_devname(),
offload[0], offload[1]))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ m2.run("ethtool -K %s %s %s" % (m2_phy1.get_devname(),
offload[0], offload[1]))
if ipv in [ 'ipv4', 'both' ]:
@@ -234,7 +237,6 @@ for vlan1 in vlans:
perf_api.save_result(result_udp)
srv_proc.intr()
-
# These tests should fail
# Ping across different VLAN
else:
@@ -246,7 +248,7 @@ for vlan1 in vlans:
#reset offload states
for offload in offloads:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy1.get_devname(),
offload, "on"))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ m2.run("ethtool -K %s %s %s" % (m2_phy1.get_devname(),
offload, "on"))
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 79c4b4d..d382036 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -39,6 +39,8 @@ nperf_max_runs = int(ctl.get_alias("nperf_max_runs"))
m1_bond = m1.get_interface("test_bond")
m1_bond.set_mtu(mtu)
+m1_phy1 = m1.get_interface("eth1")
+m1_phy2 = m1.get_interface("eth2")
m2_phy1 = m2.get_interface("eth1")
m2_phy1.set_mtu(mtu)
@@ -99,28 +101,31 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
})
for vlan1 in vlans:
+ m1_vlan1 = m1.get_interface(vlan1)
for vlan2 in vlans:
- ping_mod.update_options({"addr": m2.get_ip(vlan2, 0),
- "iface": m1.get_devname(vlan1)})
+ m2_vlan2 = m2.get_interface(vlan2)
- ping_mod6.update_options({"addr": m2.get_ip(vlan2, 1),
- "iface": m1.get_ip(vlan1, 1)})
+ ping_mod.update_options({"addr": m2_vlan2.get_ip(0),
+ "iface": m1_vlan1.get_devname()})
- netperf_srv.update_options({"bind": m1.get_ip(vlan1, 0)})
+ ping_mod6.update_options({"addr": m2_vlan2.get_ip(1),
+ "iface": m1_vlan1.get_ip(1)})
- netperf_srv6.update_options({"bind": m1.get_ip(vlan1, 1)})
+ netperf_srv.update_options({"bind": m1_vlan1.get_ip(0)})
- netperf_cli_tcp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_srv6.update_options({"bind": m1_vlan1.get_ip(1)})
- netperf_cli_udp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_cli_tcp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_tcp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_udp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_udp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_tcp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
+
+ netperf_cli_udp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
if vlan1 == vlan2:
# These tests should pass
@@ -128,11 +133,11 @@ for vlan1 in vlans:
for setting in offload_settings:
#apply offload setting
for offload in setting:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy1.get_devname(),
offload[0], offload[1]))
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy2.get_devname(),
offload[0], offload[1]))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ m2.run("ethtool -K %s %s %s" % (m2_phy1.get_devname(),
offload[0], offload[1]))
if ipv in [ 'ipv4', 'both' ]:
@@ -238,7 +243,6 @@ for vlan1 in vlans:
perf_api.save_result(result_udp)
srv_proc.intr()
-
# These tests should fail
# Ping across different VLAN
else:
@@ -250,9 +254,9 @@ for vlan1 in vlans:
#reset offload states
for offload in offloads:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy1.get_devname(),
offload, "on"))
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy2.get_devname(),
offload, "on"))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ m2.run("ethtool -K %s %s %s" % (m2_phy1.get_devname(),
offload, "on"))
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index 18659d1..079a8fe 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -44,83 +44,83 @@ test_if2.set_mtu(mtu)
ping_mod = ctl.get_module("IcmpPing",
options={
- "addr" : m2.get_ip("test_if", 0),
+ "addr" : test_if2.get_ip(0),
"count" : 100,
- "iface" : m1.get_devname("test_if"),
+ "iface" : test_if1.get_devname(),
"interval" : 0.1
})
ping_mod6 = ctl.get_module("Icmp6Ping",
options={
- "addr" : m2.get_ip("test_if", 1),
+ "addr" : test_if2.get_ip(1),
"count" : 100,
- "iface" : m1.get_devname("test_if"),
+ "iface" : test_if1.get_devname(),
"interval" : 0.1
})
netperf_srv = ctl.get_module("Netperf",
options = {
"role" : "server",
- "bind" : m1.get_ip("test_if", 0)
+ "bind" : test_if1.get_ip(0)
})
netperf_srv6 = ctl.get_module("Netperf",
options={
"role" : "server",
- "bind" : m1.get_ip("test_if", 1),
+ "bind" : test_if1.get_ip(1),
"netperf_opts" : " -6",
})
netperf_cli_tcp = ctl.get_module("Netperf",
options = {
"role" : "client",
- "netperf_server" : m1.get_ip("test_if", 0),
+ "netperf_server" : test_if1.get_ip(0),
"duration" : netperf_duration,
"testname" : "TCP_STREAM",
"confidence" : nperf_confidence,
- "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, m2.get_ip("test_if", 0))
+ "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, test_if2.get_ip(0))
})
netperf_cli_udp = ctl.get_module("Netperf",
options = {
"role" : "client",
- "netperf_server" : m1.get_ip("test_if", 0),
+ "netperf_server" : test_if1.get_ip(0),
"duration" : netperf_duration,
"testname" : "UDP_STREAM",
"confidence" : nperf_confidence,
- "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, m2.get_ip("test_if", 0))
+ "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, test_if2.get_ip(0))
})
netperf_cli_tcp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
- m1.get_ip("test_if", 1),
+ test_if1.get_ip(1),
"duration" : netperf_duration,
"testname" : "TCP_STREAM",
"confidence" : nperf_confidence,
"netperf_opts" :
- "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip("test_if", 1))
+ "-i %s -L %s -6" % (nperf_max_runs, test_if2.get_ip(1))
})
netperf_cli_udp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
- m1.get_ip("test_if", 1),
+ test_if1.get_ip(1),
"duration" : netperf_duration,
"testname" : "UDP_STREAM",
"confidence" : nperf_confidence,
"netperf_opts" :
- "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip("test_if", 1))
+ "-i %s -L %s -6" % (nperf_max_runs, test_if2.get_ip(1))
})
ctl.wait(15)
for setting in offload_settings:
for offload in setting:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ m1.run("ethtool -K %s %s %s" % (test_if1.get_devname(),
offload[0], offload[1]))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ m2.run("ethtool -K %s %s %s" % (test_if2.get_devname(),
offload[0], offload[1]))
if ipv in [ 'ipv4', 'both' ]:
@@ -217,7 +217,7 @@ for setting in offload_settings:
#reset offload states
for offload in offloads:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ m1.run("ethtool -K %s %s %s" % (test_if1.get_devname(),
offload, "on"))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ m2.run("ethtool -K %s %s %s" % (test_if2.get_devname(),
offload, "on"))
diff --git a/recipes/regression_tests/phase1/simple_ping.py b/recipes/regression_tests/phase1/simple_ping.py
index f9e5837..3591402 100644
--- a/recipes/regression_tests/phase1/simple_ping.py
+++ b/recipes/regression_tests/phase1/simple_ping.py
@@ -6,20 +6,23 @@ hostB = ctl.get_host("machine2")
hostA.sync_resources(modules=["Icmp6Ping", "IcmpPing"])
hostB.sync_resources(modules=["Icmp6Ping", "IcmpPing"])
+hostA_testiface = hostA.get_interface("testiface")
+hostB_testiface = hostB.get_interface("testiface")
+
ping_mod = ctl.get_module("IcmpPing",
options={
- "addr": hostB.get_ip("testiface", 0),
+ "addr": hostB_testiface.get_ip(0),
"count": 100,
"interval": 0.2,
- "iface" : hostA.get_devname("testiface"),
+ "iface" : hostA_testiface.get_devname(),
"limit_rate": 90})
ping_mod6 = ctl.get_module("Icmp6Ping",
options={
- "addr": hostB.get_ip("testiface", 1),
+ "addr": hostB_testiface.get_ip(1),
"count": 100,
"interval": 0.2,
- "iface" : hostA.get_ip("testiface", 1),
+ "iface" : hostA_testiface.get_ip(1),
"limit_rate": 90})
ctl.wait(15)
--
2.4.3
8 years, 5 months
[PATCH] regression-tests: test only some specific offload combinations
by Ondrej Lichtner
From: Ondrej Lichtner <olichtne(a)redhat.com>
This patch changes which offload combinations we test. Previously we
would test gso, gro and tso in both on and off states - 6 combinations,
and since all the offloads are on by default this means that 3 of those
combinations were identical (gro=on; gso=on; tso=on) resulting in 2
useless tests.
>From now on we will only be testing some specific combinations, for now
we have:
* gro=on + gso=on + tso=on + tx=on + rx=on
* gro=off + gso=on + tso=on + tx=on + rx=on
* gro=on + gso=off + tso=off + tx=on + rx=on
* gro=on + gso=on + tso=off + tx=off + rx=on
* gro=on + gso=on + tso=on + tx=on + rx=off
This should halve the test time compared to before. Unfortunately this
patch will change all the hashes generated for PerfRepo results.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 224 ++++++-----
.../regression_tests/phase1/3_vlans_over_bond.py | 231 ++++++-----
recipes/regression_tests/phase1/bonding_test.py | 203 +++++-----
.../phase1/virtual_bridge_2_vlans_over_bond.py | 197 ++++++----
.../phase1/virtual_bridge_vlan_in_guest.py | 166 ++++----
.../phase1/virtual_bridge_vlan_in_host.py | 165 ++++----
.../regression_tests/phase2/3_vlans_over_team.py | 229 ++++++-----
recipes/regression_tests/phase2/team_test.py | 427 +++++++++++----------
...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 235 +++++++-----
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 203 +++++-----
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 205 +++++-----
11 files changed, 1358 insertions(+), 1127 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index 3fdf60c..2007dc4 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# ------
vlans = ["vlan10", "vlan20", "vlan30"]
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
mtu = ctl.get_alias("mtu")
@@ -120,111 +125,115 @@ for vlan1 in vlans:
if vlan1 == vlan2:
# These tests should pass
# Ping between same VLANs
- for offload in offloads:
- for state in ["off", "on"]:
- # Offload setup
+ for setting in offload_settings:
+ for offload in setting:
m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
- offload, state))
+ offload[0], offload[1]))
m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- # Ping test
- m1.run(ping_mod)
-
- # Netperf test (both TCP and UDP)
- srv_proc = m1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
- result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server_on_vlan', vlan1)
- result_udp.set_parameter('netperf_client_on_vlan', vlan2)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- srv_proc.intr()
-
- if ipv in [ 'ipv6', 'both' ]:
- # Ping test
- m1.run(ping_mod6)
-
- # Netperf test (both TCP and UDP)
- srv_proc = m1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
- result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
- result_tcp.set_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server_on_vlan', vlan1)
- result_udp.set_parameter('netperf_client_on_vlan', vlan2)
- result_udp.set_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- srv_proc.intr()
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ # Ping test
+ m1.run(ping_mod)
+
+ # Netperf test (both TCP and UDP)
+ srv_proc = m1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_udp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ srv_proc.intr()
+
+ if ipv in [ 'ipv6', 'both' ]:
+ # Ping test
+ m1.run(ping_mod6)
+
+ # Netperf test (both TCP and UDP)
+ srv_proc = m1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_tcp.set_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_udp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_udp.set_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ srv_proc.intr()
# These tests should fail
# Ping across different VLAN
@@ -234,3 +243,10 @@ for vlan1 in vlans:
if ipv in [ 'ipv6', 'both' ]:
m1.run(ping_mod6, expect="fail")
+
+#reset offload states
+for offload in offloads:
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ offload, "on"))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index d96a44f..79c4b4d 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# ------
vlans = ["vlan10", "vlan20", "vlan30"]
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
mtu = ctl.get_alias("mtu")
@@ -120,114 +125,119 @@ for vlan1 in vlans:
if vlan1 == vlan2:
# These tests should pass
# Ping between same VLANs
- for offload in offloads:
- for state in ["off", "on"]:
- # Offload setup
+ for setting in offload_settings:
+ #apply offload setting
+ for offload in setting:
m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
- offload, state))
+ offload[0], offload[1]))
m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
- offload, state))
+ offload[0], offload[1]))
m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- # Ping test
- m1.run(ping_mod)
-
- # Netperf test (both TCP and UDP)
- srv_proc = m1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
- result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server_on_vlan', vlan1)
- result_udp.set_parameter('netperf_client_on_vlan', vlan2)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- srv_proc.intr()
-
- if ipv in [ 'ipv6', 'both' ]:
- # Ping test
- m1.run(ping_mod6)
-
- # Netperf test (both TCP and UDP)
- srv_proc = m1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
- result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server_on_vlan', vlan1)
- result_udp.set_parameter('netperf_client_on_vlan', vlan2)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- srv_proc.intr()
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ # Ping test
+ m1.run(ping_mod)
+
+ # Netperf test (both TCP and UDP)
+ srv_proc = m1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_udp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ srv_proc.intr()
+
+ if ipv in [ 'ipv6', 'both' ]:
+ # Ping test
+ m1.run(ping_mod6)
+
+ # Netperf test (both TCP and UDP)
+ srv_proc = m1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_udp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ srv_proc.intr()
# These tests should fail
# Ping across different VLAN
@@ -237,3 +247,12 @@ for vlan1 in vlans:
if ipv in [ 'ipv6', 'both' ]:
m1.run(ping_mod6, expect="fail")
+
+#reset offload states
+for offload in offloads:
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ offload, "on"))
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
+ offload, "on"))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index ffbfc55..18659d1 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["tso", "gro", "gso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
mtu = ctl.get_alias("mtu")
@@ -111,96 +116,108 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
ctl.wait(15)
+for setting in offload_settings:
+ for offload in setting:
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ offload[0], offload[1]))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ m1.run(ping_mod)
+
+ server_proc = m1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+ if ipv in [ 'ipv6', 'both' ]:
+ m1.run(ping_mod6)
+
+ server_proc = m1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+#reset offload states
for offload in offloads:
- for state in ["off", "on"]:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload,
- state))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload,
- state))
- if ipv in [ 'ipv4', 'both' ]:
- m1.run(ping_mod)
-
- server_proc = m1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
-
- if ipv in [ 'ipv6', 'both' ]:
- m1.run(ping_mod6)
-
- server_proc = m1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ offload, "on"))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
index 5b0cb2b..ed2de32 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
@@ -30,7 +30,12 @@ g4.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
netperf_duration = int(ctl.get_alias("netperf_duration"))
@@ -187,120 +192,144 @@ g4.get_interface("guestnic").set_mtu(mtu)
ctl.wait(15)
-for offload in offloads:
- for state in ["off", "on"]:
+for setting in offload_settings:
+ for offload in setting:
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"),
- offload, state))
+ offload[0], offload[1]))
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"),
- offload, state))
+ offload[0], offload[1]))
g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- g1.run(ping_mod)
- g4.run(ping_mod2)
- g1.run(ping_mod_bad, expect="fail")
- g3.run(ping_mod_bad2, expect="fail")
-
- server_proc = g1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ g1.run(ping_mod)
+ g4.run(ping_mod2)
+ g1.run(ping_mod_bad, expect="fail")
+ g3.run(ping_mod_bad2, expect="fail")
+
+ server_proc = g1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ if enable_udp_perf is not None:
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
- tcp_res_data = g3.run(netperf_cli_tcp,
+ udp_res_data = g3.run(netperf_cli_udp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
- if enable_udp_perf is not None:
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
+ server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
+ if ipv in [ 'ipv6', 'both' ]:
+ g1.run(ping_mod6)
+ g4.run(ping_mod62)
+ g1.run(ping_mod6_bad, expect="fail")
+ g3.run(ping_mod6_bad2, expect="fail")
- udp_res_data = g3.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ server_proc = g1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
- server_proc.intr()
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- if ipv in [ 'ipv6', 'both' ]:
- g1.run(ping_mod6)
- g4.run(ping_mod62)
- g1.run(ping_mod6_bad, expect="fail")
- g3.run(ping_mod6_bad2, expect="fail")
+ tcp_res_data = g3.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True)
- ctl.wait(2)
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
+ # prepare PerfRepo result for udp ipv6
+ if enable_udp_perf is not None:
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
- tcp_res_data = g3.run(netperf_cli_tcp6,
+ udp_res_data = g3.run(netperf_cli_udp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf is not None:
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
- udp_res_data = g3.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ server_proc.intr()
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+#reset offload states
+for offload in offloads:
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"),
+ offload, "on"))
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"),
+ offload, "on"))
+ g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
+ offload, "on"))
+ g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"),
+ offload, "on"))
+ g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"),
+ offload, "on"))
+ g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
index f0b2c65..b762f8c 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
netperf_duration = int(ctl.get_alias("netperf_duration"))
@@ -122,105 +127,118 @@ h2.get_interface("nic").set_mtu(mtu)
ctl.wait(15)
-for offload in offloads:
- for state in ["off", "on"]:
+for setting in offload_settings:
+ for offload in setting:
g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
- offload, state))
-
- if ipv in [ 'ipv4', 'both' ]:
- g1.run(ping_mod)
-
- server_proc = g1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ g1.run(ping_mod)
+
+ server_proc = g1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ if enable_udp_perf is not None:
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp,
+ udp_res_data = h2.run(netperf_cli_udp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
- # prepare PerfRepo result for udp
- if enable_udp_perf is not None:
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
+ server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
+ if ipv in [ 'ipv6', 'both' ]:
+ g1.run(ping_mod6)
- udp_res_data = h2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ server_proc = g1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
- server_proc.intr()
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- if ipv in [ 'ipv6', 'both' ]:
- g1.run(ping_mod6)
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True)
- ctl.wait(2)
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
+ # prepare PerfRepo result for udp ipv6
+ if enable_udp_perf is not None:
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp6,
+ udp_res_data = h2.run(netperf_cli_udp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf is not None:
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
+ server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = h2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+#reset offload states
+for offload in offloads:
+ g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
+ offload, "on"))
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
index fa64aba..4c1a454 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
netperf_duration = int(ctl.get_alias("netperf_duration"))
@@ -123,104 +128,118 @@ h2.get_interface("vlan10").set_mtu(mtu)
ctl.wait(15)
-for offload in offloads:
- for state in ["off", "on"]:
+for setting in offload_settings:
+ for offload in setting:
g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- g1.run(ping_mod)
-
- server_proc = g1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ g1.run(ping_mod)
+
+ server_proc = g1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ if enable_udp_perf is not None:
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp,
+ udp_res_data = h2.run(netperf_cli_udp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
- # prepare PerfRepo result for udp
- if enable_udp_perf is not None:
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
+ server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
+ if ipv in [ 'ipv6', 'both' ]:
+ g1.run(ping_mod6)
- udp_res_data = h2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ server_proc = g1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
- server_proc.intr()
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- if ipv in [ 'ipv6', 'both' ]:
- g1.run(ping_mod6)
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True)
- ctl.wait(2)
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
+ # prepare PerfRepo result for udp ipv6
+ if enable_udp_perf:
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp6,
+ udp_res_data = h2.run(netperf_cli_udp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf:
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
+ server_proc.intr()
- udp_res_data = h2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+#reset offload states
+for offload in offloads:
+ g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
+ offload, "on"))
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index 905674d..77298a2 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# ------
vlans = ["vlan10", "vlan20", "vlan30"]
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
mtu = ctl.get_alias("mtu")
@@ -121,114 +126,117 @@ for vlan1 in vlans:
if vlan1 == vlan2:
# These tests should pass
# Ping between same VLANs
- for offload in offloads:
- for state in ["off", "on"]:
- # Offload setup
+ for setting in offload_settings:
+ for offload in setting:
m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
- offload, state))
+ offload[0], offload[1]))
m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
- offload, state))
+ offload[0], offload[1]))
m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
- offload, state))
-
- if ipv in [ 'ipv4', 'both' ]:
- # Ping test
- m1.run(ping_mod)
-
- # Netperf test (both TCP and UDP)
- srv_proc = m1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
- result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server_on_vlan', vlan1)
- result_udp.set_parameter('netperf_client_on_vlan', vlan2)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- srv_proc.intr()
-
- if ipv in [ 'ipv6', 'both' ]:
- m1.run(ping_mod6)
-
- # Netperf test (both TCP and UDP)
- srv_proc = m1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
- result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server_on_vlan', vlan1)
- result_udp.set_parameter('netperf_client_on_vlan', vlan2)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- srv_proc.intr()
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ # Ping test
+ m1.run(ping_mod)
+
+ # Netperf test (both TCP and UDP)
+ srv_proc = m1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_udp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ srv_proc.intr()
+
+ if ipv in [ 'ipv6', 'both' ]:
+ m1.run(ping_mod6)
+
+ # Netperf test (both TCP and UDP)
+ srv_proc = m1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_tcp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server_on_vlan', vlan1)
+ result_udp.set_parameter('netperf_client_on_vlan', vlan2)
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ srv_proc.intr()
# These tests should fail
# Ping across different VLAN
else:
@@ -237,3 +245,12 @@ for vlan1 in vlans:
if ipv in [ 'ipv6', 'both' ]:
m1.run(ping_mod6, expect="fail")
+
+#reset offload states
+for offload in offloads:
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ offload, "on"))
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
+ offload, "on"))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index e974ec2..8ebb5cf 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -22,7 +22,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["tso", "gro", "gso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
mtu = ctl.get_alias("mtu")
@@ -111,106 +116,118 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
ctl.wait(15)
+for setting in offload_settings:
+ for offload in setting:
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ offload[0], offload[1]))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ m1.run(ping_mod)
+
+ server_proc = m1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server', "testmachine1")
+ result_tcp.set_parameter('netperf_client', "testmachine2")
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server', "testmachine1")
+ result_udp.set_parameter('netperf_client', "testmachine2")
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+ if ipv in [ 'ipv6', 'both' ]:
+ m1.run(ping_mod6)
+
+ server_proc = m1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server', "testmachine1")
+ result_tcp.set_parameter('netperf_client', "testmachine2")
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*5)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server', "testmachine1")
+ result_udp.set_parameter('netperf_client', "testmachine2")
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = m2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*5)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+#reset offload states
for offload in offloads:
- for state in ["off", "on"]:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload,
- state))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload,
- state))
- if ipv in [ 'ipv4', 'both' ]:
- m1.run(ping_mod)
-
- server_proc = m1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server', "testmachine1")
- result_tcp.set_parameter('netperf_client', "testmachine2")
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server', "testmachine1")
- result_udp.set_parameter('netperf_client', "testmachine2")
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
- if ipv in [ 'ipv6', 'both' ]:
- m1.run(ping_mod6)
-
- server_proc = m1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server', "testmachine1")
- result_tcp.set_parameter('netperf_client', "testmachine2")
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*5)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server', "testmachine1")
- result_udp.set_parameter('netperf_client', "testmachine2")
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = m2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*5)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ offload, "on"))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ offload, "on"))
ping_mod.update_options({"addr" : m1.get_ip("test_if", 0),
@@ -235,103 +252,115 @@ netperf_cli_tcp6.update_options({"netperf_server" : m2.get_ip("test_if", 1),
netperf_cli_udp6.update_options({"netperf_server" : m2.get_ip("test_if", 1),
"netperf_opts" : "-i %s -L %s -6" % (nperf_max_runs, m1.get_ip("test_if", 1))})
+for setting in offload_settings:
+ for offload in setting:
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ offload[0], offload[1]))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ m2.run(ping_mod)
+
+ server_proc = m2.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server', "testmachine2")
+ result_tcp.set_parameter('netperf_client', "testmachine1")
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m1.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server', "testmachine2")
+ result_udp.set_parameter('netperf_client', "testmachine1")
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = m1.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+ if ipv in [ 'ipv6', 'both' ]:
+ m2.run(ping_mod6)
+
+ server_proc = m2.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.set_parameter('netperf_server', "testmachine2")
+ result_tcp.set_parameter('netperf_client', "testmachine1")
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m1.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.set_parameter('netperf_server', "testmachine2")
+ result_udp.set_parameter('netperf_client', "testmachine1")
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = m1.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+#reset offload states
for offload in offloads:
- for state in ["off", "on"]:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload,
- state))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload,
- state))
- if ipv in [ 'ipv4', 'both' ]:
- m2.run(ping_mod)
-
- server_proc = m2.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server', "testmachine2")
- result_tcp.set_parameter('netperf_client', "testmachine1")
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m1.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server', "testmachine2")
- result_udp.set_parameter('netperf_client', "testmachine1")
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = m1.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
- if ipv in [ 'ipv6', 'both' ]:
- m2.run(ping_mod6)
-
- server_proc = m2.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.set_parameter('netperf_server', "testmachine2")
- result_tcp.set_parameter('netperf_client', "testmachine1")
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m1.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.set_parameter('netperf_server', "testmachine2")
- result_udp.set_parameter('netperf_client', "testmachine1")
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = m1.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+ m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"),
+ offload, "on"))
+ m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
index 6ba9541..1c1aad7 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
@@ -30,7 +30,12 @@ g4.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
netperf_duration = int(ctl.get_alias("netperf_duration"))
@@ -164,113 +169,137 @@ ping_mod6_bad2 = ctl.get_module("Icmp6Ping",
ctl.wait(15)
-for offload in offloads:
- for state in ["off", "on"]:
+for setting in offload_settings:
+ for offload in setting:
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"),
- offload, state))
+ offload[0], offload[1]))
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"),
- offload, state))
+ offload[0], offload[1]))
g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- g1.run(ping_mod)
- g4.run(ping_mod2)
- g1.run(ping_mod_bad, expect="fail")
- g3.run(ping_mod_bad2, expect="fail")
-
- server_proc = g1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = g3.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
- if ipv in [ 'ipv6', 'both' ]:
- g1.run(ping_mod6)
- g4.run(ping_mod62)
- g1.run(ping_mod6_bad, expect="fail")
- g3.run(ping_mod6_bad2, expect="fail")
-
- server_proc = g1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = g3.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ g1.run(ping_mod)
+ g4.run(ping_mod2)
+ g1.run(ping_mod_bad, expect="fail")
+ g3.run(ping_mod_bad2, expect="fail")
+
+ server_proc = g1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = g3.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+ if ipv in [ 'ipv6', 'both' ]:
+ g1.run(ping_mod6)
+ g4.run(ping_mod62)
+ g1.run(ping_mod6_bad, expect="fail")
+ g3.run(ping_mod6_bad2, expect="fail")
+
+ server_proc = g1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = g3.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+#reset offload states
+for offload in offloads:
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"),
+ offload, "on"))
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"),
+ offload, "on"))
+ g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
+ offload, "on"))
+ g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"),
+ offload, "on"))
+ g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"),
+ offload, "on"))
+ g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
index 3a09ec0..598c31b 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
@@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
netperf_duration = int(ctl.get_alias("netperf_duration"))
@@ -109,97 +114,111 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
ctl.wait(15)
-for offload in offloads:
- for state in ["off", "on"]:
+for setting in offload_settings:
+ for offload in setting:
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
- offload, state))
+ offload[0], offload[1]))
g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- g1.run(ping_mod)
-
- server_proc = g1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = h2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
- if ipv in [ 'ipv6', 'both' ]:
- g1.run(ping_mod6)
-
- server_proc = g1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = h2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ g1.run(ping_mod)
+
+ server_proc = g1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = h2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+ if ipv in [ 'ipv6', 'both' ]:
+ g1.run(ping_mod6)
+
+ server_proc = g1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = h2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+#reset offload states
+for offload in offloads:
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
+ offload, "on"))
+ g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
+ offload, "on"))
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
index 6e1cc74..9c2fd5d 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
@@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"])
# TESTS
# ------
-offloads = ["gso", "gro", "tso"]
+offloads = ["gro", "gso", "tso", "rx", "tx"]
+offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")],
+ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv")
netperf_duration = int(ctl.get_alias("netperf_duration"))
@@ -108,98 +113,112 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
})
ctl.wait(15)
-for offload in offloads:
- for state in ["off", "on"]:
+for setting in offload_settings:
+ for offload in setting:
h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
- offload, state))
+ offload[0], offload[1]))
g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
- offload, state))
+ offload[0], offload[1]))
h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
- offload, state))
- if ipv in [ 'ipv4', 'both' ]:
- g1.run(ping_mod)
-
- server_proc = g1.run(netperf_srv, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp, baseline)
-
- udp_res_data = h2.run(netperf_cli_udp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
-
- if ipv in [ 'ipv6', 'both' ]:
- g1.run(ping_mod6)
-
- server_proc = g1.run(netperf_srv6, bg=True)
- ctl.wait(2)
-
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_tcp.set_parameter(offload, state)
- result_tcp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- result_udp.set_parameter(offload, state)
- result_udp.add_tag(product_name)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- netperf_baseline_template(netperf_cli_udp6, baseline)
-
- udp_res_data = h2.run(netperf_cli_udp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- perf_api.save_result(result_udp)
-
- server_proc.intr()
+ offload[0], offload[1]))
+
+ if ipv in [ 'ipv4', 'both' ]:
+ g1.run(ping_mod)
+
+ server_proc = g1.run(netperf_srv, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp, baseline)
+
+ udp_res_data = h2.run(netperf_cli_udp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+ if ipv in [ 'ipv6', 'both' ]:
+ g1.run(ping_mod6)
+
+ server_proc = g1.run(netperf_srv6, bg=True)
+ ctl.wait(2)
+
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+ result_tcp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ perf_api.save_result(result_tcp)
+
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_udp.set_parameter(offload[0], offload[1])
+ result_udp.add_tag(product_name)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ netperf_baseline_template(netperf_cli_udp6, baseline)
+
+ udp_res_data = h2.run(netperf_cli_udp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ perf_api.save_result(result_udp)
+
+ server_proc.intr()
+
+#reset offload states
+for offload in offloads:
+ h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"),
+ offload, "on"))
+ g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"),
+ offload, "on"))
+ h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"),
+ offload, "on"))
--
2.6.1
8 years, 5 months
[PATCH] PacketCapture: fix capturing into files
by Jan Tluka
This patch fixes the problem with capturing data on configured
interfaces. The problem is that we start tcpdump inside shell. When we
stop the capture we call Popen.terminate() but this terminates the
shell process, not the tcpdump process. Until it's terminated the data are
not flushed to capture file and we transfer empty file to controller.
The fix for this problem is running without shell.
Additionally I'm removing the quotation marks around pcap filter as they
are not required and cause unnecessary entry in log when it is empty.
The last change in the patch is moving redirection of stderr to the code
where Popen is called. This is a must because of using shell=False.
Resolves #150
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
lnst/Common/PacketCapture.py | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/lnst/Common/PacketCapture.py b/lnst/Common/PacketCapture.py
index f45dc99..2717200 100644
--- a/lnst/Common/PacketCapture.py
+++ b/lnst/Common/PacketCapture.py
@@ -11,6 +11,7 @@ rpazdera(a)redhat.com (Radek Pazdera)
"""
import subprocess
+import os
class PacketCapture:
""" Capture/handle traffic that goes through a specific
@@ -49,14 +50,15 @@ class PacketCapture:
output_file = self._file
pcap_filter = self._filter
- self._cmd = "tcpdump -p -i %s -w %s \"%s\" 2>/dev/null" % \
+ self._cmd = "tcpdump -p -i %s -w %s %s" % \
(interface, output_file, pcap_filter)
def _execute_tcpdump(self):
""" Start tcpdump in the background """
- cmd = self._cmd
- self._tcpdump = subprocess.Popen(cmd, shell=True, stdout=None,
- stderr=None)
+ cmd = self._cmd.split()
+ fnull = open(os.devnull, "w")
+ self._tcpdump = subprocess.Popen(cmd, shell=False, stdout=fnull,
+ stderr=subprocess.STDOUT)
def _run(self):
self._compose_cmd()
--
2.1.0
8 years, 5 months
[PATCH 1/4] regression-tests: Replace deprecated methods in phase1 baremetal tests
by Jiri Prochazka
This commit replaces InterfaceAPI methods get_ip() and get_devname() with
HostAPI methods which are supported and recommended.
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 35 ++++++++++----------
.../regression_tests/phase1/3_vlans_over_bond.py | 37 ++++++++++++----------
recipes/regression_tests/phase1/bonding_test.py | 32 +++++++++----------
recipes/regression_tests/phase1/simple_ping.py | 11 ++++---
4 files changed, 63 insertions(+), 52 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index 3fdf60c..cf436db 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -94,28 +94,31 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
})
for vlan1 in vlans:
+ m1_vlan1 = m1.get_interface(vlan1)
for vlan2 in vlans:
- ping_mod.update_options({"addr": m2.get_ip(vlan2, 0),
- "iface": m1.get_devname(vlan1)})
+ m2_vlan2 = m2.get_interface(vlan2)
- ping_mod6.update_options({"addr": m2.get_ip(vlan2, 1),
- "iface": m1.get_ip(vlan1, 1)})
+ ping_mod.update_options({"addr": m2_vlan2.get_ip(0),
+ "iface": m1_vlan1.get_devname()})
- netperf_srv.update_options({"bind": m1.get_ip(vlan1, 0)})
+ ping_mod6.update_options({"addr": m2_vlan2.get_ip(1),
+ "iface": m1_vlan1.get_ip(1)})
- netperf_srv6.update_options({"bind": m1.get_ip(vlan1, 1)})
+ netperf_srv.update_options({"bind": m1_vlan1.get_ip(0)})
- netperf_cli_tcp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_srv6.update_options({"bind": m1_vlan1.get_ip(1)})
- netperf_cli_udp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_cli_tcp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_tcp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_udp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_udp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_tcp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
+
+ netperf_cli_udp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
if vlan1 == vlan2:
# These tests should pass
@@ -123,9 +126,9 @@ for vlan1 in vlans:
for offload in offloads:
for state in ["off", "on"]:
# Offload setup
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy1.get_devname(),
offload, state))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ m2.run("ethtool -K %s %s %s" % (m2_phy1.get_devname(),
offload, state))
if ipv in [ 'ipv4', 'both' ]:
# Ping test
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index d96a44f..3b3cfb8 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -34,6 +34,8 @@ nperf_max_runs = int(ctl.get_alias("nperf_max_runs"))
m1_bond = m1.get_interface("test_bond")
m1_bond.set_mtu(mtu)
+m1_phy1 = m1.get_interface("eth1")
+m1_phy2 = m1.get_interface("eth2")
m2_phy1 = m2.get_interface("eth1")
m2_phy1.set_mtu(mtu)
@@ -94,28 +96,31 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
})
for vlan1 in vlans:
+ m1_vlan1 = m1.get_interface(vlan1)
for vlan2 in vlans:
- ping_mod.update_options({"addr": m2.get_ip(vlan2, 0),
+ m2_vlan2 = m2.get_interface(vlan2)
+
+ ping_mod.update_options({"addr": m2_vlan2.get_ip(0),
"iface": m1.get_devname(vlan1)})
- ping_mod6.update_options({"addr": m2.get_ip(vlan2, 1),
- "iface": m1.get_ip(vlan1, 1)})
+ ping_mod6.update_options({"addr": m2_vlan2.get_ip(1),
+ "iface": m1_vlan1.get_ip(1)})
- netperf_srv.update_options({"bind": m1.get_ip(vlan1, 0)})
+ netperf_srv.update_options({"bind": m1_vlan1.get_ip(0)})
- netperf_srv6.update_options({"bind": m1.get_ip(vlan1, 1)})
+ netperf_srv6.update_options({"bind": m1_vlan1.get_ip(1)})
- netperf_cli_tcp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_cli_tcp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_udp.update_options({"netperf_server": m1.get_ip(vlan1, 0),
- "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2.get_ip(vlan1, 0))})
+ netperf_cli_udp.update_options({"netperf_server": m1_vlan1.get_ip(0),
+ "netperf_opts": "-i %s -L %s" % (nperf_max_runs, m2_vlan2.get_ip(0))})
- netperf_cli_tcp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_tcp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
- netperf_cli_udp6.update_options({"netperf_server": m1.get_ip(vlan1, 1),
- "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip(vlan1, 1))})
+ netperf_cli_udp6.update_options({"netperf_server": m1_vlan1.get_ip(1),
+ "netperf_opts": "-i %s -L %s -6" % (nperf_max_runs, m2_vlan2.get_ip(1))})
if vlan1 == vlan2:
# These tests should pass
@@ -123,11 +128,11 @@ for vlan1 in vlans:
for offload in offloads:
for state in ["off", "on"]:
# Offload setup
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy1.get_devname(),
offload, state))
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"),
+ m1.run("ethtool -K %s %s %s" % (m1_phy2.get_devname(),
offload, state))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"),
+ m2.run("ethtool -K %s %s %s" % (m2_phy1.get_devname(),
offload, state))
if ipv in [ 'ipv4', 'both' ]:
# Ping test
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index ffbfc55..f9b1127 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -39,83 +39,83 @@ test_if2.set_mtu(mtu)
ping_mod = ctl.get_module("IcmpPing",
options={
- "addr" : m2.get_ip("test_if", 0),
+ "addr" : test_if2.get_ip(0),
"count" : 100,
- "iface" : m1.get_devname("test_if"),
+ "iface" : test_if1.get_devname(),
"interval" : 0.1
})
ping_mod6 = ctl.get_module("Icmp6Ping",
options={
- "addr" : m2.get_ip("test_if", 1),
+ "addr" : test_if2.get_ip(1),
"count" : 100,
- "iface" : m1.get_devname("test_if"),
+ "iface" : test_if1.get_devname(),
"interval" : 0.1
})
netperf_srv = ctl.get_module("Netperf",
options = {
"role" : "server",
- "bind" : m1.get_ip("test_if", 0)
+ "bind" : test_if1.get_ip(0)
})
netperf_srv6 = ctl.get_module("Netperf",
options={
"role" : "server",
- "bind" : m1.get_ip("test_if", 1),
+ "bind" : test_if1.get_ip(1),
"netperf_opts" : " -6",
})
netperf_cli_tcp = ctl.get_module("Netperf",
options = {
"role" : "client",
- "netperf_server" : m1.get_ip("test_if", 0),
+ "netperf_server" : test_if1.get_ip(0),
"duration" : netperf_duration,
"testname" : "TCP_STREAM",
"confidence" : nperf_confidence,
- "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, m2.get_ip("test_if", 0))
+ "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, test_if2.get_ip(0))
})
netperf_cli_udp = ctl.get_module("Netperf",
options = {
"role" : "client",
- "netperf_server" : m1.get_ip("test_if", 0),
+ "netperf_server" : test_if1.get_ip(0),
"duration" : netperf_duration,
"testname" : "UDP_STREAM",
"confidence" : nperf_confidence,
- "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, m2.get_ip("test_if", 0))
+ "netperf_opts" : "-i %s -L %s" % (nperf_max_runs, test_if2.get_ip(0))
})
netperf_cli_tcp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
- m1.get_ip("test_if", 1),
+ test_if1.get_ip(1),
"duration" : netperf_duration,
"testname" : "TCP_STREAM",
"confidence" : nperf_confidence,
"netperf_opts" :
- "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip("test_if", 1))
+ "-i %s -L %s -6" % (nperf_max_runs, test_if2.get_ip(1))
})
netperf_cli_udp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
- m1.get_ip("test_if", 1),
+ test_if1.get_ip(1),
"duration" : netperf_duration,
"testname" : "UDP_STREAM",
"confidence" : nperf_confidence,
"netperf_opts" :
- "-i %s -L %s -6" % (nperf_max_runs, m2.get_ip("test_if", 1))
+ "-i %s -L %s -6" % (nperf_max_runs, test_if2.get_ip(1))
})
ctl.wait(15)
for offload in offloads:
for state in ["off", "on"]:
- m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload,
+ m1.run("ethtool -K %s %s %s" % (test_if1.get_devname(), offload,
state))
- m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload,
+ m2.run("ethtool -K %s %s %s" % (test_if2.get_devname(), offload,
state))
if ipv in [ 'ipv4', 'both' ]:
m1.run(ping_mod)
diff --git a/recipes/regression_tests/phase1/simple_ping.py b/recipes/regression_tests/phase1/simple_ping.py
index f9e5837..3591402 100644
--- a/recipes/regression_tests/phase1/simple_ping.py
+++ b/recipes/regression_tests/phase1/simple_ping.py
@@ -6,20 +6,23 @@ hostB = ctl.get_host("machine2")
hostA.sync_resources(modules=["Icmp6Ping", "IcmpPing"])
hostB.sync_resources(modules=["Icmp6Ping", "IcmpPing"])
+hostA_testiface = hostA.get_interface("testiface")
+hostB_testiface = hostB.get_interface("testiface")
+
ping_mod = ctl.get_module("IcmpPing",
options={
- "addr": hostB.get_ip("testiface", 0),
+ "addr": hostB_testiface.get_ip(0),
"count": 100,
"interval": 0.2,
- "iface" : hostA.get_devname("testiface"),
+ "iface" : hostA_testiface.get_devname(),
"limit_rate": 90})
ping_mod6 = ctl.get_module("Icmp6Ping",
options={
- "addr": hostB.get_ip("testiface", 1),
+ "addr": hostB_testiface.get_ip(1),
"count": 100,
"interval": 0.2,
- "iface" : hostA.get_ip("testiface", 1),
+ "iface" : hostA_testiface.get_ip(1),
"limit_rate": 90})
ctl.wait(15)
--
2.4.3
8 years, 5 months
[PATCH] perfrepo: add conversion from argv to int for some parameters
by Jan Tluka
As the same is done for other numeric parameter values there are some
others left that also need conversion otherwise the application crash
with TypeError: %d format: a number is required, not str
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
perfrepo | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/perfrepo b/perfrepo
index 2fddf39..e4fa719 100755
--- a/perfrepo
+++ b/perfrepo
@@ -605,7 +605,7 @@ class ReportCLI(GenericCLI):
else:
break
elif op == "del":
- series_num = argv[i+1]
+ series_num = int(argv[i+1])
report.del_series(chart_num, series_num)
i += 2
continue
@@ -623,7 +623,7 @@ class ReportCLI(GenericCLI):
% e.args[0])
return -1
elif op == "edit":
- baseline_num = argv[i+1]
+ baseline_num = int(argv[i+1])
i += 2
while i < len(argv):
if argv[i] == "name":
@@ -647,7 +647,7 @@ class ReportCLI(GenericCLI):
else:
break
elif op == "del":
- baseline_num = argv[i+1]
+ baseline_num = int(argv[i+1])
report.del_baseline(chart_num, baseline_num)
i += 2
continue
--
2.1.0
8 years, 5 months
[PATCH 1/2] Task: add method unset_option to ModuleAPI
by Ondrej Lichtner
From: Ondrej Lichtner <olichtne(a)redhat.com>
Sometimes when reusing ModuleAPI objects it is needed to unset module
options, This method should help with that.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
lnst/Controller/Task.py | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/lnst/Controller/Task.py b/lnst/Controller/Task.py
index d3ce6ba..49ea816 100644
--- a/lnst/Controller/Task.py
+++ b/lnst/Controller/Task.py
@@ -444,6 +444,10 @@ class ModuleAPI(object):
else:
self._opts[opt].append({"value": str(val)})
+ def unset_option(self, option_name):
+ if option_name in self._opts:
+ del self._opts[option_name]
+
class ProcessAPI(object):
""" An API class representing either a running or finished process. """
--
2.6.1
8 years, 5 months
[PATCH] recipes: fix typo in get_baseline in bridge_vlan_in_guest ipv6
by Jan Tluka
Everything under udp branch should be udp, tcp is typo here.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
index 9b81c83..f0b2c65 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -214,7 +214,7 @@ for offload in offloads:
result_udp.set_parameter(offload, state)
result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perf_api.get_baseline_of_result(result_udp)
netperf_baseline_template(netperf_cli_udp6, baseline)
udp_res_data = h2.run(netperf_cli_udp6,
--
2.1.0
8 years, 5 months
[PATCH] PerfRepoUtils: baseline template inits module options
by Ondrej Lichtner
From: Ondrej Lichtner <olichtne(a)redhat.com>
This commit makes sure that we reinitialize the module options for the
Netperf module passed. This is needed in case a client netperf module is
reused multiple times, in a single python task, in order to remove a
baseline from a previous run.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
lnst/Controller/PerfRepoUtils.py | 3 +++
1 file changed, 3 insertions(+)
diff --git a/lnst/Controller/PerfRepoUtils.py b/lnst/Controller/PerfRepoUtils.py
index 2169c6b..2dec65e 100644
--- a/lnst/Controller/PerfRepoUtils.py
+++ b/lnst/Controller/PerfRepoUtils.py
@@ -15,6 +15,9 @@ import logging
from lnst.Common.Utils import Noop
def netperf_baseline_template(module, baseline):
+ module.update_options({'threshold': None,
+ 'threshold_deviation': None})
+
if baseline.get_texec() is None:
return module
--
2.6.1
8 years, 5 months
[PATCH] regression-tests: fix typo in python task
by Ondrej Lichtner
From: Ondrej Lichtner <olichtne(a)redhat.com>
One of the python tasks had a typo in it (ignore_hash instead of
hash_ignore). This commit fixes that.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
index 10ce9a8..fa64aba 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -140,7 +140,7 @@ for offload in offloads:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
- ignore_hash=['kernel_release',
+ hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr'])
--
2.6.1
8 years, 5 months