def setup_vm_env(self, driver='igb_uio'):
"""
Create testing environment with VF generated from 1PF
"""
if self.env_done is False:
self.bind_nic_driver(self.dut_ports[:1], driver="igb_uio")
self.used_dut_port = self.dut_ports[0]
tester_port = self.tester.get_local_port(self.used_dut_port)
self.tester_intf = self.tester.get_interface(tester_port)
self.dut.generate_sriov_vfs_by_port(self.used_dut_port,
1,
driver=driver)
self.sriov_vfs_port = self.dut.ports_info[
self.used_dut_port]['vfs_port']
for port in self.sriov_vfs_port:
port.bind_driver('pci-stub')
time.sleep(1)
self.dut_testpmd = PmdOutput(self.dut)
time.sleep(1)
vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci}
# set up VM0 ENV
self.vm0 = QEMUKvm(self.dut, 'vm0', 'ddp_gtp')
self.vm0.set_vm_device(driver='pci-assign', **vf0_prop)
try:
self.vm0_dut = self.vm0.start()
if self.vm0_dut is None:
raise Exception("Set up VM0 ENV failed!")
except Exception as e:
self.destroy_vm_env()
raise Exception(e)
self.vm0_dut_ports = self.vm0_dut.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm0_dut)
self.env_done = True
def setup_vm_env(self, driver='igb_uio'):
"""
Create testing environment with 2VFs generated from 1PF
"""
if self.env_done:
return
self.bind_nic_driver(self.dut_ports[:1], driver="igb_uio")
self.used_dut_port = self.dut_ports[0]
tester_port = self.tester.get_local_port(self.used_dut_port)
self.tester_intf = self.tester.get_interface(tester_port)
self.dut.generate_sriov_vfs_by_port(self.used_dut_port,
2,
driver=driver)
self.sriov_vfs_port = self.dut.ports_info[
self.used_dut_port]['vfs_port']
for port in self.sriov_vfs_port:
port.bind_driver('pci-stub')
time.sleep(1)
self.dut_testpmd = PmdOutput(self.dut)
self.dut_testpmd.start_testpmd(
"Default", "--rxq=4 --txq=4 --port-topology=chained")
self.dut_testpmd.execute_cmd("start")
time.sleep(5)
vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci}
# set up VM0 ENV
self.vm0 = QEMUKvm(self.dut, 'vm0', 'vf_daemon')
self.vm0.set_vm_device(driver='pci-assign', **vf0_prop)
try:
self.vm0_dut = self.vm0.start()
if self.vm0_dut is None:
raise Exception("Set up VM0 ENV failed!")
except Exception as e:
self.destroy_vm_env()
raise Exception(e)
self.vm0_dut_ports = self.vm0_dut.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm0_dut)
vf1_prop = {'opt_host': self.sriov_vfs_port[1].pci}
self.vm1 = QEMUKvm(self.dut, 'vm1', 'vf_daemon')
self.vm1.set_vm_device(driver='pci-assign', **vf1_prop)
try:
self.vm1_dut = self.vm1.start()
if self.vm1_dut is None:
raise Exception("Set up VM1 ENV failed!")
except Exception as e:
self.destroy_vm_env()
raise Exception(e)
self.vm1_dut_ports = self.vm1_dut.get_ports('any')
self.vm1_testpmd = PmdOutput(self.vm1_dut)
self.env_done = True
self.dut_testpmd.quit()
def test_vf_reset(self):
self.setup_3vf_2vm_env(driver='')
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm1_dut_ports = self.vm_dut_1.get_ports('any')
port_id_0 = 0
port_id_1 = 1
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
self.vm0_testpmd.execute_cmd('show port info all')
pmd0_vf0_mac = self.vm0_testpmd.get_port_mac(port_id_0)
self.vm0_testpmd.execute_cmd('set fwd mac')
self.vm0_testpmd.execute_cmd('start')
time.sleep(2)
self.vm1_testpmd = PmdOutput(self.vm_dut_1)
self.vm1_testpmd.start_testpmd(VM_CORES_MASK)
self.vm1_testpmd.execute_cmd('show port info all')
tx_port = self.tester.get_local_port(self.dut_ports[0])
rx_port = tx_port
dst_mac = pmd0_vf0_mac
self.tester.sendpkt_bg(tx_port, dst_mac)
#vf port stop/start can trigger reset action
for num in range(1000):
self.vm1_testpmd.execute_cmd('port stop all')
time.sleep(0.1)
self.vm1_testpmd.execute_cmd('port start all')
time.sleep(0.1)
self.tester.stop_sendpkt_bg()
pmd0_vf0_stats = self.vm0_testpmd.get_pmd_stats(port_id_0)
pmd0_vf1_stats = self.vm0_testpmd.get_pmd_stats(port_id_1)
vf0_rx_cnt = pmd0_vf0_stats['RX-packets']
self.verify(vf0_rx_cnt != 0, "no packet was received by vm0_VF0")
vf0_rx_err = pmd0_vf0_stats['RX-errors']
self.verify(vf0_rx_err == 0, "vm0_VF0 rx-errors")
vf1_tx_cnt = pmd0_vf1_stats['TX-packets']
self.verify(vf1_tx_cnt != 0, "no packet was transmitted by vm0_VF1")
vf1_tx_err = pmd0_vf1_stats['TX-errors']
self.verify(vf1_tx_err == 0, "vm0_VF0 tx-errors")
self.verify(
vf0_rx_cnt == vf1_tx_cnt,
"vm0_VF0 failed to forward packets to vm0_VF1 when reset vm1_VF0 frequently"
)
def set_up_all(self):
"""
Run at the start of each test suite.
Move RSS to rte_flow Prerequisites
"""
# Based on h/w type, choose how many ports to use
self.dut_ports = self.dut.get_ports(self.nic)
# Verify that enough ports are available
self.verify(len(self.dut_ports) >= 1, "Insufficient ports")
localPort = self.tester.get_local_port(self.dut_ports[0])
self.tester_itf = self.tester.get_interface(localPort)
self.tester_mac = self.tester.get_mac(localPort)
self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf']
self.pf_mac = self.dut.get_mac_address(0)
self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci']
self.pmdout = PmdOutput(self.dut)
self.cores = "1S/2C/1T"
self.pkt1 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.2')/SCTP(dport=80, sport=80)/('X'*48)" % self.pf_mac
self.pkt2 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.2')/UDP(dport=50, sport=50)/('X'*48)" % self.pf_mac
self.pkt3 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.3')/TCP(dport=50, sport=50)/('X'*48)" % self.pf_mac
self.pkt4 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.2')/('X'*48)" % self.pf_mac
self.pkt5 = "Ether(dst='%s')/IPv6(src='2001::1',dst='2001::2',nh=132)/SCTP(dport=80, sport=80)/('X'*48)" % self.pf_mac
self.pkt6 = "Ether(dst='%s')/IPv6(src='2001::1',dst='2001::2')/UDP(dport=50, sport=50)/('X'*48)" % self.pf_mac
self.pkt7 = "Ether(dst='%s')/IPv6(src='2001::2',dst='2001::3')/TCP(dport=50, sport=50)/('X'*48)" % self.pf_mac
self.pkt8 = "Ether(dst='%s')/IPv6(src='2001::2',dst='2001::3')/('X'*48)" % self.pf_mac
self.prio_pkt1 = "Ether(dst='%s')/Dot1Q(prio=1)/IP(src='10.0.0.1',dst='192.168.0.2')/TCP(dport=80, sport=80)/('X'*48)" % self.pf_mac
self.prio_pkt2 = "Ether(dst='%s')/Dot1Q(prio=2)/IP(src='10.0.0.1',dst='192.168.0.2')/TCP(dport=80, sport=80)/('X'*48)" % self.pf_mac
self.prio_pkt3 = "Ether(dst='%s')/Dot1Q(prio=3)/IP(src='10.0.0.1',dst='192.168.0.2')/TCP(dport=80, sport=80)/('X'*48)" % self.pf_mac
def set_up_all(self):
"""
Run at the start of each test suite.
Vlan Prerequistites
"""
# Based on h/w type, choose how many ports to use
ports = self.dut.get_ports()
# Verify that enough ports are available
self.verify(len(ports) >= 2, "Insufficient ports")
global valports
valports = [_ for _ in ports if self.tester.get_local_port(_) != -1]
portMask = dts.create_mask(valports[:2])
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("all", "--portmask=%s" % portMask)
self.dut.send_expect("set verbose 1", "testpmd> ")
out = self.dut.send_expect("set fwd mac", "testpmd> ")
self.dut.send_expect("vlan set strip off %s" % valports[0],
"testpmd> ")
self.verify('Set mac packet forwarding mode' in out,
"set fwd rxonly error")
def setup_vm_env(self):
"""
Start One VM with one virtio device
"""
self.dut_testpmd = PmdOutput(self.dut)
self.dut_testpmd.start_testpmd(
"Default", "--rxq=4 --txq=4 --port-topology=chained")
self.dut_testpmd.execute_cmd("start")
vf0_prop_1 = {'opt_host': self.sriov_vfs_port_0[0].pci}
vf0_prop_2 = {'opt_host': self.sriov_vfs_port_1[0].pci}
self.vm0 = QEMUKvm(self.dut, 'vm0', 'vf_interrupt_pmd')
self.vm0.set_vm_device(driver='pci-assign', **vf0_prop_1)
self.vm0.set_vm_device(driver='pci-assign', **vf0_prop_2)
try:
self.vm0_dut = self.vm0.start()
if self.vm0_dut is None:
raise Exception("Set up VM ENV failed")
else:
self.verify(self.vm0_dut.ports_info[0]['intf'] != 'N/A',
"Not interface")
except Exception as e:
self.destroy_vm_env()
self.logger.error("Failure for %s" % str(e))
self.vm0_vf0_mac = self.vm0_dut.get_mac_address(0)
self.vm0_vf1_mac = self.vm0_dut.get_mac_address(1)
self.vm0_dut.send_expect("systemctl stop NetworkManager", "# ", 60)
def test_2vf_k2d_scapy_stream(self):
self.vm0_ports = self.vm0_dut.get_ports('any')
self.vm0_pmd = PmdOutput(self.vm0_dut)
self.vm0_pmd.start_testpmd('all')
self.vm0_pmd.execute_cmd('set fwd rxonly')
self.vm0_pmd.execute_cmd('start')
# disable promisc to filter misc packets from tester.
self.vm0_pmd.execute_cmd('set promisc all off')
self.vm0_pmd.execute_cmd('clear port stats all')
self.vm1_ports = self.vm1_dut.get_ports('any')
self.vm1_dut.restore_interfaces()
vf1_intf = self.vm1_dut.ports_info[self.vm1_ports[0]]['intf']
dst_mac = self.vm0_dut.ports_info[self.vm0_ports[0]]['mac']
src_mac = self.vm1_dut.ports_info[self.vm1_ports[0]]['mac']
pkt_content = 'Ether(dst="%s", src="%s")/IP()/Raw(load="X"*46)' % \
(dst_mac, src_mac)
self.vm1_dut.send_expect('scapy', '>>> ', 10)
self.vm1_dut.send_expect(
'sendp([%s], iface="%s", count=%d)' %
(pkt_content, vf1_intf, SEND_PACKET), '>>> ', 30)
self.vm1_dut.send_expect('quit()', '# ', 10)
self.vm1_dut.bind_interfaces_linux(self.drivername)
recv_num = self.vm0_pmd.get_pmd_stats(0)['RX-packets']
self.vm0_pmd.execute_cmd('stop')
self.vm0_pmd.execute_cmd('quit', '# ')
self.verify(recv_num is SEND_PACKET,
'Rx port recv error: %d' % recv_num)
def test_pvid_vf_tx(self):
"""
Add port based vlan on vf device and check vlan tx work
"""
random_vlan = random.randint(1, MAX_VLAN)
self.dut.send_expect(
"ip link set %s vf 0 vlan %d" % (self.host_intf0, random_vlan),
"# ")
out = self.dut.send_expect("ip link show %s" % self.host_intf0, "# ")
self.verify("vlan %d" % random_vlan in out,
"Failed to add pvid on VF0")
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
self.vm0_testpmd.execute_cmd('set fwd mac')
self.vm0_testpmd.execute_cmd('start')
pkt = Packet(pkt_type='UDP')
pkt.config_layer('ether', {'dst': self.vf1_mac})
inst = self.tester.tcpdump_sniff_packets(self.tester_intf0, timeout=5)
pkt.send_pkt(tx_port=self.tester_intf1)
pkts = self.tester.load_tcpdump_sniff_packets(inst)
self.verify(len(pkts), "Not receive expected packet")
self.vm0_testpmd.quit()
# disable pvid
self.dut.send_expect("ip link set %s vf 0 vlan 0" % (self.host_intf0),
"# ")
def setup_1pf_2vf_1vm_env(self, driver='default'):
self.used_dut_port = self.dut_ports[0]
self.dut.generate_sriov_vfs_by_port(self.used_dut_port, 2, driver=driver)
self.sriov_vfs_port = self.dut.ports_info[self.used_dut_port]['vfs_port']
try:
for port in self.sriov_vfs_port:
port.bind_driver(self.vf_driver)
time.sleep(1)
vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci}
vf1_prop = {'opt_host': self.sriov_vfs_port[1].pci}
if driver == 'igb_uio':
# start testpmd without the two VFs on the host
self.host_testpmd = PmdOutput(self.dut)
eal_param = '-b %(vf0)s -b %(vf1)s' % {'vf0': self.sriov_vfs_port[0].pci,
'vf1': self.sriov_vfs_port[1].pci}
self.host_testpmd.start_testpmd("1S/2C/2T", eal_param=eal_param)
# set up VM0 ENV
self.vm0 = QEMUKvm(self.dut, 'vm0', 'vf_port_start_stop')
self.vm0.set_vm_device(driver=self.vf_assign_method, **vf0_prop)
self.vm0.set_vm_device(driver=self.vf_assign_method, **vf1_prop)
self.vm_dut_0 = self.vm0.start()
if self.vm_dut_0 is None:
raise Exception("Set up VM0 ENV failed!")
self.setup_1pf_2vf_1vm_env_flag = 1
except Exception as e:
self.destroy_1pf_2vf_1vm_env()
raise Exception(e)
def test_vf_vlan_strip(self):
random_vlan = random.randint(1, MAX_VLAN - 1)
rx_vlans = [1, random_vlan, MAX_VLAN]
# start testpmd in VM
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
if self.kdriver == "i40e":
self.vm0_testpmd.start_testpmd(VM_CORES_MASK, '')
else:
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
self.vm0_testpmd.execute_cmd('set fwd rxonly')
self.vm0_testpmd.execute_cmd('set verbose 1')
self.vm0_testpmd.execute_cmd('start')
for rx_vlan in rx_vlans:
self.vm0_testpmd.execute_cmd('vlan set strip on 0')
self.vm0_testpmd.execute_cmd('rx_vlan add %d 0' % rx_vlan)
time.sleep(1)
out = self.send_and_getout(vlan=rx_vlan, pkt_type="VLAN_UDP")
# enable strip, vlan will be in mbuf
vlan_hex = hex(rx_vlan)
self.verify("VLAN tci=%s" %
vlan_hex in out, "Failed to strip vlan packet!!!")
self.verify("PKT_RX_VLAN_STRIPPED" in out, "Failed to strip vlan packet!")
self.vm0_testpmd.execute_cmd('vlan set strip off 0')
out = self.send_and_getout(vlan=rx_vlan, pkt_type="VLAN_UDP")
self.verify(
"received 1 packets" in out, "Not received vlan packet as expected!!!")
self.verify(
"PKT_RX_VLAN_STRIPPED" not in out, "Failed to disable strip vlan!!!")
self.vm0_testpmd.quit()
def packet_rx_tx(self, driver='default'):
if driver == 'igb_uio':
self.setup_2pf_2vf_1vm_env(driver='igb_uio')
else:
self.setup_2pf_2vf_1vm_env(driver='')
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
port_id_0 = 0
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
out = self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
pmd_vf0_mac = self.vm0_testpmd.get_port_mac(port_id_0)
self.vm0_testpmd.execute_cmd('set fwd mac')
self.vm0_testpmd.execute_cmd('start')
time.sleep(2)
tgen_ports = []
tx_port = self.tester.get_local_port(self.dut_ports[0])
rx_port = self.tester.get_local_port(self.dut_ports[1])
tgen_ports.append((tx_port, rx_port))
dst_mac = pmd_vf0_mac
src_mac = self.tester.get_mac(tx_port)
pkt_param = [("ether", {'dst': dst_mac, 'src': src_mac})]
result = self.tester.check_random_pkts(tgen_ports,
allow_miss=False,
params=pkt_param)
print self.vm0_testpmd.execute_cmd('show port stats all')
self.verify(result != False, "VF0 failed to forward packets to VF1")
def test_kernel_2pf_2vf_1vm_iplink_macfilter(self):
self.setup_2pf_2vf_1vm_env(driver='')
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
# Get VF's MAC
pmd_vf0_mac = self.vm0_testpmd.get_port_mac(0)
vf0_wrongmac = "00:11:22:33:48:55"
self.vm0_testpmd.execute_cmd('set promisc all off')
self.vm0_testpmd.execute_cmd('set fwd mac')
self.vm0_testpmd.execute_cmd('start')
time.sleep(2)
tgen_ports = []
tx_port = self.tester.get_local_port(self.dut_ports[0])
rx_port = self.tester.get_local_port(self.dut_ports[1])
tgen_ports.append((tx_port, rx_port))
dst_mac = self.pf0_vf0_mac
src_mac = self.tester.get_mac(tx_port)
pkt_param=[("ether", {'dst': dst_mac, 'src': src_mac})]
print "\nfirst send packets to the kernel PF set MAC, expected result is RX packets=TX packets\n"
result1 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param)
print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd('show port stats all')
self.verify(result1 != False, "VF0 failed to forward packets to VF1")
print "\nSecondly, negative test, send packets to a wrong MAC, expected result is RX packets=0\n"
dst_mac = vf0_wrongmac
pkt_param=[("ether", {'dst': dst_mac, 'src': src_mac})]
result2 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param)
print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd('show port stats all')
self.verify(result2 != True, "VF0 failed to forward packets to VF1")
def test_2vf_k2d_scapy_stream(self):
self.vm0_ports = self.vm0_dut.get_ports('any')
self.vm0_pmd = PmdOutput(self.vm0_dut)
self.vm0_pmd.start_testpmd('all')
self.vm1_ports = self.vm1_dut.get_ports('any')
self.vm1_dut.restore_interfaces()
vf1_intf = self.vm1_dut.ports_info[self.vm1_ports[0]]['intf']
dst_mac = self.vm0_dut.ports_info[self.vm0_ports[0]]['mac']
src_mac = self.vm1_dut.ports_info[self.vm1_ports[0]]['mac']
pkt_content = 'Ether(dst="%s", src="%s")/IP()/Raw(load="X"*46)' % \
(dst_mac, src_mac)
self.vm1_dut.send_expect('scapy', '>>> ', 10)
self.vm0_pmd.execute_cmd('set promisc all off')
self.vm0_pmd.execute_cmd('set fwd rxonly')
self.vm0_pmd.execute_cmd('set verbose 1')
self.vm0_pmd.execute_cmd('start')
self.vm1_dut.send_expect('sendp([%s], iface="%s", count=%d)' %
(pkt_content, vf1_intf, SEND_PACKET), '>>> ', 30)
out = self.vm0_dut.get_session_output(timeout=60)
rx_packets = re.findall("src=%s - dst=%s" % (src_mac, dst_mac), out)
recv_num = len(rx_packets)
self.vm1_dut.send_expect('quit()', '# ', 10)
self.vm1_dut.bind_interfaces_linux(self.drivername)
self.vm0_pmd.execute_cmd('stop')
self.vm0_pmd.execute_cmd('quit', '# ')
self.verify(recv_num is SEND_PACKET,
'Rx port recv error: %d' % recv_num)
def set_up_all(self):
"""
Run at the start of each test suite.
New rx tx offload API Prerequisites
"""
self.verify(
self.nic in [
"fortville_eagle", "fortville_spirit",
"fortville_spirit_single", "niantic"
], "NIC Unsupported: " + str(self.nic))
# Based on h/w type, choose how many ports to use
self.dut_ports = self.dut.get_ports(self.nic)
# Verify that enough ports are available
self.verify(len(self.dut_ports) >= 2, "Insufficient ports")
localPort0 = self.tester.get_local_port(self.dut_ports[0])
localPort1 = self.tester.get_local_port(self.dut_ports[1])
self.tester_itf0 = self.tester.get_interface(localPort0)
self.tester_itf1 = self.tester.get_interface(localPort1)
self.tester_mac0 = self.tester.get_mac(localPort0)
self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf']
self.pf_mac = self.dut.get_mac_address(0)
self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci']
self.pmdout = PmdOutput(self.dut)
self.cores = "1S/4C/1T"
self.jumbo_pkt1 = r'sendp([Ether(dst="%s")/IP(dst="192.168.0.1",src="192.168.0.2", len=8981)/Raw(load="P"*8961)], iface="%s")' % (
self.pf_mac, self.tester_itf0)
self.jumbo_pkt2 = r'sendp([Ether(dst="%s")/IP(dst="192.168.0.1",src="192.168.0.3", len=8981)/Raw(load="P"*8961)], iface="%s")' % (
self.pf_mac, self.tester_itf0)
self.vlan_pkt1 = r'sendp([Ether(dst="%s")/Dot1Q(vlan=1)/IP(src="192.168.0.1",dst="192.168.0.3")/UDP(sport=33, dport=34)/Raw("x"*20)], iface="%s")' % (
self.pf_mac, self.tester_itf0)
self.vlan_pkt2 = r'sendp([Ether(dst="%s")/Dot1Q(vlan=1)/IP(src="192.168.0.2",dst="192.168.0.3")/UDP(sport=33, dport=34)/Raw("x"*20)], iface="%s")' % (
self.pf_mac, self.tester_itf0)
def set_up_all(self):
"""
Run at the start of each test suite.
Vlan Prerequistites
"""
global dutRxPortId
global dutTxPortId
# Based on h/w type, choose how many ports to use
ports = self.dut.get_ports(self.nic)
self.verify(len(ports) >= 2, "Insufficient ports")
self.ports_socket = self.dut.get_numa_id(ports[0])
cores = self.dut.get_core_list('1S/2C/2T')
coreMask = utils.create_mask(cores)
ports = self.dut.get_ports(self.nic)
valports = [_ for _ in ports if self.tester.get_local_port(_) != -1]
portMask = utils.create_mask(valports[:2])
dutRxPortId = valports[0]
dutTxPortId = valports[1]
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("Default", "--portmask=%s" % portMask, socket=self.ports_socket)
if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortville_25g", "fortpark_TLV"]:
self.dut.send_expect("vlan set filter on all", "testpmd> ")
self.dut.send_expect("set promisc all off", "testpmd> ")
out = self.dut.send_expect("set fwd mac", "testpmd> ")
self.verify('Set mac packet forwarding mode' in out, "set fwd mac error")
out = self.dut.send_expect("start", "testpmd> ", 120)
def set_up_all(self):
"""
Run at the start of each test suite.
Whitelist Prerequistites:
Two Ports
testpmd can normally started
"""
self.frames_to_send = 1
# Based on h/w type, choose how many ports to use
self.dutPorts = self.dut.get_ports()
# Verify that enough ports are available
self.verify(len(self.dutPorts) >= 1, "Insufficient ports")
portMask = dts.create_mask(self.dutPorts[:2])
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("1S/2C/1T", "--portmask=%s" % portMask)
self.dut.send_expect("set verbose 1", "testpmd> ")
# get dest address from self.target port
out = self.dut.send_expect("show port info %d" % self.dutPorts[0],
"testpmd> ")
self.dest = self.dut.get_mac_address(self.dutPorts[0])
mac_scanner = r"MAC address: (([\dA-F]{2}:){5}[\dA-F]{2})"
ret = dts.regexp(out, mac_scanner)
self.verify(ret is not None, "MAC address not found")
self.verify(cmp(ret.lower(), self.dest) == 0, "MAC address wrong")
self.max_mac_addr = dts.regexp(
out, "Maximum number of MAC addresses: ([0-9]+)")
def set_up_all(self):
"""
Prerequisite steps for each test suit.
"""
self.dut_ports = self.dut.get_ports()
self.verify(len(self.dut_ports) >= 1, "Insufficient ports")
self.rx_port = self.dut_ports[0]
self.tx_port = self.dut_ports[0]
cores = self.dut.get_core_list("1S/2C/1T")
self.coremask = utils.create_mask(cores)
self.port_mask = utils.create_mask([self.rx_port, self.tx_port])
if self.kdriver == "fm10k":
netobj = self.dut.ports_info[self.tx_port]['port']
netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU)
netobj = self.dut.ports_info[self.rx_port]['port']
netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU)
self.tester.send_expect(
"ifconfig %s mtu %s" %
(self.tester.get_interface(self.tester.get_local_port(
self.rx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ")
# self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.tx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ")
self.pmdout = PmdOutput(self.dut)
def set_up_all(self):
"""
Run at the start of each test suite.
Queue region Prerequisites
"""
self.verify(
self.nic in [
"fortville_eagle", "fortville_spirit",
"fortville_spirit_single", "fortpark_TLV"
], "NIC Unsupported: " + str(self.nic))
# Based on h/w type, choose how many ports to use
self.dut_ports = self.dut.get_ports(self.nic)
# Verify that enough ports are available
self.verify(len(self.dut_ports) >= 1, "Insufficient ports")
localPort = self.tester.get_local_port(self.dut_ports[0])
self.tester_intf = self.tester.get_interface(localPort)
self.tester_mac = self.tester.get_mac(localPort)
self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf']
self.pf_mac = self.dut.get_mac_address(0)
self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci']
self.pmdout = PmdOutput(self.dut)
self.cores = "1S/4C/1T"
self.pmdout.start_testpmd("%s" % self.cores, "--rxq=16 --txq=16")
self.dut.send_expect("port config all rss all", "testpmd> ", 120)
self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
self.dut.send_expect("set verbose 1", "testpmd> ", 120)
self.dut.send_expect("start", "testpmd> ", 120)
time.sleep(2)
def set_up_all(self):
"""
Run at the start of each test suite.
Scatter Prerequistites
"""
dutPorts = self.dut.get_ports(self.nic)
# Verify that enough ports are available
self.verify(len(dutPorts) >= 1, "Insufficient ports")
self.port = dutPorts[0]
tester_port = self.tester.get_local_port(self.port)
self.intf = self.tester.get_interface(tester_port)
self.pmdout = PmdOutput(self.dut)
if self.nic in ["magnolia_park", "niantic", "sageville", "fortpark", "fortville_eagle",
"fortville_spirit", "fortville_spirit_single",
"redrockcanyou", "atwood", "boulderrapid",
"ironpond", "twinpond", "springfountain", "fortpark_TLV"]:
self.mbsize = 2048
else:
self.mbsize = 1024
if self.kdriver == "fm10k":
self.dut.ports_info[self.port]['port'].enable_jumbo(framesize=9000)
self.tester.send_expect("ifconfig %s mtu 9000" % self.intf, "#")
def set_up_all(self):
"""
Run at the start of each test suite.
IEEE1588 Prerequisites
"""
dutPorts = self.dut.get_ports()
self.verify(len(dutPorts) > 0, "No ports found for " + self.nic)
# Change the config file to support IEEE1588 and recompile the package.
if "bsdapp" in self.target:
self.dut.send_expect(
"sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_bsdapp",
"# ", 30)
else:
self.dut.send_expect(
"sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_linuxapp",
"# ", 30)
self.dut.skip_setup = False
self.dut.build_install_dpdk(self.target)
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("all")
def test_2vf_d2d_pktgen_stream(self):
self.vm0_ports = self.vm0_dut.get_ports('any')
self.vm0_pmd = PmdOutput(self.vm0_dut)
self.vm0_pmd.start_testpmd('all')
self.vm0_pmd.execute_cmd('set fwd rxonly')
self.vm0_pmd.execute_cmd("set promisc all off")
self.vm0_pmd.execute_cmd('start')
self.vm1_ports = self.vm1_dut.get_ports('any')
self.prepare_pktgen(self.vm1_dut)
dst = {}
dst['server'] = self.vm0_dut
dst['ether'] = self.vm0_dut.ports_info[self.vm0_ports[0]]['mac']
src = {}
src['server'] = self.vm1_dut
src['ether'] = self.vm1_dut.ports_info[self.vm1_ports[0]]['mac']
load = {}
load['content'] = "'X'*46"
self.generate_pcap_pkt(dst, src, load)
self.vm0_pmd.execute_cmd('clear port stats all')
self.send_stream_pktgen(self.vm1_dut)
recv_num = self.vm0_pmd.get_pmd_stats(0)['RX-packets']
time.sleep(1)
self.stop_stream_pktgen(self.vm1_dut)
self.vm0_pmd.execute_cmd('stop')
self.vm0_pmd.execute_cmd('quit', '# ')
self.verify(recv_num is SEND_PACKET,
'Rx port recv error: %d' % recv_num)
def test_vf_vlan_tx(self):
self.verify(self.kdriver not in ["ixgbe"],
"NIC Unsupported: " + str(self.nic))
random_vlan = random.randint(1, MAX_VLAN)
tx_vlans = [1, random_vlan, MAX_VLAN]
# start testpmd in VM
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
self.vm0_testpmd.execute_cmd('set verbose 1')
for tx_vlan in tx_vlans:
# for fortville ,
# if you want insert tx_vlan,
# please enable rx_vlan at the same time
if self.kdriver == "i40e":
self.vm0_testpmd.execute_cmd('rx_vlan add %d 0' % tx_vlan)
self.vm0_testpmd.execute_cmd('stop')
self.vm0_testpmd.execute_cmd('port stop all')
self.vm0_testpmd.execute_cmd('tx_vlan set 0 %d' % tx_vlan)
self.vm0_testpmd.execute_cmd('port start all')
self.tx_and_check(tx_vlan=tx_vlan)
self.vm0_testpmd.quit()
def setup_3vf_2vm_env(self, driver='default'):
self.used_dut_port = self.dut_ports[0]
self.dut.generate_sriov_vfs_by_port(self.used_dut_port,
3,
driver=driver)
self.sriov_vfs_port = self.dut.ports_info[
self.used_dut_port]['vfs_port']
try:
for port in self.sriov_vfs_port:
print port.pci
port.bind_driver(self.vf_driver)
time.sleep(1)
vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci}
vf1_prop = {'opt_host': self.sriov_vfs_port[1].pci}
vf2_prop = {'opt_host': self.sriov_vfs_port[2].pci}
for port_id in self.dut_ports:
if port_id == self.used_dut_port:
continue
port = self.dut.ports_info[port_id]['port']
port.bind_driver()
if driver == 'igb_uio':
self.host_testpmd = PmdOutput(self.dut)
eal_param = '-b %(vf0)s -b %(vf1)s -b %(vf2)s' % {
'vf0': self.sriov_vfs_port[0].pci,
'vf1': self.sriov_vfs_port[1].pci,
'vf2': self.sriov_vfs_port[2].pci
}
if (self.nic in ["niantic", "sageville", "sagepond"]):
self.host_testpmd.start_testpmd("1S/9C/1T",
"--txq=4 --rxq=4 ",
eal_param=eal_param)
else:
self.host_testpmd.start_testpmd("1S/2C/2T",
eal_param=eal_param)
# set up VM0 ENV
self.vm0 = VM(self.dut, 'vm0', 'vf_packet_rxtx')
self.vm0.set_vm_device(driver=self.vf_assign_method, **vf0_prop)
self.vm0.set_vm_device(driver=self.vf_assign_method, **vf1_prop)
self.vm_dut_0 = self.vm0.start()
if self.vm_dut_0 is None:
raise Exception("Set up VM0 ENV failed!")
# set up VM1 ENV
self.vm1 = VM(self.dut, 'vm1', 'vf_packet_rxtx')
self.vm1.set_vm_device(driver=self.vf_assign_method, **vf2_prop)
self.vm_dut_1 = self.vm1.start()
if self.vm_dut_1 is None:
raise Exception("Set up VM1 ENV failed!")
self.setup_3vf_2vm_env_flag = 1
except Exception as e:
self.destroy_3vf_2vm_env()
raise Exception(e)
def get_stats(self, portid):
"""
Get packets number from port statistic.
@param: stop -- stop forward before get stats
"""
output = PmdOutput(self.dut)
stats = output.get_pmd_stats(portid)
return stats
def set_up_all(self):
"""
Run at the start of each test suite.
"""
ports = self.dut.get_ports()
self.verify(len(ports) >= 2, "Not enough ports available")
self.pmdout = PmdOutput(self.dut)
def set_up(self):
"""
Run before each test case.
"""
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("Default", "--portmask=%s" % self.portmask)
if self.kdriver == "i40e":
self.dut.send_expect("set promisc all off", "testpmd> ")
def set_up_all(self):
self.dut_ports = self.dut.get_ports(self.nic)
self.verify(len(self.dut_ports) > 1, "Insufficient ports")
self.vm0 = None
self.setup_2pf_2vf_1vm_env_flag = 0
self.setup_2pf_2vf_1vm_env(driver='')
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.portMask = utils.create_mask([self.vm0_dut_ports[0]])
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
def set_up(self):
"""
Run before each test case.
"""
self.dut_testpmd = PmdOutput(self.dut)
self.dut_testpmd.start_testpmd(
"Default", "--port-topology=chained --txq=%s --rxq=%s" %
(self.PF_QUEUE, self.PF_QUEUE))
self.load_profile()
def set_up(self):
"""
Run before each test case.
"""
self.dut_testpmd = PmdOutput(self.dut)
self.dut_testpmd.start_testpmd("Default", "--port-topology=chained")
self.dut_testpmd.execute_cmd('set fwd rxonly')
self.dut_testpmd.execute_cmd('set verbose 1')
self.dut_testpmd.execute_cmd('start')
def test_add_pvid_vf(self):
random_vlan = random.randint(1, MAX_VLAN)
self.dut.send_expect(
"ip link set %s vf 0 vlan %d" % (self.host_intf0, random_vlan),
"# ")
out = self.dut.send_expect("ip link show %s" % self.host_intf0, "# ")
self.verify("vlan %d" % random_vlan in out,
"Failed to add pvid on VF0")
# start testpmd in VM
self.vm0_dut_ports = self.vm_dut_0.get_ports('any')
self.vm0_testpmd = PmdOutput(self.vm_dut_0)
self.vm0_testpmd.start_testpmd(VM_CORES_MASK)
self.vm0_testpmd.execute_cmd('set fwd rxonly')
self.vm0_testpmd.execute_cmd('set verbose 1')
self.vm0_testpmd.execute_cmd('start')
out = self.send_and_getout(vlan=random_vlan, pkt_type="VLAN_UDP")
self.verify("received" in out, "Failed to received vlan packet!!!")
# send packet without vlan
out = self.send_and_getout(pkt_type="UDP")
self.verify("received" not in out, "Received packet without vlan!!!")
# send packet with vlan not matched
wrong_vlan = (random_vlan + 1) % 4096
out = self.send_and_getout(vlan=wrong_vlan, pkt_type="VLAN_UDP")
self.verify("received" not in out,
"Received pacekt with wrong vlan!!!")
# remove vlan
self.dut.send_expect("ip link set %s vf 0 vlan 0" % self.host_intf0,
"# ")
# send packet with vlan
out = self.send_and_getout(vlan=random_vlan, pkt_type="VLAN_UDP")
if self.kdriver == "i40e":
self.verify("received" in out, "Failed to received vlan packet!!!")
else:
self.verify("received" not in out,
"Received vlan packet without pvid!!!")
# send packet with vlan 0
out = self.send_and_getout(vlan=0, pkt_type="VLAN_UDP")
self.verify("received" in out, "Not recevied packet with vlan 0!!!")
# send packet without vlan
out = self.send_and_getout(vlan=0, pkt_type="UDP")
self.verify("received" in out, "Not received packet without vlan!!!")
self.vm0_testpmd.quit()
# disable pvid
self.dut.send_expect("ip link set %s vf 0 vlan 0" % (self.host_intf0),
"# ")
