def test_retrieve_eeprom(self):
"""
Test ethtool app dump eeprom function
"""
# require md5sum to check file
out = self.dut.send_expect("whereis md5sum", "# ")
self.verify("/usr/bin/md5sum" in out,
"This case required md5sum installed on DUT")
self.dut.send_expect(self.cmd, "EthApp>", 60)
portsinfo = []
ori_drivers = []
for portid in range(len(self.ports)):
# dump eemprom by userspace ethtool
self.dut.send_expect("eeprom %d eeprom_%d.bin" % (portid, portid),
"EthApp>")
portinfo = {
'portid': portid,
'eeprom_file': 'eeprom_%d.bin' % portid
}
portsinfo.append(portinfo)
self.dut.send_expect("quit", "# ")
for index in range(len(self.ports)):
port = self.ports[index]
netdev = self.dut.ports_info[port]['port']
portinfo = portsinfo[index]
# strip orignal driver
portinfo['ori_driver'] = netdev.get_nic_driver()
portinfo['net_dev'] = netdev
# bind to default driver
netdev.bind_driver()
# get linux interface
intf = netdev.get_interface_name()
ethtool_eeprom = "ethtool_eeprom_%d.bin" % index
# dump eemprom by linux ethtool
self.dut.send_expect(
"ethtool --eeprom-dump %s raw on > %s" %
(intf, ethtool_eeprom), "# ")
# wait for file ready
time.sleep(2)
portinfo['ethtool_eeprom'] = ethtool_eeprom
# bind to original driver
portinfo['net_dev'].bind_driver(portinfo['ori_driver'])
for index in range(len(self.ports)):
md5 = self.strip_md5(portsinfo[index]['eeprom_file'])
md5_ref = self.strip_md5(portsinfo[index]['ethtool_eeprom'])
print utils.GREEN("Reference eeprom md5 %s" % md5)
print utils.GREEN("Reference eeprom md5_ref %s" % md5_ref)
self.verify(md5 == md5_ref,
"Dumped eeprom not same as linux dumped")
def check_packet_transmission(self, pkt_types, layer_configs=None):
time.sleep(1)
for pkt_type in pkt_types.keys():
pkt_names = pkt_types[pkt_type]
pkt = Packet(pkt_type=pkt_type)
if layer_configs:
for layer in layer_configs.keys():
pkt.config_layer(layer, layer_configs[layer])
inst = self.tester.tcpdump_sniff_packets(self.tester_iface,
count=1,
timeout=8)
pkt.send_pkt(tx_port=self.tester_iface)
out = self.dut.get_session_output(timeout=2)
time.sleep(1)
self.tester.load_tcpdump_sniff_packets(inst)
if self.printFlag: # debug output
print out
for pkt_layer_name in pkt_names:
if self.printFlag: # debug output
print pkt_layer_name
if pkt_layer_name not in out:
print utils.RED("Fail to detect %s" % pkt_layer_name)
if not self.printFlag:
raise VerifyFailure("Failed to detect %s" %
pkt_layer_name)
else:
print utils.GREEN("Detected %s successfully" % pkt_type)
time.sleep(1)
def test_vm_power_managment_freqdown(self):
"""
Check host cpu frequency can scale down in VM
"""
guest_cmd = self.vm_power_dir + \
"guest_cli/build/guest_vm_power_mgr -c 0xf -n 4 -- --vm-name=%s --vcpu-list=0,1,2,3" % self.vm_name
out = self.vm_dut.send_expect(guest_cmd, "vmpower\(guest\)>", 120)
for vcpu in range(self.core_num):
self.vm_dut.send_expect("set_cpu_freq %d max" % vcpu,
"vmpower\(guest\)>")
for vcpu in range(self.core_num):
# map between host cpu and guest cpu
ori_freq = self.get_cpu_frequency(self.vcpu_map[vcpu])
# get cpu frequencies range
freqs = self.get_cpu_freqs(vcpu)
for loop in range(len(freqs) - 1):
# connect vm power host and guest
self.vm_dut.send_expect("set_cpu_freq %d down" % vcpu,
"vmpower\(guest\)>")
cur_freq = self.get_cpu_frequency(self.vcpu_map[vcpu])
print utils.GREEN("After freqency down, freq is %d\n" %
cur_freq)
self.verify(ori_freq > cur_freq,
"Cpu freqenecy can not scale down")
ori_freq = cur_freq
self.vm_dut.send_expect("quit", "# ")
def test_vm_power_managment_frequp(self):
"""
Check host cpu frequency can scale up in VM
"""
guest_cmd = self.vm_power_dir + \
"guest_cli/build/guest_vm_power_mgr -c 0xf -n 4 -- -i"
out = self.vm_dut.send_expect(guest_cmd, "vmpower\(guest\)>", 120)
for vcpu in range(self.core_num):
self.vm_dut.send_expect(
"set_cpu_freq %d min" % vcpu, "vmpower\(guest\)>")
for vcpu in range(self.core_num):
ori_freq = self.get_cpu_frequency(self.vcpu_map[vcpu])
# get cpu frequencies range
freqs = self.get_cpu_freqs(vcpu)
for loop in range(len(freqs)-1):
self.vm_dut.send_expect(
"set_cpu_freq %d up" % vcpu, "vmpower\(guest\)>")
cur_freq = self.get_cpu_frequency(self.vcpu_map[vcpu])
print utils.GREEN("After freqency up, freq is %d\n" % cur_freq)
self.verify(
cur_freq > ori_freq, "Cpu freqenecy can not scale up")
ori_freq = cur_freq
self.vm_dut.send_expect("quit", "# ")
def send_email(sender, mailto, message, smtp_server):
try:
smtp = smtplib.SMTP(smtp_server)
smtp.sendmail(sender, mailto, message.as_string())
smtp.quit()
print utils.GREEN("Email sent successfully.")
except Exception, e:
print utils.RED("Failed to send email " + str(e))
def compare_checksum(self):
chksums_ref = self.get_chksums('/tmp/ref_pkt.pcap')
chksums = self.get_chksums('/tmp/sniff_{0}.pcap'.format(self.tester_iface))
self.logger.info("chksums_ref :: %s"%chksums_ref)
self.logger.info("chksums :: %s"%chksums)
# verify saved pcap checksum same to expected checksum
for key in chksums_ref:
self.verify(int(chksums[key], 16) == int(chksums_ref[key], 16), "%s not matched to %s" % (key, chksums_ref[key]))
print utils.GREEN("Checksum is ok")
def handle_dev_destroy(self, **opts):
if 'pf_idx' in opts.keys():
port = int(opts['pf_idx'])
try:
print utils.GREEN("destroy vfs on port %d" % port)
self.host_dut.destroy_sriov_vfs_by_port(port)
except:
print utils.RED("Failed to destroy vf as requested!!!")
def check_packet_transmission(self, pkt_types):
time.sleep(1)
for pkt_type in pkt_types.keys():
intf = self.src_intf
pkt = Packet(pkt_type=pkt_type)
# set packet every layer's input parameters
if 'layer_configs' in pkt_types[pkt_type].keys():
pkt_configs = pkt_types[pkt_type]['layer_configs']
if pkt_configs:
for layer in pkt_configs.keys():
pkt.config_layer(layer, pkt_configs[layer])
pkt.send_pkt(tx_port=self.src_intf)
# check vm testpmd packet received information
if 'vm' in pkt_types[pkt_type].keys():
out = self.vm0_testpmd.get_output(timeout=2)
if self.printFlag: # debug output
print out
for pkt_attribute in pkt_types[pkt_type]['vm']:
if self.printFlag: # debug output
print pkt_attribute
if pkt_attribute not in out:
print utils.RED('Fail to detect %s' % pkt_attribute)
if not self.printFlag: # print out all info in debug mode
raise VerifyFailure('Failed to detect %s' %
pkt_attribute)
print utils.GREEN('VM detected %s successfully' % pkt_type)
# check dut testpmd packet received information
if 'dut' in pkt_types[pkt_type].keys():
out = self.host_testpmd.get_output(timeout=2)
if self.printFlag: # debug output
print out
for pkt_attribute in pkt_types[pkt_type]['dut']:
if self.printFlag: # debug output
print pkt_attribute
if pkt_attribute not in out:
print utils.RED('Fail to detect %s' % pkt_attribute)
if not self.printFlag: # print out all info in debug mode
raise VerifyFailure('Failed to detect %s' %
pkt_attribute)
print utils.GREEN('DUT detected %s successfully' % pkt_type)
time.sleep(1)
def run_test(self, pkt_types):
time.sleep(1)
for pkt_type in pkt_types.keys():
pkt_names = pkt_types[pkt_type]
pkt = Packet(pkt_type=pkt_type)
pkt.send_pkt(tx_port=self.tester_iface)
out = self.dut.get_session_output(timeout=2)
for pkt_layer_name in pkt_names:
if pkt_layer_name not in out:
print utils.RED("Fail to detect %s" % pkt_layer_name)
raise VerifyFailure("Failed to detect %s" % pkt_layer_name)
print utils.GREEN("Detected %s successfully" % pkt_type)
def test_rss_key_size(self):
nic_rss_key_size = {
"fortville_eagle": 52,
"fortville_spirit": 52,
"fortville_spirit_single": 52,
"fortville_25g": 52,
"niantic": 40,
"e1000": 40,
"redrockcanyou": 40,
"atwood": 40,
"boulderrapid": 40,
"fortpark_TLV": 52
}
self.verify(self.nic in nic_rss_key_size.keys(),
"Not supporte rss key on %s" % self.nic)
dutPorts = self.dut.get_ports(self.nic)
localPort = self.tester.get_local_port(dutPorts[0])
itf = self.tester.get_interface(localPort)
self.dut.kill_all()
self.dut.send_expect(
"./%s/app/testpmd -c fffff -n %d -- -i --coremask=0xffffe --rxq=2 --txq=2"
% (self.target, self.dut.get_memory_channels()), "testpmd> ", 120)
self.dut.send_expect("start", "testpmd> ", 120)
out = self.dut.send_expect("show port info all", "testpmd> ", 120)
self.dut.send_expect("quit", "# ", 30)
pattern = re.compile("Hash key size in bytes:\s(\d+)")
m = pattern.search(out)
if m is not None:
size = m.group(1)
print utils.GREEN("******************")
print utils.GREEN(
"NIC %s hash size %d and expected %d" %
(self.nic, int(size), nic_rss_key_size[self.nic]))
if (nic_rss_key_size[self.nic] == int(size)):
self.verify(True, "pass")
else:
self.verify(False, "fail")
def run_nvgre_cope(self, pkt_nvgre):
time.sleep(1)
for pkts in pkt_nvgre:
pkt = Packet()
pkt.assign_layers(pkts[2])
if 'inner_icmp' in pkts[2]:
pkt.config_layers([('ipv6',{'nh':47}), ('inner_ipv6', {'nh': 58})])
else:
pkt.config_layers([('ipv6',{'nh':47}),('inner_ipv6', {'nh': 132})])
pkt.send_pkt(tx_port=self.tester_iface)
out = self.dut.get_session_output(timeout=2)
for pkt_layer_name in pkts[1]:
if pkt_layer_name not in out:
print utils.RED("Fail to detect %s" % pkt_layer_name)
raise VerifyFailure("Failed to detect %s" % pkt_layer_name)
print utils.GREEN("Detected %s successfully" % pkts[0])
def handle_dev_gen(self, **opts):
if 'pf_idx' in opts.keys():
port = int(opts['pf_idx'])
if 'vf_num' in opts.keys():
vf_num = int(opts['vf_num'])
else:
print utils.RED("No vf_num for port %d, assum one VF" % port)
vf_num = 1
if 'driver' in opts.keys():
driver = opts['driver']
try:
print utils.GREEN("create vf %d %d %s" %
(port, vf_num, driver))
self.host_dut.generate_sriov_vfs_by_port(port, vf_num, driver)
self.reset_pf_cmds(port)
except:
print utils.RED("Failed to create vf as requested!!!")
raise VirtDeviceCreateException
def test_nsh(self):
"""
check if NSH packets can be normally detected by Fortpark and Fortville
"""
self.verify(self.kdriver == 'i40e', "NSH packet detection only supported by i40e driver nic")
nsh_packets = {'ether+nsh': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x0,NSP=0x000002,NSI=0xff)', \
'ether+nsh+ip': 'Ether(dst="00:00:00:00:01:00",type=0x894f)/NSH(Len=0x6,NextProto=0x1,NSP=0x000002,NSI=0xff)/IP()', \
'ether+nsh+ip+icmp': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x1,NSP=0x000002,NSI=0xff)/IP()/ICMP()', \
'ether+nsh+ip_frag': 'Ether(dst="00:00:00:00:01:00",type=0x894f)/NSH(Len=0x6,NextProto=0x1,NSP=0x000002,NSI=0xff)/IP(frag=1,flags="MF")', \
'ether+nsh+ip+tcp': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x1,NSP=0x000002,NSI=0xff)/IP()/TCP()', \
'ether+nsh+ip+udp': 'Ether(dst="00:00:00:00:01:00",type=0x894f)/NSH(Len=0x6,NextProto=0x1,NSP=0x000002,NSI=0xff)/IP()/UDP()', \
'ether+nsh+ip+sctp': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x1,NSP=0x000002,NSI=0xff)/IP()/SCTP(tag=1)/SCTPChunkData(data=\'X\' * 16)', \
'ether+nsh+ipv6': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x2,NSP=0x000002,NSI=0xff)/IPv6()', \
'ether+nsh+ipv6+icmp': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x2,NSP=0x000002,NSI=0xff)/IPv6(src="2001::1",dst="2003::2",nh=0x3A)/ICMP()',
'ether+nsh+ipv6_frag': 'Ether(dst="00:00:00:00:01:00",type=0x894f)/NSH(Len=0x6,NextProto=0x2,NSP=0x000002,NSI=0xff)/IPv6()/IPv6ExtHdrFragment()', \
'ether+nsh+ipv6+tcp': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x2,NSP=0x000002,NSI=0xff)/IPv6()/TCP()', \
'ether+nsh+ipv6+udp': 'Ether(dst="00:00:00:00:01:00",type=0x894f)/NSH(Len=0x6,NextProto=0x2,NSP=0x000002,NSI=0xff)/IPv6()/UDP()', \
'ether+nsh+ipv6+sctp': 'Ether(type=0x894f)/NSH(Len=0x6,NextProto=0x2,NSP=0x000002,NSI=0xff)/IPv6(nh=0x84)/SCTP(tag=1)/SCTPChunkData("x" * 16)'
}
nsh_detect_message = {"ether+nsh": "L2_ETHER_NSH", \
"ether+nsh+ip": "L2_ETHER_NSH L3_IPV4_EXT_UNKNOWN L4_NONFRAG", \
"ether+nsh+ip+icmp": "L2_ETHER_NSH L3_IPV4_EXT_UNKNOWN L4_ICMP", \
"ether+nsh+ip_frag": "L2_ETHER_NSH L3_IPV4_EXT_UNKNOWN L4_FRAG", \
"ether+nsh+ip+tcp": "L2_ETHER_NSH L3_IPV4_EXT_UNKNOWN L4_TCP", \
"ether+nsh+ip+udp": "L2_ETHER_NSH L3_IPV4_EXT_UNKNOWN L4_UDP", \
"ether+nsh+ip+sctp": "L2_ETHER_NSH L3_IPV4_EXT_UNKNOWN L4_SCTP", \
"ether+nsh+ipv6": "L2_ETHER_NSH L3_IPV6_EXT_UNKNOWN L4_NONFRAG", \
"ether+nsh+ipv6+icmp": "L2_ETHER_NSH L3_IPV6_EXT_UNKNOWN L4_ICMP", \
"ether+nsh+ipv6_frag": "L2_ETHER_NSH L3_IPV6_EXT_UNKNOWN L4_FRAG", \
"ether+nsh+ipv6+tcp": "L2_ETHER_NSH L3_IPV6_EXT_UNKNOWN L4_TCP", \
"ether+nsh+ipv6+udp": "L2_ETHER_NSH L3_IPV6_EXT_UNKNOWN L4_UDP", \
"ether+nsh+ipv6+sctp": "L2_ETHER_NSH L3_IPV6_EXT_UNKNOWN L4_SCTP"
}
for packet in nsh_packets:
self.tester.scapy_foreground()
self.tester.scapy_append("sendp([%s],iface='%s')" % (nsh_packets[packet], self.tester_iface))
self.tester.scapy_execute()
out = self.dut.get_session_output(timeout=2)
self.verify(nsh_detect_message[packet] in out, "Packet Detection Error for : %s" % packet)
print utils.GREEN("Detected packet %s Successfully" % packet)
def run_test(self, sw_ptype, pkt_types, chk_types):
"""
Generate and send packet according to packet type, detect each packet
layer.
"""
for pkt_type in pkt_types.keys():
if chk_types != None:
pkt_names = chk_types[pkt_type]
else:
pkt_names = pkt_types[pkt_type]
pkt = Packet(pkt_type=pkt_type)
pkt.send_pkt(tx_port=self.tester_iface)
out = self.dut.get_session_output(timeout=2)
self.verify(sw_ptype in out,
"Failed to detect correct ptype value")
for pkt_layer_name in pkt_names:
if pkt_layer_name not in out:
print utils.RED("Fail to detect %s" % pkt_layer_name)
raise VerifyFailure("Failed to detect %s" % pkt_layer_name)
print utils.GREEN("Detected %s successfully" % pkt_type)
def test_l2pkt_detect(self):
"""
Check whether L2 packet can be detected"
"""
self.verify(("fortville" in self.nic or "fortpark_TLV" in self.nic),
"L2 packet detect only support by Fortville")
self.L2_types = {
"TIMESYNC": "L2_ETHER_TIMESYNC",
"ARP": "L2_ETHER_ARP",
"LLDP": "L2_ETHER_LLDP",
}
for l2_type in self.L2_types.keys():
pkt_name = self.L2_types[l2_type]
pkt = Packet(pkt_type=l2_type)
pkt.send_pkt(tx_port=self.tester_iface)
out = self.dut.get_session_output(timeout=2)
if pkt_name in out:
print utils.GREEN("Detected L2 %s successfully" % l2_type)
else:
raise VerifyFailure("Failed to detect L2 %s" % l2_type)
def test_vm_power_managment_freqmin(self):
"""
Check host cpu frequency can scale to min in VM
"""
guest_cmd = self.vm_power_dir + \
"guest_cli/build/guest_vm_power_mgr -c 0xf -n 4 -- -i"
out = self.vm_dut.send_expect(guest_cmd, "vmpower\(guest\)>", 120)
min_freq_path = "cat /sys/devices/system/cpu/cpu%s/cpufreq/" + \
"cpuinfo_min_freq"
for vcpu in range(self.core_num):
self.vm_dut.send_expect(
"set_cpu_freq %d min" % vcpu, "vmpower\(guest\)>")
freq = self.get_cpu_frequency(self.vcpu_map[vcpu])
out = self.dut.alt_session.send_expect(
min_freq_path % self.vcpu_map[vcpu], "# ")
min_freq = int(out)
self.verify(freq == min_freq, "Cpu min frequency not correct")
print utils.GREEN("After freqency min, freq is %d\n" % min_freq)
self.vm_dut.send_expect("quit", "# ")
def count_packet(self, out, mac):
"""
Count packet sum number.
"""
lines = out.split("\r\n")
cnt = 0
count_pkt = 0
# count the packet received from specified mac address.
for line in lines:
line = line.strip()
if len(line) != 0 and line.startswith(("src=",)):
for item in line.split(" "):
item = item.strip()
if(item == ("src=%s" % mac)):
cnt = cnt + 1
elif(item == "L4_UDP"):
cnt = cnt + 1
if (cnt == 2):
count_pkt = count_pkt + 1
cnt = 0
print utils.GREEN("The number of UDP packets received by pf is %d." % count_pkt)
return count_pkt
def test_perf_vmdq_performance(self):
"""
Try different configuration and different packe size
"""
self.tester.get_interface(self.tester.get_local_port(
self.dut_ports[0]))
frame_sizes = [64, 128, 256, 512, 1024, 1280, 1518]
for config in self.core_configs:
print utils.BLUE(config["cores"])
self.dut.kill_all()
core_config = config['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
core_mask = utils.create_mask(core_list)
portmask = utils.create_mask(self.dut.get_ports())
if self.nic in ("niantic", "springfountain"):
self.queues = 64
self.dut.send_expect(
"examples/vmdq/build/vmdq_app -n %d -c %s -- -p %s --nb-pools 64&"
% (self.dut.get_memory_channels(), core_mask, portmask),
"reading queues", 30)
elif self.nic in ("fortville_spirit", "fortville_spirit_single"):
self.queues = 63
self.dut.send_expect(
"examples/vmdq/build/vmdq_app -n %d -c %s -- -p %s --nb-pools 63&"
% (self.dut.get_memory_channels(), core_mask, portmask),
"reading queues", 30)
elif self.nic in ("fortville_eagle"):
self.queues = 34
self.dut.send_expect(
"examples/vmdq/build/vmdq_app -n %d -c %s -- -p %s --nb-pools 34&"
% (self.dut.get_memory_channels(), core_mask, portmask),
"reading queues", 30)
else:
self.queues = 8
self.dut.send_expect(
"examples/vmdq/build/vmdq_app -n %d -c %s -- -p %s --nb-pools 8&"
% (self.dut.get_memory_channels(), core_mask, portmask),
"reading queues", 30)
tx_port = self.tester.get_local_port(self.dut_ports[0])
rx_port = self.tester.get_local_port(self.dut_ports[1])
print utils.GREEN("Waiting for application to initialize")
sleep(5)
for frame_size in frame_sizes:
TestVmdq.current_frame_size = frame_size
print utils.BLUE(str(frame_size))
self.tester.scapy_append('dstmac="%s"' % self.destmac_port0)
tx_mac = self.tester.get_mac(tx_port)
self.tester.scapy_append('srcmac="%s"' % tx_mac)
self.tester.scapy_append(
'flows = [Ether(src=srcmac,dst=dstmac)/Dot1Q(vlan=0)/("X"*%d)]'
% (frame_size - TestVmdq.ip_dot1q_header_size))
self.tester.scapy_append('wrpcap("test1.pcap", flows)')
self.tester.scapy_execute()
self.tester.scapy_append('dstmac="%s"' % self.destmac_port1)
tx_mac = self.tester.get_mac(rx_port)
self.tester.scapy_append('srcmac="%s"' % tx_mac)
self.tester.scapy_append(
'flows = [Ether(src=srcmac,dst=dstmac)/Dot1Q(vlan=0)/("X"*%d)]'
% (frame_size - TestVmdq.ip_dot1q_header_size))
self.tester.scapy_append('wrpcap("test2.pcap", flows)')
self.tester.scapy_execute()
self.vlan_repeat = self.queues
self.da_repeat = self.queues
tgen_input = []
tgen_input.append((tx_port, rx_port, "test1.pcap"))
tgen_input.append((rx_port, tx_port, "test2.pcap"))
_, pps = self.tester.traffic_generator_throughput(tgen_input)
config['mpps'][frame_size] = pps / 1000000.0
for n in range(len(self.core_configs)):
for size in frame_sizes:
self.verify(self.core_configs[n]['mpps'][size] is not 0,
"No traffic detected")
# Print results
self.result_table_create(['Frame size'] +
[n['cores'] for n in self.core_configs])
for size in frame_sizes:
self.result_table_add([size] +
[n['mpps'][size] for n in self.core_configs])
self.result_table_print()
def test_VEB_switching_inter_vfs_and_pf(self):
"""
DPDK PF, then create 2VFs, PF in the host running dpdk testpmd, VFs
running dpdk testpmd, VF1 send traffic to VF2, check if VF2 can receive
the packets. send traffic from PF to VF1, ensure PF->VF1; send traffic
from VF1 to PF, ensure VF1->PF can work.
"""
# VF->PF
self.setup_env(driver=self.drivername)
self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
self.dut.send_expect("set fwd rxonly", "testpmd>")
self.dut.send_expect("set verbose 1", "testpmd>")
self.dut.send_expect("set promisc all off", "testpmd>")
self.dut.send_expect("start", "testpmd>")
time.sleep(2)
self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.pf_mac_address), "testpmd>", 120)
self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
self.session_secondary.send_expect("set fwd txonly", "testpmd>")
self.session_secondary.send_expect("set promisc all off", "testpmd>")
self.session_secondary.send_expect("start", "testpmd>")
time.sleep(2)
# print the packets which received by pf, this caused most packets missed.
out = self.dut.get_session_output(timeout=1)
self.session_secondary.send_expect("stop", "testpmd>", 2)
self.dut.send_expect("stop", "testpmd>", 2)
count_pkt = self.count_packet(out, self.vf0_mac)
vf0_tx_stats = self.veb_get_pmd_stats("second", 0, "tx")
pf_rx_stats = self.veb_get_pmd_stats("first", 0, "rx")
self.verify(vf0_tx_stats[0] > 1000, "no packet was sent by VF0")
self.verify(count_pkt > 100, "no packet was received by PF")
self.session_secondary.send_expect("quit", "# ")
time.sleep(2)
self.dut.send_expect("quit", "# ")
time.sleep(2)
# PF->VF
self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i --eth-peer=0,%s" % (self.target, self.pf_pci, self.vf0_mac), "testpmd>", 120)
self.dut.send_expect("set fwd txonly", "testpmd>")
self.dut.send_expect("set promisc all off", "testpmd>")
self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
self.session_secondary.send_expect("set promisc all off", "testpmd>")
self.session_secondary.send_expect("start", "testpmd>")
time.sleep(2)
self.dut.send_expect("start", "testpmd>")
time.sleep(2)
self.dut.send_expect("stop", "testpmd>", 2)
self.session_secondary.send_expect("stop", "testpmd>", 2)
vf0_rx_stats = self.veb_get_pmd_stats("second", 0, "rx")
print utils.GREEN("The number of UDP packets received by vf is %d." % vf0_rx_stats[0])
self.verify(vf0_rx_stats[0] > 100, "no packet was received by VF0")
self.session_secondary.send_expect("quit", "# ")
time.sleep(2)
self.dut.send_expect("quit", "# ")
time.sleep(2)
# tester->VF
self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("set promisc all off", "testpmd>")
self.dut.send_expect("start", "testpmd>")
time.sleep(2)
self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
self.session_secondary.send_expect("mac_addr add 0 %s" % self.vf0_mac, "testpmd>")
self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
self.session_secondary.send_expect("set promisc all off", "testpmd>")
self.session_secondary.send_expect("start", "testpmd>")
time.sleep(2)
vf0_start_rx_stats = self.veb_get_pmd_stats("second", 0, "rx")
self.send_packet(self.vf0_mac, self.tester_itf)
time.sleep(2)
self.session_secondary.send_expect("stop", "testpmd>", 2)
self.dut.send_expect("stop", "testpmd>", 2)
vf0_end_rx_stats = self.veb_get_pmd_stats("second", 0, "rx")
self.verify(vf0_end_rx_stats[0] - vf0_start_rx_stats[0] == 1, "no packet was received by VF0")
self.dut.send_expect("start", "testpmd>")
time.sleep(2)
self.session_secondary.send_expect("start", "testpmd>")
time.sleep(2)
vf0_start_rx_stats = self.veb_get_pmd_stats("second", 0, "rx")
pf_start_tx_stats = self.veb_get_pmd_stats("first", 0, "tx")
pf_start_rx_stats = self.veb_get_pmd_stats("first", 0, "rx")
self.send_packet(self.pf_mac_address, self.tester_itf)
time.sleep(2)
self.session_secondary.send_expect("stop", "testpmd>", 2)
self.dut.send_expect("stop", "testpmd>", 2)
vf0_end_rx_stats = self.veb_get_pmd_stats("second", 0, "rx")
pf_end_tx_stats = self.veb_get_pmd_stats("first", 0, "tx")
pf_end_rx_stats = self.veb_get_pmd_stats("first", 0, "rx")
self.verify(pf_end_tx_stats[0] - pf_start_tx_stats[0] == 1, "no packet was sent by PF")
self.verify(pf_end_rx_stats[0] - pf_start_rx_stats[0] == 1, "no packet was received by PF")
self.verify(vf0_end_rx_stats[0] - vf0_start_rx_stats[0] == 0, "VF0 received unexpected packet")
self.session_secondary.send_expect("quit", "# ")
time.sleep(2)
self.dut.send_expect("quit", "# ")
time.sleep(2)
# VF1->VF2
self.dut.send_expect("./%s/app/testpmd -c 0xf -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test1 -- -i" % (self.target, self.pf_pci), "testpmd>", 120)
self.dut.send_expect("set promisc all off", "testpmd>")
self.session_secondary.send_expect("./%s/app/testpmd -c 0xf0 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test2 -- -i --eth-peer=0,%s" % (self.target, self.sriov_vfs_port[0].pci, self.vf1_mac), "testpmd>", 120)
self.session_secondary.send_expect("set fwd txonly", "testpmd>")
self.session_secondary.send_expect("set promisc all off", "testpmd>")
time.sleep(2)
self.session_third.send_expect("./%s/app/testpmd -c 0xf00 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=test3 -- -i" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
self.session_third.send_expect("mac_addr add 0 %s" % self.vf1_mac, "testpmd>")
self.session_third.send_expect("set fwd rxonly", "testpmd>")
self.session_third.send_expect("set promisc all off", "testpmd>")
self.session_third.send_expect("start", "testpmd>")
self.session_secondary.send_expect("start", "testpmd>")
time.sleep(2)
self.session_secondary.send_expect("stop", "testpmd>", 5)
self.session_third.send_expect("stop", "testpmd>", 5)
vf0_tx_stats = self.veb_get_pmd_stats("second", 0, "tx")
vf1_rx_stats = self.veb_get_pmd_stats("third", 0, "rx")
self.verify(vf0_tx_stats[0] != 0, "no packet was sent by VF0")
self.verify(vf0_tx_stats[0] * 0.5 < vf1_rx_stats[0], "VF1 failed to receive packets from VF0")
def get_freq_in_transmission(self):
self.cur_freq = self.get_cpu_frequency(self.vcpu_map[1])
print utils.GREEN("Current cpu frequency %d" % self.cur_freq)
def send_and_verify(self, vm_id, vf_id, pkt_type):
params = {}
case_pass = True
tester_recv_port = self.tester.get_local_port(self.pf)
tester_iface = self.tester.get_interface(tester_recv_port)
tester_smac = self.tester.get_mac(tester_recv_port)
if pkt_type == "normal_udp":
self.start_capture(tester_iface, pkt_smac=self.pf_mac)
self.tester.scapy_append(
'sendp([Ether(dst="%s",src="%s")/IP()/UDP()/Raw("X"*18)], iface="%s")'
% (self.pf_mac, tester_smac, tester_iface))
self.tester.scapy_execute()
time.sleep(5)
pkts = self.transfer_capture_file()
self.verify(len(pkts) >= 1, "Failed to capture packets")
self.verify(pkts[0].haslayer(Vxlan) == 1,
"Packet not encapsulated")
try:
payload = str(pkts[0][UDP][Vxlan][UDP].payload)
for i in range(18):
self.verify(ord(payload[i]) == 88, "Check udp data failed")
except:
case_pass = False
print utils.RED("Failure in checking packet payload")
if case_pass:
print utils.GREEN("Check normal udp packet forward pass on "
"virtIO port %d" % vf_id)
if pkt_type == "vxlan_udp_decap":
# create vxlan packet pf mac + vni=1000 + inner virtIO port0 mac
params['outer_mac_dst'] = self.pf_mac
params['vni'] = 1000 + vm_id
mac_incr = 2 * vm_id + vf_id
params['inner_mac_dst'] = self.mac_address_add(mac_incr)
# create vxlan pcap file and tranfer it to tester
vxlan_pkt = VxlanTestConfig(self, **params)
vxlan_pkt.create_pcap()
# start capture
self.start_capture(tester_iface, pkt_dmac=params['inner_mac_dst'])
vxlan_pkt.send_pcap(tester_iface)
time.sleep(5)
# transfer capture pcap to server
pkts = self.transfer_capture_file()
# check packet number and payload
self.verify(len(pkts) >= 1, "Failed to capture packets")
self.verify(pkts[0].haslayer(Vxlan) == 0,
"Packet not de-encapsulated")
try:
payload = str(pkts[0][UDP].payload)
for i in range(18):
self.verify(ord(payload[i]) == 88, "Check udp data failed")
except:
case_pass = False
print utils.RED("Failure in checking packet payload")
if case_pass:
print utils.GREEN(
"Check vxlan packet decap pass on virtIO port"
" %d" % vf_id)
if pkt_type == "vxlan_udp":
# create vxlan packet pf mac + vni=1000 + inner virtIO port0 mac
params['outer_mac_dst'] = self.pf_mac
params['vni'] = 1000 + vm_id
mac_incr = 2 * vm_id + vf_id
params['inner_mac_dst'] = self.mac_address_add(mac_incr)
# create vxlan pcap file and tranfer it to tester
vxlan_pkt = VxlanTestConfig(self, **params)
vxlan_pkt.create_pcap()
# start capture
self.start_capture(tester_iface, pkt_smac=self.pf_mac)
vxlan_pkt.send_pcap(tester_iface)
time.sleep(5)
# transfer capture pcap to server
pkts = self.transfer_capture_file()
# check packet number and payload
self.verify(len(pkts) >= 1, "Failed to capture packets")
self.verify(pkts[0].haslayer(Vxlan) == 1,
"Packet not encapsulated")
try:
payload = str(pkts[0][UDP][Vxlan][UDP].payload)
for i in range(18):
self.verify(ord(payload[i]) == 88, "Check udp data failed")
except:
case_pass = False
print utils.RED("Failure in checking packet payload")
if case_pass:
print utils.GREEN("Check vxlan packet decap and encap pass on "
"virtIO port %d" % vf_id)
if pkt_type == "vxlan_udp_chksum":
params['inner_l4_type'] = 'UDP'
if pkt_type == "vxlan_tcp_chksum":
params['inner_l4_type'] = 'TCP'
if pkt_type == "vxlan_sctp_chksum":
params['inner_l4_type'] = 'SCTP'
if 'chksum' in pkt_type:
# create vxlan packet pf mac + vni=1000 + inner virtIO port0 mac
params['outer_mac_dst'] = self.pf_mac
params['vni'] = 1000 + vm_id
mac_incr = 2 * vm_id + vf_id
params['inner_mac_dst'] = self.mac_address_add(mac_incr)
# extract reference chksum value
vxlan_pkt = VxlanTestConfig(self, **params)
vxlan_pkt.create_pcap()
chksums_ref = vxlan_pkt.get_chksums()
print utils.GREEN("Checksum reference: %s" % chksums_ref)
params['inner_ip_invalid'] = 1
params['inner_l4_invalid'] = 1
# create vxlan pcap file and tranfer it to tester
vxlan_pkt = VxlanTestConfig(self, **params)
vxlan_pkt.create_pcap()
# start capture
self.start_capture(tester_iface, pkt_smac=self.pf_mac)
vxlan_pkt.send_pcap(tester_iface)
time.sleep(5)
# transfer capture pcap to server
pkts = self.transfer_capture_file()
# check packet number and payload
self.verify(len(pkts) >= 1, "Failed to capture packets")
self.verify(pkts[0].haslayer(Vxlan) == 1,
"Packet not encapsulated")
chksums = vxlan_pkt.get_chksums(pcap='vxlan_cap.pcap')
print utils.GREEN("Checksum : %s" % chksums)
for key in chksums_ref:
if 'inner' in key: # only check inner packet chksum
self.verify(
chksums[key] == chksums_ref[key],
"%s not matched to %s" % (key, chksums_ref[key]))
print utils.GREEN("%s checksum pass" % params['inner_l4_type'])
if pkt_type == "vxlan_tcp_tso":
# create vxlan packet pf mac + vni=1000 + inner virtIO port0 mac +
# tcp
params['inner_l4_type'] = 'TCP'
params['outer_mac_dst'] = self.pf_mac
params['vni'] = 1000 + vm_id
mac_incr = 2 * vm_id + vf_id
params['inner_mac_dst'] = self.mac_address_add(mac_incr)
params['payload_size'] = 892 # 256 + 256 + 256 + 124
# extract reference chksum value
vxlan_pkt = VxlanTestConfig(self, **params)
vxlan_pkt.create_pcap()
# start capture
self.start_capture(tester_iface, pkt_smac=self.pf_mac, count=4)
vxlan_pkt.send_pcap(tester_iface)
time.sleep(5)
# transfer capture pcap to server
pkts = self.transfer_capture_file()
# check packet number and payload
self.verify(len(pkts) == 4, "Failed to capture tso packets")
# calculation checksum, and checkt it
for pkt in pkts:
inner = pkt[Vxlan]
inner_ip_chksum = inner[IP].chksum
del inner.chksum
inner[IP] = inner[IP].__class__(str(inner[IP]))
inner_ip_chksum_ref = inner[IP].chksum
print utils.GREEN("inner ip checksum reference: %x" %
inner_ip_chksum_ref)
print utils.GREEN("inner ip checksum: %x" % inner_ip_chksum)
self.verify(inner_ip_chksum == inner_ip_chksum_ref,
"inner ip checksum error")
inner_l4_chksum = inner[params['inner_l4_type']].chksum
del inner[params['inner_l4_type']].chksum
inner[params['inner_l4_type']] = inner[
params['inner_l4_type']].__class__(
str(inner[params['inner_l4_type']]))
inner_l4_chksum_ref = inner[params['inner_l4_type']].chksum
print utils.GREEN("inner l4 checksum reference: %x" %
inner_l4_chksum_ref)
print utils.GREEN("inner l4 checksum: %x" % inner_l4_chksum)
self.verify(
inner_l4_chksum == inner_l4_chksum_ref,
"inner %s checksum error" % params['inner_l4_type'])
length = 0
for pkt in pkts:
self.verify(
pkt.haslayer(Vxlan) == 1, "Packet not encapsulated")
try:
payload = str(pkt[UDP][Vxlan][TCP].payload)
self.verify(
len(payload) <= self.def_mss, "TCP payload oversized")
length += len(payload)
except:
case_pass = False
print utils.RED("Failure in checking tso payload")
self.verify(length == 892, "Total tcp payload size not match")
if case_pass:
print utils.GREEN("Vxlan packet tso pass on virtIO port %d" %
vf_id)
